diff --git a/ast/asdl_rs.py b/ast/asdl_rs.py index d9367b2..261883f 100755 --- a/ast/asdl_rs.py +++ b/ast/asdl_rs.py @@ -12,7 +12,7 @@ from typing import Optional, Dict import asdl TABSIZE = 4 -AUTOGEN_MESSAGE = "// File automatically generated by {}.\n" +AUTOGEN_MESSAGE = "// File automatically generated by {}.\n\n" builtin_type_mapping = { "identifier": "Ident", @@ -535,13 +535,9 @@ class FoldImplVisitor(EmitVisitor): class FoldModuleVisitor(EmitVisitor): def visitModule(self, mod): depth = 0 - self.emit('#[cfg(feature = "fold")]', depth) - self.emit("pub mod fold {", depth) - self.emit("use super::*;", depth + 1) - self.emit("use crate::fold_helpers::Foldable;", depth + 1) - FoldTraitDefVisitor(self.file, self.typeinfo).visit(mod, depth + 1) - FoldImplVisitor(self.file, self.typeinfo).visit(mod, depth + 1) - self.emit("}", depth) + self.emit("use crate::fold_helpers::Foldable;", depth) + FoldTraitDefVisitor(self.file, self.typeinfo).visit(mod, depth) + FoldImplVisitor(self.file, self.typeinfo).visit(mod, depth) class VisitorTraitDefVisitor(StructVisitor): @@ -577,7 +573,9 @@ class VisitorTraitDefVisitor(StructVisitor): else: node_type = "()" node_value = "()" - self.emit(f"fn visit_{typeinfo.sum_name}(&mut self, node: {node_type}) {{", depth) + self.emit( + f"fn visit_{typeinfo.sum_name}(&mut self, node: {node_type}) {{", depth + ) self.emit(f"self.generic_visit_{typeinfo.sum_name}({node_value})", depth + 1) self.emit("}", depth) @@ -587,7 +585,10 @@ class VisitorTraitDefVisitor(StructVisitor): node_type = typeinfo.rust_sum_name else: node_type = "()" - self.emit(f"fn generic_visit_{typeinfo.sum_name}(&mut self, node: {node_type}) {{", depth) + self.emit( + f"fn generic_visit_{typeinfo.sum_name}(&mut self, node: {node_type}) {{", + depth, + ) def emit_empty_generic_visitor(self, nodename, depth): self.emit_generic_visitor_signature(nodename, depth) @@ -665,13 +666,8 @@ class VisitorTraitDefVisitor(StructVisitor): class VisitorModuleVisitor(EmitVisitor): def visitModule(self, mod): depth = 0 - self.emit('#[cfg(feature = "visitor")]', depth) self.emit("#[allow(unused_variables, non_snake_case)]", depth) - self.emit("pub mod visitor {", depth) - self.emit("use super::*;", depth + 1) - VisitorTraitDefVisitor(self.file, self.typeinfo).visit(mod, depth + 1) - self.emit("}", depth) - self.emit("", depth) + VisitorTraitDefVisitor(self.file, self.typeinfo).visit(mod, depth) class ClassDefVisitor(EmitVisitor): @@ -930,27 +926,19 @@ class ChainOfVisitors: v.emit("", 0) -def write_generic_def(mod, typeinfo, f): - f.write( - textwrap.dedent( - """ - pub use crate::{Attributed, constant::*}; - - type Ident = String; - \n - """ - ) - ) - - c = ChainOfVisitors( - StructVisitor(f, typeinfo), - FoldModuleVisitor(f, typeinfo), - VisitorModuleVisitor(f, typeinfo), - ) - c.visit(mod) +def write_ast_def(mod, typeinfo, f): + StructVisitor(f, typeinfo).visit(mod) -def write_located_def(typeinfo, f): +def write_fold_def(mod, typeinfo, f): + FoldModuleVisitor(f, typeinfo).visit(mod) + + +def write_visitor_def(mod, typeinfo, f): + VisitorModuleVisitor(f, typeinfo).visit(mod) + + +def write_located_def(mod, typeinfo, f): f.write( textwrap.dedent( """ @@ -1000,8 +988,7 @@ def write_ast_mod(mod, typeinfo, f): def main( input_filename, - generic_filename, - located_filename, + ast_dir, module_filename, dump_module=False, ): @@ -1016,34 +1003,34 @@ def main( typeinfo = {} FindUserdataTypesVisitor(typeinfo).visit(mod) - with generic_filename.open("w") as generic_file, located_filename.open( - "w" - ) as located_file: - generic_file.write(auto_gen_msg) - write_generic_def(mod, typeinfo, generic_file) - located_file.write(auto_gen_msg) - write_located_def(typeinfo, located_file) + for filename, write in [ + ("generic", write_ast_def), + ("fold", write_fold_def), + ("located", write_located_def), + ("visitor", write_visitor_def), + ]: + with (ast_dir / f"{filename}.rs").open("w") as f: + f.write(auto_gen_msg) + write(mod, typeinfo, f) with module_filename.open("w") as module_file: module_file.write(auto_gen_msg) write_ast_mod(mod, typeinfo, module_file) - print(f"{generic_filename}, {located_filename}, {module_filename} regenerated.") + print(f"{ast_dir}, {module_filename} regenerated.") if __name__ == "__main__": parser = ArgumentParser() parser.add_argument("input_file", type=Path) - parser.add_argument("-G", "--generic-file", type=Path, required=True) - parser.add_argument("-L", "--located-file", type=Path, required=True) + parser.add_argument("-A", "--ast-dir", type=Path, required=True) parser.add_argument("-M", "--module-file", type=Path, required=True) parser.add_argument("-d", "--dump-module", action="store_true") args = parser.parse_args() main( args.input_file, - args.generic_file, - args.located_file, + args.ast_dir, args.module_file, args.dump_module, ) diff --git a/ast/src/gen/fold.rs b/ast/src/gen/fold.rs new file mode 100644 index 0000000..b2e1c9f --- /dev/null +++ b/ast/src/gen/fold.rs @@ -0,0 +1,888 @@ +// File automatically generated by ast/asdl_rs.py. + +use crate::fold_helpers::Foldable; +pub trait Fold { + type TargetU; + type Error; + fn map_user(&mut self, user: U) -> Result; + + fn map_attributed( + &mut self, + attributed: Attributed, + ) -> Result, Self::Error> { + let custom = self.map_user(attributed.custom)?; + Ok(Attributed { + range: attributed.range, + custom, + node: attributed.node, + }) + } + + fn fold>(&mut self, node: X) -> Result { + node.fold(self) + } + fn fold_mod(&mut self, node: Mod) -> Result, Self::Error> { + fold_mod(self, node) + } + fn fold_stmt(&mut self, node: Stmt) -> Result, Self::Error> { + fold_stmt(self, node) + } + fn fold_expr(&mut self, node: Expr) -> Result, Self::Error> { + fold_expr(self, node) + } + fn fold_expr_context(&mut self, node: ExprContext) -> Result { + fold_expr_context(self, node) + } + fn fold_boolop(&mut self, node: Boolop) -> Result { + fold_boolop(self, node) + } + fn fold_operator(&mut self, node: Operator) -> Result { + fold_operator(self, node) + } + fn fold_unaryop(&mut self, node: Unaryop) -> Result { + fold_unaryop(self, node) + } + fn fold_cmpop(&mut self, node: Cmpop) -> Result { + fold_cmpop(self, node) + } + fn fold_comprehension( + &mut self, + node: Comprehension, + ) -> Result, Self::Error> { + fold_comprehension(self, node) + } + fn fold_excepthandler( + &mut self, + node: Excepthandler, + ) -> Result, Self::Error> { + fold_excepthandler(self, node) + } + fn fold_arguments( + &mut self, + node: Arguments, + ) -> Result, Self::Error> { + fold_arguments(self, node) + } + fn fold_arg(&mut self, node: Arg) -> Result, Self::Error> { + fold_arg(self, node) + } + fn fold_keyword(&mut self, node: Keyword) -> Result, Self::Error> { + fold_keyword(self, node) + } + fn fold_alias(&mut self, node: Alias) -> Result, Self::Error> { + fold_alias(self, node) + } + fn fold_withitem(&mut self, node: Withitem) -> Result, Self::Error> { + fold_withitem(self, node) + } + fn fold_match_case( + &mut self, + node: MatchCase, + ) -> Result, Self::Error> { + fold_match_case(self, node) + } + fn fold_pattern(&mut self, node: Pattern) -> Result, Self::Error> { + fold_pattern(self, node) + } + fn fold_type_ignore(&mut self, node: TypeIgnore) -> Result { + fold_type_ignore(self, node) + } +} +fn fold_attributed + ?Sized, T, MT>( + folder: &mut F, + node: Attributed, + f: impl FnOnce(&mut F, T) -> Result, +) -> Result, F::Error> { + let node = folder.map_attributed(node)?; + Ok(Attributed { + custom: node.custom, + range: node.range, + node: f(folder, node.node)?, + }) +} +impl Foldable for Mod { + type Mapped = Mod; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_mod(self) + } +} +pub fn fold_mod + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Mod, +) -> Result, F::Error> { + match node { + Mod::Module(ModModule { body, type_ignores }) => Ok(Mod::Module(ModModule { + body: Foldable::fold(body, folder)?, + type_ignores: Foldable::fold(type_ignores, folder)?, + })), + Mod::Interactive(ModInteractive { body }) => Ok(Mod::Interactive(ModInteractive { + body: Foldable::fold(body, folder)?, + })), + Mod::Expression(ModExpression { body }) => Ok(Mod::Expression(ModExpression { + body: Foldable::fold(body, folder)?, + })), + Mod::FunctionType(ModFunctionType { argtypes, returns }) => { + Ok(Mod::FunctionType(ModFunctionType { + argtypes: Foldable::fold(argtypes, folder)?, + returns: Foldable::fold(returns, folder)?, + })) + } + } +} +impl Foldable for Stmt { + type Mapped = Stmt; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_stmt(self) + } +} +pub fn fold_stmt + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Stmt, +) -> Result, F::Error> { + fold_attributed(folder, node, |folder, node| match node { + StmtKind::FunctionDef(StmtFunctionDef { + name, + args, + body, + decorator_list, + returns, + type_comment, + }) => Ok(StmtKind::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)?, + })), + StmtKind::AsyncFunctionDef(StmtAsyncFunctionDef { + name, + args, + body, + decorator_list, + returns, + type_comment, + }) => Ok(StmtKind::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)?, + })), + StmtKind::ClassDef(StmtClassDef { + name, + bases, + keywords, + body, + decorator_list, + }) => Ok(StmtKind::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)?, + })), + StmtKind::Return(StmtReturn { value }) => Ok(StmtKind::Return(StmtReturn { + value: Foldable::fold(value, folder)?, + })), + StmtKind::Delete(StmtDelete { targets }) => Ok(StmtKind::Delete(StmtDelete { + targets: Foldable::fold(targets, folder)?, + })), + StmtKind::Assign(StmtAssign { + targets, + value, + type_comment, + }) => Ok(StmtKind::Assign(StmtAssign { + targets: Foldable::fold(targets, folder)?, + value: Foldable::fold(value, folder)?, + type_comment: Foldable::fold(type_comment, folder)?, + })), + StmtKind::AugAssign(StmtAugAssign { target, op, value }) => { + Ok(StmtKind::AugAssign(StmtAugAssign { + target: Foldable::fold(target, folder)?, + op: Foldable::fold(op, folder)?, + value: Foldable::fold(value, folder)?, + })) + } + StmtKind::AnnAssign(StmtAnnAssign { + target, + annotation, + value, + simple, + }) => Ok(StmtKind::AnnAssign(StmtAnnAssign { + target: Foldable::fold(target, folder)?, + annotation: Foldable::fold(annotation, folder)?, + value: Foldable::fold(value, folder)?, + simple: Foldable::fold(simple, folder)?, + })), + StmtKind::For(StmtFor { + target, + iter, + body, + orelse, + type_comment, + }) => Ok(StmtKind::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)?, + })), + StmtKind::AsyncFor(StmtAsyncFor { + target, + iter, + body, + orelse, + type_comment, + }) => Ok(StmtKind::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)?, + })), + StmtKind::While(StmtWhile { test, body, orelse }) => Ok(StmtKind::While(StmtWhile { + test: Foldable::fold(test, folder)?, + body: Foldable::fold(body, folder)?, + orelse: Foldable::fold(orelse, folder)?, + })), + StmtKind::If(StmtIf { test, body, orelse }) => Ok(StmtKind::If(StmtIf { + test: Foldable::fold(test, folder)?, + body: Foldable::fold(body, folder)?, + orelse: Foldable::fold(orelse, folder)?, + })), + StmtKind::With(StmtWith { + items, + body, + type_comment, + }) => Ok(StmtKind::With(StmtWith { + items: Foldable::fold(items, folder)?, + body: Foldable::fold(body, folder)?, + type_comment: Foldable::fold(type_comment, folder)?, + })), + StmtKind::AsyncWith(StmtAsyncWith { + items, + body, + type_comment, + }) => Ok(StmtKind::AsyncWith(StmtAsyncWith { + items: Foldable::fold(items, folder)?, + body: Foldable::fold(body, folder)?, + type_comment: Foldable::fold(type_comment, folder)?, + })), + StmtKind::Match(StmtMatch { subject, cases }) => Ok(StmtKind::Match(StmtMatch { + subject: Foldable::fold(subject, folder)?, + cases: Foldable::fold(cases, folder)?, + })), + StmtKind::Raise(StmtRaise { exc, cause }) => Ok(StmtKind::Raise(StmtRaise { + exc: Foldable::fold(exc, folder)?, + cause: Foldable::fold(cause, folder)?, + })), + StmtKind::Try(StmtTry { + body, + handlers, + orelse, + finalbody, + }) => Ok(StmtKind::Try(StmtTry { + body: Foldable::fold(body, folder)?, + handlers: Foldable::fold(handlers, folder)?, + orelse: Foldable::fold(orelse, folder)?, + finalbody: Foldable::fold(finalbody, folder)?, + })), + StmtKind::TryStar(StmtTryStar { + body, + handlers, + orelse, + finalbody, + }) => Ok(StmtKind::TryStar(StmtTryStar { + body: Foldable::fold(body, folder)?, + handlers: Foldable::fold(handlers, folder)?, + orelse: Foldable::fold(orelse, folder)?, + finalbody: Foldable::fold(finalbody, folder)?, + })), + StmtKind::Assert(StmtAssert { test, msg }) => Ok(StmtKind::Assert(StmtAssert { + test: Foldable::fold(test, folder)?, + msg: Foldable::fold(msg, folder)?, + })), + StmtKind::Import(StmtImport { names }) => Ok(StmtKind::Import(StmtImport { + names: Foldable::fold(names, folder)?, + })), + StmtKind::ImportFrom(StmtImportFrom { + module, + names, + level, + }) => Ok(StmtKind::ImportFrom(StmtImportFrom { + module: Foldable::fold(module, folder)?, + names: Foldable::fold(names, folder)?, + level: Foldable::fold(level, folder)?, + })), + StmtKind::Global(StmtGlobal { names }) => Ok(StmtKind::Global(StmtGlobal { + names: Foldable::fold(names, folder)?, + })), + StmtKind::Nonlocal(StmtNonlocal { names }) => Ok(StmtKind::Nonlocal(StmtNonlocal { + names: Foldable::fold(names, folder)?, + })), + StmtKind::Expr(StmtExpr { value }) => Ok(StmtKind::Expr(StmtExpr { + value: Foldable::fold(value, folder)?, + })), + StmtKind::Pass {} => Ok(StmtKind::Pass {}), + StmtKind::Break {} => Ok(StmtKind::Break {}), + StmtKind::Continue {} => Ok(StmtKind::Continue {}), + }) +} +impl Foldable for Expr { + type Mapped = Expr; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr(self) + } +} +pub fn fold_expr + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Expr, +) -> Result, F::Error> { + fold_attributed(folder, node, |folder, node| match node { + ExprKind::BoolOp(ExprBoolOp { op, values }) => Ok(ExprKind::BoolOp(ExprBoolOp { + op: Foldable::fold(op, folder)?, + values: Foldable::fold(values, folder)?, + })), + ExprKind::NamedExpr(ExprNamedExpr { target, value }) => { + Ok(ExprKind::NamedExpr(ExprNamedExpr { + target: Foldable::fold(target, folder)?, + value: Foldable::fold(value, folder)?, + })) + } + ExprKind::BinOp(ExprBinOp { left, op, right }) => Ok(ExprKind::BinOp(ExprBinOp { + left: Foldable::fold(left, folder)?, + op: Foldable::fold(op, folder)?, + right: Foldable::fold(right, folder)?, + })), + ExprKind::UnaryOp(ExprUnaryOp { op, operand }) => Ok(ExprKind::UnaryOp(ExprUnaryOp { + op: Foldable::fold(op, folder)?, + operand: Foldable::fold(operand, folder)?, + })), + ExprKind::Lambda(ExprLambda { args, body }) => Ok(ExprKind::Lambda(ExprLambda { + args: Foldable::fold(args, folder)?, + body: Foldable::fold(body, folder)?, + })), + ExprKind::IfExp(ExprIfExp { test, body, orelse }) => Ok(ExprKind::IfExp(ExprIfExp { + test: Foldable::fold(test, folder)?, + body: Foldable::fold(body, folder)?, + orelse: Foldable::fold(orelse, folder)?, + })), + ExprKind::Dict(ExprDict { keys, values }) => Ok(ExprKind::Dict(ExprDict { + keys: Foldable::fold(keys, folder)?, + values: Foldable::fold(values, folder)?, + })), + ExprKind::Set(ExprSet { elts }) => Ok(ExprKind::Set(ExprSet { + elts: Foldable::fold(elts, folder)?, + })), + ExprKind::ListComp(ExprListComp { elt, generators }) => { + Ok(ExprKind::ListComp(ExprListComp { + elt: Foldable::fold(elt, folder)?, + generators: Foldable::fold(generators, folder)?, + })) + } + ExprKind::SetComp(ExprSetComp { elt, generators }) => Ok(ExprKind::SetComp(ExprSetComp { + elt: Foldable::fold(elt, folder)?, + generators: Foldable::fold(generators, folder)?, + })), + ExprKind::DictComp(ExprDictComp { + key, + value, + generators, + }) => Ok(ExprKind::DictComp(ExprDictComp { + key: Foldable::fold(key, folder)?, + value: Foldable::fold(value, folder)?, + generators: Foldable::fold(generators, folder)?, + })), + ExprKind::GeneratorExp(ExprGeneratorExp { elt, generators }) => { + Ok(ExprKind::GeneratorExp(ExprGeneratorExp { + elt: Foldable::fold(elt, folder)?, + generators: Foldable::fold(generators, folder)?, + })) + } + ExprKind::Await(ExprAwait { value }) => Ok(ExprKind::Await(ExprAwait { + value: Foldable::fold(value, folder)?, + })), + ExprKind::Yield(ExprYield { value }) => Ok(ExprKind::Yield(ExprYield { + value: Foldable::fold(value, folder)?, + })), + ExprKind::YieldFrom(ExprYieldFrom { value }) => Ok(ExprKind::YieldFrom(ExprYieldFrom { + value: Foldable::fold(value, folder)?, + })), + ExprKind::Compare(ExprCompare { + left, + ops, + comparators, + }) => Ok(ExprKind::Compare(ExprCompare { + left: Foldable::fold(left, folder)?, + ops: Foldable::fold(ops, folder)?, + comparators: Foldable::fold(comparators, folder)?, + })), + ExprKind::Call(ExprCall { + func, + args, + keywords, + }) => Ok(ExprKind::Call(ExprCall { + func: Foldable::fold(func, folder)?, + args: Foldable::fold(args, folder)?, + keywords: Foldable::fold(keywords, folder)?, + })), + ExprKind::FormattedValue(ExprFormattedValue { + value, + conversion, + format_spec, + }) => Ok(ExprKind::FormattedValue(ExprFormattedValue { + value: Foldable::fold(value, folder)?, + conversion: Foldable::fold(conversion, folder)?, + format_spec: Foldable::fold(format_spec, folder)?, + })), + ExprKind::JoinedStr(ExprJoinedStr { values }) => Ok(ExprKind::JoinedStr(ExprJoinedStr { + values: Foldable::fold(values, folder)?, + })), + ExprKind::Constant(ExprConstant { value, kind }) => Ok(ExprKind::Constant(ExprConstant { + value: Foldable::fold(value, folder)?, + kind: Foldable::fold(kind, folder)?, + })), + ExprKind::Attribute(ExprAttribute { value, attr, ctx }) => { + Ok(ExprKind::Attribute(ExprAttribute { + value: Foldable::fold(value, folder)?, + attr: Foldable::fold(attr, folder)?, + ctx: Foldable::fold(ctx, folder)?, + })) + } + ExprKind::Subscript(ExprSubscript { value, slice, ctx }) => { + Ok(ExprKind::Subscript(ExprSubscript { + value: Foldable::fold(value, folder)?, + slice: Foldable::fold(slice, folder)?, + ctx: Foldable::fold(ctx, folder)?, + })) + } + ExprKind::Starred(ExprStarred { value, ctx }) => Ok(ExprKind::Starred(ExprStarred { + value: Foldable::fold(value, folder)?, + ctx: Foldable::fold(ctx, folder)?, + })), + ExprKind::Name(ExprName { id, ctx }) => Ok(ExprKind::Name(ExprName { + id: Foldable::fold(id, folder)?, + ctx: Foldable::fold(ctx, folder)?, + })), + ExprKind::List(ExprList { elts, ctx }) => Ok(ExprKind::List(ExprList { + elts: Foldable::fold(elts, folder)?, + ctx: Foldable::fold(ctx, folder)?, + })), + ExprKind::Tuple(ExprTuple { elts, ctx }) => Ok(ExprKind::Tuple(ExprTuple { + elts: Foldable::fold(elts, folder)?, + ctx: Foldable::fold(ctx, folder)?, + })), + ExprKind::Slice(ExprSlice { lower, upper, step }) => Ok(ExprKind::Slice(ExprSlice { + lower: Foldable::fold(lower, folder)?, + upper: Foldable::fold(upper, folder)?, + step: Foldable::fold(step, folder)?, + })), + }) +} +impl Foldable for ExprContext { + type Mapped = ExprContext; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_expr_context(self) + } +} +pub fn fold_expr_context + ?Sized>( + #[allow(unused)] folder: &mut F, + node: ExprContext, +) -> Result { + match node { + ExprContext::Load {} => Ok(ExprContext::Load {}), + ExprContext::Store {} => Ok(ExprContext::Store {}), + ExprContext::Del {} => Ok(ExprContext::Del {}), + } +} +impl Foldable for Boolop { + type Mapped = Boolop; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_boolop(self) + } +} +pub fn fold_boolop + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Boolop, +) -> Result { + match node { + Boolop::And {} => Ok(Boolop::And {}), + Boolop::Or {} => Ok(Boolop::Or {}), + } +} +impl Foldable for Operator { + type Mapped = Operator; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_operator(self) + } +} +pub fn fold_operator + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Operator, +) -> Result { + match node { + Operator::Add {} => Ok(Operator::Add {}), + Operator::Sub {} => Ok(Operator::Sub {}), + Operator::Mult {} => Ok(Operator::Mult {}), + Operator::MatMult {} => Ok(Operator::MatMult {}), + Operator::Div {} => Ok(Operator::Div {}), + Operator::Mod {} => Ok(Operator::Mod {}), + Operator::Pow {} => Ok(Operator::Pow {}), + Operator::LShift {} => Ok(Operator::LShift {}), + Operator::RShift {} => Ok(Operator::RShift {}), + Operator::BitOr {} => Ok(Operator::BitOr {}), + Operator::BitXor {} => Ok(Operator::BitXor {}), + Operator::BitAnd {} => Ok(Operator::BitAnd {}), + Operator::FloorDiv {} => Ok(Operator::FloorDiv {}), + } +} +impl Foldable for Unaryop { + type Mapped = Unaryop; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_unaryop(self) + } +} +pub fn fold_unaryop + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Unaryop, +) -> Result { + match node { + Unaryop::Invert {} => Ok(Unaryop::Invert {}), + Unaryop::Not {} => Ok(Unaryop::Not {}), + Unaryop::UAdd {} => Ok(Unaryop::UAdd {}), + Unaryop::USub {} => Ok(Unaryop::USub {}), + } +} +impl Foldable for Cmpop { + type Mapped = Cmpop; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_cmpop(self) + } +} +pub fn fold_cmpop + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Cmpop, +) -> Result { + match node { + Cmpop::Eq {} => Ok(Cmpop::Eq {}), + Cmpop::NotEq {} => Ok(Cmpop::NotEq {}), + Cmpop::Lt {} => Ok(Cmpop::Lt {}), + Cmpop::LtE {} => Ok(Cmpop::LtE {}), + Cmpop::Gt {} => Ok(Cmpop::Gt {}), + Cmpop::GtE {} => Ok(Cmpop::GtE {}), + Cmpop::Is {} => Ok(Cmpop::Is {}), + Cmpop::IsNot {} => Ok(Cmpop::IsNot {}), + Cmpop::In {} => Ok(Cmpop::In {}), + Cmpop::NotIn {} => Ok(Cmpop::NotIn {}), + } +} +impl Foldable for Comprehension { + type Mapped = Comprehension; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_comprehension(self) + } +} +pub fn fold_comprehension + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Comprehension, +) -> Result, F::Error> { + let Comprehension { + target, + iter, + ifs, + is_async, + } = node; + Ok(Comprehension { + target: Foldable::fold(target, folder)?, + iter: Foldable::fold(iter, folder)?, + ifs: Foldable::fold(ifs, folder)?, + is_async: Foldable::fold(is_async, folder)?, + }) +} +impl Foldable for Excepthandler { + type Mapped = Excepthandler; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_excepthandler(self) + } +} +pub fn fold_excepthandler + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Excepthandler, +) -> Result, F::Error> { + fold_attributed(folder, node, |folder, node| match node { + ExcepthandlerKind::ExceptHandler(ExcepthandlerExceptHandler { type_, name, body }) => Ok( + ExcepthandlerKind::ExceptHandler(ExcepthandlerExceptHandler { + type_: Foldable::fold(type_, folder)?, + name: Foldable::fold(name, folder)?, + body: Foldable::fold(body, folder)?, + }), + ), + }) +} +impl Foldable for Arguments { + type Mapped = Arguments; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_arguments(self) + } +} +pub fn fold_arguments + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Arguments, +) -> Result, F::Error> { + let Arguments { + posonlyargs, + args, + vararg, + kwonlyargs, + kw_defaults, + kwarg, + defaults, + } = node; + 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)?, + }) +} +impl Foldable for Arg { + type Mapped = Arg; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_arg(self) + } +} +pub fn fold_arg + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Arg, +) -> Result, F::Error> { + fold_attributed(folder, node, |folder, node| { + let ArgData { + arg, + annotation, + type_comment, + } = node; + Ok(ArgData { + arg: Foldable::fold(arg, folder)?, + annotation: Foldable::fold(annotation, folder)?, + type_comment: Foldable::fold(type_comment, folder)?, + }) + }) +} +impl Foldable for Keyword { + type Mapped = Keyword; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_keyword(self) + } +} +pub fn fold_keyword + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Keyword, +) -> Result, F::Error> { + fold_attributed(folder, node, |folder, node| { + let KeywordData { arg, value } = node; + Ok(KeywordData { + arg: Foldable::fold(arg, folder)?, + value: Foldable::fold(value, folder)?, + }) + }) +} +impl Foldable for Alias { + type Mapped = Alias; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_alias(self) + } +} +pub fn fold_alias + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Alias, +) -> Result, F::Error> { + fold_attributed(folder, node, |folder, node| { + let AliasData { name, asname } = node; + Ok(AliasData { + name: Foldable::fold(name, folder)?, + asname: Foldable::fold(asname, folder)?, + }) + }) +} +impl Foldable for Withitem { + type Mapped = Withitem; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_withitem(self) + } +} +pub fn fold_withitem + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Withitem, +) -> Result, F::Error> { + let Withitem { + context_expr, + optional_vars, + } = node; + Ok(Withitem { + context_expr: Foldable::fold(context_expr, folder)?, + optional_vars: Foldable::fold(optional_vars, folder)?, + }) +} +impl Foldable for MatchCase { + type Mapped = MatchCase; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_match_case(self) + } +} +pub fn fold_match_case + ?Sized>( + #[allow(unused)] folder: &mut F, + node: MatchCase, +) -> Result, F::Error> { + let MatchCase { + pattern, + guard, + body, + } = node; + Ok(MatchCase { + pattern: Foldable::fold(pattern, folder)?, + guard: Foldable::fold(guard, folder)?, + body: Foldable::fold(body, folder)?, + }) +} +impl Foldable for Pattern { + type Mapped = Pattern; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_pattern(self) + } +} +pub fn fold_pattern + ?Sized>( + #[allow(unused)] folder: &mut F, + node: Pattern, +) -> Result, F::Error> { + fold_attributed(folder, node, |folder, node| match node { + PatternKind::MatchValue(PatternMatchValue { value }) => { + Ok(PatternKind::MatchValue(PatternMatchValue { + value: Foldable::fold(value, folder)?, + })) + } + PatternKind::MatchSingleton(PatternMatchSingleton { value }) => { + Ok(PatternKind::MatchSingleton(PatternMatchSingleton { + value: Foldable::fold(value, folder)?, + })) + } + PatternKind::MatchSequence(PatternMatchSequence { patterns }) => { + Ok(PatternKind::MatchSequence(PatternMatchSequence { + patterns: Foldable::fold(patterns, folder)?, + })) + } + PatternKind::MatchMapping(PatternMatchMapping { + keys, + patterns, + rest, + }) => Ok(PatternKind::MatchMapping(PatternMatchMapping { + keys: Foldable::fold(keys, folder)?, + patterns: Foldable::fold(patterns, folder)?, + rest: Foldable::fold(rest, folder)?, + })), + PatternKind::MatchClass(PatternMatchClass { + cls, + patterns, + kwd_attrs, + kwd_patterns, + }) => Ok(PatternKind::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)?, + })), + PatternKind::MatchStar(PatternMatchStar { name }) => { + Ok(PatternKind::MatchStar(PatternMatchStar { + name: Foldable::fold(name, folder)?, + })) + } + PatternKind::MatchAs(PatternMatchAs { pattern, name }) => { + Ok(PatternKind::MatchAs(PatternMatchAs { + pattern: Foldable::fold(pattern, folder)?, + name: Foldable::fold(name, folder)?, + })) + } + PatternKind::MatchOr(PatternMatchOr { patterns }) => { + Ok(PatternKind::MatchOr(PatternMatchOr { + patterns: Foldable::fold(patterns, folder)?, + })) + } + }) +} +impl Foldable for TypeIgnore { + type Mapped = TypeIgnore; + fn fold + ?Sized>( + self, + folder: &mut F, + ) -> Result { + folder.fold_type_ignore(self) + } +} +pub fn fold_type_ignore + ?Sized>( + #[allow(unused)] folder: &mut F, + node: TypeIgnore, +) -> Result { + match node { + TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { lineno, tag }) => { + Ok(TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { + lineno: Foldable::fold(lineno, folder)?, + tag: Foldable::fold(tag, folder)?, + })) + } + } +} diff --git a/ast/src/gen/generic.rs b/ast/src/gen/generic.rs index be48836..0b830db 100644 --- a/ast/src/gen/generic.rs +++ b/ast/src/gen/generic.rs @@ -1,9 +1,5 @@ // File automatically generated by ast/asdl_rs.py. -pub use crate::{constant::*, Attributed}; - -type Ident = String; - #[derive(Clone, Debug, PartialEq)] pub struct ModModule { pub body: Vec>, @@ -1010,916 +1006,3 @@ impl From for TypeIgnore { pub enum TypeIgnore { TypeIgnore(TypeIgnoreTypeIgnore), } - -#[cfg(feature = "fold")] -pub mod fold { - use super::*; - use crate::fold_helpers::Foldable; - pub trait Fold { - type TargetU; - type Error; - fn map_user(&mut self, user: U) -> Result; - - fn map_attributed( - &mut self, - attributed: Attributed, - ) -> Result, Self::Error> { - let custom = self.map_user(attributed.custom)?; - Ok(Attributed { - range: attributed.range, - custom, - node: attributed.node, - }) - } - - fn fold>( - &mut self, - node: X, - ) -> Result { - node.fold(self) - } - fn fold_mod(&mut self, node: Mod) -> Result, Self::Error> { - fold_mod(self, node) - } - fn fold_stmt(&mut self, node: Stmt) -> Result, Self::Error> { - fold_stmt(self, node) - } - fn fold_expr(&mut self, node: Expr) -> Result, Self::Error> { - fold_expr(self, node) - } - fn fold_expr_context(&mut self, node: ExprContext) -> Result { - fold_expr_context(self, node) - } - fn fold_boolop(&mut self, node: Boolop) -> Result { - fold_boolop(self, node) - } - fn fold_operator(&mut self, node: Operator) -> Result { - fold_operator(self, node) - } - fn fold_unaryop(&mut self, node: Unaryop) -> Result { - fold_unaryop(self, node) - } - fn fold_cmpop(&mut self, node: Cmpop) -> Result { - fold_cmpop(self, node) - } - fn fold_comprehension( - &mut self, - node: Comprehension, - ) -> Result, Self::Error> { - fold_comprehension(self, node) - } - fn fold_excepthandler( - &mut self, - node: Excepthandler, - ) -> Result, Self::Error> { - fold_excepthandler(self, node) - } - fn fold_arguments( - &mut self, - node: Arguments, - ) -> Result, Self::Error> { - fold_arguments(self, node) - } - fn fold_arg(&mut self, node: Arg) -> Result, Self::Error> { - fold_arg(self, node) - } - fn fold_keyword( - &mut self, - node: Keyword, - ) -> Result, Self::Error> { - fold_keyword(self, node) - } - fn fold_alias(&mut self, node: Alias) -> Result, Self::Error> { - fold_alias(self, node) - } - fn fold_withitem( - &mut self, - node: Withitem, - ) -> Result, Self::Error> { - fold_withitem(self, node) - } - fn fold_match_case( - &mut self, - node: MatchCase, - ) -> Result, Self::Error> { - fold_match_case(self, node) - } - fn fold_pattern( - &mut self, - node: Pattern, - ) -> Result, Self::Error> { - fold_pattern(self, node) - } - fn fold_type_ignore(&mut self, node: TypeIgnore) -> Result { - fold_type_ignore(self, node) - } - } - fn fold_attributed + ?Sized, T, MT>( - folder: &mut F, - node: Attributed, - f: impl FnOnce(&mut F, T) -> Result, - ) -> Result, F::Error> { - let node = folder.map_attributed(node)?; - Ok(Attributed { - custom: node.custom, - range: node.range, - node: f(folder, node.node)?, - }) - } - impl Foldable for Mod { - type Mapped = Mod; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_mod(self) - } - } - pub fn fold_mod + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Mod, - ) -> Result, F::Error> { - match node { - Mod::Module(ModModule { body, type_ignores }) => Ok(Mod::Module(ModModule { - body: Foldable::fold(body, folder)?, - type_ignores: Foldable::fold(type_ignores, folder)?, - })), - Mod::Interactive(ModInteractive { body }) => Ok(Mod::Interactive(ModInteractive { - body: Foldable::fold(body, folder)?, - })), - Mod::Expression(ModExpression { body }) => Ok(Mod::Expression(ModExpression { - body: Foldable::fold(body, folder)?, - })), - Mod::FunctionType(ModFunctionType { argtypes, returns }) => { - Ok(Mod::FunctionType(ModFunctionType { - argtypes: Foldable::fold(argtypes, folder)?, - returns: Foldable::fold(returns, folder)?, - })) - } - } - } - impl Foldable for Stmt { - type Mapped = Stmt; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_stmt(self) - } - } - pub fn fold_stmt + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Stmt, - ) -> Result, F::Error> { - fold_attributed(folder, node, |folder, node| match node { - StmtKind::FunctionDef(StmtFunctionDef { - name, - args, - body, - decorator_list, - returns, - type_comment, - }) => Ok(StmtKind::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)?, - })), - StmtKind::AsyncFunctionDef(StmtAsyncFunctionDef { - name, - args, - body, - decorator_list, - returns, - type_comment, - }) => Ok(StmtKind::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)?, - })), - StmtKind::ClassDef(StmtClassDef { - name, - bases, - keywords, - body, - decorator_list, - }) => Ok(StmtKind::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)?, - })), - StmtKind::Return(StmtReturn { value }) => Ok(StmtKind::Return(StmtReturn { - value: Foldable::fold(value, folder)?, - })), - StmtKind::Delete(StmtDelete { targets }) => Ok(StmtKind::Delete(StmtDelete { - targets: Foldable::fold(targets, folder)?, - })), - StmtKind::Assign(StmtAssign { - targets, - value, - type_comment, - }) => Ok(StmtKind::Assign(StmtAssign { - targets: Foldable::fold(targets, folder)?, - value: Foldable::fold(value, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - })), - StmtKind::AugAssign(StmtAugAssign { target, op, value }) => { - Ok(StmtKind::AugAssign(StmtAugAssign { - target: Foldable::fold(target, folder)?, - op: Foldable::fold(op, folder)?, - value: Foldable::fold(value, folder)?, - })) - } - StmtKind::AnnAssign(StmtAnnAssign { - target, - annotation, - value, - simple, - }) => Ok(StmtKind::AnnAssign(StmtAnnAssign { - target: Foldable::fold(target, folder)?, - annotation: Foldable::fold(annotation, folder)?, - value: Foldable::fold(value, folder)?, - simple: Foldable::fold(simple, folder)?, - })), - StmtKind::For(StmtFor { - target, - iter, - body, - orelse, - type_comment, - }) => Ok(StmtKind::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)?, - })), - StmtKind::AsyncFor(StmtAsyncFor { - target, - iter, - body, - orelse, - type_comment, - }) => Ok(StmtKind::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)?, - })), - StmtKind::While(StmtWhile { test, body, orelse }) => Ok(StmtKind::While(StmtWhile { - test: Foldable::fold(test, folder)?, - body: Foldable::fold(body, folder)?, - orelse: Foldable::fold(orelse, folder)?, - })), - StmtKind::If(StmtIf { test, body, orelse }) => Ok(StmtKind::If(StmtIf { - test: Foldable::fold(test, folder)?, - body: Foldable::fold(body, folder)?, - orelse: Foldable::fold(orelse, folder)?, - })), - StmtKind::With(StmtWith { - items, - body, - type_comment, - }) => Ok(StmtKind::With(StmtWith { - items: Foldable::fold(items, folder)?, - body: Foldable::fold(body, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - })), - StmtKind::AsyncWith(StmtAsyncWith { - items, - body, - type_comment, - }) => Ok(StmtKind::AsyncWith(StmtAsyncWith { - items: Foldable::fold(items, folder)?, - body: Foldable::fold(body, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - })), - StmtKind::Match(StmtMatch { subject, cases }) => Ok(StmtKind::Match(StmtMatch { - subject: Foldable::fold(subject, folder)?, - cases: Foldable::fold(cases, folder)?, - })), - StmtKind::Raise(StmtRaise { exc, cause }) => Ok(StmtKind::Raise(StmtRaise { - exc: Foldable::fold(exc, folder)?, - cause: Foldable::fold(cause, folder)?, - })), - StmtKind::Try(StmtTry { - body, - handlers, - orelse, - finalbody, - }) => Ok(StmtKind::Try(StmtTry { - body: Foldable::fold(body, folder)?, - handlers: Foldable::fold(handlers, folder)?, - orelse: Foldable::fold(orelse, folder)?, - finalbody: Foldable::fold(finalbody, folder)?, - })), - StmtKind::TryStar(StmtTryStar { - body, - handlers, - orelse, - finalbody, - }) => Ok(StmtKind::TryStar(StmtTryStar { - body: Foldable::fold(body, folder)?, - handlers: Foldable::fold(handlers, folder)?, - orelse: Foldable::fold(orelse, folder)?, - finalbody: Foldable::fold(finalbody, folder)?, - })), - StmtKind::Assert(StmtAssert { test, msg }) => Ok(StmtKind::Assert(StmtAssert { - test: Foldable::fold(test, folder)?, - msg: Foldable::fold(msg, folder)?, - })), - StmtKind::Import(StmtImport { names }) => Ok(StmtKind::Import(StmtImport { - names: Foldable::fold(names, folder)?, - })), - StmtKind::ImportFrom(StmtImportFrom { - module, - names, - level, - }) => Ok(StmtKind::ImportFrom(StmtImportFrom { - module: Foldable::fold(module, folder)?, - names: Foldable::fold(names, folder)?, - level: Foldable::fold(level, folder)?, - })), - StmtKind::Global(StmtGlobal { names }) => Ok(StmtKind::Global(StmtGlobal { - names: Foldable::fold(names, folder)?, - })), - StmtKind::Nonlocal(StmtNonlocal { names }) => Ok(StmtKind::Nonlocal(StmtNonlocal { - names: Foldable::fold(names, folder)?, - })), - StmtKind::Expr(StmtExpr { value }) => Ok(StmtKind::Expr(StmtExpr { - value: Foldable::fold(value, folder)?, - })), - StmtKind::Pass {} => Ok(StmtKind::Pass {}), - StmtKind::Break {} => Ok(StmtKind::Break {}), - StmtKind::Continue {} => Ok(StmtKind::Continue {}), - }) - } - impl Foldable for Expr { - type Mapped = Expr; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_expr(self) - } - } - pub fn fold_expr + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Expr, - ) -> Result, F::Error> { - fold_attributed(folder, node, |folder, node| match node { - ExprKind::BoolOp(ExprBoolOp { op, values }) => Ok(ExprKind::BoolOp(ExprBoolOp { - op: Foldable::fold(op, folder)?, - values: Foldable::fold(values, folder)?, - })), - ExprKind::NamedExpr(ExprNamedExpr { target, value }) => { - Ok(ExprKind::NamedExpr(ExprNamedExpr { - target: Foldable::fold(target, folder)?, - value: Foldable::fold(value, folder)?, - })) - } - ExprKind::BinOp(ExprBinOp { left, op, right }) => Ok(ExprKind::BinOp(ExprBinOp { - left: Foldable::fold(left, folder)?, - op: Foldable::fold(op, folder)?, - right: Foldable::fold(right, folder)?, - })), - ExprKind::UnaryOp(ExprUnaryOp { op, operand }) => Ok(ExprKind::UnaryOp(ExprUnaryOp { - op: Foldable::fold(op, folder)?, - operand: Foldable::fold(operand, folder)?, - })), - ExprKind::Lambda(ExprLambda { args, body }) => Ok(ExprKind::Lambda(ExprLambda { - args: Foldable::fold(args, folder)?, - body: Foldable::fold(body, folder)?, - })), - ExprKind::IfExp(ExprIfExp { test, body, orelse }) => Ok(ExprKind::IfExp(ExprIfExp { - test: Foldable::fold(test, folder)?, - body: Foldable::fold(body, folder)?, - orelse: Foldable::fold(orelse, folder)?, - })), - ExprKind::Dict(ExprDict { keys, values }) => Ok(ExprKind::Dict(ExprDict { - keys: Foldable::fold(keys, folder)?, - values: Foldable::fold(values, folder)?, - })), - ExprKind::Set(ExprSet { elts }) => Ok(ExprKind::Set(ExprSet { - elts: Foldable::fold(elts, folder)?, - })), - ExprKind::ListComp(ExprListComp { elt, generators }) => { - Ok(ExprKind::ListComp(ExprListComp { - elt: Foldable::fold(elt, folder)?, - generators: Foldable::fold(generators, folder)?, - })) - } - ExprKind::SetComp(ExprSetComp { elt, generators }) => { - Ok(ExprKind::SetComp(ExprSetComp { - elt: Foldable::fold(elt, folder)?, - generators: Foldable::fold(generators, folder)?, - })) - } - ExprKind::DictComp(ExprDictComp { - key, - value, - generators, - }) => Ok(ExprKind::DictComp(ExprDictComp { - key: Foldable::fold(key, folder)?, - value: Foldable::fold(value, folder)?, - generators: Foldable::fold(generators, folder)?, - })), - ExprKind::GeneratorExp(ExprGeneratorExp { elt, generators }) => { - Ok(ExprKind::GeneratorExp(ExprGeneratorExp { - elt: Foldable::fold(elt, folder)?, - generators: Foldable::fold(generators, folder)?, - })) - } - ExprKind::Await(ExprAwait { value }) => Ok(ExprKind::Await(ExprAwait { - value: Foldable::fold(value, folder)?, - })), - ExprKind::Yield(ExprYield { value }) => Ok(ExprKind::Yield(ExprYield { - value: Foldable::fold(value, folder)?, - })), - ExprKind::YieldFrom(ExprYieldFrom { value }) => { - Ok(ExprKind::YieldFrom(ExprYieldFrom { - value: Foldable::fold(value, folder)?, - })) - } - ExprKind::Compare(ExprCompare { - left, - ops, - comparators, - }) => Ok(ExprKind::Compare(ExprCompare { - left: Foldable::fold(left, folder)?, - ops: Foldable::fold(ops, folder)?, - comparators: Foldable::fold(comparators, folder)?, - })), - ExprKind::Call(ExprCall { - func, - args, - keywords, - }) => Ok(ExprKind::Call(ExprCall { - func: Foldable::fold(func, folder)?, - args: Foldable::fold(args, folder)?, - keywords: Foldable::fold(keywords, folder)?, - })), - ExprKind::FormattedValue(ExprFormattedValue { - value, - conversion, - format_spec, - }) => Ok(ExprKind::FormattedValue(ExprFormattedValue { - value: Foldable::fold(value, folder)?, - conversion: Foldable::fold(conversion, folder)?, - format_spec: Foldable::fold(format_spec, folder)?, - })), - ExprKind::JoinedStr(ExprJoinedStr { values }) => { - Ok(ExprKind::JoinedStr(ExprJoinedStr { - values: Foldable::fold(values, folder)?, - })) - } - ExprKind::Constant(ExprConstant { value, kind }) => { - Ok(ExprKind::Constant(ExprConstant { - value: Foldable::fold(value, folder)?, - kind: Foldable::fold(kind, folder)?, - })) - } - ExprKind::Attribute(ExprAttribute { value, attr, ctx }) => { - Ok(ExprKind::Attribute(ExprAttribute { - value: Foldable::fold(value, folder)?, - attr: Foldable::fold(attr, folder)?, - ctx: Foldable::fold(ctx, folder)?, - })) - } - ExprKind::Subscript(ExprSubscript { value, slice, ctx }) => { - Ok(ExprKind::Subscript(ExprSubscript { - value: Foldable::fold(value, folder)?, - slice: Foldable::fold(slice, folder)?, - ctx: Foldable::fold(ctx, folder)?, - })) - } - ExprKind::Starred(ExprStarred { value, ctx }) => Ok(ExprKind::Starred(ExprStarred { - value: Foldable::fold(value, folder)?, - ctx: Foldable::fold(ctx, folder)?, - })), - ExprKind::Name(ExprName { id, ctx }) => Ok(ExprKind::Name(ExprName { - id: Foldable::fold(id, folder)?, - ctx: Foldable::fold(ctx, folder)?, - })), - ExprKind::List(ExprList { elts, ctx }) => Ok(ExprKind::List(ExprList { - elts: Foldable::fold(elts, folder)?, - ctx: Foldable::fold(ctx, folder)?, - })), - ExprKind::Tuple(ExprTuple { elts, ctx }) => Ok(ExprKind::Tuple(ExprTuple { - elts: Foldable::fold(elts, folder)?, - ctx: Foldable::fold(ctx, folder)?, - })), - ExprKind::Slice(ExprSlice { lower, upper, step }) => Ok(ExprKind::Slice(ExprSlice { - lower: Foldable::fold(lower, folder)?, - upper: Foldable::fold(upper, folder)?, - step: Foldable::fold(step, folder)?, - })), - }) - } - impl Foldable for ExprContext { - type Mapped = ExprContext; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_expr_context(self) - } - } - pub fn fold_expr_context + ?Sized>( - #[allow(unused)] folder: &mut F, - node: ExprContext, - ) -> Result { - match node { - ExprContext::Load {} => Ok(ExprContext::Load {}), - ExprContext::Store {} => Ok(ExprContext::Store {}), - ExprContext::Del {} => Ok(ExprContext::Del {}), - } - } - impl Foldable for Boolop { - type Mapped = Boolop; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_boolop(self) - } - } - pub fn fold_boolop + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Boolop, - ) -> Result { - match node { - Boolop::And {} => Ok(Boolop::And {}), - Boolop::Or {} => Ok(Boolop::Or {}), - } - } - impl Foldable for Operator { - type Mapped = Operator; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_operator(self) - } - } - pub fn fold_operator + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Operator, - ) -> Result { - match node { - Operator::Add {} => Ok(Operator::Add {}), - Operator::Sub {} => Ok(Operator::Sub {}), - Operator::Mult {} => Ok(Operator::Mult {}), - Operator::MatMult {} => Ok(Operator::MatMult {}), - Operator::Div {} => Ok(Operator::Div {}), - Operator::Mod {} => Ok(Operator::Mod {}), - Operator::Pow {} => Ok(Operator::Pow {}), - Operator::LShift {} => Ok(Operator::LShift {}), - Operator::RShift {} => Ok(Operator::RShift {}), - Operator::BitOr {} => Ok(Operator::BitOr {}), - Operator::BitXor {} => Ok(Operator::BitXor {}), - Operator::BitAnd {} => Ok(Operator::BitAnd {}), - Operator::FloorDiv {} => Ok(Operator::FloorDiv {}), - } - } - impl Foldable for Unaryop { - type Mapped = Unaryop; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_unaryop(self) - } - } - pub fn fold_unaryop + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Unaryop, - ) -> Result { - match node { - Unaryop::Invert {} => Ok(Unaryop::Invert {}), - Unaryop::Not {} => Ok(Unaryop::Not {}), - Unaryop::UAdd {} => Ok(Unaryop::UAdd {}), - Unaryop::USub {} => Ok(Unaryop::USub {}), - } - } - impl Foldable for Cmpop { - type Mapped = Cmpop; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_cmpop(self) - } - } - pub fn fold_cmpop + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Cmpop, - ) -> Result { - match node { - Cmpop::Eq {} => Ok(Cmpop::Eq {}), - Cmpop::NotEq {} => Ok(Cmpop::NotEq {}), - Cmpop::Lt {} => Ok(Cmpop::Lt {}), - Cmpop::LtE {} => Ok(Cmpop::LtE {}), - Cmpop::Gt {} => Ok(Cmpop::Gt {}), - Cmpop::GtE {} => Ok(Cmpop::GtE {}), - Cmpop::Is {} => Ok(Cmpop::Is {}), - Cmpop::IsNot {} => Ok(Cmpop::IsNot {}), - Cmpop::In {} => Ok(Cmpop::In {}), - Cmpop::NotIn {} => Ok(Cmpop::NotIn {}), - } - } - impl Foldable for Comprehension { - type Mapped = Comprehension; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_comprehension(self) - } - } - pub fn fold_comprehension + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Comprehension, - ) -> Result, F::Error> { - let Comprehension { - target, - iter, - ifs, - is_async, - } = node; - Ok(Comprehension { - target: Foldable::fold(target, folder)?, - iter: Foldable::fold(iter, folder)?, - ifs: Foldable::fold(ifs, folder)?, - is_async: Foldable::fold(is_async, folder)?, - }) - } - impl Foldable for Excepthandler { - type Mapped = Excepthandler; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_excepthandler(self) - } - } - pub fn fold_excepthandler + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Excepthandler, - ) -> Result, F::Error> { - fold_attributed(folder, node, |folder, node| match node { - ExcepthandlerKind::ExceptHandler(ExcepthandlerExceptHandler { type_, name, body }) => { - Ok(ExcepthandlerKind::ExceptHandler( - ExcepthandlerExceptHandler { - type_: Foldable::fold(type_, folder)?, - name: Foldable::fold(name, folder)?, - body: Foldable::fold(body, folder)?, - }, - )) - } - }) - } - impl Foldable for Arguments { - type Mapped = Arguments; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_arguments(self) - } - } - pub fn fold_arguments + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Arguments, - ) -> Result, F::Error> { - let Arguments { - posonlyargs, - args, - vararg, - kwonlyargs, - kw_defaults, - kwarg, - defaults, - } = node; - 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)?, - }) - } - impl Foldable for Arg { - type Mapped = Arg; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_arg(self) - } - } - pub fn fold_arg + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Arg, - ) -> Result, F::Error> { - fold_attributed(folder, node, |folder, node| { - let ArgData { - arg, - annotation, - type_comment, - } = node; - Ok(ArgData { - arg: Foldable::fold(arg, folder)?, - annotation: Foldable::fold(annotation, folder)?, - type_comment: Foldable::fold(type_comment, folder)?, - }) - }) - } - impl Foldable for Keyword { - type Mapped = Keyword; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_keyword(self) - } - } - pub fn fold_keyword + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Keyword, - ) -> Result, F::Error> { - fold_attributed(folder, node, |folder, node| { - let KeywordData { arg, value } = node; - Ok(KeywordData { - arg: Foldable::fold(arg, folder)?, - value: Foldable::fold(value, folder)?, - }) - }) - } - impl Foldable for Alias { - type Mapped = Alias; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_alias(self) - } - } - pub fn fold_alias + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Alias, - ) -> Result, F::Error> { - fold_attributed(folder, node, |folder, node| { - let AliasData { name, asname } = node; - Ok(AliasData { - name: Foldable::fold(name, folder)?, - asname: Foldable::fold(asname, folder)?, - }) - }) - } - impl Foldable for Withitem { - type Mapped = Withitem; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_withitem(self) - } - } - pub fn fold_withitem + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Withitem, - ) -> Result, F::Error> { - let Withitem { - context_expr, - optional_vars, - } = node; - Ok(Withitem { - context_expr: Foldable::fold(context_expr, folder)?, - optional_vars: Foldable::fold(optional_vars, folder)?, - }) - } - impl Foldable for MatchCase { - type Mapped = MatchCase; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_match_case(self) - } - } - pub fn fold_match_case + ?Sized>( - #[allow(unused)] folder: &mut F, - node: MatchCase, - ) -> Result, F::Error> { - let MatchCase { - pattern, - guard, - body, - } = node; - Ok(MatchCase { - pattern: Foldable::fold(pattern, folder)?, - guard: Foldable::fold(guard, folder)?, - body: Foldable::fold(body, folder)?, - }) - } - impl Foldable for Pattern { - type Mapped = Pattern; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_pattern(self) - } - } - pub fn fold_pattern + ?Sized>( - #[allow(unused)] folder: &mut F, - node: Pattern, - ) -> Result, F::Error> { - fold_attributed(folder, node, |folder, node| match node { - PatternKind::MatchValue(PatternMatchValue { value }) => { - Ok(PatternKind::MatchValue(PatternMatchValue { - value: Foldable::fold(value, folder)?, - })) - } - PatternKind::MatchSingleton(PatternMatchSingleton { value }) => { - Ok(PatternKind::MatchSingleton(PatternMatchSingleton { - value: Foldable::fold(value, folder)?, - })) - } - PatternKind::MatchSequence(PatternMatchSequence { patterns }) => { - Ok(PatternKind::MatchSequence(PatternMatchSequence { - patterns: Foldable::fold(patterns, folder)?, - })) - } - PatternKind::MatchMapping(PatternMatchMapping { - keys, - patterns, - rest, - }) => Ok(PatternKind::MatchMapping(PatternMatchMapping { - keys: Foldable::fold(keys, folder)?, - patterns: Foldable::fold(patterns, folder)?, - rest: Foldable::fold(rest, folder)?, - })), - PatternKind::MatchClass(PatternMatchClass { - cls, - patterns, - kwd_attrs, - kwd_patterns, - }) => Ok(PatternKind::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)?, - })), - PatternKind::MatchStar(PatternMatchStar { name }) => { - Ok(PatternKind::MatchStar(PatternMatchStar { - name: Foldable::fold(name, folder)?, - })) - } - PatternKind::MatchAs(PatternMatchAs { pattern, name }) => { - Ok(PatternKind::MatchAs(PatternMatchAs { - pattern: Foldable::fold(pattern, folder)?, - name: Foldable::fold(name, folder)?, - })) - } - PatternKind::MatchOr(PatternMatchOr { patterns }) => { - Ok(PatternKind::MatchOr(PatternMatchOr { - patterns: Foldable::fold(patterns, folder)?, - })) - } - }) - } - impl Foldable for TypeIgnore { - type Mapped = TypeIgnore; - fn fold + ?Sized>( - self, - folder: &mut F, - ) -> Result { - folder.fold_type_ignore(self) - } - } - pub fn fold_type_ignore + ?Sized>( - #[allow(unused)] folder: &mut F, - node: TypeIgnore, - ) -> Result { - match node { - TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { lineno, tag }) => { - Ok(TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { - lineno: Foldable::fold(lineno, folder)?, - tag: Foldable::fold(tag, folder)?, - })) - } - } - } -} diff --git a/ast/src/gen/visitor.rs b/ast/src/gen/visitor.rs new file mode 100644 index 0000000..55a740d --- /dev/null +++ b/ast/src/gen/visitor.rs @@ -0,0 +1,822 @@ +// File automatically generated by ast/asdl_rs.py. + +#[allow(unused_variables, non_snake_case)] +pub trait Visitor { + fn visit_stmt(&mut self, node: Stmt) { + self.generic_visit_stmt(node) + } + fn generic_visit_stmt(&mut self, node: Stmt) { + match node.node { + StmtKind::FunctionDef(data) => self.visit_stmt_FunctionDef(data), + StmtKind::AsyncFunctionDef(data) => self.visit_stmt_AsyncFunctionDef(data), + StmtKind::ClassDef(data) => self.visit_stmt_ClassDef(data), + StmtKind::Return(data) => self.visit_stmt_Return(data), + StmtKind::Delete(data) => self.visit_stmt_Delete(data), + StmtKind::Assign(data) => self.visit_stmt_Assign(data), + StmtKind::AugAssign(data) => self.visit_stmt_AugAssign(data), + StmtKind::AnnAssign(data) => self.visit_stmt_AnnAssign(data), + StmtKind::For(data) => self.visit_stmt_For(data), + StmtKind::AsyncFor(data) => self.visit_stmt_AsyncFor(data), + StmtKind::While(data) => self.visit_stmt_While(data), + StmtKind::If(data) => self.visit_stmt_If(data), + StmtKind::With(data) => self.visit_stmt_With(data), + StmtKind::AsyncWith(data) => self.visit_stmt_AsyncWith(data), + StmtKind::Match(data) => self.visit_stmt_Match(data), + StmtKind::Raise(data) => self.visit_stmt_Raise(data), + StmtKind::Try(data) => self.visit_stmt_Try(data), + StmtKind::TryStar(data) => self.visit_stmt_TryStar(data), + StmtKind::Assert(data) => self.visit_stmt_Assert(data), + StmtKind::Import(data) => self.visit_stmt_Import(data), + StmtKind::ImportFrom(data) => self.visit_stmt_ImportFrom(data), + StmtKind::Global(data) => self.visit_stmt_Global(data), + StmtKind::Nonlocal(data) => self.visit_stmt_Nonlocal(data), + StmtKind::Expr(data) => self.visit_stmt_Expr(data), + StmtKind::Pass => self.visit_stmt_Pass(()), + StmtKind::Break => self.visit_stmt_Break(()), + StmtKind::Continue => self.visit_stmt_Continue(()), + } + } + fn visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef) { + self.generic_visit_stmt_FunctionDef(node) + } + fn generic_visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef) { + { + let value = node.args; + self.visit_arguments(*value); + } + for value in node.body { + self.visit_stmt(value); + } + for value in node.decorator_list { + self.visit_expr(value); + } + if let Some(value) = node.returns { + self.visit_expr(*value); + } + } + fn visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef) { + self.generic_visit_stmt_AsyncFunctionDef(node) + } + fn generic_visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef) { + { + let value = node.args; + self.visit_arguments(*value); + } + for value in node.body { + self.visit_stmt(value); + } + for value in node.decorator_list { + self.visit_expr(value); + } + if let Some(value) = node.returns { + self.visit_expr(*value); + } + } + fn visit_stmt_ClassDef(&mut self, node: StmtClassDef) { + self.generic_visit_stmt_ClassDef(node) + } + fn generic_visit_stmt_ClassDef(&mut self, node: StmtClassDef) { + for value in node.bases { + self.visit_expr(value); + } + for value in node.keywords { + self.visit_keyword(value); + } + for value in node.body { + self.visit_stmt(value); + } + for value in node.decorator_list { + self.visit_expr(value); + } + } + fn visit_stmt_Return(&mut self, node: StmtReturn) { + self.generic_visit_stmt_Return(node) + } + fn generic_visit_stmt_Return(&mut self, node: StmtReturn) { + if let Some(value) = node.value { + self.visit_expr(*value); + } + } + fn visit_stmt_Delete(&mut self, node: StmtDelete) { + self.generic_visit_stmt_Delete(node) + } + fn generic_visit_stmt_Delete(&mut self, node: StmtDelete) { + for value in node.targets { + self.visit_expr(value); + } + } + fn visit_stmt_Assign(&mut self, node: StmtAssign) { + self.generic_visit_stmt_Assign(node) + } + fn generic_visit_stmt_Assign(&mut self, node: StmtAssign) { + for value in node.targets { + self.visit_expr(value); + } + { + let value = node.value; + self.visit_expr(*value); + } + } + fn visit_stmt_AugAssign(&mut self, node: StmtAugAssign) { + self.generic_visit_stmt_AugAssign(node) + } + fn generic_visit_stmt_AugAssign(&mut self, node: StmtAugAssign) { + { + let value = node.target; + self.visit_expr(*value); + } + { + let value = node.value; + self.visit_expr(*value); + } + } + fn visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign) { + self.generic_visit_stmt_AnnAssign(node) + } + fn generic_visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign) { + { + let value = node.target; + self.visit_expr(*value); + } + { + let value = node.annotation; + self.visit_expr(*value); + } + if let Some(value) = node.value { + self.visit_expr(*value); + } + } + fn visit_stmt_For(&mut self, node: StmtFor) { + self.generic_visit_stmt_For(node) + } + fn generic_visit_stmt_For(&mut self, node: StmtFor) { + { + let value = node.target; + self.visit_expr(*value); + } + { + let value = node.iter; + self.visit_expr(*value); + } + for value in node.body { + self.visit_stmt(value); + } + for value in node.orelse { + self.visit_stmt(value); + } + } + fn visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor) { + self.generic_visit_stmt_AsyncFor(node) + } + fn generic_visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor) { + { + let value = node.target; + self.visit_expr(*value); + } + { + let value = node.iter; + self.visit_expr(*value); + } + for value in node.body { + self.visit_stmt(value); + } + for value in node.orelse { + self.visit_stmt(value); + } + } + fn visit_stmt_While(&mut self, node: StmtWhile) { + self.generic_visit_stmt_While(node) + } + fn generic_visit_stmt_While(&mut self, node: StmtWhile) { + { + let value = node.test; + self.visit_expr(*value); + } + for value in node.body { + self.visit_stmt(value); + } + for value in node.orelse { + self.visit_stmt(value); + } + } + fn visit_stmt_If(&mut self, node: StmtIf) { + self.generic_visit_stmt_If(node) + } + fn generic_visit_stmt_If(&mut self, node: StmtIf) { + { + let value = node.test; + self.visit_expr(*value); + } + for value in node.body { + self.visit_stmt(value); + } + for value in node.orelse { + self.visit_stmt(value); + } + } + fn visit_stmt_With(&mut self, node: StmtWith) { + self.generic_visit_stmt_With(node) + } + fn generic_visit_stmt_With(&mut self, node: StmtWith) { + for value in node.items { + self.visit_withitem(value); + } + for value in node.body { + self.visit_stmt(value); + } + } + fn visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith) { + self.generic_visit_stmt_AsyncWith(node) + } + fn generic_visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith) { + for value in node.items { + self.visit_withitem(value); + } + for value in node.body { + self.visit_stmt(value); + } + } + fn visit_stmt_Match(&mut self, node: StmtMatch) { + self.generic_visit_stmt_Match(node) + } + fn generic_visit_stmt_Match(&mut self, node: StmtMatch) { + { + let value = node.subject; + self.visit_expr(*value); + } + for value in node.cases { + self.visit_match_case(value); + } + } + fn visit_stmt_Raise(&mut self, node: StmtRaise) { + self.generic_visit_stmt_Raise(node) + } + fn generic_visit_stmt_Raise(&mut self, node: StmtRaise) { + if let Some(value) = node.exc { + self.visit_expr(*value); + } + if let Some(value) = node.cause { + self.visit_expr(*value); + } + } + fn visit_stmt_Try(&mut self, node: StmtTry) { + self.generic_visit_stmt_Try(node) + } + fn generic_visit_stmt_Try(&mut self, node: StmtTry) { + for value in node.body { + self.visit_stmt(value); + } + for value in node.handlers { + self.visit_excepthandler(value); + } + for value in node.orelse { + self.visit_stmt(value); + } + for value in node.finalbody { + self.visit_stmt(value); + } + } + fn visit_stmt_TryStar(&mut self, node: StmtTryStar) { + self.generic_visit_stmt_TryStar(node) + } + fn generic_visit_stmt_TryStar(&mut self, node: StmtTryStar) { + for value in node.body { + self.visit_stmt(value); + } + for value in node.handlers { + self.visit_excepthandler(value); + } + for value in node.orelse { + self.visit_stmt(value); + } + for value in node.finalbody { + self.visit_stmt(value); + } + } + fn visit_stmt_Assert(&mut self, node: StmtAssert) { + self.generic_visit_stmt_Assert(node) + } + fn generic_visit_stmt_Assert(&mut self, node: StmtAssert) { + { + let value = node.test; + self.visit_expr(*value); + } + if let Some(value) = node.msg { + self.visit_expr(*value); + } + } + fn visit_stmt_Import(&mut self, node: StmtImport) { + self.generic_visit_stmt_Import(node) + } + fn generic_visit_stmt_Import(&mut self, node: StmtImport) { + for value in node.names { + self.visit_alias(value); + } + } + fn visit_stmt_ImportFrom(&mut self, node: StmtImportFrom) { + self.generic_visit_stmt_ImportFrom(node) + } + fn generic_visit_stmt_ImportFrom(&mut self, node: StmtImportFrom) { + for value in node.names { + self.visit_alias(value); + } + } + fn visit_stmt_Global(&mut self, node: StmtGlobal) { + self.generic_visit_stmt_Global(node) + } + fn generic_visit_stmt_Global(&mut self, node: StmtGlobal) {} + fn visit_stmt_Nonlocal(&mut self, node: StmtNonlocal) { + self.generic_visit_stmt_Nonlocal(node) + } + fn generic_visit_stmt_Nonlocal(&mut self, node: StmtNonlocal) {} + fn visit_stmt_Expr(&mut self, node: StmtExpr) { + self.generic_visit_stmt_Expr(node) + } + fn generic_visit_stmt_Expr(&mut self, node: StmtExpr) { + { + let value = node.value; + self.visit_expr(*value); + } + } + fn visit_stmt_Pass(&mut self, node: ()) { + self.generic_visit_stmt_Pass(()) + } + fn generic_visit_stmt_Pass(&mut self, node: ()) {} + fn visit_stmt_Break(&mut self, node: ()) { + self.generic_visit_stmt_Break(()) + } + fn generic_visit_stmt_Break(&mut self, node: ()) {} + fn visit_stmt_Continue(&mut self, node: ()) { + self.generic_visit_stmt_Continue(()) + } + fn generic_visit_stmt_Continue(&mut self, node: ()) {} + fn visit_expr(&mut self, node: Expr) { + self.generic_visit_expr(node) + } + fn generic_visit_expr(&mut self, node: Expr) { + match node.node { + ExprKind::BoolOp(data) => self.visit_expr_BoolOp(data), + ExprKind::NamedExpr(data) => self.visit_expr_NamedExpr(data), + ExprKind::BinOp(data) => self.visit_expr_BinOp(data), + ExprKind::UnaryOp(data) => self.visit_expr_UnaryOp(data), + ExprKind::Lambda(data) => self.visit_expr_Lambda(data), + ExprKind::IfExp(data) => self.visit_expr_IfExp(data), + ExprKind::Dict(data) => self.visit_expr_Dict(data), + ExprKind::Set(data) => self.visit_expr_Set(data), + ExprKind::ListComp(data) => self.visit_expr_ListComp(data), + ExprKind::SetComp(data) => self.visit_expr_SetComp(data), + ExprKind::DictComp(data) => self.visit_expr_DictComp(data), + ExprKind::GeneratorExp(data) => self.visit_expr_GeneratorExp(data), + ExprKind::Await(data) => self.visit_expr_Await(data), + ExprKind::Yield(data) => self.visit_expr_Yield(data), + ExprKind::YieldFrom(data) => self.visit_expr_YieldFrom(data), + ExprKind::Compare(data) => self.visit_expr_Compare(data), + ExprKind::Call(data) => self.visit_expr_Call(data), + ExprKind::FormattedValue(data) => self.visit_expr_FormattedValue(data), + ExprKind::JoinedStr(data) => self.visit_expr_JoinedStr(data), + ExprKind::Constant(data) => self.visit_expr_Constant(data), + ExprKind::Attribute(data) => self.visit_expr_Attribute(data), + ExprKind::Subscript(data) => self.visit_expr_Subscript(data), + ExprKind::Starred(data) => self.visit_expr_Starred(data), + ExprKind::Name(data) => self.visit_expr_Name(data), + ExprKind::List(data) => self.visit_expr_List(data), + ExprKind::Tuple(data) => self.visit_expr_Tuple(data), + ExprKind::Slice(data) => self.visit_expr_Slice(data), + } + } + fn visit_expr_BoolOp(&mut self, node: ExprBoolOp) { + self.generic_visit_expr_BoolOp(node) + } + fn generic_visit_expr_BoolOp(&mut self, node: ExprBoolOp) { + for value in node.values { + self.visit_expr(value); + } + } + fn visit_expr_NamedExpr(&mut self, node: ExprNamedExpr) { + self.generic_visit_expr_NamedExpr(node) + } + fn generic_visit_expr_NamedExpr(&mut self, node: ExprNamedExpr) { + { + let value = node.target; + self.visit_expr(*value); + } + { + let value = node.value; + self.visit_expr(*value); + } + } + fn visit_expr_BinOp(&mut self, node: ExprBinOp) { + self.generic_visit_expr_BinOp(node) + } + fn generic_visit_expr_BinOp(&mut self, node: ExprBinOp) { + { + let value = node.left; + self.visit_expr(*value); + } + { + let value = node.right; + self.visit_expr(*value); + } + } + fn visit_expr_UnaryOp(&mut self, node: ExprUnaryOp) { + self.generic_visit_expr_UnaryOp(node) + } + fn generic_visit_expr_UnaryOp(&mut self, node: ExprUnaryOp) { + { + let value = node.operand; + self.visit_expr(*value); + } + } + fn visit_expr_Lambda(&mut self, node: ExprLambda) { + self.generic_visit_expr_Lambda(node) + } + fn generic_visit_expr_Lambda(&mut self, node: ExprLambda) { + { + let value = node.args; + self.visit_arguments(*value); + } + { + let value = node.body; + self.visit_expr(*value); + } + } + fn visit_expr_IfExp(&mut self, node: ExprIfExp) { + self.generic_visit_expr_IfExp(node) + } + fn generic_visit_expr_IfExp(&mut self, node: ExprIfExp) { + { + let value = node.test; + self.visit_expr(*value); + } + { + let value = node.body; + self.visit_expr(*value); + } + { + let value = node.orelse; + self.visit_expr(*value); + } + } + fn visit_expr_Dict(&mut self, node: ExprDict) { + self.generic_visit_expr_Dict(node) + } + fn generic_visit_expr_Dict(&mut self, node: ExprDict) { + for value in node.keys.into_iter().flatten() { + self.visit_expr(value); + } + for value in node.values { + self.visit_expr(value); + } + } + fn visit_expr_Set(&mut self, node: ExprSet) { + self.generic_visit_expr_Set(node) + } + fn generic_visit_expr_Set(&mut self, node: ExprSet) { + for value in node.elts { + self.visit_expr(value); + } + } + fn visit_expr_ListComp(&mut self, node: ExprListComp) { + self.generic_visit_expr_ListComp(node) + } + fn generic_visit_expr_ListComp(&mut self, node: ExprListComp) { + { + let value = node.elt; + self.visit_expr(*value); + } + for value in node.generators { + self.visit_comprehension(value); + } + } + fn visit_expr_SetComp(&mut self, node: ExprSetComp) { + self.generic_visit_expr_SetComp(node) + } + fn generic_visit_expr_SetComp(&mut self, node: ExprSetComp) { + { + let value = node.elt; + self.visit_expr(*value); + } + for value in node.generators { + self.visit_comprehension(value); + } + } + fn visit_expr_DictComp(&mut self, node: ExprDictComp) { + self.generic_visit_expr_DictComp(node) + } + fn generic_visit_expr_DictComp(&mut self, node: ExprDictComp) { + { + let value = node.key; + self.visit_expr(*value); + } + { + let value = node.value; + self.visit_expr(*value); + } + for value in node.generators { + self.visit_comprehension(value); + } + } + fn visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp) { + self.generic_visit_expr_GeneratorExp(node) + } + fn generic_visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp) { + { + let value = node.elt; + self.visit_expr(*value); + } + for value in node.generators { + self.visit_comprehension(value); + } + } + fn visit_expr_Await(&mut self, node: ExprAwait) { + self.generic_visit_expr_Await(node) + } + fn generic_visit_expr_Await(&mut self, node: ExprAwait) { + { + let value = node.value; + self.visit_expr(*value); + } + } + fn visit_expr_Yield(&mut self, node: ExprYield) { + self.generic_visit_expr_Yield(node) + } + fn generic_visit_expr_Yield(&mut self, node: ExprYield) { + if let Some(value) = node.value { + self.visit_expr(*value); + } + } + fn visit_expr_YieldFrom(&mut self, node: ExprYieldFrom) { + self.generic_visit_expr_YieldFrom(node) + } + fn generic_visit_expr_YieldFrom(&mut self, node: ExprYieldFrom) { + { + let value = node.value; + self.visit_expr(*value); + } + } + fn visit_expr_Compare(&mut self, node: ExprCompare) { + self.generic_visit_expr_Compare(node) + } + fn generic_visit_expr_Compare(&mut self, node: ExprCompare) { + { + let value = node.left; + self.visit_expr(*value); + } + for value in node.comparators { + self.visit_expr(value); + } + } + fn visit_expr_Call(&mut self, node: ExprCall) { + self.generic_visit_expr_Call(node) + } + fn generic_visit_expr_Call(&mut self, node: ExprCall) { + { + let value = node.func; + self.visit_expr(*value); + } + for value in node.args { + self.visit_expr(value); + } + for value in node.keywords { + self.visit_keyword(value); + } + } + fn visit_expr_FormattedValue(&mut self, node: ExprFormattedValue) { + self.generic_visit_expr_FormattedValue(node) + } + fn generic_visit_expr_FormattedValue(&mut self, node: ExprFormattedValue) { + { + let value = node.value; + self.visit_expr(*value); + } + if let Some(value) = node.format_spec { + self.visit_expr(*value); + } + } + fn visit_expr_JoinedStr(&mut self, node: ExprJoinedStr) { + self.generic_visit_expr_JoinedStr(node) + } + fn generic_visit_expr_JoinedStr(&mut self, node: ExprJoinedStr) { + for value in node.values { + self.visit_expr(value); + } + } + fn visit_expr_Constant(&mut self, node: ExprConstant) { + self.generic_visit_expr_Constant(node) + } + fn generic_visit_expr_Constant(&mut self, node: ExprConstant) {} + fn visit_expr_Attribute(&mut self, node: ExprAttribute) { + self.generic_visit_expr_Attribute(node) + } + fn generic_visit_expr_Attribute(&mut self, node: ExprAttribute) { + { + let value = node.value; + self.visit_expr(*value); + } + } + fn visit_expr_Subscript(&mut self, node: ExprSubscript) { + self.generic_visit_expr_Subscript(node) + } + fn generic_visit_expr_Subscript(&mut self, node: ExprSubscript) { + { + let value = node.value; + self.visit_expr(*value); + } + { + let value = node.slice; + self.visit_expr(*value); + } + } + fn visit_expr_Starred(&mut self, node: ExprStarred) { + self.generic_visit_expr_Starred(node) + } + fn generic_visit_expr_Starred(&mut self, node: ExprStarred) { + { + let value = node.value; + self.visit_expr(*value); + } + } + fn visit_expr_Name(&mut self, node: ExprName) { + self.generic_visit_expr_Name(node) + } + fn generic_visit_expr_Name(&mut self, node: ExprName) {} + fn visit_expr_List(&mut self, node: ExprList) { + self.generic_visit_expr_List(node) + } + fn generic_visit_expr_List(&mut self, node: ExprList) { + for value in node.elts { + self.visit_expr(value); + } + } + fn visit_expr_Tuple(&mut self, node: ExprTuple) { + self.generic_visit_expr_Tuple(node) + } + fn generic_visit_expr_Tuple(&mut self, node: ExprTuple) { + for value in node.elts { + self.visit_expr(value); + } + } + fn visit_expr_Slice(&mut self, node: ExprSlice) { + self.generic_visit_expr_Slice(node) + } + fn generic_visit_expr_Slice(&mut self, node: ExprSlice) { + if let Some(value) = node.lower { + self.visit_expr(*value); + } + if let Some(value) = node.upper { + self.visit_expr(*value); + } + if let Some(value) = node.step { + self.visit_expr(*value); + } + } + fn visit_expr_context(&mut self, node: ExprContext) { + self.generic_visit_expr_context(node) + } + fn generic_visit_expr_context(&mut self, node: ExprContext) {} + fn visit_boolop(&mut self, node: Boolop) { + self.generic_visit_boolop(node) + } + fn generic_visit_boolop(&mut self, node: Boolop) {} + fn visit_operator(&mut self, node: Operator) { + self.generic_visit_operator(node) + } + fn generic_visit_operator(&mut self, node: Operator) {} + fn visit_unaryop(&mut self, node: Unaryop) { + self.generic_visit_unaryop(node) + } + fn generic_visit_unaryop(&mut self, node: Unaryop) {} + fn visit_cmpop(&mut self, node: Cmpop) { + self.generic_visit_cmpop(node) + } + fn generic_visit_cmpop(&mut self, node: Cmpop) {} + fn visit_comprehension(&mut self, node: Comprehension) { + self.generic_visit_comprehension(node) + } + fn generic_visit_comprehension(&mut self, node: Comprehension) {} + fn visit_excepthandler(&mut self, node: Excepthandler) { + self.generic_visit_excepthandler(node) + } + fn generic_visit_excepthandler(&mut self, node: Excepthandler) { + match node.node { + ExcepthandlerKind::ExceptHandler(data) => self.visit_excepthandler_ExceptHandler(data), + } + } + fn visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler) { + self.generic_visit_excepthandler_ExceptHandler(node) + } + fn generic_visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler) { + if let Some(value) = node.type_ { + self.visit_expr(*value); + } + for value in node.body { + self.visit_stmt(value); + } + } + fn visit_arguments(&mut self, node: Arguments) { + self.generic_visit_arguments(node) + } + fn generic_visit_arguments(&mut self, node: Arguments) {} + fn visit_arg(&mut self, node: Arg) { + self.generic_visit_arg(node) + } + fn generic_visit_arg(&mut self, node: Arg) {} + fn visit_keyword(&mut self, node: Keyword) { + self.generic_visit_keyword(node) + } + fn generic_visit_keyword(&mut self, node: Keyword) {} + fn visit_alias(&mut self, node: Alias) { + self.generic_visit_alias(node) + } + fn generic_visit_alias(&mut self, node: Alias) {} + fn visit_withitem(&mut self, node: Withitem) { + self.generic_visit_withitem(node) + } + fn generic_visit_withitem(&mut self, node: Withitem) {} + fn visit_match_case(&mut self, node: MatchCase) { + self.generic_visit_match_case(node) + } + fn generic_visit_match_case(&mut self, node: MatchCase) {} + fn visit_pattern(&mut self, node: Pattern) { + self.generic_visit_pattern(node) + } + fn generic_visit_pattern(&mut self, node: Pattern) { + match node.node { + PatternKind::MatchValue(data) => self.visit_pattern_MatchValue(data), + PatternKind::MatchSingleton(data) => self.visit_pattern_MatchSingleton(data), + PatternKind::MatchSequence(data) => self.visit_pattern_MatchSequence(data), + PatternKind::MatchMapping(data) => self.visit_pattern_MatchMapping(data), + PatternKind::MatchClass(data) => self.visit_pattern_MatchClass(data), + PatternKind::MatchStar(data) => self.visit_pattern_MatchStar(data), + PatternKind::MatchAs(data) => self.visit_pattern_MatchAs(data), + PatternKind::MatchOr(data) => self.visit_pattern_MatchOr(data), + } + } + fn visit_pattern_MatchValue(&mut self, node: PatternMatchValue) { + self.generic_visit_pattern_MatchValue(node) + } + fn generic_visit_pattern_MatchValue(&mut self, node: PatternMatchValue) { + { + let value = node.value; + self.visit_expr(*value); + } + } + fn visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton) { + self.generic_visit_pattern_MatchSingleton(node) + } + fn generic_visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton) {} + fn visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence) { + self.generic_visit_pattern_MatchSequence(node) + } + fn generic_visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence) { + for value in node.patterns { + self.visit_pattern(value); + } + } + fn visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping) { + self.generic_visit_pattern_MatchMapping(node) + } + fn generic_visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping) { + for value in node.keys { + self.visit_expr(value); + } + for value in node.patterns { + self.visit_pattern(value); + } + } + fn visit_pattern_MatchClass(&mut self, node: PatternMatchClass) { + self.generic_visit_pattern_MatchClass(node) + } + fn generic_visit_pattern_MatchClass(&mut self, node: PatternMatchClass) { + { + let value = node.cls; + self.visit_expr(*value); + } + for value in node.patterns { + self.visit_pattern(value); + } + for value in node.kwd_patterns { + self.visit_pattern(value); + } + } + fn visit_pattern_MatchStar(&mut self, node: PatternMatchStar) { + self.generic_visit_pattern_MatchStar(node) + } + fn generic_visit_pattern_MatchStar(&mut self, node: PatternMatchStar) {} + fn visit_pattern_MatchAs(&mut self, node: PatternMatchAs) { + self.generic_visit_pattern_MatchAs(node) + } + fn generic_visit_pattern_MatchAs(&mut self, node: PatternMatchAs) { + if let Some(value) = node.pattern { + self.visit_pattern(*value); + } + } + fn visit_pattern_MatchOr(&mut self, node: PatternMatchOr) { + self.generic_visit_pattern_MatchOr(node) + } + fn generic_visit_pattern_MatchOr(&mut self, node: PatternMatchOr) { + for value in node.patterns { + self.visit_pattern(value); + } + } +} diff --git a/ast/src/lib.rs b/ast/src/lib.rs index 683698c..66c7804 100644 --- a/ast/src/lib.rs +++ b/ast/src/lib.rs @@ -4,6 +4,10 @@ mod constant; mod fold_helpers; mod generic { #![allow(clippy::derive_partial_eq_without_eq)] + pub use crate::{constant::*, Attributed}; + + type Ident = String; + include!("gen/generic.rs"); } mod impls; @@ -19,9 +23,23 @@ pub use rustpython_parser_core::{text_size, ConversionFlag}; pub type Suite = Vec>; +#[cfg(feature = "fold")] +pub mod fold { + use super::generic::*; + include!("gen/fold.rs"); +} + +#[cfg(feature = "visitor")] +mod visitor { + use super::generic::*; + include!("gen/visitor.rs"); +} + #[cfg(feature = "source-code")] pub mod located { include!("gen/located.rs"); } pub use rustpython_parser_core::source_code; +#[cfg(feature = "visitor")] +pub use visitor::Visitor; diff --git a/scripts/update_asdl.sh b/scripts/update_asdl.sh index d912a72..72bcf32 100755 --- a/scripts/update_asdl.sh +++ b/scripts/update_asdl.sh @@ -3,5 +3,5 @@ set -e cd "$(dirname "$(dirname "$0")")" -python ast/asdl_rs.py --generic-file ast/src/gen/generic.rs --located-file ast/src/gen/located.rs --module-file ../RustPython/vm/src/stdlib/ast/gen.rs ast/Python.asdl -rustfmt ast/src/gen/generic.rs ast/src/gen/located.rs ../RustPython/vm/src/stdlib/ast/gen.rs +python ast/asdl_rs.py --ast-dir ast/src/gen/ --module-file ../RustPython/vm/src/stdlib/ast/gen.rs ast/Python.asdl +rustfmt ast/src/gen/*.rs ../RustPython/vm/src/stdlib/ast/gen.rs