mirror of
https://github.com/RustPython/Parser.git
synced 2025-09-03 17:10:58 +00:00
asdl_rs.py to multiple file output
This commit is contained in:
Jeong YunWon
parent
e000b1c304
commit
17c8abcec1
6 changed files with 1766 additions and 968 deletions
|
|
@ -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)?,
|
||||
}))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue