mirrors/RustPython-Parser
1
0
Fork 0
mirror of https://github.com/RustPython/Parser.git synced 2025-08-27 13:54:55 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

New Arguments and Arg/ArgWithDefault AST representation (#59)

Browse source
This commit is contained in:
Jeong, YunWon 2023-06-01 01:15:23 +09:00 • committed by GitHub
parent 3fbf4f6804
commit fdec727f80
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
51 changed files with 22648 additions and 21711 deletions
Download patch file Download diff file Expand all files Collapse all files

40
ast/src/gen/fold.rs
View file

@ -507,6 +507,12 @@ pub trait Fold<U> {
) -> Result<TypeIgnoreTypeIgnore<Self::TargetU>, Self::Error> {
fold_type_ignore_type_ignore(self, node)
}
fn fold_arg_with_default(
&mut self,
node: ArgWithDefault<U>,
) -> Result<ArgWithDefault<Self::TargetU>, Self::Error> {
fold_arg_with_default(self, node)
}
}
impl<T, U> Foldable<T, U> for Mod<T> {
type Mapped = Mod<U>;
@ -2368,9 +2374,7 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
args,
vararg,
kwonlyargs,
kw_defaults,
kwarg,
defaults,
range,
} = node;
let context = folder.will_map_user_cfg(&range);
@ -2378,18 +2382,14 @@ pub fn fold_arguments<U, F: Fold<U> + ?Sized>(
let args = Foldable::fold(args, folder)?;
let vararg = Foldable::fold(vararg, folder)?;
let kwonlyargs = Foldable::fold(kwonlyargs, folder)?;
let kw_defaults = Foldable::fold(kw_defaults, folder)?;
let kwarg = Foldable::fold(kwarg, folder)?;
let defaults = Foldable::fold(defaults, folder)?;
let range = folder.map_user_cfg(range, context)?;
Ok(Arguments {
posonlyargs,
args,
vararg,
kwonlyargs,
kw_defaults,
kwarg,
defaults,
range,
})
}
@ -2791,3 +2791,31 @@ pub fn fold_type_ignore_type_ignore<U, F: Fold<U> + ?Sized>(
let range = folder.map_user_cfg(range, context)?;
Ok(TypeIgnoreTypeIgnore { lineno, tag, range })
}
impl<T, U> Foldable<T, U> for ArgWithDefault<T> {
type Mapped = ArgWithDefault<U>;
fn fold<F: Fold<T, TargetU = U> + ?Sized>(
self,
folder: &mut F,
) -> Result<Self::Mapped, F::Error> {
folder.fold_arg_with_default(self)
}
}
pub fn fold_arg_with_default<U, F: Fold<U> + ?Sized>(
#[allow(unused)] folder: &mut F,
node: ArgWithDefault<U>,
) -> Result<ArgWithDefault<F::TargetU>, F::Error> {
let ArgWithDefault {
def,
default,
range,
} = node;
let context = folder.will_map_user_cfg(&range);
let def = Foldable::fold(def, folder)?;
let default = Foldable::fold(default, folder)?;
let range = folder.map_user_cfg(range, context)?;
Ok(ArgWithDefault {
def,
default,
range,
})
}

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

@ -2679,7 +2679,7 @@ impl<R> Node for Excepthandler<R> {
}
#[derive(Clone, Debug, PartialEq)]
pub struct Arguments<R = TextRange> {
pub struct PythonArguments<R = TextRange> {
pub range: OptionalRange<R>,
pub posonlyargs: Vec<Arg<R>>,
pub args: Vec<Arg<R>>,
@ -2690,7 +2690,7 @@ pub struct Arguments<R = TextRange> {
pub defaults: Vec<Expr<R>>,
}
impl<R> Node for Arguments<R> {
impl<R> Node for PythonArguments<R> {
const NAME: &'static str = "arguments";
const FIELD_NAMES: &'static [&'static str] = &[
"posonlyargs",
@ -2987,3 +2987,46 @@ impl<R> Node for TypeIgnore<R> {
const NAME: &'static str = "type_ignore";
const FIELD_NAMES: &'static [&'static str] = &[];
}
/// An alternative type of AST `arguments`. This is parser-friendly and human-friendly definition of function arguments.
/// This form also has advantage to implement pre-order traverse.
/// `defaults` and `kw_defaults` fields are removed and the default values are placed under each `arg_with_default` typed argument.
/// `vararg` and `kwarg` are still typed as `arg` because they never can have a default value.
///
/// The matching Python style AST type is [PythonArguments]. While [PythonArguments] has ordered `kwonlyargs` fields by
/// default existence, [Arguments] has location-ordered kwonlyargs fields.
///
/// NOTE: This type is different from original Python AST.
#[derive(Clone, Debug, PartialEq)]
pub struct Arguments<R = TextRange> {
pub range: OptionalRange<R>,
pub posonlyargs: Vec<ArgWithDefault<R>>,
pub args: Vec<ArgWithDefault<R>>,
pub vararg: Option<Box<Arg<R>>>,
pub kwonlyargs: Vec<ArgWithDefault<R>>,
pub kwarg: Option<Box<Arg<R>>>,
}
impl<R> Node for Arguments<R> {
const NAME: &'static str = "alt:arguments";
const FIELD_NAMES: &'static [&'static str] =
&["posonlyargs", "args", "vararg", "kwonlyargs", "kwarg"];
}
/// An alternative type of AST `arg`. This is used for each function argument that might have a default value.
/// Used by `Arguments` original type.
///
/// NOTE: This type is different from original Python AST.
#[derive(Clone, Debug, PartialEq)]
pub struct ArgWithDefault<R = TextRange> {
pub range: OptionalRange<R>,
pub def: Arg<R>,
pub default: Option<Box<Expr<R>>>,
}
impl<R> Node for ArgWithDefault<R> {
const NAME: &'static str = "arg_with_default";
const FIELD_NAMES: &'static [&'static str] = &["def", "default"];
}

24
ast/src/gen/located.rs
View file

@ -660,11 +660,11 @@ impl Located for Excepthandler {
}
}
pub type Arguments = crate::generic::Arguments<SourceRange>;
pub type PythonArguments = crate::generic::PythonArguments<SourceRange>;
#[cfg(feature = "all-nodes-with-ranges")]
impl Located for Arguments {
impl Located for PythonArguments {
fn range(&self) -> SourceRange {
self.range
}
@ -815,3 +815,23 @@ impl Located for TypeIgnore {
}
}
}
pub type Arguments = crate::generic::Arguments<SourceRange>;
#[cfg(feature = "all-nodes-with-ranges")]
impl Located for Arguments {
fn range(&self) -> SourceRange {
self.range
}
}
pub type ArgWithDefault = crate::generic::ArgWithDefault<SourceRange>;
#[cfg(feature = "all-nodes-with-ranges")]
impl Located for ArgWithDefault {
fn range(&self) -> SourceRange {
self.range
}
}

15
ast/src/gen/ranged.rs
View file

@ -394,7 +394,7 @@ impl Ranged for crate::Excepthandler {
}
#[cfg(feature = "all-nodes-with-ranges")]
impl Ranged for crate::generic::Arguments<TextRange> {
impl Ranged for crate::generic::PythonArguments<TextRange> {
fn range(&self) -> TextRange {
self.range
}
@ -495,3 +495,16 @@ impl Ranged for crate::TypeIgnore {
}
}
}
#[cfg(feature = "all-nodes-with-ranges")]
impl Ranged for crate::generic::Arguments<TextRange> {
fn range(&self) -> TextRange {
self.range
}
}
#[cfg(feature = "all-nodes-with-ranges")]
impl Ranged for crate::generic::ArgWithDefault<TextRange> {
fn range(&self) -> TextRange {
self.range
}
}

494
ast/src/gen/visitor.rs
View file

@ -1,45 +1,45 @@
// File automatically generated by ast/asdl_rs.py.
#[allow(unused_variables, non_snake_case)]
#[allow(unused_variables)]
pub trait Visitor<R = crate::text_size::TextRange> {
fn visit_stmt(&mut self, node: Stmt<R>) {
self.generic_visit_stmt(node)
}
fn generic_visit_stmt(&mut self, node: Stmt<R>) {
match node {
Stmt::FunctionDef(data) => self.visit_stmt_FunctionDef(data),
Stmt::AsyncFunctionDef(data) => self.visit_stmt_AsyncFunctionDef(data),
Stmt::ClassDef(data) => self.visit_stmt_ClassDef(data),
Stmt::Return(data) => self.visit_stmt_Return(data),
Stmt::Delete(data) => self.visit_stmt_Delete(data),
Stmt::Assign(data) => self.visit_stmt_Assign(data),
Stmt::AugAssign(data) => self.visit_stmt_AugAssign(data),
Stmt::AnnAssign(data) => self.visit_stmt_AnnAssign(data),
Stmt::For(data) => self.visit_stmt_For(data),
Stmt::AsyncFor(data) => self.visit_stmt_AsyncFor(data),
Stmt::While(data) => self.visit_stmt_While(data),
Stmt::If(data) => self.visit_stmt_If(data),
Stmt::With(data) => self.visit_stmt_With(data),
Stmt::AsyncWith(data) => self.visit_stmt_AsyncWith(data),
Stmt::Match(data) => self.visit_stmt_Match(data),
Stmt::Raise(data) => self.visit_stmt_Raise(data),
Stmt::Try(data) => self.visit_stmt_Try(data),
Stmt::TryStar(data) => self.visit_stmt_TryStar(data),
Stmt::Assert(data) => self.visit_stmt_Assert(data),
Stmt::Import(data) => self.visit_stmt_Import(data),
Stmt::ImportFrom(data) => self.visit_stmt_ImportFrom(data),
Stmt::Global(data) => self.visit_stmt_Global(data),
Stmt::Nonlocal(data) => self.visit_stmt_Nonlocal(data),
Stmt::Expr(data) => self.visit_stmt_Expr(data),
Stmt::Pass(data) => self.visit_stmt_Pass(data),
Stmt::Break(data) => self.visit_stmt_Break(data),
Stmt::Continue(data) => self.visit_stmt_Continue(data),
Stmt::FunctionDef(data) => self.visit_stmt_function_def(data),
Stmt::AsyncFunctionDef(data) => self.visit_stmt_async_function_def(data),
Stmt::ClassDef(data) => self.visit_stmt_class_def(data),
Stmt::Return(data) => self.visit_stmt_return(data),
Stmt::Delete(data) => self.visit_stmt_delete(data),
Stmt::Assign(data) => self.visit_stmt_assign(data),
Stmt::AugAssign(data) => self.visit_stmt_aug_assign(data),
Stmt::AnnAssign(data) => self.visit_stmt_ann_assign(data),
Stmt::For(data) => self.visit_stmt_for(data),
Stmt::AsyncFor(data) => self.visit_stmt_async_for(data),
Stmt::While(data) => self.visit_stmt_while(data),
Stmt::If(data) => self.visit_stmt_if(data),
Stmt::With(data) => self.visit_stmt_with(data),
Stmt::AsyncWith(data) => self.visit_stmt_async_with(data),
Stmt::Match(data) => self.visit_stmt_match(data),
Stmt::Raise(data) => self.visit_stmt_raise(data),
Stmt::Try(data) => self.visit_stmt_try(data),
Stmt::TryStar(data) => self.visit_stmt_try_star(data),
Stmt::Assert(data) => self.visit_stmt_assert(data),
Stmt::Import(data) => self.visit_stmt_import(data),
Stmt::ImportFrom(data) => self.visit_stmt_import_from(data),
Stmt::Global(data) => self.visit_stmt_global(data),
Stmt::Nonlocal(data) => self.visit_stmt_nonlocal(data),
Stmt::Expr(data) => self.visit_stmt_expr(data),
Stmt::Pass(data) => self.visit_stmt_pass(data),
Stmt::Break(data) => self.visit_stmt_break(data),
Stmt::Continue(data) => self.visit_stmt_continue(data),
}
}
fn visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef<R>) {
self.generic_visit_stmt_FunctionDef(node)
fn visit_stmt_function_def(&mut self, node: StmtFunctionDef<R>) {
self.generic_visit_stmt_function_def(node)
}
fn generic_visit_stmt_FunctionDef(&mut self, node: StmtFunctionDef<R>) {
fn generic_visit_stmt_function_def(&mut self, node: StmtFunctionDef<R>) {
{
let value = node.args;
self.visit_arguments(*value);
@ -54,10 +54,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef<R>) {
self.generic_visit_stmt_AsyncFunctionDef(node)
fn visit_stmt_async_function_def(&mut self, node: StmtAsyncFunctionDef<R>) {
self.generic_visit_stmt_async_function_def(node)
}
fn generic_visit_stmt_AsyncFunctionDef(&mut self, node: StmtAsyncFunctionDef<R>) {
fn generic_visit_stmt_async_function_def(&mut self, node: StmtAsyncFunctionDef<R>) {
{
let value = node.args;
self.visit_arguments(*value);
@ -72,10 +72,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_ClassDef(&mut self, node: StmtClassDef<R>) {
self.generic_visit_stmt_ClassDef(node)
fn visit_stmt_class_def(&mut self, node: StmtClassDef<R>) {
self.generic_visit_stmt_class_def(node)
}
fn generic_visit_stmt_ClassDef(&mut self, node: StmtClassDef<R>) {
fn generic_visit_stmt_class_def(&mut self, node: StmtClassDef<R>) {
for value in node.bases {
self.visit_expr(value);
}
@ -89,26 +89,26 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(value);
}
}
fn visit_stmt_Return(&mut self, node: StmtReturn<R>) {
self.generic_visit_stmt_Return(node)
fn visit_stmt_return(&mut self, node: StmtReturn<R>) {
self.generic_visit_stmt_return(node)
}
fn generic_visit_stmt_Return(&mut self, node: StmtReturn<R>) {
fn generic_visit_stmt_return(&mut self, node: StmtReturn<R>) {
if let Some(value) = node.value {
self.visit_expr(*value);
}
}
fn visit_stmt_Delete(&mut self, node: StmtDelete<R>) {
self.generic_visit_stmt_Delete(node)
fn visit_stmt_delete(&mut self, node: StmtDelete<R>) {
self.generic_visit_stmt_delete(node)
}
fn generic_visit_stmt_Delete(&mut self, node: StmtDelete<R>) {
fn generic_visit_stmt_delete(&mut self, node: StmtDelete<R>) {
for value in node.targets {
self.visit_expr(value);
}
}
fn visit_stmt_Assign(&mut self, node: StmtAssign<R>) {
self.generic_visit_stmt_Assign(node)
fn visit_stmt_assign(&mut self, node: StmtAssign<R>) {
self.generic_visit_stmt_assign(node)
}
fn generic_visit_stmt_Assign(&mut self, node: StmtAssign<R>) {
fn generic_visit_stmt_assign(&mut self, node: StmtAssign<R>) {
for value in node.targets {
self.visit_expr(value);
}
@ -117,10 +117,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_AugAssign(&mut self, node: StmtAugAssign<R>) {
self.generic_visit_stmt_AugAssign(node)
fn visit_stmt_aug_assign(&mut self, node: StmtAugAssign<R>) {
self.generic_visit_stmt_aug_assign(node)
}
fn generic_visit_stmt_AugAssign(&mut self, node: StmtAugAssign<R>) {
fn generic_visit_stmt_aug_assign(&mut self, node: StmtAugAssign<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -130,10 +130,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign<R>) {
self.generic_visit_stmt_AnnAssign(node)
fn visit_stmt_ann_assign(&mut self, node: StmtAnnAssign<R>) {
self.generic_visit_stmt_ann_assign(node)
}
fn generic_visit_stmt_AnnAssign(&mut self, node: StmtAnnAssign<R>) {
fn generic_visit_stmt_ann_assign(&mut self, node: StmtAnnAssign<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -146,10 +146,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_For(&mut self, node: StmtFor<R>) {
self.generic_visit_stmt_For(node)
fn visit_stmt_for(&mut self, node: StmtFor<R>) {
self.generic_visit_stmt_for(node)
}
fn generic_visit_stmt_For(&mut self, node: StmtFor<R>) {
fn generic_visit_stmt_for(&mut self, node: StmtFor<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -165,10 +165,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor<R>) {
self.generic_visit_stmt_AsyncFor(node)
fn visit_stmt_async_for(&mut self, node: StmtAsyncFor<R>) {
self.generic_visit_stmt_async_for(node)
}
fn generic_visit_stmt_AsyncFor(&mut self, node: StmtAsyncFor<R>) {
fn generic_visit_stmt_async_for(&mut self, node: StmtAsyncFor<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -184,10 +184,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_While(&mut self, node: StmtWhile<R>) {
self.generic_visit_stmt_While(node)
fn visit_stmt_while(&mut self, node: StmtWhile<R>) {
self.generic_visit_stmt_while(node)
}
fn generic_visit_stmt_While(&mut self, node: StmtWhile<R>) {
fn generic_visit_stmt_while(&mut self, node: StmtWhile<R>) {
{
let value = node.test;
self.visit_expr(*value);
@ -199,10 +199,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_If(&mut self, node: StmtIf<R>) {
self.generic_visit_stmt_If(node)
fn visit_stmt_if(&mut self, node: StmtIf<R>) {
self.generic_visit_stmt_if(node)
}
fn generic_visit_stmt_If(&mut self, node: StmtIf<R>) {
fn generic_visit_stmt_if(&mut self, node: StmtIf<R>) {
{
let value = node.test;
self.visit_expr(*value);
@ -214,10 +214,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_With(&mut self, node: StmtWith<R>) {
self.generic_visit_stmt_With(node)
fn visit_stmt_with(&mut self, node: StmtWith<R>) {
self.generic_visit_stmt_with(node)
}
fn generic_visit_stmt_With(&mut self, node: StmtWith<R>) {
fn generic_visit_stmt_with(&mut self, node: StmtWith<R>) {
for value in node.items {
self.visit_withitem(value);
}
@ -225,10 +225,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith<R>) {
self.generic_visit_stmt_AsyncWith(node)
fn visit_stmt_async_with(&mut self, node: StmtAsyncWith<R>) {
self.generic_visit_stmt_async_with(node)
}
fn generic_visit_stmt_AsyncWith(&mut self, node: StmtAsyncWith<R>) {
fn generic_visit_stmt_async_with(&mut self, node: StmtAsyncWith<R>) {
for value in node.items {
self.visit_withitem(value);
}
@ -236,10 +236,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_Match(&mut self, node: StmtMatch<R>) {
self.generic_visit_stmt_Match(node)
fn visit_stmt_match(&mut self, node: StmtMatch<R>) {
self.generic_visit_stmt_match(node)
}
fn generic_visit_stmt_Match(&mut self, node: StmtMatch<R>) {
fn generic_visit_stmt_match(&mut self, node: StmtMatch<R>) {
{
let value = node.subject;
self.visit_expr(*value);
@ -248,10 +248,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_match_case(value);
}
}
fn visit_stmt_Raise(&mut self, node: StmtRaise<R>) {
self.generic_visit_stmt_Raise(node)
fn visit_stmt_raise(&mut self, node: StmtRaise<R>) {
self.generic_visit_stmt_raise(node)
}
fn generic_visit_stmt_Raise(&mut self, node: StmtRaise<R>) {
fn generic_visit_stmt_raise(&mut self, node: StmtRaise<R>) {
if let Some(value) = node.exc {
self.visit_expr(*value);
}
@ -259,10 +259,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_Try(&mut self, node: StmtTry<R>) {
self.generic_visit_stmt_Try(node)
fn visit_stmt_try(&mut self, node: StmtTry<R>) {
self.generic_visit_stmt_try(node)
}
fn generic_visit_stmt_Try(&mut self, node: StmtTry<R>) {
fn generic_visit_stmt_try(&mut self, node: StmtTry<R>) {
for value in node.body {
self.visit_stmt(value);
}
@ -276,10 +276,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_TryStar(&mut self, node: StmtTryStar<R>) {
self.generic_visit_stmt_TryStar(node)
fn visit_stmt_try_star(&mut self, node: StmtTryStar<R>) {
self.generic_visit_stmt_try_star(node)
}
fn generic_visit_stmt_TryStar(&mut self, node: StmtTryStar<R>) {
fn generic_visit_stmt_try_star(&mut self, node: StmtTryStar<R>) {
for value in node.body {
self.visit_stmt(value);
}
@ -293,10 +293,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_stmt(value);
}
}
fn visit_stmt_Assert(&mut self, node: StmtAssert<R>) {
self.generic_visit_stmt_Assert(node)
fn visit_stmt_assert(&mut self, node: StmtAssert<R>) {
self.generic_visit_stmt_assert(node)
}
fn generic_visit_stmt_Assert(&mut self, node: StmtAssert<R>) {
fn generic_visit_stmt_assert(&mut self, node: StmtAssert<R>) {
{
let value = node.test;
self.visit_expr(*value);
@ -305,88 +305,88 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_stmt_Import(&mut self, node: StmtImport<R>) {
self.generic_visit_stmt_Import(node)
fn visit_stmt_import(&mut self, node: StmtImport<R>) {
self.generic_visit_stmt_import(node)
}
fn generic_visit_stmt_Import(&mut self, node: StmtImport<R>) {
fn generic_visit_stmt_import(&mut self, node: StmtImport<R>) {
for value in node.names {
self.visit_alias(value);
}
}
fn visit_stmt_ImportFrom(&mut self, node: StmtImportFrom<R>) {
self.generic_visit_stmt_ImportFrom(node)
fn visit_stmt_import_from(&mut self, node: StmtImportFrom<R>) {
self.generic_visit_stmt_import_from(node)
}
fn generic_visit_stmt_ImportFrom(&mut self, node: StmtImportFrom<R>) {
fn generic_visit_stmt_import_from(&mut self, node: StmtImportFrom<R>) {
for value in node.names {
self.visit_alias(value);
}
}
fn visit_stmt_Global(&mut self, node: StmtGlobal<R>) {
self.generic_visit_stmt_Global(node)
fn visit_stmt_global(&mut self, node: StmtGlobal<R>) {
self.generic_visit_stmt_global(node)
}
fn generic_visit_stmt_Global(&mut self, node: StmtGlobal<R>) {}
fn visit_stmt_Nonlocal(&mut self, node: StmtNonlocal<R>) {
self.generic_visit_stmt_Nonlocal(node)
fn generic_visit_stmt_global(&mut self, node: StmtGlobal<R>) {}
fn visit_stmt_nonlocal(&mut self, node: StmtNonlocal<R>) {
self.generic_visit_stmt_nonlocal(node)
}
fn generic_visit_stmt_Nonlocal(&mut self, node: StmtNonlocal<R>) {}
fn visit_stmt_Expr(&mut self, node: StmtExpr<R>) {
self.generic_visit_stmt_Expr(node)
fn generic_visit_stmt_nonlocal(&mut self, node: StmtNonlocal<R>) {}
fn visit_stmt_expr(&mut self, node: StmtExpr<R>) {
self.generic_visit_stmt_expr(node)
}
fn generic_visit_stmt_Expr(&mut self, node: StmtExpr<R>) {
fn generic_visit_stmt_expr(&mut self, node: StmtExpr<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_stmt_Pass(&mut self, node: StmtPass<R>) {}
fn visit_stmt_Break(&mut self, node: StmtBreak<R>) {}
fn visit_stmt_Continue(&mut self, node: StmtContinue<R>) {}
fn visit_stmt_pass(&mut self, node: StmtPass<R>) {}
fn visit_stmt_break(&mut self, node: StmtBreak<R>) {}
fn visit_stmt_continue(&mut self, node: StmtContinue<R>) {}
fn visit_expr(&mut self, node: Expr<R>) {
self.generic_visit_expr(node)
}
fn generic_visit_expr(&mut self, node: Expr<R>) {
match node {
Expr::BoolOp(data) => self.visit_expr_BoolOp(data),
Expr::NamedExpr(data) => self.visit_expr_NamedExpr(data),
Expr::BinOp(data) => self.visit_expr_BinOp(data),
Expr::UnaryOp(data) => self.visit_expr_UnaryOp(data),
Expr::Lambda(data) => self.visit_expr_Lambda(data),
Expr::IfExp(data) => self.visit_expr_IfExp(data),
Expr::Dict(data) => self.visit_expr_Dict(data),
Expr::Set(data) => self.visit_expr_Set(data),
Expr::ListComp(data) => self.visit_expr_ListComp(data),
Expr::SetComp(data) => self.visit_expr_SetComp(data),
Expr::DictComp(data) => self.visit_expr_DictComp(data),
Expr::GeneratorExp(data) => self.visit_expr_GeneratorExp(data),
Expr::Await(data) => self.visit_expr_Await(data),
Expr::Yield(data) => self.visit_expr_Yield(data),
Expr::YieldFrom(data) => self.visit_expr_YieldFrom(data),
Expr::Compare(data) => self.visit_expr_Compare(data),
Expr::Call(data) => self.visit_expr_Call(data),
Expr::FormattedValue(data) => self.visit_expr_FormattedValue(data),
Expr::JoinedStr(data) => self.visit_expr_JoinedStr(data),
Expr::Constant(data) => self.visit_expr_Constant(data),
Expr::Attribute(data) => self.visit_expr_Attribute(data),
Expr::Subscript(data) => self.visit_expr_Subscript(data),
Expr::Starred(data) => self.visit_expr_Starred(data),
Expr::Name(data) => self.visit_expr_Name(data),
Expr::List(data) => self.visit_expr_List(data),
Expr::Tuple(data) => self.visit_expr_Tuple(data),
Expr::Slice(data) => self.visit_expr_Slice(data),
Expr::BoolOp(data) => self.visit_expr_bool_op(data),
Expr::NamedExpr(data) => self.visit_expr_named_expr(data),
Expr::BinOp(data) => self.visit_expr_bin_op(data),
Expr::UnaryOp(data) => self.visit_expr_unary_op(data),
Expr::Lambda(data) => self.visit_expr_lambda(data),
Expr::IfExp(data) => self.visit_expr_if_exp(data),
Expr::Dict(data) => self.visit_expr_dict(data),
Expr::Set(data) => self.visit_expr_set(data),
Expr::ListComp(data) => self.visit_expr_list_comp(data),
Expr::SetComp(data) => self.visit_expr_set_comp(data),
Expr::DictComp(data) => self.visit_expr_dict_comp(data),
Expr::GeneratorExp(data) => self.visit_expr_generator_exp(data),
Expr::Await(data) => self.visit_expr_await(data),
Expr::Yield(data) => self.visit_expr_yield(data),
Expr::YieldFrom(data) => self.visit_expr_yield_from(data),
Expr::Compare(data) => self.visit_expr_compare(data),
Expr::Call(data) => self.visit_expr_call(data),
Expr::FormattedValue(data) => self.visit_expr_formatted_value(data),
Expr::JoinedStr(data) => self.visit_expr_joined_str(data),
Expr::Constant(data) => self.visit_expr_constant(data),
Expr::Attribute(data) => self.visit_expr_attribute(data),
Expr::Subscript(data) => self.visit_expr_subscript(data),
Expr::Starred(data) => self.visit_expr_starred(data),
Expr::Name(data) => self.visit_expr_name(data),
Expr::List(data) => self.visit_expr_list(data),
Expr::Tuple(data) => self.visit_expr_tuple(data),
Expr::Slice(data) => self.visit_expr_slice(data),
}
}
fn visit_expr_BoolOp(&mut self, node: ExprBoolOp<R>) {
self.generic_visit_expr_BoolOp(node)
fn visit_expr_bool_op(&mut self, node: ExprBoolOp<R>) {
self.generic_visit_expr_bool_op(node)
}
fn generic_visit_expr_BoolOp(&mut self, node: ExprBoolOp<R>) {
fn generic_visit_expr_bool_op(&mut self, node: ExprBoolOp<R>) {
for value in node.values {
self.visit_expr(value);
}
}
fn visit_expr_NamedExpr(&mut self, node: ExprNamedExpr<R>) {
self.generic_visit_expr_NamedExpr(node)
fn visit_expr_named_expr(&mut self, node: ExprNamedExpr<R>) {
self.generic_visit_expr_named_expr(node)
}
fn generic_visit_expr_NamedExpr(&mut self, node: ExprNamedExpr<R>) {
fn generic_visit_expr_named_expr(&mut self, node: ExprNamedExpr<R>) {
{
let value = node.target;
self.visit_expr(*value);
@ -396,10 +396,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_BinOp(&mut self, node: ExprBinOp<R>) {
self.generic_visit_expr_BinOp(node)
fn visit_expr_bin_op(&mut self, node: ExprBinOp<R>) {
self.generic_visit_expr_bin_op(node)
}
fn generic_visit_expr_BinOp(&mut self, node: ExprBinOp<R>) {
fn generic_visit_expr_bin_op(&mut self, node: ExprBinOp<R>) {
{
let value = node.left;
self.visit_expr(*value);
@ -409,19 +409,19 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_UnaryOp(&mut self, node: ExprUnaryOp<R>) {
self.generic_visit_expr_UnaryOp(node)
fn visit_expr_unary_op(&mut self, node: ExprUnaryOp<R>) {
self.generic_visit_expr_unary_op(node)
}
fn generic_visit_expr_UnaryOp(&mut self, node: ExprUnaryOp<R>) {
fn generic_visit_expr_unary_op(&mut self, node: ExprUnaryOp<R>) {
{
let value = node.operand;
self.visit_expr(*value);
}
}
fn visit_expr_Lambda(&mut self, node: ExprLambda<R>) {
self.generic_visit_expr_Lambda(node)
fn visit_expr_lambda(&mut self, node: ExprLambda<R>) {
self.generic_visit_expr_lambda(node)
}
fn generic_visit_expr_Lambda(&mut self, node: ExprLambda<R>) {
fn generic_visit_expr_lambda(&mut self, node: ExprLambda<R>) {
{
let value = node.args;
self.visit_arguments(*value);
@ -431,10 +431,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_IfExp(&mut self, node: ExprIfExp<R>) {
self.generic_visit_expr_IfExp(node)
fn visit_expr_if_exp(&mut self, node: ExprIfExp<R>) {
self.generic_visit_expr_if_exp(node)
}
fn generic_visit_expr_IfExp(&mut self, node: ExprIfExp<R>) {
fn generic_visit_expr_if_exp(&mut self, node: ExprIfExp<R>) {
{
let value = node.test;
self.visit_expr(*value);
@ -448,10 +448,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_Dict(&mut self, node: ExprDict<R>) {
self.generic_visit_expr_Dict(node)
fn visit_expr_dict(&mut self, node: ExprDict<R>) {
self.generic_visit_expr_dict(node)
}
fn generic_visit_expr_Dict(&mut self, node: ExprDict<R>) {
fn generic_visit_expr_dict(&mut self, node: ExprDict<R>) {
for value in node.keys.into_iter().flatten() {
self.visit_expr(value);
}
@ -459,18 +459,18 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(value);
}
}
fn visit_expr_Set(&mut self, node: ExprSet<R>) {
self.generic_visit_expr_Set(node)
fn visit_expr_set(&mut self, node: ExprSet<R>) {
self.generic_visit_expr_set(node)
}
fn generic_visit_expr_Set(&mut self, node: ExprSet<R>) {
fn generic_visit_expr_set(&mut self, node: ExprSet<R>) {
for value in node.elts {
self.visit_expr(value);
}
}
fn visit_expr_ListComp(&mut self, node: ExprListComp<R>) {
self.generic_visit_expr_ListComp(node)
fn visit_expr_list_comp(&mut self, node: ExprListComp<R>) {
self.generic_visit_expr_list_comp(node)
}
fn generic_visit_expr_ListComp(&mut self, node: ExprListComp<R>) {
fn generic_visit_expr_list_comp(&mut self, node: ExprListComp<R>) {
{
let value = node.elt;
self.visit_expr(*value);
@ -479,10 +479,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_comprehension(value);
}
}
fn visit_expr_SetComp(&mut self, node: ExprSetComp<R>) {
self.generic_visit_expr_SetComp(node)
fn visit_expr_set_comp(&mut self, node: ExprSetComp<R>) {
self.generic_visit_expr_set_comp(node)
}
fn generic_visit_expr_SetComp(&mut self, node: ExprSetComp<R>) {
fn generic_visit_expr_set_comp(&mut self, node: ExprSetComp<R>) {
{
let value = node.elt;
self.visit_expr(*value);
@ -491,10 +491,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_comprehension(value);
}
}
fn visit_expr_DictComp(&mut self, node: ExprDictComp<R>) {
self.generic_visit_expr_DictComp(node)
fn visit_expr_dict_comp(&mut self, node: ExprDictComp<R>) {
self.generic_visit_expr_dict_comp(node)
}
fn generic_visit_expr_DictComp(&mut self, node: ExprDictComp<R>) {
fn generic_visit_expr_dict_comp(&mut self, node: ExprDictComp<R>) {
{
let value = node.key;
self.visit_expr(*value);
@ -507,10 +507,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_comprehension(value);
}
}
fn visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp<R>) {
self.generic_visit_expr_GeneratorExp(node)
fn visit_expr_generator_exp(&mut self, node: ExprGeneratorExp<R>) {
self.generic_visit_expr_generator_exp(node)
}
fn generic_visit_expr_GeneratorExp(&mut self, node: ExprGeneratorExp<R>) {
fn generic_visit_expr_generator_exp(&mut self, node: ExprGeneratorExp<R>) {
{
let value = node.elt;
self.visit_expr(*value);
@ -519,36 +519,36 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_comprehension(value);
}
}
fn visit_expr_Await(&mut self, node: ExprAwait<R>) {
self.generic_visit_expr_Await(node)
fn visit_expr_await(&mut self, node: ExprAwait<R>) {
self.generic_visit_expr_await(node)
}
fn generic_visit_expr_Await(&mut self, node: ExprAwait<R>) {
fn generic_visit_expr_await(&mut self, node: ExprAwait<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_expr_Yield(&mut self, node: ExprYield<R>) {
self.generic_visit_expr_Yield(node)
fn visit_expr_yield(&mut self, node: ExprYield<R>) {
self.generic_visit_expr_yield(node)
}
fn generic_visit_expr_Yield(&mut self, node: ExprYield<R>) {
fn generic_visit_expr_yield(&mut self, node: ExprYield<R>) {
if let Some(value) = node.value {
self.visit_expr(*value);
}
}
fn visit_expr_YieldFrom(&mut self, node: ExprYieldFrom<R>) {
self.generic_visit_expr_YieldFrom(node)
fn visit_expr_yield_from(&mut self, node: ExprYieldFrom<R>) {
self.generic_visit_expr_yield_from(node)
}
fn generic_visit_expr_YieldFrom(&mut self, node: ExprYieldFrom<R>) {
fn generic_visit_expr_yield_from(&mut self, node: ExprYieldFrom<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_expr_Compare(&mut self, node: ExprCompare<R>) {
self.generic_visit_expr_Compare(node)
fn visit_expr_compare(&mut self, node: ExprCompare<R>) {
self.generic_visit_expr_compare(node)
}
fn generic_visit_expr_Compare(&mut self, node: ExprCompare<R>) {
fn generic_visit_expr_compare(&mut self, node: ExprCompare<R>) {
{
let value = node.left;
self.visit_expr(*value);
@ -557,10 +557,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(value);
}
}
fn visit_expr_Call(&mut self, node: ExprCall<R>) {
self.generic_visit_expr_Call(node)
fn visit_expr_call(&mut self, node: ExprCall<R>) {
self.generic_visit_expr_call(node)
}
fn generic_visit_expr_Call(&mut self, node: ExprCall<R>) {
fn generic_visit_expr_call(&mut self, node: ExprCall<R>) {
{
let value = node.func;
self.visit_expr(*value);
@ -572,10 +572,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_keyword(value);
}
}
fn visit_expr_FormattedValue(&mut self, node: ExprFormattedValue<R>) {
self.generic_visit_expr_FormattedValue(node)
fn visit_expr_formatted_value(&mut self, node: ExprFormattedValue<R>) {
self.generic_visit_expr_formatted_value(node)
}
fn generic_visit_expr_FormattedValue(&mut self, node: ExprFormattedValue<R>) {
fn generic_visit_expr_formatted_value(&mut self, node: ExprFormattedValue<R>) {
{
let value = node.value;
self.visit_expr(*value);
@ -584,31 +584,31 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_JoinedStr(&mut self, node: ExprJoinedStr<R>) {
self.generic_visit_expr_JoinedStr(node)
fn visit_expr_joined_str(&mut self, node: ExprJoinedStr<R>) {
self.generic_visit_expr_joined_str(node)
}
fn generic_visit_expr_JoinedStr(&mut self, node: ExprJoinedStr<R>) {
fn generic_visit_expr_joined_str(&mut self, node: ExprJoinedStr<R>) {
for value in node.values {
self.visit_expr(value);
}
}
fn visit_expr_Constant(&mut self, node: ExprConstant<R>) {
self.generic_visit_expr_Constant(node)
fn visit_expr_constant(&mut self, node: ExprConstant<R>) {
self.generic_visit_expr_constant(node)
}
fn generic_visit_expr_Constant(&mut self, node: ExprConstant<R>) {}
fn visit_expr_Attribute(&mut self, node: ExprAttribute<R>) {
self.generic_visit_expr_Attribute(node)
fn generic_visit_expr_constant(&mut self, node: ExprConstant<R>) {}
fn visit_expr_attribute(&mut self, node: ExprAttribute<R>) {
self.generic_visit_expr_attribute(node)
}
fn generic_visit_expr_Attribute(&mut self, node: ExprAttribute<R>) {
fn generic_visit_expr_attribute(&mut self, node: ExprAttribute<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_expr_Subscript(&mut self, node: ExprSubscript<R>) {
self.generic_visit_expr_Subscript(node)
fn visit_expr_subscript(&mut self, node: ExprSubscript<R>) {
self.generic_visit_expr_subscript(node)
}
fn generic_visit_expr_Subscript(&mut self, node: ExprSubscript<R>) {
fn generic_visit_expr_subscript(&mut self, node: ExprSubscript<R>) {
{
let value = node.value;
self.visit_expr(*value);
@ -618,39 +618,39 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_expr(*value);
}
}
fn visit_expr_Starred(&mut self, node: ExprStarred<R>) {
self.generic_visit_expr_Starred(node)
fn visit_expr_starred(&mut self, node: ExprStarred<R>) {
self.generic_visit_expr_starred(node)
}
fn generic_visit_expr_Starred(&mut self, node: ExprStarred<R>) {
fn generic_visit_expr_starred(&mut self, node: ExprStarred<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_expr_Name(&mut self, node: ExprName<R>) {
self.generic_visit_expr_Name(node)
fn visit_expr_name(&mut self, node: ExprName<R>) {
self.generic_visit_expr_name(node)
}
fn generic_visit_expr_Name(&mut self, node: ExprName<R>) {}
fn visit_expr_List(&mut self, node: ExprList<R>) {
self.generic_visit_expr_List(node)
fn generic_visit_expr_name(&mut self, node: ExprName<R>) {}
fn visit_expr_list(&mut self, node: ExprList<R>) {
self.generic_visit_expr_list(node)
}
fn generic_visit_expr_List(&mut self, node: ExprList<R>) {
fn generic_visit_expr_list(&mut self, node: ExprList<R>) {
for value in node.elts {
self.visit_expr(value);
}
}
fn visit_expr_Tuple(&mut self, node: ExprTuple<R>) {
self.generic_visit_expr_Tuple(node)
fn visit_expr_tuple(&mut self, node: ExprTuple<R>) {
self.generic_visit_expr_tuple(node)
}
fn generic_visit_expr_Tuple(&mut self, node: ExprTuple<R>) {
fn generic_visit_expr_tuple(&mut self, node: ExprTuple<R>) {
for value in node.elts {
self.visit_expr(value);
}
}
fn visit_expr_Slice(&mut self, node: ExprSlice<R>) {
self.generic_visit_expr_Slice(node)
fn visit_expr_slice(&mut self, node: ExprSlice<R>) {
self.generic_visit_expr_slice(node)
}
fn generic_visit_expr_Slice(&mut self, node: ExprSlice<R>) {
fn generic_visit_expr_slice(&mut self, node: ExprSlice<R>) {
if let Some(value) = node.lower {
self.visit_expr(*value);
}
@ -690,13 +690,13 @@ pub trait Visitor<R = crate::text_size::TextRange> {
}
fn generic_visit_excepthandler(&mut self, node: Excepthandler<R>) {
match node {
Excepthandler::ExceptHandler(data) => self.visit_excepthandler_ExceptHandler(data),
Excepthandler::ExceptHandler(data) => self.visit_excepthandler_except_handler(data),
}
}
fn visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler<R>) {
self.generic_visit_excepthandler_ExceptHandler(node)
fn visit_excepthandler_except_handler(&mut self, node: ExcepthandlerExceptHandler<R>) {
self.generic_visit_excepthandler_except_handler(node)
}
fn generic_visit_excepthandler_ExceptHandler(&mut self, node: ExcepthandlerExceptHandler<R>) {
fn generic_visit_excepthandler_except_handler(&mut self, node: ExcepthandlerExceptHandler<R>) {
if let Some(value) = node.type_ {
self.visit_expr(*value);
}
@ -733,41 +733,41 @@ pub trait Visitor<R = crate::text_size::TextRange> {
}
fn generic_visit_pattern(&mut self, node: Pattern<R>) {
match node {
Pattern::MatchValue(data) => self.visit_pattern_MatchValue(data),
Pattern::MatchSingleton(data) => self.visit_pattern_MatchSingleton(data),
Pattern::MatchSequence(data) => self.visit_pattern_MatchSequence(data),
Pattern::MatchMapping(data) => self.visit_pattern_MatchMapping(data),
Pattern::MatchClass(data) => self.visit_pattern_MatchClass(data),
Pattern::MatchStar(data) => self.visit_pattern_MatchStar(data),
Pattern::MatchAs(data) => self.visit_pattern_MatchAs(data),
Pattern::MatchOr(data) => self.visit_pattern_MatchOr(data),
Pattern::MatchValue(data) => self.visit_pattern_match_value(data),
Pattern::MatchSingleton(data) => self.visit_pattern_match_singleton(data),
Pattern::MatchSequence(data) => self.visit_pattern_match_sequence(data),
Pattern::MatchMapping(data) => self.visit_pattern_match_mapping(data),
Pattern::MatchClass(data) => self.visit_pattern_match_class(data),
Pattern::MatchStar(data) => self.visit_pattern_match_star(data),
Pattern::MatchAs(data) => self.visit_pattern_match_as(data),
Pattern::MatchOr(data) => self.visit_pattern_match_or(data),
}
}
fn visit_pattern_MatchValue(&mut self, node: PatternMatchValue<R>) {
self.generic_visit_pattern_MatchValue(node)
fn visit_pattern_match_value(&mut self, node: PatternMatchValue<R>) {
self.generic_visit_pattern_match_value(node)
}
fn generic_visit_pattern_MatchValue(&mut self, node: PatternMatchValue<R>) {
fn generic_visit_pattern_match_value(&mut self, node: PatternMatchValue<R>) {
{
let value = node.value;
self.visit_expr(*value);
}
}
fn visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton<R>) {
self.generic_visit_pattern_MatchSingleton(node)
fn visit_pattern_match_singleton(&mut self, node: PatternMatchSingleton<R>) {
self.generic_visit_pattern_match_singleton(node)
}
fn generic_visit_pattern_MatchSingleton(&mut self, node: PatternMatchSingleton<R>) {}
fn visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence<R>) {
self.generic_visit_pattern_MatchSequence(node)
fn generic_visit_pattern_match_singleton(&mut self, node: PatternMatchSingleton<R>) {}
fn visit_pattern_match_sequence(&mut self, node: PatternMatchSequence<R>) {
self.generic_visit_pattern_match_sequence(node)
}
fn generic_visit_pattern_MatchSequence(&mut self, node: PatternMatchSequence<R>) {
fn generic_visit_pattern_match_sequence(&mut self, node: PatternMatchSequence<R>) {
for value in node.patterns {
self.visit_pattern(value);
}
}
fn visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping<R>) {
self.generic_visit_pattern_MatchMapping(node)
fn visit_pattern_match_mapping(&mut self, node: PatternMatchMapping<R>) {
self.generic_visit_pattern_match_mapping(node)
}
fn generic_visit_pattern_MatchMapping(&mut self, node: PatternMatchMapping<R>) {
fn generic_visit_pattern_match_mapping(&mut self, node: PatternMatchMapping<R>) {
for value in node.keys {
self.visit_expr(value);
}
@ -775,10 +775,10 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_pattern(value);
}
}
fn visit_pattern_MatchClass(&mut self, node: PatternMatchClass<R>) {
self.generic_visit_pattern_MatchClass(node)
fn visit_pattern_match_class(&mut self, node: PatternMatchClass<R>) {
self.generic_visit_pattern_match_class(node)
}
fn generic_visit_pattern_MatchClass(&mut self, node: PatternMatchClass<R>) {
fn generic_visit_pattern_match_class(&mut self, node: PatternMatchClass<R>) {
{
let value = node.cls;
self.visit_expr(*value);
@ -790,22 +790,22 @@ pub trait Visitor<R = crate::text_size::TextRange> {
self.visit_pattern(value);
}
}
fn visit_pattern_MatchStar(&mut self, node: PatternMatchStar<R>) {
self.generic_visit_pattern_MatchStar(node)
fn visit_pattern_match_star(&mut self, node: PatternMatchStar<R>) {
self.generic_visit_pattern_match_star(node)
}
fn generic_visit_pattern_MatchStar(&mut self, node: PatternMatchStar<R>) {}
fn visit_pattern_MatchAs(&mut self, node: PatternMatchAs<R>) {
self.generic_visit_pattern_MatchAs(node)
fn generic_visit_pattern_match_star(&mut self, node: PatternMatchStar<R>) {}
fn visit_pattern_match_as(&mut self, node: PatternMatchAs<R>) {
self.generic_visit_pattern_match_as(node)
}
fn generic_visit_pattern_MatchAs(&mut self, node: PatternMatchAs<R>) {
fn generic_visit_pattern_match_as(&mut self, node: PatternMatchAs<R>) {
if let Some(value) = node.pattern {
self.visit_pattern(*value);
}
}
fn visit_pattern_MatchOr(&mut self, node: PatternMatchOr<R>) {
self.generic_visit_pattern_MatchOr(node)
fn visit_pattern_match_or(&mut self, node: PatternMatchOr<R>) {
self.generic_visit_pattern_match_or(node)
}
fn generic_visit_pattern_MatchOr(&mut self, node: PatternMatchOr<R>) {
fn generic_visit_pattern_match_or(&mut self, node: PatternMatchOr<R>) {
for value in node.patterns {
self.visit_pattern(value);
}

262
ast/src/generic.rs
View file

@ -11,6 +11,15 @@ pub type OptionalRange<R> = R;
#[cfg(not(feature = "all-nodes-with-ranges"))]
pub type OptionalRange<R> = EmptyRange<R>;
#[cfg(not(feature = "all-nodes-with-ranges"))]
impl<R> From<R> for OptionalRange<R> {
fn from(_: R) -> Self {
Self {
phantom: PhantomData,
}
}
}
#[derive(Eq, PartialEq, Hash, Copy, Clone)]
pub struct EmptyRange<R> {
phantom: PhantomData<R>,
@ -62,4 +71,257 @@ impl Cmpop {
}
}
impl<R> Arguments<R> {
pub fn empty(range: OptionalRange<R>) -> Self {
Self {
range,
posonlyargs: Vec::new(),
args: Vec::new(),
vararg: None,
kwonlyargs: Vec::new(),
kwarg: None,
}
}
}
#[allow(clippy::borrowed_box)] // local utility
fn clone_boxed_expr<R: Clone>(expr: &Box<Expr<R>>) -> Box<Expr<R>> {
let expr: &Expr<_> = expr.as_ref();
Box::new(expr.clone())
}
impl<R> ArgWithDefault<R> {
pub fn from_arg(def: Arg<R>, default: Option<Expr<R>>) -> Self
where
R: Clone,
{
let range = {
if cfg!(feature = "all-nodes-with-ranges") {
todo!("range recovery is not implemented yet") // def.range.start()..default.range.end()
} else {
#[allow(clippy::useless_conversion)] // false positive by cfg
OptionalRange::from(def.range.clone())
}
};
Self {
range,
def,
default: default.map(Box::new),
}
}
pub fn as_arg(&self) -> &Arg<R> {
&self.def
}
pub fn to_arg(&self) -> (Arg<R>, Option<Box<Expr<R>>>)
where
R: Clone,
{
let ArgWithDefault {
range: _,
def,
default,
} = self;
(def.clone(), default.as_ref().map(clone_boxed_expr))
}
pub fn into_arg(self) -> (Arg<R>, Option<Box<Expr<R>>>) {
let ArgWithDefault {
range: _,
def,
default,
} = self;
(def, default)
}
}
impl<R> Arguments<R> {
pub fn defaults(&self) -> impl std::iter::Iterator<Item = &Expr<R>> {
self.posonlyargs
.iter()
.chain(self.args.iter())
.filter_map(|arg| arg.default.as_ref().map(|e| e.as_ref()))
}
#[allow(clippy::type_complexity)]
pub fn split_kwonlyargs(&self) -> (Vec<&Arg<R>>, Vec<(&Arg<R>, &Expr<R>)>) {
let mut args = Vec::new();
let mut with_defaults = Vec::new();
for arg in self.kwonlyargs.iter() {
if let Some(ref default) = arg.default {
with_defaults.push((arg.as_arg(), &**default));
} else {
args.push(arg.as_arg());
}
}
(args, with_defaults)
}
pub fn to_python_arguments(&self) -> PythonArguments<R>
where
R: Clone,
{
let Arguments {
range,
posonlyargs,
args,
vararg,
kwonlyargs,
kwarg,
} = self;
let mut pos_only = Vec::with_capacity(posonlyargs.len());
let mut pos_args = Vec::with_capacity(args.len());
let mut defaults = Vec::new();
for arg in posonlyargs {
let (arg, default) = arg.to_arg();
if let Some(default) = default {
defaults.push(*default);
}
pos_only.push(arg);
}
for arg in args {
let (arg, default) = arg.to_arg();
if let Some(default) = default {
defaults.push(*default);
}
pos_args.push(arg);
}
let mut kw_only = Vec::with_capacity(kwonlyargs.len());
let mut kw_defaults = Vec::new();
for arg in kwonlyargs {
let (arg, default) = arg.to_arg();
if let Some(default) = default {
kw_defaults.push(*default);
}
kw_only.push(arg);
}
PythonArguments {
range: range.clone(),
posonlyargs: pos_only,
args: pos_args,
defaults,
vararg: vararg.clone(),
kwonlyargs: kw_only,
kw_defaults,
kwarg: kwarg.clone(),
}
}
pub fn into_python_arguments(self) -> PythonArguments<R> {
let Arguments {
range,
posonlyargs,
args,
vararg,
kwonlyargs,
kwarg,
} = self;
let mut pos_only = Vec::with_capacity(posonlyargs.len());
let mut pos_args = Vec::with_capacity(args.len());
let mut defaults = Vec::new();
for arg in posonlyargs {
let (arg, default) = arg.into_arg();
if let Some(default) = default {
defaults.push(*default);
}
pos_only.push(arg);
}
for arg in args {
let (arg, default) = arg.into_arg();
if let Some(default) = default {
defaults.push(*default);
}
pos_args.push(arg);
}
let mut kw_only = Vec::with_capacity(kwonlyargs.len());
let mut kw_defaults = Vec::new();
for arg in kwonlyargs {
let (arg, default) = arg.into_arg();
if let Some(default) = default {
kw_defaults.push(*default);
}
kw_only.push(arg);
}
PythonArguments {
range,
posonlyargs: pos_only,
args: pos_args,
defaults,
vararg,
kwonlyargs: kw_only,
kw_defaults,
kwarg,
}
}
}
impl<R> PythonArguments<R> {
pub fn into_arguments(self) -> Arguments<R>
where
R: Clone,
{
let PythonArguments {
range,
posonlyargs,
args,
defaults,
vararg,
kwonlyargs,
kw_defaults,
kwarg,
} = self;
let mut pos_only = Vec::with_capacity(posonlyargs.len());
let mut pos_args = Vec::with_capacity(args.len());
let args_len = posonlyargs.len() + args.len();
// not optimal
let mut defaults: Vec<_> = std::iter::repeat_with(|| None)
.take(args_len - defaults.len())
.chain(defaults.into_iter().map(Some))
.collect();
debug_assert_eq!(args_len, defaults.len());
for (arg, default) in std::iter::zip(args, defaults.drain(posonlyargs.len()..)) {
let arg = ArgWithDefault::from_arg(arg, default);
pos_args.push(arg);
}
for (arg, default) in std::iter::zip(posonlyargs, defaults.drain(..)) {
let arg = ArgWithDefault::from_arg(arg, default);
pos_only.push(arg);
}
let mut kw_only = Vec::with_capacity(kwonlyargs.len());
let kw_defaults: Vec<_> = std::iter::repeat_with(|| None)
.take(kw_only.len().saturating_sub(kw_defaults.len()))
.chain(kw_defaults.into_iter().map(Some))
.collect();
for (arg, default) in std::iter::zip(kwonlyargs, kw_defaults) {
let arg = ArgWithDefault::from_arg(arg, default);
kw_only.push(arg);
}
Arguments {
range,
posonlyargs: pos_only,
args: pos_args,
vararg,
kwonlyargs: kw_only,
kwarg,
}
}
}
impl<R> From<Arguments<R>> for PythonArguments<R> {
fn from(arguments: Arguments<R>) -> Self {
arguments.into_python_arguments()
}
}
include!("gen/generic.rs");

9
ast/src/lib.rs
View file

@ -1,3 +1,12 @@
//! Python AST node definitions and utilities.
//!
//! AST nodes are very similary defined like [Python AST](https://docs.python.org/3/library/ast.html).
//! But a few exceptions exist due to parser optimization.
//! They can be transformed to matching Python-styled AST in reasonable cost.
//!
//! [PythonArguments] is replaced by [Arguments]. The new [Arguments] type representation uses a new type
//! [ArgWithDefault] to represent arguments with default values. See each type documentation for more details.
mod builtin;
mod generic;
mod impls;

47
ast/src/unparse.rs
View file

@ -1,5 +1,7 @@
use crate::ConversionFlag;
use crate::{Arg, Arguments, Boolop, Comprehension, Constant, Expr, Identifier, Operator};
use crate::{
Arg, ArgWithDefault, Arguments, Boolop, Comprehension, Constant, ConversionFlag, Expr,
Identifier, Operator, PythonArguments,
};
use std::fmt;
mod precedence {
@ -155,7 +157,7 @@ impl<'a> Unparser<'a> {
group_if!(precedence::TEST, {
let pos = args.args.len() + args.posonlyargs.len();
self.p(if pos > 0 { "lambda " } else { "lambda" })?;
self.unparse_args(args)?;
self.unparse_arguments(args)?;
write!(self, ": {}", **body)?;
})
}
@ -437,7 +439,44 @@ impl<'a> Unparser<'a> {
Ok(())
}
fn unparse_args<U>(&mut self, args: &Arguments<U>) -> fmt::Result {
fn unparse_arguments<U>(&mut self, args: &Arguments<U>) -> fmt::Result {
let mut first = true;
for (i, arg) in args.posonlyargs.iter().chain(&args.args).enumerate() {
self.p_delim(&mut first, ", ")?;
self.unparse_function_arg(arg)?;
self.p_if(i + 1 == args.posonlyargs.len(), ", /")?;
}
if args.vararg.is_some() || !args.kwonlyargs.is_empty() {
self.p_delim(&mut first, ", ")?;
self.p("*")?;
}
if let Some(vararg) = &args.vararg {
self.unparse_arg(vararg)?;
}
for kwarg in args.kwonlyargs.iter() {
self.p_delim(&mut first, ", ")?;
self.unparse_function_arg(kwarg)?;
}
if let Some(kwarg) = &args.kwarg {
self.p_delim(&mut first, ", ")?;
self.p("**")?;
self.unparse_arg(kwarg)?;
}
Ok(())
}
fn unparse_function_arg<U>(&mut self, arg: &ArgWithDefault<U>) -> fmt::Result {
self.p_id(&arg.def.arg)?;
if let Some(ann) = &arg.def.annotation {
write!(self, ": {}", **ann)?;
}
if let Some(default) = &arg.default {
write!(self, "={}", default)?;
}
Ok(())
}
#[allow(dead_code)]
fn unparse_python_arguments<U>(&mut self, args: &PythonArguments<U>) -> fmt::Result {
let mut first = true;
let defaults_start = args.posonlyargs.len() + args.args.len() - args.defaults.len();
for (i, arg) in args.posonlyargs.iter().chain(&args.args).enumerate() {