diff --git a/ast/asdl_rs.py b/ast/asdl_rs.py index b82ea2b..a558500 100755 --- a/ast/asdl_rs.py +++ b/ast/asdl_rs.py @@ -496,15 +496,29 @@ class FoldTraitDefVisitor(EmitVisitor): self.emit("pub trait Fold {", depth) self.emit("type TargetU;", depth + 1) self.emit("type Error;", depth + 1) + self.emit("type UserContext;", depth + 1) self.emit( """ - fn map_user(&mut self, user: U) -> Result; + fn will_map_user(&mut self, user: &U) -> Self::UserContext; #[cfg(feature = "all-nodes-with-ranges")] - fn map_user_cfg(&mut self, user: U) -> Result { - self.map_user(user) + fn will_map_user_cfg(&mut self, user: &U) -> Self::UserContext { + self.will_map_user(user) } #[cfg(not(feature = "all-nodes-with-ranges"))] - fn map_user_cfg(&mut self, _user: crate::EmptyRange) -> Result, Self::Error> { + fn will_map_user_cfg(&mut self, user: &crate::EmptyRange) -> crate::EmptyRange { + crate::EmptyRange::default() + } + fn map_user(&mut self, user: U, context: Self::UserContext) -> Result; + #[cfg(feature = "all-nodes-with-ranges")] + fn map_user_cfg(&mut self, user: U, context: Self::UserContext) -> Result { + self.map_user(user, context) + } + #[cfg(not(feature = "all-nodes-with-ranges"))] + fn map_user_cfg( + &mut self, + _user: crate::EmptyRange, + _context: crate::EmptyRange, + ) -> Result, Self::Error> { Ok(crate::EmptyRange::default()) } """, @@ -532,6 +546,21 @@ class FoldTraitDefVisitor(EmitVisitor): self.emit(f"fold_{name}(self, node)", depth + 1) self.emit("}", depth) + if isinstance(type.value, asdl.Sum) and not is_simple(type.value): + for cons in type.value.types: + self.visit(cons, type, depth) + + def visitConstructor(self, cons, type, depth): + apply_u, apply_target_u = self.apply_generics(type.name, "U", "Self::TargetU") + enum_name = rust_type_name(type.name) + func_name = f"fold_{type.name}_{rust_field_name(cons.name)}" + self.emit( + f"fn {func_name}(&mut self, node: {enum_name}{cons.name}{apply_u}) -> Result<{enum_name}{cons.name}{apply_target_u}, Self::Error> {{", + depth, + ) + self.emit(f"{func_name}(self, node)", depth + 1) + self.emit("}", depth) + class FoldImplVisitor(EmitVisitor): def visitModule(self, mod, depth): @@ -539,10 +568,10 @@ class FoldImplVisitor(EmitVisitor): self.visit(dfn, depth) def visitType(self, type, depth=0): - self.visit(type.value, type.name, depth) + self.visit(type.value, type, depth) - def visitSum(self, sum, name, depth): - type_info = self.type_info[name] + def visitSum(self, sum, type, depth): + name = type.name apply_t, apply_u, apply_target_u = self.apply_generics( name, "T", "U", "F::TargetU" ) @@ -568,27 +597,69 @@ class FoldImplVisitor(EmitVisitor): self.emit("Ok(node) }", depth + 1) return - self.emit("match node {", depth + 1) + self.emit("let folded = match node {", depth + 1) for cons in sum.types: - fields_pattern = self.make_pattern(enum_name, cons.name, cons.fields) self.emit( - f"{fields_pattern[0]} {{ {fields_pattern[1]}}} {fields_pattern[2]} => {{", - depth + 2, + f"{enum_name}::{cons.name}(cons) => {enum_name}::{cons.name}(Foldable::fold(cons, folder)?),", + depth + 1, ) - map_user_suffix = "" if type_info.has_attributes else "_cfg" - self.emit( - f"let range = folder.map_user{map_user_suffix}(range)?;", depth + 3 - ) + self.emit("};", depth + 1) + self.emit("Ok(folded)", depth + 1) + self.emit("}", depth) - self.gen_construction( - fields_pattern[0], cons.fields, fields_pattern[2], depth + 3 - ) - self.emit("}", depth + 2) + for cons in sum.types: + self.visit(cons, type, depth) + + def visitConstructor(self, cons, type, depth): + apply_t, apply_u, apply_target_u = self.apply_generics( + type.name, "T", "U", "F::TargetU" + ) + enum_name = rust_type_name(type.name) + + cons_type_name = f"{enum_name}{cons.name}" + + self.emit( + f"impl Foldable for {cons_type_name}{apply_t} {{", depth + ) + self.emit(f"type Mapped = {cons_type_name}{apply_u};", depth + 1) + self.emit( + "fn fold + ?Sized>(self, folder: &mut F) -> Result {", + depth + 1, + ) + self.emit( + f"folder.fold_{type.name}_{rust_field_name(cons.name)}(self)", depth + 2 + ) self.emit("}", depth + 1) self.emit("}", depth) - def visitProduct(self, product, name, depth): + self.emit( + f"pub fn fold_{type.name}_{rust_field_name(cons.name)} + ?Sized>(#[allow(unused)] folder: &mut F, node: {cons_type_name}{apply_u}) -> Result<{enum_name}{cons.name}{apply_target_u}, F::Error> {{", + depth, + ) + + type_info = self.type_info[type.name] + + fields_pattern = self.make_pattern(cons.fields) + + map_user_suffix = "" if type_info.has_attributes else "_cfg" + self.emit( + f""" + let {cons_type_name} {{ {fields_pattern} }} = node; + let context = folder.will_map_user{map_user_suffix}(&range); + """, + depth + 3, + ) + self.fold_fields(cons.fields, depth + 3) + self.emit( + f"let range = folder.map_user{map_user_suffix}(range, context)?;", + depth + 3, + ) + self.composite_fields(f"{cons_type_name}", cons.fields, depth + 3) + self.emit("}", depth + 2) + + def visitProduct(self, product, type, depth): + name = type.name apply_t, apply_u, apply_target_u = self.apply_generics( name, "T", "U", "F::TargetU" ) @@ -610,41 +681,47 @@ class FoldImplVisitor(EmitVisitor): depth, ) - fields_pattern = self.make_pattern(struct_name, struct_name, product.fields) - self.emit(f"let {struct_name} {{ {fields_pattern[1]} }} = node;", depth + 1) + fields_pattern = self.make_pattern(product.fields) + self.emit(f"let {struct_name} {{ {fields_pattern} }} = node;", depth + 1) map_user_suffix = "" if has_attributes else "_cfg" - self.emit(f"let range = folder.map_user{map_user_suffix}(range)?;", depth + 3) - self.gen_construction(struct_name, product.fields, "", depth + 1) + self.emit( + f"let context = folder.will_map_user{map_user_suffix}(&range);", depth + 3 + ) + self.fold_fields(product.fields, depth + 1) + self.emit( + f"let range = folder.map_user{map_user_suffix}(range, context)?;", depth + 3 + ) + self.composite_fields(struct_name, product.fields, depth + 1) self.emit("}", depth) - def make_pattern(self, rust_name, fieldname: str, fields): - header = f"{rust_name}::{fieldname}({rust_name}{fieldname}" - footer = ")" - + def make_pattern(self, fields): body = ",".join(rust_field(f.name) for f in fields) if body: body += "," body += "range" - return header, body, footer + return body - def gen_construction(self, header, fields, footer, depth): + def fold_fields(self, fields, depth): + for field in fields: + name = rust_field(field.name) + self.emit(f"let {name} = Foldable::fold({name}, folder)?;", depth + 1) + + def composite_fields(self, header, fields, depth): self.emit(f"Ok({header} {{", depth) for field in fields: name = rust_field(field.name) - self.emit(f"{name}: Foldable::fold({name}, folder)?,", depth + 1) + self.emit(f"{name},", depth + 1) self.emit("range,", depth + 1) - - self.emit(f"}}{footer})", depth) + self.emit(f"}})", depth) class FoldModuleVisitor(EmitVisitor): def visitModule(self, mod): depth = 0 - self.emit("use crate::fold_helpers::Foldable;", depth) FoldTraitDefVisitor(self.file, self.type_info).visit(mod, depth) FoldImplVisitor(self.file, self.type_info).visit(mod, depth) diff --git a/ast/src/fold_helpers.rs b/ast/src/fold.rs similarity index 91% rename from ast/src/fold_helpers.rs rename to ast/src/fold.rs index 4b54966..ccbcc7b 100644 --- a/ast/src/fold_helpers.rs +++ b/ast/src/fold.rs @@ -1,4 +1,6 @@ -use crate::{builtin, fold::Fold, ConversionFlag}; +use super::generic::*; + +use crate::{builtin, ConversionFlag}; pub trait Foldable { type Mapped; @@ -49,7 +51,7 @@ where macro_rules! simple_fold { ($($t:ty),+$(,)?) => { - $(impl $crate::fold_helpers::Foldable for $t { + $(impl $crate::fold::Foldable for $t { type Mapped = Self; #[inline] fn fold + ?Sized>( @@ -70,3 +72,5 @@ simple_fold!( ConversionFlag, builtin::Constant ); + +include!("gen/fold.rs"); diff --git a/ast/src/gen/fold.rs b/ast/src/gen/fold.rs index 6d4342d..3944f3f 100644 --- a/ast/src/gen/fold.rs +++ b/ast/src/gen/fold.rs @@ -1,19 +1,40 @@ // File automatically generated by ast/asdl_rs.py. -use crate::fold_helpers::Foldable; pub trait Fold { type TargetU; type Error; + type UserContext; - fn map_user(&mut self, user: U) -> Result; + fn will_map_user(&mut self, user: &U) -> Self::UserContext; #[cfg(feature = "all-nodes-with-ranges")] - fn map_user_cfg(&mut self, user: U) -> Result { - self.map_user(user) + fn will_map_user_cfg(&mut self, user: &U) -> Self::UserContext { + self.will_map_user(user) + } + #[cfg(not(feature = "all-nodes-with-ranges"))] + fn will_map_user_cfg( + &mut self, + user: &crate::EmptyRange, + ) -> crate::EmptyRange { + crate::EmptyRange::default() + } + fn map_user( + &mut self, + user: U, + context: Self::UserContext, + ) -> Result; + #[cfg(feature = "all-nodes-with-ranges")] + fn map_user_cfg( + &mut self, + user: U, + context: Self::UserContext, + ) -> Result { + self.map_user(user, context) } #[cfg(not(feature = "all-nodes-with-ranges"))] fn map_user_cfg( &mut self, _user: crate::EmptyRange, + _context: crate::EmptyRange, ) -> Result, Self::Error> { Ok(crate::EmptyRange::default()) } @@ -24,12 +45,348 @@ pub trait Fold { fn fold_mod(&mut self, node: Mod) -> Result, Self::Error> { fold_mod(self, node) } + fn fold_mod_module( + &mut self, + node: ModModule, + ) -> Result, Self::Error> { + fold_mod_module(self, node) + } + fn fold_mod_interactive( + &mut self, + node: ModInteractive, + ) -> Result, Self::Error> { + fold_mod_interactive(self, node) + } + fn fold_mod_expression( + &mut self, + node: ModExpression, + ) -> Result, Self::Error> { + fold_mod_expression(self, node) + } + fn fold_mod_function_type( + &mut self, + node: ModFunctionType, + ) -> Result, Self::Error> { + fold_mod_function_type(self, node) + } fn fold_stmt(&mut self, node: Stmt) -> Result, Self::Error> { fold_stmt(self, node) } + fn fold_stmt_function_def( + &mut self, + node: StmtFunctionDef, + ) -> Result, Self::Error> { + fold_stmt_function_def(self, node) + } + fn fold_stmt_async_function_def( + &mut self, + node: StmtAsyncFunctionDef, + ) -> Result, Self::Error> { + fold_stmt_async_function_def(self, node) + } + fn fold_stmt_class_def( + &mut self, + node: StmtClassDef, + ) -> Result, Self::Error> { + fold_stmt_class_def(self, node) + } + fn fold_stmt_return( + &mut self, + node: StmtReturn, + ) -> Result, Self::Error> { + fold_stmt_return(self, node) + } + fn fold_stmt_delete( + &mut self, + node: StmtDelete, + ) -> Result, Self::Error> { + fold_stmt_delete(self, node) + } + fn fold_stmt_assign( + &mut self, + node: StmtAssign, + ) -> Result, Self::Error> { + fold_stmt_assign(self, node) + } + fn fold_stmt_aug_assign( + &mut self, + node: StmtAugAssign, + ) -> Result, Self::Error> { + fold_stmt_aug_assign(self, node) + } + fn fold_stmt_ann_assign( + &mut self, + node: StmtAnnAssign, + ) -> Result, Self::Error> { + fold_stmt_ann_assign(self, node) + } + fn fold_stmt_for(&mut self, node: StmtFor) -> Result, Self::Error> { + fold_stmt_for(self, node) + } + fn fold_stmt_async_for( + &mut self, + node: StmtAsyncFor, + ) -> Result, Self::Error> { + fold_stmt_async_for(self, node) + } + fn fold_stmt_while( + &mut self, + node: StmtWhile, + ) -> Result, Self::Error> { + fold_stmt_while(self, node) + } + fn fold_stmt_if(&mut self, node: StmtIf) -> Result, Self::Error> { + fold_stmt_if(self, node) + } + fn fold_stmt_with( + &mut self, + node: StmtWith, + ) -> Result, Self::Error> { + fold_stmt_with(self, node) + } + fn fold_stmt_async_with( + &mut self, + node: StmtAsyncWith, + ) -> Result, Self::Error> { + fold_stmt_async_with(self, node) + } + fn fold_stmt_match( + &mut self, + node: StmtMatch, + ) -> Result, Self::Error> { + fold_stmt_match(self, node) + } + fn fold_stmt_raise( + &mut self, + node: StmtRaise, + ) -> Result, Self::Error> { + fold_stmt_raise(self, node) + } + fn fold_stmt_try(&mut self, node: StmtTry) -> Result, Self::Error> { + fold_stmt_try(self, node) + } + fn fold_stmt_try_star( + &mut self, + node: StmtTryStar, + ) -> Result, Self::Error> { + fold_stmt_try_star(self, node) + } + fn fold_stmt_assert( + &mut self, + node: StmtAssert, + ) -> Result, Self::Error> { + fold_stmt_assert(self, node) + } + fn fold_stmt_import( + &mut self, + node: StmtImport, + ) -> Result, Self::Error> { + fold_stmt_import(self, node) + } + fn fold_stmt_import_from( + &mut self, + node: StmtImportFrom, + ) -> Result, Self::Error> { + fold_stmt_import_from(self, node) + } + fn fold_stmt_global( + &mut self, + node: StmtGlobal, + ) -> Result, Self::Error> { + fold_stmt_global(self, node) + } + fn fold_stmt_nonlocal( + &mut self, + node: StmtNonlocal, + ) -> Result, Self::Error> { + fold_stmt_nonlocal(self, node) + } + fn fold_stmt_expr( + &mut self, + node: StmtExpr, + ) -> Result, Self::Error> { + fold_stmt_expr(self, node) + } + fn fold_stmt_pass( + &mut self, + node: StmtPass, + ) -> Result, Self::Error> { + fold_stmt_pass(self, node) + } + fn fold_stmt_break( + &mut self, + node: StmtBreak, + ) -> Result, Self::Error> { + fold_stmt_break(self, node) + } + fn fold_stmt_continue( + &mut self, + node: StmtContinue, + ) -> Result, Self::Error> { + fold_stmt_continue(self, node) + } fn fold_expr(&mut self, node: Expr) -> Result, Self::Error> { fold_expr(self, node) } + fn fold_expr_bool_op( + &mut self, + node: ExprBoolOp, + ) -> Result, Self::Error> { + fold_expr_bool_op(self, node) + } + fn fold_expr_named_expr( + &mut self, + node: ExprNamedExpr, + ) -> Result, Self::Error> { + fold_expr_named_expr(self, node) + } + fn fold_expr_bin_op( + &mut self, + node: ExprBinOp, + ) -> Result, Self::Error> { + fold_expr_bin_op(self, node) + } + fn fold_expr_unary_op( + &mut self, + node: ExprUnaryOp, + ) -> Result, Self::Error> { + fold_expr_unary_op(self, node) + } + fn fold_expr_lambda( + &mut self, + node: ExprLambda, + ) -> Result, Self::Error> { + fold_expr_lambda(self, node) + } + fn fold_expr_if_exp( + &mut self, + node: ExprIfExp, + ) -> Result, Self::Error> { + fold_expr_if_exp(self, node) + } + fn fold_expr_dict( + &mut self, + node: ExprDict, + ) -> Result, Self::Error> { + fold_expr_dict(self, node) + } + fn fold_expr_set(&mut self, node: ExprSet) -> Result, Self::Error> { + fold_expr_set(self, node) + } + fn fold_expr_list_comp( + &mut self, + node: ExprListComp, + ) -> Result, Self::Error> { + fold_expr_list_comp(self, node) + } + fn fold_expr_set_comp( + &mut self, + node: ExprSetComp, + ) -> Result, Self::Error> { + fold_expr_set_comp(self, node) + } + fn fold_expr_dict_comp( + &mut self, + node: ExprDictComp, + ) -> Result, Self::Error> { + fold_expr_dict_comp(self, node) + } + fn fold_expr_generator_exp( + &mut self, + node: ExprGeneratorExp, + ) -> Result, Self::Error> { + fold_expr_generator_exp(self, node) + } + fn fold_expr_await( + &mut self, + node: ExprAwait, + ) -> Result, Self::Error> { + fold_expr_await(self, node) + } + fn fold_expr_yield( + &mut self, + node: ExprYield, + ) -> Result, Self::Error> { + fold_expr_yield(self, node) + } + fn fold_expr_yield_from( + &mut self, + node: ExprYieldFrom, + ) -> Result, Self::Error> { + fold_expr_yield_from(self, node) + } + fn fold_expr_compare( + &mut self, + node: ExprCompare, + ) -> Result, Self::Error> { + fold_expr_compare(self, node) + } + fn fold_expr_call( + &mut self, + node: ExprCall, + ) -> Result, Self::Error> { + fold_expr_call(self, node) + } + fn fold_expr_formatted_value( + &mut self, + node: ExprFormattedValue, + ) -> Result, Self::Error> { + fold_expr_formatted_value(self, node) + } + fn fold_expr_joined_str( + &mut self, + node: ExprJoinedStr, + ) -> Result, Self::Error> { + fold_expr_joined_str(self, node) + } + fn fold_expr_constant( + &mut self, + node: ExprConstant, + ) -> Result, Self::Error> { + fold_expr_constant(self, node) + } + fn fold_expr_attribute( + &mut self, + node: ExprAttribute, + ) -> Result, Self::Error> { + fold_expr_attribute(self, node) + } + fn fold_expr_subscript( + &mut self, + node: ExprSubscript, + ) -> Result, Self::Error> { + fold_expr_subscript(self, node) + } + fn fold_expr_starred( + &mut self, + node: ExprStarred, + ) -> Result, Self::Error> { + fold_expr_starred(self, node) + } + fn fold_expr_name( + &mut self, + node: ExprName, + ) -> Result, Self::Error> { + fold_expr_name(self, node) + } + fn fold_expr_list( + &mut self, + node: ExprList, + ) -> Result, Self::Error> { + fold_expr_list(self, node) + } + fn fold_expr_tuple( + &mut self, + node: ExprTuple, + ) -> Result, Self::Error> { + fold_expr_tuple(self, node) + } + fn fold_expr_slice( + &mut self, + node: ExprSlice, + ) -> Result, Self::Error> { + fold_expr_slice(self, node) + } fn fold_expr_context(&mut self, node: ExprContext) -> Result { fold_expr_context(self, node) } @@ -57,6 +414,12 @@ pub trait Fold { ) -> Result, Self::Error> { fold_excepthandler(self, node) } + fn fold_excepthandler_except_handler( + &mut self, + node: ExcepthandlerExceptHandler, + ) -> Result, Self::Error> { + fold_excepthandler_except_handler(self, node) + } fn fold_arguments( &mut self, node: Arguments, @@ -84,12 +447,66 @@ pub trait Fold { fn fold_pattern(&mut self, node: Pattern) -> Result, Self::Error> { fold_pattern(self, node) } + fn fold_pattern_match_value( + &mut self, + node: PatternMatchValue, + ) -> Result, Self::Error> { + fold_pattern_match_value(self, node) + } + fn fold_pattern_match_singleton( + &mut self, + node: PatternMatchSingleton, + ) -> Result, Self::Error> { + fold_pattern_match_singleton(self, node) + } + fn fold_pattern_match_sequence( + &mut self, + node: PatternMatchSequence, + ) -> Result, Self::Error> { + fold_pattern_match_sequence(self, node) + } + fn fold_pattern_match_mapping( + &mut self, + node: PatternMatchMapping, + ) -> Result, Self::Error> { + fold_pattern_match_mapping(self, node) + } + fn fold_pattern_match_class( + &mut self, + node: PatternMatchClass, + ) -> Result, Self::Error> { + fold_pattern_match_class(self, node) + } + fn fold_pattern_match_star( + &mut self, + node: PatternMatchStar, + ) -> Result, Self::Error> { + fold_pattern_match_star(self, node) + } + fn fold_pattern_match_as( + &mut self, + node: PatternMatchAs, + ) -> Result, Self::Error> { + fold_pattern_match_as(self, node) + } + fn fold_pattern_match_or( + &mut self, + node: PatternMatchOr, + ) -> Result, Self::Error> { + fold_pattern_match_or(self, node) + } fn fold_type_ignore( &mut self, node: TypeIgnore, ) -> Result, Self::Error> { fold_type_ignore(self, node) } + fn fold_type_ignore_type_ignore( + &mut self, + node: TypeIgnoreTypeIgnore, + ) -> Result, Self::Error> { + fold_type_ignore_type_ignore(self, node) + } } impl Foldable for Mod { type Mapped = Mod; @@ -104,47 +521,112 @@ pub fn fold_mod + ?Sized>( #[allow(unused)] folder: &mut F, node: Mod, ) -> Result, F::Error> { - match node { - Mod::Module(ModModule { - body, - type_ignores, - range, - }) => { - let range = folder.map_user_cfg(range)?; - Ok(Mod::Module(ModModule { - body: Foldable::fold(body, folder)?, - type_ignores: Foldable::fold(type_ignores, folder)?, - range, - })) - } - Mod::Interactive(ModInteractive { body, range }) => { - let range = folder.map_user_cfg(range)?; - Ok(Mod::Interactive(ModInteractive { - body: Foldable::fold(body, folder)?, - range, - })) - } - Mod::Expression(ModExpression { body, range }) => { - let range = folder.map_user_cfg(range)?; - Ok(Mod::Expression(ModExpression { - body: Foldable::fold(body, folder)?, - range, - })) - } - Mod::FunctionType(ModFunctionType { - argtypes, - returns, - range, - }) => { - let range = folder.map_user_cfg(range)?; - Ok(Mod::FunctionType(ModFunctionType { - argtypes: Foldable::fold(argtypes, folder)?, - returns: Foldable::fold(returns, folder)?, - range, - })) - } + let folded = match node { + Mod::Module(cons) => Mod::Module(Foldable::fold(cons, folder)?), + Mod::Interactive(cons) => Mod::Interactive(Foldable::fold(cons, folder)?), + Mod::Expression(cons) => Mod::Expression(Foldable::fold(cons, folder)?), + Mod::FunctionType(cons) => Mod::FunctionType(Foldable::fold(cons, folder)?), + }; + Ok(folded) +} +impl Foldable for ModModule { + type Mapped = ModModule; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_mod_module(self) } } +pub fn fold_mod_module + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ModModule, +) -> Result, F::Error> { + let ModModule { + body, + type_ignores, + range, + } = node; + let context = folder.will_map_user_cfg(&range); + + let body = Foldable::fold(body, folder)?; + let type_ignores = Foldable::fold(type_ignores, folder)?; + let range = folder.map_user_cfg(range, context)?; + Ok(ModModule { + body, + type_ignores, + range, + }) +} +impl Foldable for ModInteractive { + type Mapped = ModInteractive; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_mod_interactive(self) + } +} +pub fn fold_mod_interactive + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ModInteractive, +) -> Result, F::Error> { + let ModInteractive { body, range } = node; + let context = folder.will_map_user_cfg(&range); + + let body = Foldable::fold(body, folder)?; + let range = folder.map_user_cfg(range, context)?; + Ok(ModInteractive { body, range }) +} +impl Foldable for ModExpression { + type Mapped = ModExpression; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_mod_expression(self) + } +} +pub fn fold_mod_expression + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ModExpression, +) -> Result, F::Error> { + let ModExpression { body, range } = node; + let context = folder.will_map_user_cfg(&range); + + let body = Foldable::fold(body, folder)?; + let range = folder.map_user_cfg(range, context)?; + Ok(ModExpression { body, range }) +} +impl Foldable for ModFunctionType { + type Mapped = ModFunctionType; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_mod_function_type(self) + } +} +pub fn fold_mod_function_type + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ModFunctionType, +) -> Result, F::Error> { + let ModFunctionType { + argtypes, + returns, + range, + } = node; + let context = folder.will_map_user_cfg(&range); + + let argtypes = Foldable::fold(argtypes, folder)?; + let returns = Foldable::fold(returns, folder)?; + let range = folder.map_user_cfg(range, context)?; + Ok(ModFunctionType { + argtypes, + returns, + range, + }) +} impl Foldable for Stmt { type Mapped = Stmt; fn fold + ?Sized>( @@ -158,331 +640,810 @@ pub fn fold_stmt + ?Sized>( #[allow(unused)] folder: &mut F, node: Stmt, ) -> Result, F::Error> { - match node { - Stmt::FunctionDef(StmtFunctionDef { - name, - args, - body, - decorator_list, - returns, - type_comment, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::FunctionDef(StmtFunctionDef { - name: Foldable::fold(name, folder)?, - args: Foldable::fold(args, folder)?, - body: Foldable::fold(body, folder)?, - decorator_list: Foldable::fold(decorator_list, folder)?, - returns: Foldable::fold(returns, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - range, - })) - } - Stmt::AsyncFunctionDef(StmtAsyncFunctionDef { - name, - args, - body, - decorator_list, - returns, - type_comment, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::AsyncFunctionDef(StmtAsyncFunctionDef { - name: Foldable::fold(name, folder)?, - args: Foldable::fold(args, folder)?, - body: Foldable::fold(body, folder)?, - decorator_list: Foldable::fold(decorator_list, folder)?, - returns: Foldable::fold(returns, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - range, - })) - } - Stmt::ClassDef(StmtClassDef { - name, - bases, - keywords, - body, - decorator_list, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::ClassDef(StmtClassDef { - name: Foldable::fold(name, folder)?, - bases: Foldable::fold(bases, folder)?, - keywords: Foldable::fold(keywords, folder)?, - body: Foldable::fold(body, folder)?, - decorator_list: Foldable::fold(decorator_list, folder)?, - range, - })) - } - Stmt::Return(StmtReturn { value, range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Return(StmtReturn { - value: Foldable::fold(value, folder)?, - range, - })) - } - Stmt::Delete(StmtDelete { targets, range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Delete(StmtDelete { - targets: Foldable::fold(targets, folder)?, - range, - })) - } - Stmt::Assign(StmtAssign { - targets, - value, - type_comment, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Assign(StmtAssign { - targets: Foldable::fold(targets, folder)?, - value: Foldable::fold(value, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - range, - })) - } - Stmt::AugAssign(StmtAugAssign { - target, - op, - value, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::AugAssign(StmtAugAssign { - target: Foldable::fold(target, folder)?, - op: Foldable::fold(op, folder)?, - value: Foldable::fold(value, folder)?, - range, - })) - } - Stmt::AnnAssign(StmtAnnAssign { - target, - annotation, - value, - simple, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::AnnAssign(StmtAnnAssign { - target: Foldable::fold(target, folder)?, - annotation: Foldable::fold(annotation, folder)?, - value: Foldable::fold(value, folder)?, - simple: Foldable::fold(simple, folder)?, - range, - })) - } - Stmt::For(StmtFor { - target, - iter, - body, - orelse, - type_comment, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::For(StmtFor { - target: Foldable::fold(target, folder)?, - iter: Foldable::fold(iter, folder)?, - body: Foldable::fold(body, folder)?, - orelse: Foldable::fold(orelse, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - range, - })) - } - Stmt::AsyncFor(StmtAsyncFor { - target, - iter, - body, - orelse, - type_comment, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::AsyncFor(StmtAsyncFor { - target: Foldable::fold(target, folder)?, - iter: Foldable::fold(iter, folder)?, - body: Foldable::fold(body, folder)?, - orelse: Foldable::fold(orelse, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - range, - })) - } - Stmt::While(StmtWhile { - test, - body, - orelse, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::While(StmtWhile { - test: Foldable::fold(test, folder)?, - body: Foldable::fold(body, folder)?, - orelse: Foldable::fold(orelse, folder)?, - range, - })) - } - Stmt::If(StmtIf { - test, - body, - orelse, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::If(StmtIf { - test: Foldable::fold(test, folder)?, - body: Foldable::fold(body, folder)?, - orelse: Foldable::fold(orelse, folder)?, - range, - })) - } - Stmt::With(StmtWith { - items, - body, - type_comment, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::With(StmtWith { - items: Foldable::fold(items, folder)?, - body: Foldable::fold(body, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - range, - })) - } - Stmt::AsyncWith(StmtAsyncWith { - items, - body, - type_comment, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::AsyncWith(StmtAsyncWith { - items: Foldable::fold(items, folder)?, - body: Foldable::fold(body, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - range, - })) - } - Stmt::Match(StmtMatch { - subject, - cases, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Match(StmtMatch { - subject: Foldable::fold(subject, folder)?, - cases: Foldable::fold(cases, folder)?, - range, - })) - } - Stmt::Raise(StmtRaise { exc, cause, range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Raise(StmtRaise { - exc: Foldable::fold(exc, folder)?, - cause: Foldable::fold(cause, folder)?, - range, - })) - } - Stmt::Try(StmtTry { - body, - handlers, - orelse, - finalbody, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Try(StmtTry { - body: Foldable::fold(body, folder)?, - handlers: Foldable::fold(handlers, folder)?, - orelse: Foldable::fold(orelse, folder)?, - finalbody: Foldable::fold(finalbody, folder)?, - range, - })) - } - Stmt::TryStar(StmtTryStar { - body, - handlers, - orelse, - finalbody, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::TryStar(StmtTryStar { - body: Foldable::fold(body, folder)?, - handlers: Foldable::fold(handlers, folder)?, - orelse: Foldable::fold(orelse, folder)?, - finalbody: Foldable::fold(finalbody, folder)?, - range, - })) - } - Stmt::Assert(StmtAssert { test, msg, range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Assert(StmtAssert { - test: Foldable::fold(test, folder)?, - msg: Foldable::fold(msg, folder)?, - range, - })) - } - Stmt::Import(StmtImport { names, range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Import(StmtImport { - names: Foldable::fold(names, folder)?, - range, - })) - } - Stmt::ImportFrom(StmtImportFrom { - module, - names, - level, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Stmt::ImportFrom(StmtImportFrom { - module: Foldable::fold(module, folder)?, - names: Foldable::fold(names, folder)?, - level: Foldable::fold(level, folder)?, - range, - })) - } - Stmt::Global(StmtGlobal { names, range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Global(StmtGlobal { - names: Foldable::fold(names, folder)?, - range, - })) - } - Stmt::Nonlocal(StmtNonlocal { names, range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Nonlocal(StmtNonlocal { - names: Foldable::fold(names, folder)?, - range, - })) - } - Stmt::Expr(StmtExpr { value, range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Expr(StmtExpr { - value: Foldable::fold(value, folder)?, - range, - })) - } - Stmt::Pass(StmtPass { range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Pass(StmtPass { range })) - } - Stmt::Break(StmtBreak { range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Break(StmtBreak { range })) - } - Stmt::Continue(StmtContinue { range }) => { - let range = folder.map_user(range)?; - Ok(Stmt::Continue(StmtContinue { range })) - } + let folded = match node { + Stmt::FunctionDef(cons) => Stmt::FunctionDef(Foldable::fold(cons, folder)?), + Stmt::AsyncFunctionDef(cons) => Stmt::AsyncFunctionDef(Foldable::fold(cons, folder)?), + Stmt::ClassDef(cons) => Stmt::ClassDef(Foldable::fold(cons, folder)?), + Stmt::Return(cons) => Stmt::Return(Foldable::fold(cons, folder)?), + Stmt::Delete(cons) => Stmt::Delete(Foldable::fold(cons, folder)?), + Stmt::Assign(cons) => Stmt::Assign(Foldable::fold(cons, folder)?), + Stmt::AugAssign(cons) => Stmt::AugAssign(Foldable::fold(cons, folder)?), + Stmt::AnnAssign(cons) => Stmt::AnnAssign(Foldable::fold(cons, folder)?), + Stmt::For(cons) => Stmt::For(Foldable::fold(cons, folder)?), + Stmt::AsyncFor(cons) => Stmt::AsyncFor(Foldable::fold(cons, folder)?), + Stmt::While(cons) => Stmt::While(Foldable::fold(cons, folder)?), + Stmt::If(cons) => Stmt::If(Foldable::fold(cons, folder)?), + Stmt::With(cons) => Stmt::With(Foldable::fold(cons, folder)?), + Stmt::AsyncWith(cons) => Stmt::AsyncWith(Foldable::fold(cons, folder)?), + Stmt::Match(cons) => Stmt::Match(Foldable::fold(cons, folder)?), + Stmt::Raise(cons) => Stmt::Raise(Foldable::fold(cons, folder)?), + Stmt::Try(cons) => Stmt::Try(Foldable::fold(cons, folder)?), + Stmt::TryStar(cons) => Stmt::TryStar(Foldable::fold(cons, folder)?), + Stmt::Assert(cons) => Stmt::Assert(Foldable::fold(cons, folder)?), + Stmt::Import(cons) => Stmt::Import(Foldable::fold(cons, folder)?), + Stmt::ImportFrom(cons) => Stmt::ImportFrom(Foldable::fold(cons, folder)?), + Stmt::Global(cons) => Stmt::Global(Foldable::fold(cons, folder)?), + Stmt::Nonlocal(cons) => Stmt::Nonlocal(Foldable::fold(cons, folder)?), + Stmt::Expr(cons) => Stmt::Expr(Foldable::fold(cons, folder)?), + Stmt::Pass(cons) => Stmt::Pass(Foldable::fold(cons, folder)?), + Stmt::Break(cons) => Stmt::Break(Foldable::fold(cons, folder)?), + Stmt::Continue(cons) => Stmt::Continue(Foldable::fold(cons, folder)?), + }; + Ok(folded) +} +impl Foldable for StmtFunctionDef { + type Mapped = StmtFunctionDef; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_function_def(self) } } +pub fn fold_stmt_function_def + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtFunctionDef, +) -> Result, F::Error> { + let StmtFunctionDef { + name, + args, + body, + decorator_list, + returns, + type_comment, + range, + } = node; + let context = folder.will_map_user(&range); + + let name = Foldable::fold(name, folder)?; + let args = Foldable::fold(args, folder)?; + let body = Foldable::fold(body, folder)?; + let decorator_list = Foldable::fold(decorator_list, folder)?; + let returns = Foldable::fold(returns, folder)?; + let type_comment = Foldable::fold(type_comment, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtFunctionDef { + name, + args, + body, + decorator_list, + returns, + type_comment, + range, + }) +} +impl Foldable for StmtAsyncFunctionDef { + type Mapped = StmtAsyncFunctionDef; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_async_function_def(self) + } +} +pub fn fold_stmt_async_function_def + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtAsyncFunctionDef, +) -> Result, F::Error> { + let StmtAsyncFunctionDef { + name, + args, + body, + decorator_list, + returns, + type_comment, + range, + } = node; + let context = folder.will_map_user(&range); + + let name = Foldable::fold(name, folder)?; + let args = Foldable::fold(args, folder)?; + let body = Foldable::fold(body, folder)?; + let decorator_list = Foldable::fold(decorator_list, folder)?; + let returns = Foldable::fold(returns, folder)?; + let type_comment = Foldable::fold(type_comment, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtAsyncFunctionDef { + name, + args, + body, + decorator_list, + returns, + type_comment, + range, + }) +} +impl Foldable for StmtClassDef { + type Mapped = StmtClassDef; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_class_def(self) + } +} +pub fn fold_stmt_class_def + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtClassDef, +) -> Result, F::Error> { + let StmtClassDef { + name, + bases, + keywords, + body, + decorator_list, + range, + } = node; + let context = folder.will_map_user(&range); + + let name = Foldable::fold(name, folder)?; + let bases = Foldable::fold(bases, folder)?; + let keywords = Foldable::fold(keywords, folder)?; + let body = Foldable::fold(body, folder)?; + let decorator_list = Foldable::fold(decorator_list, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtClassDef { + name, + bases, + keywords, + body, + decorator_list, + range, + }) +} +impl Foldable for StmtReturn { + type Mapped = StmtReturn; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_return(self) + } +} +pub fn fold_stmt_return + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtReturn, +) -> Result, F::Error> { + let StmtReturn { value, range } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtReturn { value, range }) +} +impl Foldable for StmtDelete { + type Mapped = StmtDelete; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_delete(self) + } +} +pub fn fold_stmt_delete + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtDelete, +) -> Result, F::Error> { + let StmtDelete { targets, range } = node; + let context = folder.will_map_user(&range); + + let targets = Foldable::fold(targets, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtDelete { targets, range }) +} +impl Foldable for StmtAssign { + type Mapped = StmtAssign; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_assign(self) + } +} +pub fn fold_stmt_assign + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtAssign, +) -> Result, F::Error> { + let StmtAssign { + targets, + value, + type_comment, + range, + } = node; + let context = folder.will_map_user(&range); + + let targets = Foldable::fold(targets, folder)?; + let value = Foldable::fold(value, folder)?; + let type_comment = Foldable::fold(type_comment, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtAssign { + targets, + value, + type_comment, + range, + }) +} +impl Foldable for StmtAugAssign { + type Mapped = StmtAugAssign; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_aug_assign(self) + } +} +pub fn fold_stmt_aug_assign + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtAugAssign, +) -> Result, F::Error> { + let StmtAugAssign { + target, + op, + value, + range, + } = node; + let context = folder.will_map_user(&range); + + let target = Foldable::fold(target, folder)?; + let op = Foldable::fold(op, folder)?; + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtAugAssign { + target, + op, + value, + range, + }) +} +impl Foldable for StmtAnnAssign { + type Mapped = StmtAnnAssign; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_ann_assign(self) + } +} +pub fn fold_stmt_ann_assign + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtAnnAssign, +) -> Result, F::Error> { + let StmtAnnAssign { + target, + annotation, + value, + simple, + range, + } = node; + let context = folder.will_map_user(&range); + + let target = Foldable::fold(target, folder)?; + let annotation = Foldable::fold(annotation, folder)?; + let value = Foldable::fold(value, folder)?; + let simple = Foldable::fold(simple, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtAnnAssign { + target, + annotation, + value, + simple, + range, + }) +} +impl Foldable for StmtFor { + type Mapped = StmtFor; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_for(self) + } +} +pub fn fold_stmt_for + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtFor, +) -> Result, F::Error> { + let StmtFor { + target, + iter, + body, + orelse, + type_comment, + range, + } = node; + let context = folder.will_map_user(&range); + + let target = Foldable::fold(target, folder)?; + let iter = Foldable::fold(iter, folder)?; + let body = Foldable::fold(body, folder)?; + let orelse = Foldable::fold(orelse, folder)?; + let type_comment = Foldable::fold(type_comment, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtFor { + target, + iter, + body, + orelse, + type_comment, + range, + }) +} +impl Foldable for StmtAsyncFor { + type Mapped = StmtAsyncFor; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_async_for(self) + } +} +pub fn fold_stmt_async_for + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtAsyncFor, +) -> Result, F::Error> { + let StmtAsyncFor { + target, + iter, + body, + orelse, + type_comment, + range, + } = node; + let context = folder.will_map_user(&range); + + let target = Foldable::fold(target, folder)?; + let iter = Foldable::fold(iter, folder)?; + let body = Foldable::fold(body, folder)?; + let orelse = Foldable::fold(orelse, folder)?; + let type_comment = Foldable::fold(type_comment, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtAsyncFor { + target, + iter, + body, + orelse, + type_comment, + range, + }) +} +impl Foldable for StmtWhile { + type Mapped = StmtWhile; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_while(self) + } +} +pub fn fold_stmt_while + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtWhile, +) -> Result, F::Error> { + let StmtWhile { + test, + body, + orelse, + range, + } = node; + let context = folder.will_map_user(&range); + + let test = Foldable::fold(test, folder)?; + let body = Foldable::fold(body, folder)?; + let orelse = Foldable::fold(orelse, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtWhile { + test, + body, + orelse, + range, + }) +} +impl Foldable for StmtIf { + type Mapped = StmtIf; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_if(self) + } +} +pub fn fold_stmt_if + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtIf, +) -> Result, F::Error> { + let StmtIf { + test, + body, + orelse, + range, + } = node; + let context = folder.will_map_user(&range); + + let test = Foldable::fold(test, folder)?; + let body = Foldable::fold(body, folder)?; + let orelse = Foldable::fold(orelse, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtIf { + test, + body, + orelse, + range, + }) +} +impl Foldable for StmtWith { + type Mapped = StmtWith; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_with(self) + } +} +pub fn fold_stmt_with + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtWith, +) -> Result, F::Error> { + let StmtWith { + items, + body, + type_comment, + range, + } = node; + let context = folder.will_map_user(&range); + + let items = Foldable::fold(items, folder)?; + let body = Foldable::fold(body, folder)?; + let type_comment = Foldable::fold(type_comment, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtWith { + items, + body, + type_comment, + range, + }) +} +impl Foldable for StmtAsyncWith { + type Mapped = StmtAsyncWith; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_async_with(self) + } +} +pub fn fold_stmt_async_with + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtAsyncWith, +) -> Result, F::Error> { + let StmtAsyncWith { + items, + body, + type_comment, + range, + } = node; + let context = folder.will_map_user(&range); + + let items = Foldable::fold(items, folder)?; + let body = Foldable::fold(body, folder)?; + let type_comment = Foldable::fold(type_comment, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtAsyncWith { + items, + body, + type_comment, + range, + }) +} +impl Foldable for StmtMatch { + type Mapped = StmtMatch; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_match(self) + } +} +pub fn fold_stmt_match + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtMatch, +) -> Result, F::Error> { + let StmtMatch { + subject, + cases, + range, + } = node; + let context = folder.will_map_user(&range); + + let subject = Foldable::fold(subject, folder)?; + let cases = Foldable::fold(cases, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtMatch { + subject, + cases, + range, + }) +} +impl Foldable for StmtRaise { + type Mapped = StmtRaise; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_raise(self) + } +} +pub fn fold_stmt_raise + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtRaise, +) -> Result, F::Error> { + let StmtRaise { exc, cause, range } = node; + let context = folder.will_map_user(&range); + + let exc = Foldable::fold(exc, folder)?; + let cause = Foldable::fold(cause, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtRaise { exc, cause, range }) +} +impl Foldable for StmtTry { + type Mapped = StmtTry; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_try(self) + } +} +pub fn fold_stmt_try + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtTry, +) -> Result, F::Error> { + let StmtTry { + body, + handlers, + orelse, + finalbody, + range, + } = node; + let context = folder.will_map_user(&range); + + let body = Foldable::fold(body, folder)?; + let handlers = Foldable::fold(handlers, folder)?; + let orelse = Foldable::fold(orelse, folder)?; + let finalbody = Foldable::fold(finalbody, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtTry { + body, + handlers, + orelse, + finalbody, + range, + }) +} +impl Foldable for StmtTryStar { + type Mapped = StmtTryStar; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_try_star(self) + } +} +pub fn fold_stmt_try_star + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtTryStar, +) -> Result, F::Error> { + let StmtTryStar { + body, + handlers, + orelse, + finalbody, + range, + } = node; + let context = folder.will_map_user(&range); + + let body = Foldable::fold(body, folder)?; + let handlers = Foldable::fold(handlers, folder)?; + let orelse = Foldable::fold(orelse, folder)?; + let finalbody = Foldable::fold(finalbody, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtTryStar { + body, + handlers, + orelse, + finalbody, + range, + }) +} +impl Foldable for StmtAssert { + type Mapped = StmtAssert; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_assert(self) + } +} +pub fn fold_stmt_assert + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtAssert, +) -> Result, F::Error> { + let StmtAssert { test, msg, range } = node; + let context = folder.will_map_user(&range); + + let test = Foldable::fold(test, folder)?; + let msg = Foldable::fold(msg, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtAssert { test, msg, range }) +} +impl Foldable for StmtImport { + type Mapped = StmtImport; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_import(self) + } +} +pub fn fold_stmt_import + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtImport, +) -> Result, F::Error> { + let StmtImport { names, range } = node; + let context = folder.will_map_user(&range); + + let names = Foldable::fold(names, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtImport { names, range }) +} +impl Foldable for StmtImportFrom { + type Mapped = StmtImportFrom; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_import_from(self) + } +} +pub fn fold_stmt_import_from + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtImportFrom, +) -> Result, F::Error> { + let StmtImportFrom { + module, + names, + level, + range, + } = node; + let context = folder.will_map_user(&range); + + let module = Foldable::fold(module, folder)?; + let names = Foldable::fold(names, folder)?; + let level = Foldable::fold(level, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtImportFrom { + module, + names, + level, + range, + }) +} +impl Foldable for StmtGlobal { + type Mapped = StmtGlobal; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_global(self) + } +} +pub fn fold_stmt_global + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtGlobal, +) -> Result, F::Error> { + let StmtGlobal { names, range } = node; + let context = folder.will_map_user(&range); + + let names = Foldable::fold(names, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtGlobal { names, range }) +} +impl Foldable for StmtNonlocal { + type Mapped = StmtNonlocal; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_nonlocal(self) + } +} +pub fn fold_stmt_nonlocal + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtNonlocal, +) -> Result, F::Error> { + let StmtNonlocal { names, range } = node; + let context = folder.will_map_user(&range); + + let names = Foldable::fold(names, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtNonlocal { names, range }) +} +impl Foldable for StmtExpr { + type Mapped = StmtExpr; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_expr(self) + } +} +pub fn fold_stmt_expr + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtExpr, +) -> Result, F::Error> { + let StmtExpr { value, range } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(StmtExpr { value, range }) +} +impl Foldable for StmtPass { + type Mapped = StmtPass; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_pass(self) + } +} +pub fn fold_stmt_pass + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtPass, +) -> Result, F::Error> { + let StmtPass { range } = node; + let context = folder.will_map_user(&range); + + let range = folder.map_user(range, context)?; + Ok(StmtPass { range }) +} +impl Foldable for StmtBreak { + type Mapped = StmtBreak; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_break(self) + } +} +pub fn fold_stmt_break + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtBreak, +) -> Result, F::Error> { + let StmtBreak { range } = node; + let context = folder.will_map_user(&range); + + let range = folder.map_user(range, context)?; + Ok(StmtBreak { range }) +} +impl Foldable for StmtContinue { + type Mapped = StmtContinue; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt_continue(self) + } +} +pub fn fold_stmt_continue + ?Sized>( + #[allow(unused)] folder: &mut F, + node: StmtContinue, +) -> Result, F::Error> { + let StmtContinue { range } = node; + let context = folder.will_map_user(&range); + + let range = folder.map_user(range, context)?; + Ok(StmtContinue { range }) +} impl Foldable for Expr { type Mapped = Expr; fn fold + ?Sized>( @@ -496,294 +1457,738 @@ pub fn fold_expr + ?Sized>( #[allow(unused)] folder: &mut F, node: Expr, ) -> Result, F::Error> { - match node { - Expr::BoolOp(ExprBoolOp { op, values, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::BoolOp(ExprBoolOp { - op: Foldable::fold(op, folder)?, - values: Foldable::fold(values, folder)?, - range, - })) - } - Expr::NamedExpr(ExprNamedExpr { - target, - value, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::NamedExpr(ExprNamedExpr { - target: Foldable::fold(target, folder)?, - value: Foldable::fold(value, folder)?, - range, - })) - } - Expr::BinOp(ExprBinOp { - left, - op, - right, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::BinOp(ExprBinOp { - left: Foldable::fold(left, folder)?, - op: Foldable::fold(op, folder)?, - right: Foldable::fold(right, folder)?, - range, - })) - } - Expr::UnaryOp(ExprUnaryOp { op, operand, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::UnaryOp(ExprUnaryOp { - op: Foldable::fold(op, folder)?, - operand: Foldable::fold(operand, folder)?, - range, - })) - } - Expr::Lambda(ExprLambda { args, body, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::Lambda(ExprLambda { - args: Foldable::fold(args, folder)?, - body: Foldable::fold(body, folder)?, - range, - })) - } - Expr::IfExp(ExprIfExp { - test, - body, - orelse, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::IfExp(ExprIfExp { - test: Foldable::fold(test, folder)?, - body: Foldable::fold(body, folder)?, - orelse: Foldable::fold(orelse, folder)?, - range, - })) - } - Expr::Dict(ExprDict { - keys, - values, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::Dict(ExprDict { - keys: Foldable::fold(keys, folder)?, - values: Foldable::fold(values, folder)?, - range, - })) - } - Expr::Set(ExprSet { elts, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::Set(ExprSet { - elts: Foldable::fold(elts, folder)?, - range, - })) - } - Expr::ListComp(ExprListComp { - elt, - generators, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::ListComp(ExprListComp { - elt: Foldable::fold(elt, folder)?, - generators: Foldable::fold(generators, folder)?, - range, - })) - } - Expr::SetComp(ExprSetComp { - elt, - generators, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::SetComp(ExprSetComp { - elt: Foldable::fold(elt, folder)?, - generators: Foldable::fold(generators, folder)?, - range, - })) - } - Expr::DictComp(ExprDictComp { - key, - value, - generators, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::DictComp(ExprDictComp { - key: Foldable::fold(key, folder)?, - value: Foldable::fold(value, folder)?, - generators: Foldable::fold(generators, folder)?, - range, - })) - } - Expr::GeneratorExp(ExprGeneratorExp { - elt, - generators, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::GeneratorExp(ExprGeneratorExp { - elt: Foldable::fold(elt, folder)?, - generators: Foldable::fold(generators, folder)?, - range, - })) - } - Expr::Await(ExprAwait { value, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::Await(ExprAwait { - value: Foldable::fold(value, folder)?, - range, - })) - } - Expr::Yield(ExprYield { value, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::Yield(ExprYield { - value: Foldable::fold(value, folder)?, - range, - })) - } - Expr::YieldFrom(ExprYieldFrom { value, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::YieldFrom(ExprYieldFrom { - value: Foldable::fold(value, folder)?, - range, - })) - } - Expr::Compare(ExprCompare { - left, - ops, - comparators, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::Compare(ExprCompare { - left: Foldable::fold(left, folder)?, - ops: Foldable::fold(ops, folder)?, - comparators: Foldable::fold(comparators, folder)?, - range, - })) - } - Expr::Call(ExprCall { - func, - args, - keywords, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::Call(ExprCall { - func: Foldable::fold(func, folder)?, - args: Foldable::fold(args, folder)?, - keywords: Foldable::fold(keywords, folder)?, - range, - })) - } - Expr::FormattedValue(ExprFormattedValue { - value, - conversion, - format_spec, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::FormattedValue(ExprFormattedValue { - value: Foldable::fold(value, folder)?, - conversion: Foldable::fold(conversion, folder)?, - format_spec: Foldable::fold(format_spec, folder)?, - range, - })) - } - Expr::JoinedStr(ExprJoinedStr { values, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::JoinedStr(ExprJoinedStr { - values: Foldable::fold(values, folder)?, - range, - })) - } - Expr::Constant(ExprConstant { value, kind, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::Constant(ExprConstant { - value: Foldable::fold(value, folder)?, - kind: Foldable::fold(kind, folder)?, - range, - })) - } - Expr::Attribute(ExprAttribute { - value, - attr, - ctx, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::Attribute(ExprAttribute { - value: Foldable::fold(value, folder)?, - attr: Foldable::fold(attr, folder)?, - ctx: Foldable::fold(ctx, folder)?, - range, - })) - } - Expr::Subscript(ExprSubscript { - value, - slice, - ctx, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::Subscript(ExprSubscript { - value: Foldable::fold(value, folder)?, - slice: Foldable::fold(slice, folder)?, - ctx: Foldable::fold(ctx, folder)?, - range, - })) - } - Expr::Starred(ExprStarred { value, ctx, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::Starred(ExprStarred { - value: Foldable::fold(value, folder)?, - ctx: Foldable::fold(ctx, folder)?, - range, - })) - } - Expr::Name(ExprName { id, ctx, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::Name(ExprName { - id: Foldable::fold(id, folder)?, - ctx: Foldable::fold(ctx, folder)?, - range, - })) - } - Expr::List(ExprList { elts, ctx, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::List(ExprList { - elts: Foldable::fold(elts, folder)?, - ctx: Foldable::fold(ctx, folder)?, - range, - })) - } - Expr::Tuple(ExprTuple { elts, ctx, range }) => { - let range = folder.map_user(range)?; - Ok(Expr::Tuple(ExprTuple { - elts: Foldable::fold(elts, folder)?, - ctx: Foldable::fold(ctx, folder)?, - range, - })) - } - Expr::Slice(ExprSlice { - lower, - upper, - step, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Expr::Slice(ExprSlice { - lower: Foldable::fold(lower, folder)?, - upper: Foldable::fold(upper, folder)?, - step: Foldable::fold(step, folder)?, - range, - })) - } + let folded = match node { + Expr::BoolOp(cons) => Expr::BoolOp(Foldable::fold(cons, folder)?), + Expr::NamedExpr(cons) => Expr::NamedExpr(Foldable::fold(cons, folder)?), + Expr::BinOp(cons) => Expr::BinOp(Foldable::fold(cons, folder)?), + Expr::UnaryOp(cons) => Expr::UnaryOp(Foldable::fold(cons, folder)?), + Expr::Lambda(cons) => Expr::Lambda(Foldable::fold(cons, folder)?), + Expr::IfExp(cons) => Expr::IfExp(Foldable::fold(cons, folder)?), + Expr::Dict(cons) => Expr::Dict(Foldable::fold(cons, folder)?), + Expr::Set(cons) => Expr::Set(Foldable::fold(cons, folder)?), + Expr::ListComp(cons) => Expr::ListComp(Foldable::fold(cons, folder)?), + Expr::SetComp(cons) => Expr::SetComp(Foldable::fold(cons, folder)?), + Expr::DictComp(cons) => Expr::DictComp(Foldable::fold(cons, folder)?), + Expr::GeneratorExp(cons) => Expr::GeneratorExp(Foldable::fold(cons, folder)?), + Expr::Await(cons) => Expr::Await(Foldable::fold(cons, folder)?), + Expr::Yield(cons) => Expr::Yield(Foldable::fold(cons, folder)?), + Expr::YieldFrom(cons) => Expr::YieldFrom(Foldable::fold(cons, folder)?), + Expr::Compare(cons) => Expr::Compare(Foldable::fold(cons, folder)?), + Expr::Call(cons) => Expr::Call(Foldable::fold(cons, folder)?), + Expr::FormattedValue(cons) => Expr::FormattedValue(Foldable::fold(cons, folder)?), + Expr::JoinedStr(cons) => Expr::JoinedStr(Foldable::fold(cons, folder)?), + Expr::Constant(cons) => Expr::Constant(Foldable::fold(cons, folder)?), + Expr::Attribute(cons) => Expr::Attribute(Foldable::fold(cons, folder)?), + Expr::Subscript(cons) => Expr::Subscript(Foldable::fold(cons, folder)?), + Expr::Starred(cons) => Expr::Starred(Foldable::fold(cons, folder)?), + Expr::Name(cons) => Expr::Name(Foldable::fold(cons, folder)?), + Expr::List(cons) => Expr::List(Foldable::fold(cons, folder)?), + Expr::Tuple(cons) => Expr::Tuple(Foldable::fold(cons, folder)?), + Expr::Slice(cons) => Expr::Slice(Foldable::fold(cons, folder)?), + }; + Ok(folded) +} +impl Foldable for ExprBoolOp { + type Mapped = ExprBoolOp; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_bool_op(self) } } +pub fn fold_expr_bool_op + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprBoolOp, +) -> Result, F::Error> { + let ExprBoolOp { op, values, range } = node; + let context = folder.will_map_user(&range); + + let op = Foldable::fold(op, folder)?; + let values = Foldable::fold(values, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprBoolOp { op, values, range }) +} +impl Foldable for ExprNamedExpr { + type Mapped = ExprNamedExpr; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_named_expr(self) + } +} +pub fn fold_expr_named_expr + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprNamedExpr, +) -> Result, F::Error> { + let ExprNamedExpr { + target, + value, + range, + } = node; + let context = folder.will_map_user(&range); + + let target = Foldable::fold(target, folder)?; + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprNamedExpr { + target, + value, + range, + }) +} +impl Foldable for ExprBinOp { + type Mapped = ExprBinOp; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_bin_op(self) + } +} +pub fn fold_expr_bin_op + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprBinOp, +) -> Result, F::Error> { + let ExprBinOp { + left, + op, + right, + range, + } = node; + let context = folder.will_map_user(&range); + + let left = Foldable::fold(left, folder)?; + let op = Foldable::fold(op, folder)?; + let right = Foldable::fold(right, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprBinOp { + left, + op, + right, + range, + }) +} +impl Foldable for ExprUnaryOp { + type Mapped = ExprUnaryOp; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_unary_op(self) + } +} +pub fn fold_expr_unary_op + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprUnaryOp, +) -> Result, F::Error> { + let ExprUnaryOp { op, operand, range } = node; + let context = folder.will_map_user(&range); + + let op = Foldable::fold(op, folder)?; + let operand = Foldable::fold(operand, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprUnaryOp { op, operand, range }) +} +impl Foldable for ExprLambda { + type Mapped = ExprLambda; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_lambda(self) + } +} +pub fn fold_expr_lambda + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprLambda, +) -> Result, F::Error> { + let ExprLambda { args, body, range } = node; + let context = folder.will_map_user(&range); + + let args = Foldable::fold(args, folder)?; + let body = Foldable::fold(body, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprLambda { args, body, range }) +} +impl Foldable for ExprIfExp { + type Mapped = ExprIfExp; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_if_exp(self) + } +} +pub fn fold_expr_if_exp + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprIfExp, +) -> Result, F::Error> { + let ExprIfExp { + test, + body, + orelse, + range, + } = node; + let context = folder.will_map_user(&range); + + let test = Foldable::fold(test, folder)?; + let body = Foldable::fold(body, folder)?; + let orelse = Foldable::fold(orelse, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprIfExp { + test, + body, + orelse, + range, + }) +} +impl Foldable for ExprDict { + type Mapped = ExprDict; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_dict(self) + } +} +pub fn fold_expr_dict + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprDict, +) -> Result, F::Error> { + let ExprDict { + keys, + values, + range, + } = node; + let context = folder.will_map_user(&range); + + let keys = Foldable::fold(keys, folder)?; + let values = Foldable::fold(values, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprDict { + keys, + values, + range, + }) +} +impl Foldable for ExprSet { + type Mapped = ExprSet; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_set(self) + } +} +pub fn fold_expr_set + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprSet, +) -> Result, F::Error> { + let ExprSet { elts, range } = node; + let context = folder.will_map_user(&range); + + let elts = Foldable::fold(elts, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprSet { elts, range }) +} +impl Foldable for ExprListComp { + type Mapped = ExprListComp; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_list_comp(self) + } +} +pub fn fold_expr_list_comp + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprListComp, +) -> Result, F::Error> { + let ExprListComp { + elt, + generators, + range, + } = node; + let context = folder.will_map_user(&range); + + let elt = Foldable::fold(elt, folder)?; + let generators = Foldable::fold(generators, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprListComp { + elt, + generators, + range, + }) +} +impl Foldable for ExprSetComp { + type Mapped = ExprSetComp; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_set_comp(self) + } +} +pub fn fold_expr_set_comp + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprSetComp, +) -> Result, F::Error> { + let ExprSetComp { + elt, + generators, + range, + } = node; + let context = folder.will_map_user(&range); + + let elt = Foldable::fold(elt, folder)?; + let generators = Foldable::fold(generators, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprSetComp { + elt, + generators, + range, + }) +} +impl Foldable for ExprDictComp { + type Mapped = ExprDictComp; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_dict_comp(self) + } +} +pub fn fold_expr_dict_comp + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprDictComp, +) -> Result, F::Error> { + let ExprDictComp { + key, + value, + generators, + range, + } = node; + let context = folder.will_map_user(&range); + + let key = Foldable::fold(key, folder)?; + let value = Foldable::fold(value, folder)?; + let generators = Foldable::fold(generators, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprDictComp { + key, + value, + generators, + range, + }) +} +impl Foldable for ExprGeneratorExp { + type Mapped = ExprGeneratorExp; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_generator_exp(self) + } +} +pub fn fold_expr_generator_exp + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprGeneratorExp, +) -> Result, F::Error> { + let ExprGeneratorExp { + elt, + generators, + range, + } = node; + let context = folder.will_map_user(&range); + + let elt = Foldable::fold(elt, folder)?; + let generators = Foldable::fold(generators, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprGeneratorExp { + elt, + generators, + range, + }) +} +impl Foldable for ExprAwait { + type Mapped = ExprAwait; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_await(self) + } +} +pub fn fold_expr_await + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprAwait, +) -> Result, F::Error> { + let ExprAwait { value, range } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprAwait { value, range }) +} +impl Foldable for ExprYield { + type Mapped = ExprYield; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_yield(self) + } +} +pub fn fold_expr_yield + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprYield, +) -> Result, F::Error> { + let ExprYield { value, range } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprYield { value, range }) +} +impl Foldable for ExprYieldFrom { + type Mapped = ExprYieldFrom; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_yield_from(self) + } +} +pub fn fold_expr_yield_from + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprYieldFrom, +) -> Result, F::Error> { + let ExprYieldFrom { value, range } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprYieldFrom { value, range }) +} +impl Foldable for ExprCompare { + type Mapped = ExprCompare; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_compare(self) + } +} +pub fn fold_expr_compare + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprCompare, +) -> Result, F::Error> { + let ExprCompare { + left, + ops, + comparators, + range, + } = node; + let context = folder.will_map_user(&range); + + let left = Foldable::fold(left, folder)?; + let ops = Foldable::fold(ops, folder)?; + let comparators = Foldable::fold(comparators, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprCompare { + left, + ops, + comparators, + range, + }) +} +impl Foldable for ExprCall { + type Mapped = ExprCall; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_call(self) + } +} +pub fn fold_expr_call + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprCall, +) -> Result, F::Error> { + let ExprCall { + func, + args, + keywords, + range, + } = node; + let context = folder.will_map_user(&range); + + let func = Foldable::fold(func, folder)?; + let args = Foldable::fold(args, folder)?; + let keywords = Foldable::fold(keywords, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprCall { + func, + args, + keywords, + range, + }) +} +impl Foldable for ExprFormattedValue { + type Mapped = ExprFormattedValue; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_formatted_value(self) + } +} +pub fn fold_expr_formatted_value + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprFormattedValue, +) -> Result, F::Error> { + let ExprFormattedValue { + value, + conversion, + format_spec, + range, + } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let conversion = Foldable::fold(conversion, folder)?; + let format_spec = Foldable::fold(format_spec, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprFormattedValue { + value, + conversion, + format_spec, + range, + }) +} +impl Foldable for ExprJoinedStr { + type Mapped = ExprJoinedStr; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_joined_str(self) + } +} +pub fn fold_expr_joined_str + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprJoinedStr, +) -> Result, F::Error> { + let ExprJoinedStr { values, range } = node; + let context = folder.will_map_user(&range); + + let values = Foldable::fold(values, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprJoinedStr { values, range }) +} +impl Foldable for ExprConstant { + type Mapped = ExprConstant; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_constant(self) + } +} +pub fn fold_expr_constant + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprConstant, +) -> Result, F::Error> { + let ExprConstant { value, kind, range } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let kind = Foldable::fold(kind, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprConstant { value, kind, range }) +} +impl Foldable for ExprAttribute { + type Mapped = ExprAttribute; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_attribute(self) + } +} +pub fn fold_expr_attribute + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprAttribute, +) -> Result, F::Error> { + let ExprAttribute { + value, + attr, + ctx, + range, + } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let attr = Foldable::fold(attr, folder)?; + let ctx = Foldable::fold(ctx, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprAttribute { + value, + attr, + ctx, + range, + }) +} +impl Foldable for ExprSubscript { + type Mapped = ExprSubscript; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_subscript(self) + } +} +pub fn fold_expr_subscript + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprSubscript, +) -> Result, F::Error> { + let ExprSubscript { + value, + slice, + ctx, + range, + } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let slice = Foldable::fold(slice, folder)?; + let ctx = Foldable::fold(ctx, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprSubscript { + value, + slice, + ctx, + range, + }) +} +impl Foldable for ExprStarred { + type Mapped = ExprStarred; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_starred(self) + } +} +pub fn fold_expr_starred + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprStarred, +) -> Result, F::Error> { + let ExprStarred { value, ctx, range } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let ctx = Foldable::fold(ctx, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprStarred { value, ctx, range }) +} +impl Foldable for ExprName { + type Mapped = ExprName; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_name(self) + } +} +pub fn fold_expr_name + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprName, +) -> Result, F::Error> { + let ExprName { id, ctx, range } = node; + let context = folder.will_map_user(&range); + + let id = Foldable::fold(id, folder)?; + let ctx = Foldable::fold(ctx, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprName { id, ctx, range }) +} +impl Foldable for ExprList { + type Mapped = ExprList; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_list(self) + } +} +pub fn fold_expr_list + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprList, +) -> Result, F::Error> { + let ExprList { elts, ctx, range } = node; + let context = folder.will_map_user(&range); + + let elts = Foldable::fold(elts, folder)?; + let ctx = Foldable::fold(ctx, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprList { elts, ctx, range }) +} +impl Foldable for ExprTuple { + type Mapped = ExprTuple; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_tuple(self) + } +} +pub fn fold_expr_tuple + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprTuple, +) -> Result, F::Error> { + let ExprTuple { elts, ctx, range } = node; + let context = folder.will_map_user(&range); + + let elts = Foldable::fold(elts, folder)?; + let ctx = Foldable::fold(ctx, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprTuple { elts, ctx, range }) +} +impl Foldable for ExprSlice { + type Mapped = ExprSlice; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_slice(self) + } +} +pub fn fold_expr_slice + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprSlice, +) -> Result, F::Error> { + let ExprSlice { + lower, + upper, + step, + range, + } = node; + let context = folder.will_map_user(&range); + + let lower = Foldable::fold(lower, folder)?; + let upper = Foldable::fold(upper, folder)?; + let step = Foldable::fold(step, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExprSlice { + lower, + upper, + step, + range, + }) +} impl Foldable for ExprContext { type Mapped = ExprContext; fn fold + ?Sized>( @@ -879,12 +2284,17 @@ pub fn fold_comprehension + ?Sized>( is_async, range, } = node; - let range = folder.map_user_cfg(range)?; + let context = folder.will_map_user_cfg(&range); + let target = Foldable::fold(target, folder)?; + let iter = Foldable::fold(iter, folder)?; + let ifs = Foldable::fold(ifs, folder)?; + let is_async = Foldable::fold(is_async, folder)?; + let range = folder.map_user_cfg(range, context)?; Ok(Comprehension { - target: Foldable::fold(target, folder)?, - iter: Foldable::fold(iter, folder)?, - ifs: Foldable::fold(ifs, folder)?, - is_async: Foldable::fold(is_async, folder)?, + target, + iter, + ifs, + is_async, range, }) } @@ -901,23 +2311,45 @@ pub fn fold_excepthandler + ?Sized>( #[allow(unused)] folder: &mut F, node: Excepthandler, ) -> Result, F::Error> { - match node { - Excepthandler::ExceptHandler(ExcepthandlerExceptHandler { - type_, - name, - body, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Excepthandler::ExceptHandler(ExcepthandlerExceptHandler { - type_: Foldable::fold(type_, folder)?, - name: Foldable::fold(name, folder)?, - body: Foldable::fold(body, folder)?, - range, - })) + let folded = match node { + Excepthandler::ExceptHandler(cons) => { + Excepthandler::ExceptHandler(Foldable::fold(cons, folder)?) } + }; + Ok(folded) +} +impl Foldable for ExcepthandlerExceptHandler { + type Mapped = ExcepthandlerExceptHandler; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_excepthandler_except_handler(self) } } +pub fn fold_excepthandler_except_handler + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExcepthandlerExceptHandler, +) -> Result, F::Error> { + let ExcepthandlerExceptHandler { + type_, + name, + body, + range, + } = node; + let context = folder.will_map_user(&range); + + let type_ = Foldable::fold(type_, folder)?; + let name = Foldable::fold(name, folder)?; + let body = Foldable::fold(body, folder)?; + let range = folder.map_user(range, context)?; + Ok(ExcepthandlerExceptHandler { + type_, + name, + body, + range, + }) +} impl Foldable for Arguments { type Mapped = Arguments; fn fold + ?Sized>( @@ -941,15 +2373,23 @@ pub fn fold_arguments + ?Sized>( defaults, range, } = node; - let range = folder.map_user_cfg(range)?; + let context = folder.will_map_user_cfg(&range); + let posonlyargs = Foldable::fold(posonlyargs, folder)?; + let args = Foldable::fold(args, folder)?; + let vararg = Foldable::fold(vararg, folder)?; + let kwonlyargs = Foldable::fold(kwonlyargs, folder)?; + let kw_defaults = Foldable::fold(kw_defaults, folder)?; + let kwarg = Foldable::fold(kwarg, folder)?; + let defaults = Foldable::fold(defaults, folder)?; + let range = folder.map_user_cfg(range, context)?; Ok(Arguments { - posonlyargs: Foldable::fold(posonlyargs, folder)?, - args: Foldable::fold(args, folder)?, - vararg: Foldable::fold(vararg, folder)?, - kwonlyargs: Foldable::fold(kwonlyargs, folder)?, - kw_defaults: Foldable::fold(kw_defaults, folder)?, - kwarg: Foldable::fold(kwarg, folder)?, - defaults: Foldable::fold(defaults, folder)?, + posonlyargs, + args, + vararg, + kwonlyargs, + kw_defaults, + kwarg, + defaults, range, }) } @@ -972,11 +2412,15 @@ pub fn fold_arg + ?Sized>( type_comment, range, } = node; - let range = folder.map_user(range)?; + let context = folder.will_map_user(&range); + let arg = Foldable::fold(arg, folder)?; + let annotation = Foldable::fold(annotation, folder)?; + let type_comment = Foldable::fold(type_comment, folder)?; + let range = folder.map_user(range, context)?; Ok(Arg { - arg: Foldable::fold(arg, folder)?, - annotation: Foldable::fold(annotation, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, + arg, + annotation, + type_comment, range, }) } @@ -994,12 +2438,11 @@ pub fn fold_keyword + ?Sized>( node: Keyword, ) -> Result, F::Error> { let Keyword { arg, value, range } = node; - let range = folder.map_user(range)?; - Ok(Keyword { - arg: Foldable::fold(arg, folder)?, - value: Foldable::fold(value, folder)?, - range, - }) + let context = folder.will_map_user(&range); + let arg = Foldable::fold(arg, folder)?; + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(Keyword { arg, value, range }) } impl Foldable for Alias { type Mapped = Alias; @@ -1019,10 +2462,13 @@ pub fn fold_alias + ?Sized>( asname, range, } = node; - let range = folder.map_user(range)?; + let context = folder.will_map_user(&range); + let name = Foldable::fold(name, folder)?; + let asname = Foldable::fold(asname, folder)?; + let range = folder.map_user(range, context)?; Ok(Alias { - name: Foldable::fold(name, folder)?, - asname: Foldable::fold(asname, folder)?, + name, + asname, range, }) } @@ -1044,10 +2490,13 @@ pub fn fold_withitem + ?Sized>( optional_vars, range, } = node; - let range = folder.map_user_cfg(range)?; + let context = folder.will_map_user_cfg(&range); + let context_expr = Foldable::fold(context_expr, folder)?; + let optional_vars = Foldable::fold(optional_vars, folder)?; + let range = folder.map_user_cfg(range, context)?; Ok(Withitem { - context_expr: Foldable::fold(context_expr, folder)?, - optional_vars: Foldable::fold(optional_vars, folder)?, + context_expr, + optional_vars, range, }) } @@ -1070,11 +2519,15 @@ pub fn fold_match_case + ?Sized>( body, range, } = node; - let range = folder.map_user_cfg(range)?; + let context = folder.will_map_user_cfg(&range); + let pattern = Foldable::fold(pattern, folder)?; + let guard = Foldable::fold(guard, folder)?; + let body = Foldable::fold(body, folder)?; + let range = folder.map_user_cfg(range, context)?; Ok(MatchCase { - pattern: Foldable::fold(pattern, folder)?, - guard: Foldable::fold(guard, folder)?, - body: Foldable::fold(body, folder)?, + pattern, + guard, + body, range, }) } @@ -1091,86 +2544,214 @@ pub fn fold_pattern + ?Sized>( #[allow(unused)] folder: &mut F, node: Pattern, ) -> Result, F::Error> { - match node { - Pattern::MatchValue(PatternMatchValue { value, range }) => { - let range = folder.map_user(range)?; - Ok(Pattern::MatchValue(PatternMatchValue { - value: Foldable::fold(value, folder)?, - range, - })) - } - Pattern::MatchSingleton(PatternMatchSingleton { value, range }) => { - let range = folder.map_user(range)?; - Ok(Pattern::MatchSingleton(PatternMatchSingleton { - value: Foldable::fold(value, folder)?, - range, - })) - } - Pattern::MatchSequence(PatternMatchSequence { patterns, range }) => { - let range = folder.map_user(range)?; - Ok(Pattern::MatchSequence(PatternMatchSequence { - patterns: Foldable::fold(patterns, folder)?, - range, - })) - } - Pattern::MatchMapping(PatternMatchMapping { - keys, - patterns, - rest, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Pattern::MatchMapping(PatternMatchMapping { - keys: Foldable::fold(keys, folder)?, - patterns: Foldable::fold(patterns, folder)?, - rest: Foldable::fold(rest, folder)?, - range, - })) - } - Pattern::MatchClass(PatternMatchClass { - cls, - patterns, - kwd_attrs, - kwd_patterns, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Pattern::MatchClass(PatternMatchClass { - cls: Foldable::fold(cls, folder)?, - patterns: Foldable::fold(patterns, folder)?, - kwd_attrs: Foldable::fold(kwd_attrs, folder)?, - kwd_patterns: Foldable::fold(kwd_patterns, folder)?, - range, - })) - } - Pattern::MatchStar(PatternMatchStar { name, range }) => { - let range = folder.map_user(range)?; - Ok(Pattern::MatchStar(PatternMatchStar { - name: Foldable::fold(name, folder)?, - range, - })) - } - Pattern::MatchAs(PatternMatchAs { - pattern, - name, - range, - }) => { - let range = folder.map_user(range)?; - Ok(Pattern::MatchAs(PatternMatchAs { - pattern: Foldable::fold(pattern, folder)?, - name: Foldable::fold(name, folder)?, - range, - })) - } - Pattern::MatchOr(PatternMatchOr { patterns, range }) => { - let range = folder.map_user(range)?; - Ok(Pattern::MatchOr(PatternMatchOr { - patterns: Foldable::fold(patterns, folder)?, - range, - })) - } + let folded = match node { + Pattern::MatchValue(cons) => Pattern::MatchValue(Foldable::fold(cons, folder)?), + Pattern::MatchSingleton(cons) => Pattern::MatchSingleton(Foldable::fold(cons, folder)?), + Pattern::MatchSequence(cons) => Pattern::MatchSequence(Foldable::fold(cons, folder)?), + Pattern::MatchMapping(cons) => Pattern::MatchMapping(Foldable::fold(cons, folder)?), + Pattern::MatchClass(cons) => Pattern::MatchClass(Foldable::fold(cons, folder)?), + Pattern::MatchStar(cons) => Pattern::MatchStar(Foldable::fold(cons, folder)?), + Pattern::MatchAs(cons) => Pattern::MatchAs(Foldable::fold(cons, folder)?), + Pattern::MatchOr(cons) => Pattern::MatchOr(Foldable::fold(cons, folder)?), + }; + Ok(folded) +} +impl Foldable for PatternMatchValue { + type Mapped = PatternMatchValue; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_pattern_match_value(self) } } +pub fn fold_pattern_match_value + ?Sized>( + #[allow(unused)] folder: &mut F, + node: PatternMatchValue, +) -> Result, F::Error> { + let PatternMatchValue { value, range } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(PatternMatchValue { value, range }) +} +impl Foldable for PatternMatchSingleton { + type Mapped = PatternMatchSingleton; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_pattern_match_singleton(self) + } +} +pub fn fold_pattern_match_singleton + ?Sized>( + #[allow(unused)] folder: &mut F, + node: PatternMatchSingleton, +) -> Result, F::Error> { + let PatternMatchSingleton { value, range } = node; + let context = folder.will_map_user(&range); + + let value = Foldable::fold(value, folder)?; + let range = folder.map_user(range, context)?; + Ok(PatternMatchSingleton { value, range }) +} +impl Foldable for PatternMatchSequence { + type Mapped = PatternMatchSequence; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_pattern_match_sequence(self) + } +} +pub fn fold_pattern_match_sequence + ?Sized>( + #[allow(unused)] folder: &mut F, + node: PatternMatchSequence, +) -> Result, F::Error> { + let PatternMatchSequence { patterns, range } = node; + let context = folder.will_map_user(&range); + + let patterns = Foldable::fold(patterns, folder)?; + let range = folder.map_user(range, context)?; + Ok(PatternMatchSequence { patterns, range }) +} +impl Foldable for PatternMatchMapping { + type Mapped = PatternMatchMapping; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_pattern_match_mapping(self) + } +} +pub fn fold_pattern_match_mapping + ?Sized>( + #[allow(unused)] folder: &mut F, + node: PatternMatchMapping, +) -> Result, F::Error> { + let PatternMatchMapping { + keys, + patterns, + rest, + range, + } = node; + let context = folder.will_map_user(&range); + + let keys = Foldable::fold(keys, folder)?; + let patterns = Foldable::fold(patterns, folder)?; + let rest = Foldable::fold(rest, folder)?; + let range = folder.map_user(range, context)?; + Ok(PatternMatchMapping { + keys, + patterns, + rest, + range, + }) +} +impl Foldable for PatternMatchClass { + type Mapped = PatternMatchClass; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_pattern_match_class(self) + } +} +pub fn fold_pattern_match_class + ?Sized>( + #[allow(unused)] folder: &mut F, + node: PatternMatchClass, +) -> Result, F::Error> { + let PatternMatchClass { + cls, + patterns, + kwd_attrs, + kwd_patterns, + range, + } = node; + let context = folder.will_map_user(&range); + + let cls = Foldable::fold(cls, folder)?; + let patterns = Foldable::fold(patterns, folder)?; + let kwd_attrs = Foldable::fold(kwd_attrs, folder)?; + let kwd_patterns = Foldable::fold(kwd_patterns, folder)?; + let range = folder.map_user(range, context)?; + Ok(PatternMatchClass { + cls, + patterns, + kwd_attrs, + kwd_patterns, + range, + }) +} +impl Foldable for PatternMatchStar { + type Mapped = PatternMatchStar; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_pattern_match_star(self) + } +} +pub fn fold_pattern_match_star + ?Sized>( + #[allow(unused)] folder: &mut F, + node: PatternMatchStar, +) -> Result, F::Error> { + let PatternMatchStar { name, range } = node; + let context = folder.will_map_user(&range); + + let name = Foldable::fold(name, folder)?; + let range = folder.map_user(range, context)?; + Ok(PatternMatchStar { name, range }) +} +impl Foldable for PatternMatchAs { + type Mapped = PatternMatchAs; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_pattern_match_as(self) + } +} +pub fn fold_pattern_match_as + ?Sized>( + #[allow(unused)] folder: &mut F, + node: PatternMatchAs, +) -> Result, F::Error> { + let PatternMatchAs { + pattern, + name, + range, + } = node; + let context = folder.will_map_user(&range); + + let pattern = Foldable::fold(pattern, folder)?; + let name = Foldable::fold(name, folder)?; + let range = folder.map_user(range, context)?; + Ok(PatternMatchAs { + pattern, + name, + range, + }) +} +impl Foldable for PatternMatchOr { + type Mapped = PatternMatchOr; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_pattern_match_or(self) + } +} +pub fn fold_pattern_match_or + ?Sized>( + #[allow(unused)] folder: &mut F, + node: PatternMatchOr, +) -> Result, F::Error> { + let PatternMatchOr { patterns, range } = node; + let context = folder.will_map_user(&range); + + let patterns = Foldable::fold(patterns, folder)?; + let range = folder.map_user(range, context)?; + Ok(PatternMatchOr { patterns, range }) +} impl Foldable for TypeIgnore { type Mapped = TypeIgnore; fn fold + ?Sized>( @@ -1184,14 +2765,29 @@ pub fn fold_type_ignore + ?Sized>( #[allow(unused)] folder: &mut F, node: TypeIgnore, ) -> Result, F::Error> { - match node { - TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { lineno, tag, range }) => { - let range = folder.map_user_cfg(range)?; - Ok(TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { - lineno: Foldable::fold(lineno, folder)?, - tag: Foldable::fold(tag, folder)?, - range, - })) - } + let folded = match node { + TypeIgnore::TypeIgnore(cons) => TypeIgnore::TypeIgnore(Foldable::fold(cons, folder)?), + }; + Ok(folded) +} +impl Foldable for TypeIgnoreTypeIgnore { + type Mapped = TypeIgnoreTypeIgnore; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_type_ignore_type_ignore(self) } } +pub fn fold_type_ignore_type_ignore + ?Sized>( + #[allow(unused)] folder: &mut F, + node: TypeIgnoreTypeIgnore, +) -> Result, F::Error> { + let TypeIgnoreTypeIgnore { lineno, tag, range } = node; + let context = folder.will_map_user_cfg(&range); + + let lineno = Foldable::fold(lineno, folder)?; + let tag = Foldable::fold(tag, folder)?; + let range = folder.map_user_cfg(range, context)?; + Ok(TypeIgnoreTypeIgnore { lineno, tag, range }) +} diff --git a/ast/src/lib.rs b/ast/src/lib.rs index 12d3714..21cca63 100644 --- a/ast/src/lib.rs +++ b/ast/src/lib.rs @@ -16,13 +16,7 @@ pub trait Node { } #[cfg(feature = "fold")] -mod fold_helpers; -#[cfg(feature = "fold")] -pub mod fold { - use super::generic::*; - - include!("gen/fold.rs"); -} +pub mod fold; #[cfg(feature = "fold")] pub use fold::Fold; diff --git a/ast/src/optimizer.rs b/ast/src/optimizer.rs index f871734..9689163 100644 --- a/ast/src/optimizer.rs +++ b/ast/src/optimizer.rs @@ -15,8 +15,12 @@ impl ConstantOptimizer { impl crate::fold::Fold for ConstantOptimizer { type TargetU = U; type Error = std::convert::Infallible; + type UserContext = (); + + #[inline(always)] + fn will_map_user(&mut self, _user: &U) -> Self::UserContext {} #[inline] - fn map_user(&mut self, user: U) -> Result { + fn map_user(&mut self, user: U, _context: ()) -> Result { Ok(user) } fn fold_expr(&mut self, node: crate::Expr) -> Result, Self::Error> { diff --git a/ast/src/source_locator.rs b/ast/src/source_locator.rs index ebacd89..ef7e43e 100644 --- a/ast/src/source_locator.rs +++ b/ast/src/source_locator.rs @@ -1,14 +1,22 @@ use rustpython_parser_core::{ - source_code::{SourceLocator, SourceRange}, + source_code::{SourceLocation, SourceLocator, SourceRange}, text_size::TextRange, }; impl crate::fold::Fold for SourceLocator<'_> { type TargetU = SourceRange; type Error = std::convert::Infallible; + type UserContext = SourceLocation; - fn map_user(&mut self, user: TextRange) -> Result { - let start = self.locate(user.start()); + fn will_map_user(&mut self, user: &TextRange) -> Self::UserContext { + self.locate(user.start()) + } + + fn map_user( + &mut self, + user: TextRange, + start: Self::UserContext, + ) -> Result { let end = self.locate(user.end()); Ok((start..end).into()) }