mirrors/RustPython-Parser
1
0
Fork 0
mirror of https://github.com/RustPython/Parser.git synced 2025-07-08 05:35:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

asdl_rs.py to multiple file output

Browse source
This commit is contained in:
Jeong YunWon 2023-05-10 17:30:28 +09:00
parent e000b1c304
commit 17c8abcec1
6 changed files with 1766 additions and 968 deletions
Download patch file Download diff file Expand all files Collapse all files

85
ast/asdl_rs.py
View file

@ -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,
)

888
ast/src/gen/fold.rs Normal file
View file

@ -0,0 +1,888 @@
// File automatically generated by ast/asdl_rs.py.
use crate::fold_helpers::Foldable;
pub trait Fold<U> {
type TargetU;
type Error;
fn map_user(&mut self, user: U) -> Result<Self::TargetU, Self::Error>;
fn map_attributed<T>(
&mut self,
attributed: Attributed<T, U>,
) -> Result<Attributed<T, Self::TargetU>, Self::Error> {
let custom = self.map_user(attributed.custom)?;
Ok(Attributed {
range: attributed.range,
custom,
node: attributed.node,
})
}
fn fold<X: Foldable<U, Self::TargetU>>(&mut self, node: X) -> Result<X::Mapped, Self::Error> {
node.fold(self)
}
fn fold_mod(&mut self, node: Mod<U>) -> Result<Mod<Self::TargetU>, Self::Error> {
fold_mod(self, node)
}
fn fold_stmt(&mut self, node: Stmt<U>) -> Result<Stmt<Self::TargetU>, Self::Error> {
fold_stmt(self, node)
}
fn fold_expr(&mut self, node: Expr<U>) -> Result<Expr<Self::TargetU>, Self::Error> {
fold_expr(self, node)
}
fn fold_expr_context(&mut self, node: ExprContext) -> Result<ExprContext, Self::Error> {
fold_expr_context(self, node)
}
fn fold_boolop(&mut self, node: Boolop) -> Result<Boolop, Self::Error> {
fold_boolop(self, node)
}
fn fold_operator(&mut self, node: Operator) -> Result<Operator, Self::Error> {
fold_operator(self, node)
}
fn fold_unaryop(&mut self, node: Unaryop) -> Result<Unaryop, Self::Error> {
fold_unaryop(self, node)
}
fn fold_cmpop(&mut self, node: Cmpop) -> Result<Cmpop, Self::Error> {
fold_cmpop(self, node)
}
fn fold_comprehension(
&mut self,
node: Comprehension<U>,
) -> Result<Comprehension<Self::TargetU>, Self::Error> {
fold_comprehension(self, node)
}
fn fold_excepthandler(
&mut self,
node: Excepthandler<U>,
) -> Result<Excepthandler<Self::TargetU>, Self::Error> {
fold_excepthandler(self, node)
}
fn fold_arguments(
&mut self,
node: Arguments<U>,
) -> Result<Arguments<Self::TargetU>, Self::Error> {
fold_arguments(self, node)
}
fn fold_arg(&mut self, node: Arg<U>) -> Result<Arg<Self::TargetU>, Self::Error> {
fold_arg(self, node)
}
fn fold_keyword(&mut self, node: Keyword<U>) -> Result<Keyword<Self::TargetU>, Self::Error> {
fold_keyword(self, node)
}
fn fold_alias(&mut self, node: Alias<U>) -> Result<Alias<Self::TargetU>, Self::Error> {
fold_alias(self, node)
}
fn fold_withitem(&mut self, node: Withitem<U>) -> Result<Withitem<Self::TargetU>, Self::Error> {
fold_withitem(self, node)
}
fn fold_match_case(
&mut self,
node: MatchCase<U>,
) -> Result<MatchCase<Self::TargetU>, Self::Error> {
fold_match_case(self, node)
}
fn fold_pattern(&mut self, node: Pattern<U>) -> Result<Pattern<Self::TargetU>, Self::Error> {
fold_pattern(self, node)
}
fn fold_type_ignore(&mut self, node: TypeIgnore) -> Result<TypeIgnore, Self::Error> {
fold_type_ignore(self, node)
}
}
fn fold_attributed<U, F: Fold<U> + ?Sized, T, MT>(
folder: &mut F,
node: Attributed<T, U>,
f: impl FnOnce(&mut F, T) -> Result<MT, F::Error>,
) -> Result<Attributed<MT, F::TargetU>, F::Error> {
let node = folder.map_attributed(node)?;
Ok(Attributed {
custom: node.custom,
range: node.range,
node: f(folder, node.node)?,
})
}
impl<T, U> Foldable<T, U> for Mod<T> {
type Mapped = Mod<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_mod(self)
}
}
pub fn fold_mod<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Mod<U>,
) -> Result<Mod<F::TargetU>, 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<T, U> Foldable<T, U> for Stmt<T> {
type Mapped = Stmt<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_stmt(self)
}
}
pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Stmt<U>,
) -> Result<Stmt<F::TargetU>, 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<T, U> Foldable<T, U> for Expr<T> {
type Mapped = Expr<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_expr(self)
}
}
pub fn fold_expr<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Expr<U>,
) -> Result<Expr<F::TargetU>, 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<T, U> Foldable<T, U> for ExprContext {
type Mapped = ExprContext;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_expr_context(self)
}
}
pub fn fold_expr_context<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: ExprContext,
) -> Result<ExprContext, F::Error> {
match node {
ExprContext::Load {} => Ok(ExprContext::Load {}),
ExprContext::Store {} => Ok(ExprContext::Store {}),
ExprContext::Del {} => Ok(ExprContext::Del {}),
}
}
impl<T, U> Foldable<T, U> for Boolop {
type Mapped = Boolop;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_boolop(self)
}
}
pub fn fold_boolop<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Boolop,
) -> Result<Boolop, F::Error> {
match node {
Boolop::And {} => Ok(Boolop::And {}),
Boolop::Or {} => Ok(Boolop::Or {}),
}
}
impl<T, U> Foldable<T, U> for Operator {
type Mapped = Operator;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_operator(self)
}
}
pub fn fold_operator<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Operator,
) -> Result<Operator, F::Error> {
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<T, U> Foldable<T, U> for Unaryop {
type Mapped = Unaryop;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_unaryop(self)
}
}
pub fn fold_unaryop<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Unaryop,
) -> Result<Unaryop, F::Error> {
match node {
Unaryop::Invert {} => Ok(Unaryop::Invert {}),
Unaryop::Not {} => Ok(Unaryop::Not {}),
Unaryop::UAdd {} => Ok(Unaryop::UAdd {}),
Unaryop::USub {} => Ok(Unaryop::USub {}),
}
}
impl<T, U> Foldable<T, U> for Cmpop {
type Mapped = Cmpop;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_cmpop(self)
}
}
pub fn fold_cmpop<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Cmpop,
) -> Result<Cmpop, F::Error> {
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<T, U> Foldable<T, U> for Comprehension<T> {
type Mapped = Comprehension<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_comprehension(self)
}
}
pub fn fold_comprehension<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Comprehension<U>,
) -> Result<Comprehension<F::TargetU>, 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<T, U> Foldable<T, U> for Excepthandler<T> {
type Mapped = Excepthandler<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_excepthandler(self)
}
}
pub fn fold_excepthandler<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Excepthandler<U>,
) -> Result<Excepthandler<F::TargetU>, 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<T, U> Foldable<T, U> for Arguments<T> {
type Mapped = Arguments<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_arguments(self)
}
}
pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Arguments<U>,
) -> Result<Arguments<F::TargetU>, 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<T, U> Foldable<T, U> for Arg<T> {
type Mapped = Arg<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_arg(self)
}
}
pub fn fold_arg<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Arg<U>,
) -> Result<Arg<F::TargetU>, 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<T, U> Foldable<T, U> for Keyword<T> {
type Mapped = Keyword<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_keyword(self)
}
}
pub fn fold_keyword<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Keyword<U>,
) -> Result<Keyword<F::TargetU>, 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<T, U> Foldable<T, U> for Alias<T> {
type Mapped = Alias<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_alias(self)
}
}
pub fn fold_alias<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Alias<U>,
) -> Result<Alias<F::TargetU>, 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<T, U> Foldable<T, U> for Withitem<T> {
type Mapped = Withitem<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_withitem(self)
}
}
pub fn fold_withitem<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Withitem<U>,
) -> Result<Withitem<F::TargetU>, 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<T, U> Foldable<T, U> for MatchCase<T> {
type Mapped = MatchCase<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_match_case(self)
}
}
pub fn fold_match_case<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: MatchCase<U>,
) -> Result<MatchCase<F::TargetU>, 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<T, U> Foldable<T, U> for Pattern<T> {
type Mapped = Pattern<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_pattern(self)
}
}
pub fn fold_pattern<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Pattern<U>,
) -> Result<Pattern<F::TargetU>, 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<T, U> Foldable<T, U> for TypeIgnore {
type Mapped = TypeIgnore;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_type_ignore(self)
}
}
pub fn fold_type_ignore<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: TypeIgnore,
) -> Result<TypeIgnore, F::Error> {
match node {
TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { lineno, tag }) => {
Ok(TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore {
lineno: Foldable::fold(lineno, folder)?,
tag: Foldable::fold(tag, folder)?,
}))
}
}
}

917
ast/src/gen/generic.rs
View file

@ -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<U = ()> {
pub body: Vec<Stmt<U>>,
@ -1010,916 +1006,3 @@ impl From<TypeIgnoreTypeIgnore> for TypeIgnore {
pub enum TypeIgnore {
TypeIgnore(TypeIgnoreTypeIgnore),
}
#[cfg(feature = "fold")]
pub mod fold {
use super::*;
use crate::fold_helpers::Foldable;
pub trait Fold<U> {
type TargetU;
type Error;
fn map_user(&mut self, user: U) -> Result<Self::TargetU, Self::Error>;
fn map_attributed<T>(
&mut self,
attributed: Attributed<T, U>,
) -> Result<Attributed<T, Self::TargetU>, Self::Error> {
let custom = self.map_user(attributed.custom)?;
Ok(Attributed {
range: attributed.range,
custom,
node: attributed.node,
})
}
fn fold<X: Foldable<U, Self::TargetU>>(
&mut self,
node: X,
) -> Result<X::Mapped, Self::Error> {
node.fold(self)
}
fn fold_mod(&mut self, node: Mod<U>) -> Result<Mod<Self::TargetU>, Self::Error> {
fold_mod(self, node)
}
fn fold_stmt(&mut self, node: Stmt<U>) -> Result<Stmt<Self::TargetU>, Self::Error> {
fold_stmt(self, node)
}
fn fold_expr(&mut self, node: Expr<U>) -> Result<Expr<Self::TargetU>, Self::Error> {
fold_expr(self, node)
}
fn fold_expr_context(&mut self, node: ExprContext) -> Result<ExprContext, Self::Error> {
fold_expr_context(self, node)
}
fn fold_boolop(&mut self, node: Boolop) -> Result<Boolop, Self::Error> {
fold_boolop(self, node)
}
fn fold_operator(&mut self, node: Operator) -> Result<Operator, Self::Error> {
fold_operator(self, node)
}
fn fold_unaryop(&mut self, node: Unaryop) -> Result<Unaryop, Self::Error> {
fold_unaryop(self, node)
}
fn fold_cmpop(&mut self, node: Cmpop) -> Result<Cmpop, Self::Error> {
fold_cmpop(self, node)
}
fn fold_comprehension(
&mut self,
node: Comprehension<U>,
) -> Result<Comprehension<Self::TargetU>, Self::Error> {
fold_comprehension(self, node)
}
fn fold_excepthandler(
&mut self,
node: Excepthandler<U>,
) -> Result<Excepthandler<Self::TargetU>, Self::Error> {
fold_excepthandler(self, node)
}
fn fold_arguments(
&mut self,
node: Arguments<U>,
) -> Result<Arguments<Self::TargetU>, Self::Error> {
fold_arguments(self, node)
}
fn fold_arg(&mut self, node: Arg<U>) -> Result<Arg<Self::TargetU>, Self::Error> {
fold_arg(self, node)
}
fn fold_keyword(
&mut self,
node: Keyword<U>,
) -> Result<Keyword<Self::TargetU>, Self::Error> {
fold_keyword(self, node)
}
fn fold_alias(&mut self, node: Alias<U>) -> Result<Alias<Self::TargetU>, Self::Error> {
fold_alias(self, node)
}
fn fold_withitem(
&mut self,
node: Withitem<U>,
) -> Result<Withitem<Self::TargetU>, Self::Error> {
fold_withitem(self, node)
}
fn fold_match_case(
&mut self,
node: MatchCase<U>,
) -> Result<MatchCase<Self::TargetU>, Self::Error> {
fold_match_case(self, node)
}
fn fold_pattern(
&mut self,
node: Pattern<U>,
) -> Result<Pattern<Self::TargetU>, Self::Error> {
fold_pattern(self, node)
}
fn fold_type_ignore(&mut self, node: TypeIgnore) -> Result<TypeIgnore, Self::Error> {
fold_type_ignore(self, node)
}
}
fn fold_attributed<U, F: Fold<U> + ?Sized, T, MT>(
folder: &mut F,
node: Attributed<T, U>,
f: impl FnOnce(&mut F, T) -> Result<MT, F::Error>,
) -> Result<Attributed<MT, F::TargetU>, F::Error> {
let node = folder.map_attributed(node)?;
Ok(Attributed {
custom: node.custom,
range: node.range,
node: f(folder, node.node)?,
})
}
impl<T, U> Foldable<T, U> for Mod<T> {
type Mapped = Mod<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_mod(self)
}
}
pub fn fold_mod<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Mod<U>,
) -> Result<Mod<F::TargetU>, 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<T, U> Foldable<T, U> for Stmt<T> {
type Mapped = Stmt<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_stmt(self)
}
}
pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Stmt<U>,
) -> Result<Stmt<F::TargetU>, 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<T, U> Foldable<T, U> for Expr<T> {
type Mapped = Expr<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_expr(self)
}
}
pub fn fold_expr<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Expr<U>,
) -> Result<Expr<F::TargetU>, 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<T, U> Foldable<T, U> for ExprContext {
type Mapped = ExprContext;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_expr_context(self)
}
}
pub fn fold_expr_context<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: ExprContext,
) -> Result<ExprContext, F::Error> {
match node {
ExprContext::Load {} => Ok(ExprContext::Load {}),
ExprContext::Store {} => Ok(ExprContext::Store {}),
ExprContext::Del {} => Ok(ExprContext::Del {}),
}
}
impl<T, U> Foldable<T, U> for Boolop {
type Mapped = Boolop;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_boolop(self)
}
}
pub fn fold_boolop<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Boolop,
) -> Result<Boolop, F::Error> {
match node {
Boolop::And {} => Ok(Boolop::And {}),
Boolop::Or {} => Ok(Boolop::Or {}),
}
}
impl<T, U> Foldable<T, U> for Operator {
type Mapped = Operator;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_operator(self)
}
}
pub fn fold_operator<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Operator,
) -> Result<Operator, F::Error> {
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<T, U> Foldable<T, U> for Unaryop {
type Mapped = Unaryop;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_unaryop(self)
}
}
pub fn fold_unaryop<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Unaryop,
) -> Result<Unaryop, F::Error> {
match node {
Unaryop::Invert {} => Ok(Unaryop::Invert {}),
Unaryop::Not {} => Ok(Unaryop::Not {}),
Unaryop::UAdd {} => Ok(Unaryop::UAdd {}),
Unaryop::USub {} => Ok(Unaryop::USub {}),
}
}
impl<T, U> Foldable<T, U> for Cmpop {
type Mapped = Cmpop;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_cmpop(self)
}
}
pub fn fold_cmpop<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Cmpop,
) -> Result<Cmpop, F::Error> {
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<T, U> Foldable<T, U> for Comprehension<T> {
type Mapped = Comprehension<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_comprehension(self)
}
}
pub fn fold_comprehension<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Comprehension<U>,
) -> Result<Comprehension<F::TargetU>, 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<T, U> Foldable<T, U> for Excepthandler<T> {
type Mapped = Excepthandler<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_excepthandler(self)
}
}
pub fn fold_excepthandler<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Excepthandler<U>,
) -> Result<Excepthandler<F::TargetU>, 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<T, U> Foldable<T, U> for Arguments<T> {
type Mapped = Arguments<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_arguments(self)
}
}
pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Arguments<U>,
) -> Result<Arguments<F::TargetU>, 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<T, U> Foldable<T, U> for Arg<T> {
type Mapped = Arg<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_arg(self)
}
}
pub fn fold_arg<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Arg<U>,
) -> Result<Arg<F::TargetU>, 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<T, U> Foldable<T, U> for Keyword<T> {
type Mapped = Keyword<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_keyword(self)
}
}
pub fn fold_keyword<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Keyword<U>,
) -> Result<Keyword<F::TargetU>, 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<T, U> Foldable<T, U> for Alias<T> {
type Mapped = Alias<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_alias(self)
}
}
pub fn fold_alias<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Alias<U>,
) -> Result<Alias<F::TargetU>, 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<T, U> Foldable<T, U> for Withitem<T> {
type Mapped = Withitem<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_withitem(self)
}
}
pub fn fold_withitem<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Withitem<U>,
) -> Result<Withitem<F::TargetU>, 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<T, U> Foldable<T, U> for MatchCase<T> {
type Mapped = MatchCase<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_match_case(self)
}
}
pub fn fold_match_case<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: MatchCase<U>,
) -> Result<MatchCase<F::TargetU>, 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<T, U> Foldable<T, U> for Pattern<T> {
type Mapped = Pattern<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_pattern(self)
}
}
pub fn fold_pattern<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: Pattern<U>,
) -> Result<Pattern<F::TargetU>, 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<T, U> Foldable<T, U> for TypeIgnore {
type Mapped = TypeIgnore;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_type_ignore(self)
}
}
pub fn fold_type_ignore<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: TypeIgnore,
) -> Result<TypeIgnore, F::Error> {
match node {
TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore { lineno, tag }) => {
Ok(TypeIgnore::TypeIgnore(TypeIgnoreTypeIgnore {
lineno: Foldable::fold(lineno, folder)?,
tag: Foldable::fold(tag, folder)?,
}))
}
}
}
}

822
ast/src/gen/visitor.rs Normal file
View file

@ -0,0 +1,822 @@
// File automatically generated by ast/asdl_rs.py.
#[allow(unused_variables, non_snake_case)]
pub trait Visitor<U = ()> {
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);
}
}
}

18
ast/src/lib.rs
View file

@ -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<U = ()> = Vec<Stmt<U>>;
#[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;

4
scripts/update_asdl.sh
View file

@ -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