mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-08-04 02:38:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Remove async AST node variants for with, for, and def (#6369)

Browse source 
## Summary

Per the suggestion in
https://github.com/astral-sh/ruff/discussions/6183, this PR removes
`AsyncWith`, `AsyncFor`, and `AsyncFunctionDef`, replacing them with an
`is_async` field on the non-async variants of those structs. Unlike an
interpreter, we _generally_ have identical handling for these nodes, so
separating them into distinct variants adds complexity from which we
don't really benefit. This can be seen below, where we get to remove a
_ton_ of code related to adding generic `Any*` wrappers, and a ton of
duplicate branches for these cases.

## Test Plan

`cargo test` is unchanged, apart from parser snapshots.
This commit is contained in:
Charlie Marsh 2023-08-07 12:36:02 -04:00 • committed by GitHub
parent c895252aae
commit daefa74e9a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
91 changed files with 375 additions and 1478 deletions
Download patch file Download diff file Expand all files Collapse all files

20
crates/ruff_python_ast/src/cast.rs
View file

@ -1,19 +1,15 @@
use crate::{nodes, Decorator, Stmt};
pub fn name(stmt: &Stmt) -> &str {
match stmt {
Stmt::FunctionDef(nodes::StmtFunctionDef { name, .. })
| Stmt::AsyncFunctionDef(nodes::StmtAsyncFunctionDef { name, .. }) => name.as_str(),
_ => panic!("Expected Stmt::FunctionDef | Stmt::AsyncFunctionDef"),
}
let Stmt::FunctionDef(nodes::StmtFunctionDef { name, .. }) = stmt else {
panic!("Expected Stmt::FunctionDef")
};
name.as_str()
}
pub fn decorator_list(stmt: &Stmt) -> &[Decorator] {
match stmt {
Stmt::FunctionDef(nodes::StmtFunctionDef { decorator_list, .. })
| Stmt::AsyncFunctionDef(nodes::StmtAsyncFunctionDef { decorator_list, .. }) => {
decorator_list
}
_ => panic!("Expected Stmt::FunctionDef | Stmt::AsyncFunctionDef"),
}
let Stmt::FunctionDef(nodes::StmtFunctionDef { decorator_list, .. }) = stmt else {
panic!("Expected Stmt::FunctionDef")
};
decorator_list
}

72
crates/ruff_python_ast/src/comparable.rs
View file

@ -950,16 +950,7 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct StmtFunctionDef<'a> {
decorator_list: Vec<ComparableDecorator<'a>>,
name: &'a str,
type_params: Option<ComparableTypeParams<'a>>,
parameters: ComparableParameters<'a>,
returns: Option<ComparableExpr<'a>>,
body: Vec<ComparableStmt<'a>>,
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct StmtAsyncFunctionDef<'a> {
is_async: bool,
decorator_list: Vec<ComparableDecorator<'a>>,
name: &'a str,
type_params: Option<ComparableTypeParams<'a>>,
@ -1084,14 +1075,7 @@ pub struct StmtAnnAssign<'a> {
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct StmtFor<'a> {
target: ComparableExpr<'a>,
iter: ComparableExpr<'a>,
body: Vec<ComparableStmt<'a>>,
orelse: Vec<ComparableStmt<'a>>,
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct StmtAsyncFor<'a> {
is_async: bool,
target: ComparableExpr<'a>,
iter: ComparableExpr<'a>,
body: Vec<ComparableStmt<'a>>,
@ -1114,12 +1098,7 @@ pub struct StmtIf<'a> {
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct StmtWith<'a> {
items: Vec<ComparableWithItem<'a>>,
body: Vec<ComparableStmt<'a>>,
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct StmtAsyncWith<'a> {
is_async: bool,
items: Vec<ComparableWithItem<'a>>,
body: Vec<ComparableStmt<'a>>,
}
@ -1194,7 +1173,6 @@ pub struct StmtLineMagic<'a> {
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum ComparableStmt<'a> {
FunctionDef(StmtFunctionDef<'a>),
AsyncFunctionDef(StmtAsyncFunctionDef<'a>),
ClassDef(StmtClassDef<'a>),
Return(StmtReturn<'a>),
Delete(StmtDelete<'a>),
@ -1202,11 +1180,9 @@ pub enum ComparableStmt<'a> {
AugAssign(StmtAugAssign<'a>),
AnnAssign(StmtAnnAssign<'a>),
For(StmtFor<'a>),
AsyncFor(StmtAsyncFor<'a>),
While(StmtWhile<'a>),
If(StmtIf<'a>),
With(StmtWith<'a>),
AsyncWith(StmtAsyncWith<'a>),
Match(StmtMatch<'a>),
Raise(StmtRaise<'a>),
Try(StmtTry<'a>),
@ -1228,6 +1204,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
fn from(stmt: &'a ast::Stmt) -> Self {
match stmt {
ast::Stmt::FunctionDef(ast::StmtFunctionDef {
is_async,
name,
parameters,
body,
@ -1236,22 +1213,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
type_params,
range: _,
}) => Self::FunctionDef(StmtFunctionDef {
name: name.as_str(),
parameters: parameters.into(),
body: body.iter().map(Into::into).collect(),
decorator_list: decorator_list.iter().map(Into::into).collect(),
returns: returns.as_ref().map(Into::into),
type_params: type_params.as_ref().map(Into::into),
}),
ast::Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
name,
parameters,
body,
decorator_list,
returns,
type_params,
range: _,
}) => Self::AsyncFunctionDef(StmtAsyncFunctionDef {
is_async: *is_async,
name: name.as_str(),
parameters: parameters.into(),
body: body.iter().map(Into::into).collect(),
@ -1320,24 +1282,14 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
simple: *simple,
}),
ast::Stmt::For(ast::StmtFor {
is_async,
target,
iter,
body,
orelse,
range: _,
}) => Self::For(StmtFor {
target: target.into(),
iter: iter.into(),
body: body.iter().map(Into::into).collect(),
orelse: orelse.iter().map(Into::into).collect(),
}),
ast::Stmt::AsyncFor(ast::StmtAsyncFor {
target,
iter,
body,
orelse,
range: _,
}) => Self::AsyncFor(StmtAsyncFor {
is_async: *is_async,
target: target.into(),
iter: iter.into(),
body: body.iter().map(Into::into).collect(),
@ -1364,18 +1316,12 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
elif_else_clauses: elif_else_clauses.iter().map(Into::into).collect(),
}),
ast::Stmt::With(ast::StmtWith {
is_async,
items,
body,
range: _,
}) => Self::With(StmtWith {
items: items.iter().map(Into::into).collect(),
body: body.iter().map(Into::into).collect(),
}),
ast::Stmt::AsyncWith(ast::StmtAsyncWith {
items,
body,
range: _,
}) => Self::AsyncWith(StmtAsyncWith {
is_async: *is_async,
items: items.iter().map(Into::into).collect(),
body: body.iter().map(Into::into).collect(),
}),

134
crates/ruff_python_ast/src/function.rs
View file

@ -1,134 +0,0 @@
use crate::node::AnyNodeRef;
use crate::{
Decorator, Expr, Identifier, Parameters, Ranged, StmtAsyncFunctionDef, StmtFunctionDef, Suite,
TypeParams,
};
use ruff_text_size::TextRange;
/// Enum that represents any python function definition.
#[derive(Copy, Clone, PartialEq, Debug)]
pub enum AnyFunctionDefinition<'a> {
FunctionDefinition(&'a StmtFunctionDef),
AsyncFunctionDefinition(&'a StmtAsyncFunctionDef),
}
impl<'a> AnyFunctionDefinition<'a> {
pub const fn cast_ref(reference: AnyNodeRef<'a>) -> Option<Self> {
match reference {
AnyNodeRef::StmtAsyncFunctionDef(definition) => {
Some(Self::AsyncFunctionDefinition(definition))
}
AnyNodeRef::StmtFunctionDef(definition) => Some(Self::FunctionDefinition(definition)),
_ => None,
}
}
/// Returns `Some` if this is a [`StmtFunctionDef`] and `None` otherwise.
pub const fn as_function_definition(self) -> Option<&'a StmtFunctionDef> {
if let Self::FunctionDefinition(definition) = self {
Some(definition)
} else {
None
}
}
/// Returns `Some` if this is a [`StmtAsyncFunctionDef`] and `None` otherwise.
pub const fn as_async_function_definition(self) -> Option<&'a StmtAsyncFunctionDef> {
if let Self::AsyncFunctionDefinition(definition) = self {
Some(definition)
} else {
None
}
}
/// Returns the function's name
pub const fn name(self) -> &'a Identifier {
match self {
Self::FunctionDefinition(definition) => &definition.name,
Self::AsyncFunctionDefinition(definition) => &definition.name,
}
}
/// Returns the function arguments (parameters).
pub fn arguments(self) -> &'a Parameters {
match self {
Self::FunctionDefinition(definition) => definition.parameters.as_ref(),
Self::AsyncFunctionDefinition(definition) => definition.parameters.as_ref(),
}
}
/// Returns the function's body
pub const fn body(self) -> &'a Suite {
match self {
Self::FunctionDefinition(definition) => &definition.body,
Self::AsyncFunctionDefinition(definition) => &definition.body,
}
}
/// Returns the decorators attributing the function.
pub fn decorators(self) -> &'a [Decorator] {
match self {
Self::FunctionDefinition(definition) => &definition.decorator_list,
Self::AsyncFunctionDefinition(definition) => &definition.decorator_list,
}
}
pub fn returns(self) -> Option<&'a Expr> {
match self {
Self::FunctionDefinition(definition) => definition.returns.as_deref(),
Self::AsyncFunctionDefinition(definition) => definition.returns.as_deref(),
}
}
pub fn type_params(self) -> Option<&'a TypeParams> {
match self {
Self::FunctionDefinition(definition) => definition.type_params.as_ref(),
Self::AsyncFunctionDefinition(definition) => definition.type_params.as_ref(),
}
}
/// Returns `true` if this is [`Self::AsyncFunctionDefinition`]
pub const fn is_async(self) -> bool {
matches!(self, Self::AsyncFunctionDefinition(_))
}
}
impl Ranged for AnyFunctionDefinition<'_> {
fn range(&self) -> TextRange {
match self {
AnyFunctionDefinition::FunctionDefinition(definition) => definition.range(),
AnyFunctionDefinition::AsyncFunctionDefinition(definition) => definition.range(),
}
}
}
impl<'a> From<&'a StmtFunctionDef> for AnyFunctionDefinition<'a> {
fn from(value: &'a StmtFunctionDef) -> Self {
Self::FunctionDefinition(value)
}
}
impl<'a> From<&'a StmtAsyncFunctionDef> for AnyFunctionDefinition<'a> {
fn from(value: &'a StmtAsyncFunctionDef) -> Self {
Self::AsyncFunctionDefinition(value)
}
}
impl<'a> From<AnyFunctionDefinition<'a>> for AnyNodeRef<'a> {
fn from(value: AnyFunctionDefinition<'a>) -> Self {
match value {
AnyFunctionDefinition::FunctionDefinition(function_def) => {
AnyNodeRef::StmtFunctionDef(function_def)
}
AnyFunctionDefinition::AsyncFunctionDefinition(async_def) => {
AnyNodeRef::StmtAsyncFunctionDef(async_def)
}
}
}
}
impl<'a> From<&'a AnyFunctionDefinition<'a>> for AnyNodeRef<'a> {
fn from(value: &'a AnyFunctionDefinition<'a>) -> Self {
(*value).into()
}
}

33
crates/ruff_python_ast/src/helpers.rs
View file

@ -18,14 +18,11 @@ pub const fn is_compound_statement(stmt: &Stmt) -> bool {
matches!(
stmt,
Stmt::FunctionDef(_)
| Stmt::AsyncFunctionDef(_)
| Stmt::ClassDef(_)
| Stmt::While(_)
| Stmt::For(_)
| Stmt::AsyncFor(_)
| Stmt::Match(_)
| Stmt::With(_)
| Stmt::AsyncWith(_)
| Stmt::If(_)
| Stmt::Try(_)
| Stmt::TryStar(_)
@ -321,14 +318,6 @@ where
decorator_list,
returns,
..
})
| Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
parameters,
type_params,
body,
decorator_list,
returns,
..
}) => {
parameters
.posonlyargs
@ -439,13 +428,6 @@ where
body,
orelse,
..
})
| Stmt::AsyncFor(ast::StmtAsyncFor {
target,
iter,
body,
orelse,
..
}) => {
any_over_expr(target, func)
|| any_over_expr(iter, func)
@ -474,8 +456,7 @@ where
|| any_over_body(&clause.body, func)
})
}
Stmt::With(ast::StmtWith { items, body, .. })
| Stmt::AsyncWith(ast::StmtAsyncWith { items, body, .. }) => {
Stmt::With(ast::StmtWith { items, body, .. }) => {
items.iter().any(|with_item| {
any_over_expr(&with_item.context_expr, func)
|| with_item
@ -912,7 +893,7 @@ where
{
fn visit_stmt(&mut self, stmt: &'b Stmt) {
match stmt {
Stmt::FunctionDef(_) | Stmt::AsyncFunctionDef(_) | Stmt::ClassDef(_) => {
Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
// Don't recurse.
}
Stmt::Return(stmt) => self.returns.push(stmt),
@ -941,11 +922,7 @@ where
self.raises
.push((stmt.range(), exc.as_deref(), cause.as_deref()));
}
Stmt::ClassDef(_)
| Stmt::FunctionDef(_)
| Stmt::AsyncFunctionDef(_)
| Stmt::Try(_)
| Stmt::TryStar(_) => {}
Stmt::ClassDef(_) | Stmt::FunctionDef(_) | Stmt::Try(_) | Stmt::TryStar(_) => {}
Stmt::If(ast::StmtIf {
body,
elif_else_clauses,
@ -958,9 +935,7 @@ where
}
Stmt::While(ast::StmtWhile { body, .. })
| Stmt::With(ast::StmtWith { body, .. })
| Stmt::AsyncWith(ast::StmtAsyncWith { body, .. })
| Stmt::For(ast::StmtFor { body, .. })
| Stmt::AsyncFor(ast::StmtAsyncFor { body, .. }) => {
| Stmt::For(ast::StmtFor { body, .. }) => {
walk_body(self, body);
}
Stmt::Match(ast::StmtMatch { cases, .. }) => {

6
crates/ruff_python_ast/src/identifier.rs
View file

@ -31,8 +31,7 @@ impl Identifier for Stmt {
fn identifier(&self) -> TextRange {
match self {
Stmt::ClassDef(ast::StmtClassDef { name, .. })
| Stmt::FunctionDef(ast::StmtFunctionDef { name, .. })
| Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { name, .. }) => name.range(),
| Stmt::FunctionDef(ast::StmtFunctionDef { name, .. }) => name.range(),
_ => self.range(),
}
}
@ -85,10 +84,9 @@ pub fn except(handler: &ExceptHandler, source: &str) -> TextRange {
.expect("Failed to find `except` token in `ExceptHandler`")
}
/// Return the [`TextRange`] of the `else` token in a `For`, `AsyncFor`, or `While` statement.
/// Return the [`TextRange`] of the `else` token in a `For` or `While` statement.
pub fn else_(stmt: &Stmt, source: &str) -> Option<TextRange> {
let (Stmt::For(ast::StmtFor { body, orelse, .. })
| Stmt::AsyncFor(ast::StmtAsyncFor { body, orelse, .. })
| Stmt::While(ast::StmtWhile { body, orelse, .. })) = stmt
else {
return None;

1
crates/ruff_python_ast/src/lib.rs
View file

@ -6,7 +6,6 @@ pub mod call_path;
pub mod cast;
pub mod comparable;
pub mod docstrings;
pub mod function;
pub mod hashable;
pub mod helpers;
pub mod identifier;

183
crates/ruff_python_ast/src/node.rs
View file

@ -24,7 +24,6 @@ pub enum AnyNode {
ModModule(ast::ModModule),
ModExpression(ast::ModExpression),
StmtFunctionDef(ast::StmtFunctionDef),
StmtAsyncFunctionDef(ast::StmtAsyncFunctionDef),
StmtClassDef(ast::StmtClassDef),
StmtReturn(ast::StmtReturn),
StmtDelete(ast::StmtDelete),
@ -33,11 +32,9 @@ pub enum AnyNode {
StmtAugAssign(ast::StmtAugAssign),
StmtAnnAssign(ast::StmtAnnAssign),
StmtFor(ast::StmtFor),
StmtAsyncFor(ast::StmtAsyncFor),
StmtWhile(ast::StmtWhile),
StmtIf(ast::StmtIf),
StmtWith(ast::StmtWith),
StmtAsyncWith(ast::StmtAsyncWith),
StmtMatch(ast::StmtMatch),
StmtRaise(ast::StmtRaise),
StmtTry(ast::StmtTry),
@ -110,7 +107,6 @@ impl AnyNode {
pub fn statement(self) -> Option<Stmt> {
match self {
AnyNode::StmtFunctionDef(node) => Some(Stmt::FunctionDef(node)),
AnyNode::StmtAsyncFunctionDef(node) => Some(Stmt::AsyncFunctionDef(node)),
AnyNode::StmtClassDef(node) => Some(Stmt::ClassDef(node)),
AnyNode::StmtReturn(node) => Some(Stmt::Return(node)),
AnyNode::StmtDelete(node) => Some(Stmt::Delete(node)),
@ -119,11 +115,9 @@ impl AnyNode {
AnyNode::StmtAugAssign(node) => Some(Stmt::AugAssign(node)),
AnyNode::StmtAnnAssign(node) => Some(Stmt::AnnAssign(node)),
AnyNode::StmtFor(node) => Some(Stmt::For(node)),
AnyNode::StmtAsyncFor(node) => Some(Stmt::AsyncFor(node)),
AnyNode::StmtWhile(node) => Some(Stmt::While(node)),
AnyNode::StmtIf(node) => Some(Stmt::If(node)),
AnyNode::StmtWith(node) => Some(Stmt::With(node)),
AnyNode::StmtAsyncWith(node) => Some(Stmt::AsyncWith(node)),
AnyNode::StmtMatch(node) => Some(Stmt::Match(node)),
AnyNode::StmtRaise(node) => Some(Stmt::Raise(node)),
AnyNode::StmtTry(node) => Some(Stmt::Try(node)),
@ -230,7 +224,6 @@ impl AnyNode {
AnyNode::ModModule(_)
| AnyNode::ModExpression(_)
| AnyNode::StmtFunctionDef(_)
| AnyNode::StmtAsyncFunctionDef(_)
| AnyNode::StmtClassDef(_)
| AnyNode::StmtReturn(_)
| AnyNode::StmtDelete(_)
@ -239,11 +232,9 @@ impl AnyNode {
| AnyNode::StmtAugAssign(_)
| AnyNode::StmtAnnAssign(_)
| AnyNode::StmtFor(_)
| AnyNode::StmtAsyncFor(_)
| AnyNode::StmtWhile(_)
| AnyNode::StmtIf(_)
| AnyNode::StmtWith(_)
| AnyNode::StmtAsyncWith(_)
| AnyNode::StmtMatch(_)
| AnyNode::StmtRaise(_)
| AnyNode::StmtTry(_)
@ -291,7 +282,6 @@ impl AnyNode {
AnyNode::ModExpression(node) => Some(Mod::Expression(node)),
AnyNode::StmtFunctionDef(_)
| AnyNode::StmtAsyncFunctionDef(_)
| AnyNode::StmtClassDef(_)
| AnyNode::StmtReturn(_)
| AnyNode::StmtDelete(_)
@ -300,11 +290,9 @@ impl AnyNode {
| AnyNode::StmtAugAssign(_)
| AnyNode::StmtAnnAssign(_)
| AnyNode::StmtFor(_)
| AnyNode::StmtAsyncFor(_)
| AnyNode::StmtWhile(_)
| AnyNode::StmtIf(_)
| AnyNode::StmtWith(_)
| AnyNode::StmtAsyncWith(_)
| AnyNode::StmtMatch(_)
| AnyNode::StmtRaise(_)
| AnyNode::StmtTry(_)
@ -388,7 +376,6 @@ impl AnyNode {
AnyNode::ModModule(_)
| AnyNode::ModExpression(_)
| AnyNode::StmtFunctionDef(_)
| AnyNode::StmtAsyncFunctionDef(_)
| AnyNode::StmtClassDef(_)
| AnyNode::StmtReturn(_)
| AnyNode::StmtDelete(_)
@ -397,11 +384,9 @@ impl AnyNode {
| AnyNode::StmtAugAssign(_)
| AnyNode::StmtAnnAssign(_)
| AnyNode::StmtFor(_)
| AnyNode::StmtAsyncFor(_)
| AnyNode::StmtWhile(_)
| AnyNode::StmtIf(_)
| AnyNode::StmtWith(_)
| AnyNode::StmtAsyncWith(_)
| AnyNode::StmtMatch(_)
| AnyNode::StmtRaise(_)
| AnyNode::StmtTry(_)
@ -470,7 +455,6 @@ impl AnyNode {
AnyNode::ModModule(_)
| AnyNode::ModExpression(_)
| AnyNode::StmtFunctionDef(_)
| AnyNode::StmtAsyncFunctionDef(_)
| AnyNode::StmtClassDef(_)
| AnyNode::StmtReturn(_)
| AnyNode::StmtDelete(_)
@ -479,11 +463,9 @@ impl AnyNode {
| AnyNode::StmtAugAssign(_)
| AnyNode::StmtAnnAssign(_)
| AnyNode::StmtFor(_)
| AnyNode::StmtAsyncFor(_)
| AnyNode::StmtWhile(_)
| AnyNode::StmtIf(_)
| AnyNode::StmtWith(_)
| AnyNode::StmtAsyncWith(_)
| AnyNode::StmtMatch(_)
| AnyNode::StmtRaise(_)
| AnyNode::StmtTry(_)
@ -577,7 +559,6 @@ impl AnyNode {
Self::ModModule(node) => AnyNodeRef::ModModule(node),
Self::ModExpression(node) => AnyNodeRef::ModExpression(node),
Self::StmtFunctionDef(node) => AnyNodeRef::StmtFunctionDef(node),
Self::StmtAsyncFunctionDef(node) => AnyNodeRef::StmtAsyncFunctionDef(node),
Self::StmtClassDef(node) => AnyNodeRef::StmtClassDef(node),
Self::StmtReturn(node) => AnyNodeRef::StmtReturn(node),
Self::StmtDelete(node) => AnyNodeRef::StmtDelete(node),
@ -586,11 +567,9 @@ impl AnyNode {
Self::StmtAugAssign(node) => AnyNodeRef::StmtAugAssign(node),
Self::StmtAnnAssign(node) => AnyNodeRef::StmtAnnAssign(node),
Self::StmtFor(node) => AnyNodeRef::StmtFor(node),
Self::StmtAsyncFor(node) => AnyNodeRef::StmtAsyncFor(node),
Self::StmtWhile(node) => AnyNodeRef::StmtWhile(node),
Self::StmtIf(node) => AnyNodeRef::StmtIf(node),
Self::StmtWith(node) => AnyNodeRef::StmtWith(node),
Self::StmtAsyncWith(node) => AnyNodeRef::StmtAsyncWith(node),
Self::StmtMatch(node) => AnyNodeRef::StmtMatch(node),
Self::StmtRaise(node) => AnyNodeRef::StmtRaise(node),
Self::StmtTry(node) => AnyNodeRef::StmtTry(node),
@ -750,34 +729,6 @@ impl AstNode for ast::StmtFunctionDef {
AnyNode::from(self)
}
}
impl AstNode for ast::StmtAsyncFunctionDef {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::StmtAsyncFunctionDef(node) = kind {
Some(node)
} else {
None
}
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::StmtAsyncFunctionDef(node) = kind {
Some(node)
} else {
None
}
}
fn as_any_node_ref(&self) -> AnyNodeRef {
AnyNodeRef::from(self)
}
fn into_any_node(self) -> AnyNode {
AnyNode::from(self)
}
}
impl AstNode for ast::StmtClassDef {
fn cast(kind: AnyNode) -> Option<Self>
where
@ -1002,34 +953,6 @@ impl AstNode for ast::StmtFor {
AnyNode::from(self)
}
}
impl AstNode for ast::StmtAsyncFor {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::StmtAsyncFor(node) = kind {
Some(node)
} else {
None
}
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::StmtAsyncFor(node) = kind {
Some(node)
} else {
None
}
}
fn as_any_node_ref(&self) -> AnyNodeRef {
AnyNodeRef::from(self)
}
fn into_any_node(self) -> AnyNode {
AnyNode::from(self)
}
}
impl AstNode for ast::StmtWhile {
fn cast(kind: AnyNode) -> Option<Self>
where
@ -1142,34 +1065,6 @@ impl AstNode for ast::StmtWith {
AnyNode::from(self)
}
}
impl AstNode for ast::StmtAsyncWith {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::StmtAsyncWith(node) = kind {
Some(node)
} else {
None
}
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::StmtAsyncWith(node) = kind {
Some(node)
} else {
None
}
}
fn as_any_node_ref(&self) -> AnyNodeRef {
AnyNodeRef::from(self)
}
fn into_any_node(self) -> AnyNode {
AnyNode::from(self)
}
}
impl AstNode for ast::StmtMatch {
fn cast(kind: AnyNode) -> Option<Self>
where
@ -2996,7 +2891,6 @@ impl From<Stmt> for AnyNode {
fn from(stmt: Stmt) -> Self {
match stmt {
Stmt::FunctionDef(node) => AnyNode::StmtFunctionDef(node),
Stmt::AsyncFunctionDef(node) => AnyNode::StmtAsyncFunctionDef(node),
Stmt::ClassDef(node) => AnyNode::StmtClassDef(node),
Stmt::Return(node) => AnyNode::StmtReturn(node),
Stmt::Delete(node) => AnyNode::StmtDelete(node),
@ -3005,11 +2899,9 @@ impl From<Stmt> for AnyNode {
Stmt::AugAssign(node) => AnyNode::StmtAugAssign(node),
Stmt::AnnAssign(node) => AnyNode::StmtAnnAssign(node),
Stmt::For(node) => AnyNode::StmtFor(node),
Stmt::AsyncFor(node) => AnyNode::StmtAsyncFor(node),
Stmt::While(node) => AnyNode::StmtWhile(node),
Stmt::If(node) => AnyNode::StmtIf(node),
Stmt::With(node) => AnyNode::StmtWith(node),
Stmt::AsyncWith(node) => AnyNode::StmtAsyncWith(node),
Stmt::Match(node) => AnyNode::StmtMatch(node),
Stmt::Raise(node) => AnyNode::StmtRaise(node),
Stmt::Try(node) => AnyNode::StmtTry(node),
@ -3113,12 +3005,6 @@ impl From<ast::StmtFunctionDef> for AnyNode {
}
}
impl From<ast::StmtAsyncFunctionDef> for AnyNode {
fn from(node: ast::StmtAsyncFunctionDef) -> Self {
AnyNode::StmtAsyncFunctionDef(node)
}
}
impl From<ast::StmtClassDef> for AnyNode {
fn from(node: ast::StmtClassDef) -> Self {
AnyNode::StmtClassDef(node)
@ -3167,12 +3053,6 @@ impl From<ast::StmtFor> for AnyNode {
}
}
impl From<ast::StmtAsyncFor> for AnyNode {
fn from(node: ast::StmtAsyncFor) -> Self {
AnyNode::StmtAsyncFor(node)
}
}
impl From<ast::StmtWhile> for AnyNode {
fn from(node: ast::StmtWhile) -> Self {
AnyNode::StmtWhile(node)
@ -3197,12 +3077,6 @@ impl From<ast::StmtWith> for AnyNode {
}
}
impl From<ast::StmtAsyncWith> for AnyNode {
fn from(node: ast::StmtAsyncWith) -> Self {
AnyNode::StmtAsyncWith(node)
}
}
impl From<ast::StmtMatch> for AnyNode {
fn from(node: ast::StmtMatch) -> Self {
AnyNode::StmtMatch(node)
@ -3588,7 +3462,6 @@ impl Ranged for AnyNode {
AnyNode::ModModule(node) => node.range(),
AnyNode::ModExpression(node) => node.range(),
AnyNode::StmtFunctionDef(node) => node.range(),
AnyNode::StmtAsyncFunctionDef(node) => node.range(),
AnyNode::StmtClassDef(node) => node.range(),
AnyNode::StmtReturn(node) => node.range(),
AnyNode::StmtDelete(node) => node.range(),
@ -3597,11 +3470,9 @@ impl Ranged for AnyNode {
AnyNode::StmtAugAssign(node) => node.range(),
AnyNode::StmtAnnAssign(node) => node.range(),
AnyNode::StmtFor(node) => node.range(),
AnyNode::StmtAsyncFor(node) => node.range(),
AnyNode::StmtWhile(node) => node.range(),
AnyNode::StmtIf(node) => node.range(),
AnyNode::StmtWith(node) => node.range(),
AnyNode::StmtAsyncWith(node) => node.range(),
AnyNode::StmtMatch(node) => node.range(),
AnyNode::StmtRaise(node) => node.range(),
AnyNode::StmtTry(node) => node.range(),
@ -3677,7 +3548,6 @@ pub enum AnyNodeRef<'a> {
ModModule(&'a ast::ModModule),
ModExpression(&'a ast::ModExpression),
StmtFunctionDef(&'a ast::StmtFunctionDef),
StmtAsyncFunctionDef(&'a ast::StmtAsyncFunctionDef),
StmtClassDef(&'a ast::StmtClassDef),
StmtReturn(&'a ast::StmtReturn),
StmtDelete(&'a ast::StmtDelete),
@ -3686,11 +3556,9 @@ pub enum AnyNodeRef<'a> {
StmtAugAssign(&'a ast::StmtAugAssign),
StmtAnnAssign(&'a ast::StmtAnnAssign),
StmtFor(&'a ast::StmtFor),
StmtAsyncFor(&'a ast::StmtAsyncFor),
StmtWhile(&'a ast::StmtWhile),
StmtIf(&'a ast::StmtIf),
StmtWith(&'a ast::StmtWith),
StmtAsyncWith(&'a ast::StmtAsyncWith),
StmtMatch(&'a ast::StmtMatch),
StmtRaise(&'a ast::StmtRaise),
StmtTry(&'a ast::StmtTry),
@ -3765,7 +3633,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::ModModule(node) => NonNull::from(*node).cast(),
AnyNodeRef::ModExpression(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtFunctionDef(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtAsyncFunctionDef(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtClassDef(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtReturn(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtDelete(node) => NonNull::from(*node).cast(),
@ -3774,11 +3641,9 @@ impl AnyNodeRef<'_> {
AnyNodeRef::StmtAugAssign(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtAnnAssign(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtFor(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtAsyncFor(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtWhile(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtIf(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtWith(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtAsyncWith(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtMatch(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtRaise(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtTry(node) => NonNull::from(*node).cast(),
@ -3859,7 +3724,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::ModModule(_) => NodeKind::ModModule,
AnyNodeRef::ModExpression(_) => NodeKind::ModExpression,
AnyNodeRef::StmtFunctionDef(_) => NodeKind::StmtFunctionDef,
AnyNodeRef::StmtAsyncFunctionDef(_) => NodeKind::StmtAsyncFunctionDef,
AnyNodeRef::StmtClassDef(_) => NodeKind::StmtClassDef,
AnyNodeRef::StmtReturn(_) => NodeKind::StmtReturn,
AnyNodeRef::StmtDelete(_) => NodeKind::StmtDelete,
@ -3868,11 +3732,9 @@ impl AnyNodeRef<'_> {
AnyNodeRef::StmtAugAssign(_) => NodeKind::StmtAugAssign,
AnyNodeRef::StmtAnnAssign(_) => NodeKind::StmtAnnAssign,
AnyNodeRef::StmtFor(_) => NodeKind::StmtFor,
AnyNodeRef::StmtAsyncFor(_) => NodeKind::StmtAsyncFor,
AnyNodeRef::StmtWhile(_) => NodeKind::StmtWhile,
AnyNodeRef::StmtIf(_) => NodeKind::StmtIf,
AnyNodeRef::StmtWith(_) => NodeKind::StmtWith,
AnyNodeRef::StmtAsyncWith(_) => NodeKind::StmtAsyncWith,
AnyNodeRef::StmtMatch(_) => NodeKind::StmtMatch,
AnyNodeRef::StmtRaise(_) => NodeKind::StmtRaise,
AnyNodeRef::StmtTry(_) => NodeKind::StmtTry,
@ -3945,7 +3807,6 @@ impl AnyNodeRef<'_> {
pub const fn is_statement(self) -> bool {
match self {
AnyNodeRef::StmtFunctionDef(_)
| AnyNodeRef::StmtAsyncFunctionDef(_)
| AnyNodeRef::StmtClassDef(_)
| AnyNodeRef::StmtReturn(_)
| AnyNodeRef::StmtDelete(_)
@ -3954,11 +3815,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtAugAssign(_)
| AnyNodeRef::StmtAnnAssign(_)
| AnyNodeRef::StmtFor(_)
| AnyNodeRef::StmtAsyncFor(_)
| AnyNodeRef::StmtWhile(_)
| AnyNodeRef::StmtIf(_)
| AnyNodeRef::StmtWith(_)
| AnyNodeRef::StmtAsyncWith(_)
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
@ -4065,7 +3924,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::ModModule(_)
| AnyNodeRef::ModExpression(_)
| AnyNodeRef::StmtFunctionDef(_)
| AnyNodeRef::StmtAsyncFunctionDef(_)
| AnyNodeRef::StmtClassDef(_)
| AnyNodeRef::StmtReturn(_)
| AnyNodeRef::StmtDelete(_)
@ -4074,11 +3932,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtAugAssign(_)
| AnyNodeRef::StmtAnnAssign(_)
| AnyNodeRef::StmtFor(_)
| AnyNodeRef::StmtAsyncFor(_)
| AnyNodeRef::StmtWhile(_)
| AnyNodeRef::StmtIf(_)
| AnyNodeRef::StmtWith(_)
| AnyNodeRef::StmtAsyncWith(_)
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
@ -4125,7 +3981,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::ModModule(_) | AnyNodeRef::ModExpression(_) => true,
AnyNodeRef::StmtFunctionDef(_)
| AnyNodeRef::StmtAsyncFunctionDef(_)
| AnyNodeRef::StmtClassDef(_)
| AnyNodeRef::StmtReturn(_)
| AnyNodeRef::StmtDelete(_)
@ -4134,11 +3989,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtAugAssign(_)
| AnyNodeRef::StmtAnnAssign(_)
| AnyNodeRef::StmtFor(_)
| AnyNodeRef::StmtAsyncFor(_)
| AnyNodeRef::StmtWhile(_)
| AnyNodeRef::StmtIf(_)
| AnyNodeRef::StmtWith(_)
| AnyNodeRef::StmtAsyncWith(_)
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
@ -4222,7 +4075,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::ModModule(_)
| AnyNodeRef::ModExpression(_)
| AnyNodeRef::StmtFunctionDef(_)
| AnyNodeRef::StmtAsyncFunctionDef(_)
| AnyNodeRef::StmtClassDef(_)
| AnyNodeRef::StmtReturn(_)
| AnyNodeRef::StmtDelete(_)
@ -4231,11 +4083,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtAugAssign(_)
| AnyNodeRef::StmtAnnAssign(_)
| AnyNodeRef::StmtFor(_)
| AnyNodeRef::StmtAsyncFor(_)
| AnyNodeRef::StmtWhile(_)
| AnyNodeRef::StmtIf(_)
| AnyNodeRef::StmtWith(_)
| AnyNodeRef::StmtAsyncWith(_)
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
@ -4304,7 +4154,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::ModModule(_)
| AnyNodeRef::ModExpression(_)
| AnyNodeRef::StmtFunctionDef(_)
| AnyNodeRef::StmtAsyncFunctionDef(_)
| AnyNodeRef::StmtClassDef(_)
| AnyNodeRef::StmtReturn(_)
| AnyNodeRef::StmtDelete(_)
@ -4313,11 +4162,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtAugAssign(_)
| AnyNodeRef::StmtAnnAssign(_)
| AnyNodeRef::StmtFor(_)
| AnyNodeRef::StmtAsyncFor(_)
| AnyNodeRef::StmtWhile(_)
| AnyNodeRef::StmtIf(_)
| AnyNodeRef::StmtWith(_)
| AnyNodeRef::StmtAsyncWith(_)
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
@ -4391,13 +4238,10 @@ impl AnyNodeRef<'_> {
self,
AnyNodeRef::StmtIf(_)
| AnyNodeRef::StmtFor(_)
| AnyNodeRef::StmtAsyncFor(_)
| AnyNodeRef::StmtWhile(_)
| AnyNodeRef::StmtWith(_)
| AnyNodeRef::StmtAsyncWith(_)
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtFunctionDef(_)
| AnyNodeRef::StmtAsyncFunctionDef(_)
| AnyNodeRef::StmtClassDef(_)
| AnyNodeRef::StmtTry(_)
| AnyNodeRef::StmtTryStar(_)
@ -4435,12 +4279,6 @@ impl<'a> From<&'a ast::StmtFunctionDef> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a ast::StmtAsyncFunctionDef> for AnyNodeRef<'a> {
fn from(node: &'a ast::StmtAsyncFunctionDef) -> Self {
AnyNodeRef::StmtAsyncFunctionDef(node)
}
}
impl<'a> From<&'a ast::StmtClassDef> for AnyNodeRef<'a> {
fn from(node: &'a ast::StmtClassDef) -> Self {
AnyNodeRef::StmtClassDef(node)
@ -4489,12 +4327,6 @@ impl<'a> From<&'a ast::StmtFor> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a ast::StmtAsyncFor> for AnyNodeRef<'a> {
fn from(node: &'a ast::StmtAsyncFor) -> Self {
AnyNodeRef::StmtAsyncFor(node)
}
}
impl<'a> From<&'a ast::StmtWhile> for AnyNodeRef<'a> {
fn from(node: &'a ast::StmtWhile) -> Self {
AnyNodeRef::StmtWhile(node)
@ -4519,12 +4351,6 @@ impl<'a> From<&'a ast::StmtWith> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a ast::StmtAsyncWith> for AnyNodeRef<'a> {
fn from(node: &'a ast::StmtAsyncWith) -> Self {
AnyNodeRef::StmtAsyncWith(node)
}
}
impl<'a> From<&'a ast::StmtMatch> for AnyNodeRef<'a> {
fn from(node: &'a ast::StmtMatch) -> Self {
AnyNodeRef::StmtMatch(node)
@ -4864,7 +4690,6 @@ impl<'a> From<&'a Stmt> for AnyNodeRef<'a> {
fn from(stmt: &'a Stmt) -> Self {
match stmt {
Stmt::FunctionDef(node) => AnyNodeRef::StmtFunctionDef(node),
Stmt::AsyncFunctionDef(node) => AnyNodeRef::StmtAsyncFunctionDef(node),
Stmt::ClassDef(node) => AnyNodeRef::StmtClassDef(node),
Stmt::Return(node) => AnyNodeRef::StmtReturn(node),
Stmt::Delete(node) => AnyNodeRef::StmtDelete(node),
@ -4873,11 +4698,9 @@ impl<'a> From<&'a Stmt> for AnyNodeRef<'a> {
Stmt::AugAssign(node) => AnyNodeRef::StmtAugAssign(node),
Stmt::AnnAssign(node) => AnyNodeRef::StmtAnnAssign(node),
Stmt::For(node) => AnyNodeRef::StmtFor(node),
Stmt::AsyncFor(node) => AnyNodeRef::StmtAsyncFor(node),
Stmt::While(node) => AnyNodeRef::StmtWhile(node),
Stmt::If(node) => AnyNodeRef::StmtIf(node),
Stmt::With(node) => AnyNodeRef::StmtWith(node),
Stmt::AsyncWith(node) => AnyNodeRef::StmtAsyncWith(node),
Stmt::Match(node) => AnyNodeRef::StmtMatch(node),
Stmt::Raise(node) => AnyNodeRef::StmtRaise(node),
Stmt::Try(node) => AnyNodeRef::StmtTry(node),
@ -5027,7 +4850,6 @@ impl Ranged for AnyNodeRef<'_> {
AnyNodeRef::ModModule(node) => node.range(),
AnyNodeRef::ModExpression(node) => node.range(),
AnyNodeRef::StmtFunctionDef(node) => node.range(),
AnyNodeRef::StmtAsyncFunctionDef(node) => node.range(),
AnyNodeRef::StmtClassDef(node) => node.range(),
AnyNodeRef::StmtReturn(node) => node.range(),
AnyNodeRef::StmtDelete(node) => node.range(),
@ -5036,11 +4858,9 @@ impl Ranged for AnyNodeRef<'_> {
AnyNodeRef::StmtAugAssign(node) => node.range(),
AnyNodeRef::StmtAnnAssign(node) => node.range(),
AnyNodeRef::StmtFor(node) => node.range(),
AnyNodeRef::StmtAsyncFor(node) => node.range(),
AnyNodeRef::StmtWhile(node) => node.range(),
AnyNodeRef::StmtIf(node) => node.range(),
AnyNodeRef::StmtWith(node) => node.range(),
AnyNodeRef::StmtAsyncWith(node) => node.range(),
AnyNodeRef::StmtMatch(node) => node.range(),
AnyNodeRef::StmtRaise(node) => node.range(),
AnyNodeRef::StmtTry(node) => node.range(),
@ -5118,7 +4938,6 @@ pub enum NodeKind {
ModExpression,
ModFunctionType,
StmtFunctionDef,
StmtAsyncFunctionDef,
StmtClassDef,
StmtReturn,
StmtDelete,
@ -5127,11 +4946,9 @@ pub enum NodeKind {
StmtAugAssign,
StmtAnnAssign,
StmtFor,
StmtAsyncFor,
StmtWhile,
StmtIf,
StmtWith,
StmtAsyncWith,
StmtMatch,
StmtRaise,
StmtTry,

99
crates/ruff_python_ast/src/nodes.rs
View file

@ -45,8 +45,6 @@ impl From<ModExpression> for Mod {
pub enum Stmt {
#[is(name = "function_def_stmt")]
FunctionDef(StmtFunctionDef),
#[is(name = "async_function_def_stmt")]
AsyncFunctionDef(StmtAsyncFunctionDef),
#[is(name = "class_def_stmt")]
ClassDef(StmtClassDef),
#[is(name = "return_stmt")]
@ -63,16 +61,12 @@ pub enum Stmt {
TypeAlias(StmtTypeAlias),
#[is(name = "for_stmt")]
For(StmtFor),
#[is(name = "async_for_stmt")]
AsyncFor(StmtAsyncFor),
#[is(name = "while_stmt")]
While(StmtWhile),
#[is(name = "if_stmt")]
If(StmtIf),
#[is(name = "with_stmt")]
With(StmtWith),
#[is(name = "async_with_stmt")]
AsyncWith(StmtAsyncWith),
#[is(name = "match_stmt")]
Match(StmtMatch),
#[is(name = "raise_stmt")]
@ -118,10 +112,15 @@ impl From<StmtLineMagic> for Stmt {
}
}
/// See also [FunctionDef](https://docs.python.org/3/library/ast.html#ast.FunctionDef)
/// See also [FunctionDef](https://docs.python.org/3/library/ast.html#ast.FunctionDef) and
/// [AsyncFunctionDef](https://docs.python.org/3/library/ast.html#ast.AsyncFunctionDef).
///
/// This type differs from the original Python AST, as it collapses the
/// synchronous and asynchronous variants into a single type.
#[derive(Clone, Debug, PartialEq)]
pub struct StmtFunctionDef {
pub range: TextRange,
pub is_async: bool,
pub decorator_list: Vec<Decorator>,
pub name: Identifier,
pub type_params: Option<TypeParams>,
@ -136,24 +135,6 @@ impl From<StmtFunctionDef> for Stmt {
}
}
/// See also [AsyncFunctionDef](https://docs.python.org/3/library/ast.html#ast.AsyncFunctionDef)
#[derive(Clone, Debug, PartialEq)]
pub struct StmtAsyncFunctionDef {
pub range: TextRange,
pub decorator_list: Vec<Decorator>,
pub name: Identifier,
pub type_params: Option<TypeParams>,
pub parameters: Box<Parameters>,
pub returns: Option<Box<Expr>>,
pub body: Vec<Stmt>,
}
impl From<StmtAsyncFunctionDef> for Stmt {
fn from(payload: StmtAsyncFunctionDef) -> Self {
Stmt::AsyncFunctionDef(payload)
}
}
/// See also [ClassDef](https://docs.python.org/3/library/ast.html#ast.ClassDef)
#[derive(Clone, Debug, PartialEq)]
pub struct StmtClassDef {
@ -275,10 +256,15 @@ impl From<StmtAnnAssign> for Stmt {
}
}
/// See also [For](https://docs.python.org/3/library/ast.html#ast.For)
/// See also [For](https://docs.python.org/3/library/ast.html#ast.For) and
/// [AsyncFor](https://docs.python.org/3/library/ast.html#ast.AsyncFor).
///
/// This type differs from the original Python AST, as it collapses the
/// synchronous and asynchronous variants into a single type.
#[derive(Clone, Debug, PartialEq)]
pub struct StmtFor {
pub range: TextRange,
pub is_async: bool,
pub target: Box<Expr>,
pub iter: Box<Expr>,
pub body: Vec<Stmt>,
@ -291,23 +277,8 @@ impl From<StmtFor> for Stmt {
}
}
/// See also [AsyncFor](https://docs.python.org/3/library/ast.html#ast.AsyncFor)
#[derive(Clone, Debug, PartialEq)]
pub struct StmtAsyncFor {
pub range: TextRange,
pub target: Box<Expr>,
pub iter: Box<Expr>,
pub body: Vec<Stmt>,
pub orelse: Vec<Stmt>,
}
impl From<StmtAsyncFor> for Stmt {
fn from(payload: StmtAsyncFor) -> Self {
Stmt::AsyncFor(payload)
}
}
/// See also [While](https://docs.python.org/3/library/ast.html#ast.While)
/// See also [While](https://docs.python.org/3/library/ast.html#ast.While) and
/// [AsyncWhile](https://docs.python.org/3/library/ast.html#ast.AsyncWhile).
#[derive(Clone, Debug, PartialEq)]
pub struct StmtWhile {
pub range: TextRange,
@ -344,10 +315,15 @@ pub struct ElifElseClause {
pub body: Vec<Stmt>,
}
/// See also [With](https://docs.python.org/3/library/ast.html#ast.With)
/// See also [With](https://docs.python.org/3/library/ast.html#ast.With) and
/// [AsyncWith](https://docs.python.org/3/library/ast.html#ast.AsyncWith).
///
/// This type differs from the original Python AST, as it collapses the
/// synchronous and asynchronous variants into a single type.
#[derive(Clone, Debug, PartialEq)]
pub struct StmtWith {
pub range: TextRange,
pub is_async: bool,
pub items: Vec<WithItem>,
pub body: Vec<Stmt>,
}
@ -358,20 +334,6 @@ impl From<StmtWith> for Stmt {
}
}
/// See also [AsyncWith](https://docs.python.org/3/library/ast.html#ast.AsyncWith)
#[derive(Clone, Debug, PartialEq)]
pub struct StmtAsyncWith {
pub range: TextRange,
pub items: Vec<WithItem>,
pub body: Vec<Stmt>,
}
impl From<StmtAsyncWith> for Stmt {
fn from(payload: StmtAsyncWith) -> Self {
Stmt::AsyncWith(payload)
}
}
/// See also [Match](https://docs.python.org/3/library/ast.html#ast.Match)
#[derive(Clone, Debug, PartialEq)]
pub struct StmtMatch {
@ -2599,11 +2561,6 @@ impl Ranged for crate::nodes::StmtFunctionDef {
self.range
}
}
impl Ranged for crate::nodes::StmtAsyncFunctionDef {
fn range(&self) -> TextRange {
self.range
}
}
impl Ranged for crate::nodes::StmtClassDef {
fn range(&self) -> TextRange {
self.range
@ -2644,11 +2601,6 @@ impl Ranged for crate::nodes::StmtFor {
self.range
}
}
impl Ranged for crate::nodes::StmtAsyncFor {
fn range(&self) -> TextRange {
self.range
}
}
impl Ranged for crate::nodes::StmtWhile {
fn range(&self) -> TextRange {
self.range
@ -2669,11 +2621,6 @@ impl Ranged for crate::nodes::StmtWith {
self.range
}
}
impl Ranged for crate::nodes::StmtAsyncWith {
fn range(&self) -> TextRange {
self.range
}
}
impl Ranged for crate::nodes::StmtMatch {
fn range(&self) -> TextRange {
self.range
@ -2748,7 +2695,6 @@ impl Ranged for crate::Stmt {
fn range(&self) -> TextRange {
match self {
Self::FunctionDef(node) => node.range(),
Self::AsyncFunctionDef(node) => node.range(),
Self::ClassDef(node) => node.range(),
Self::Return(node) => node.range(),
Self::Delete(node) => node.range(),
@ -2757,11 +2703,9 @@ impl Ranged for crate::Stmt {
Self::AugAssign(node) => node.range(),
Self::AnnAssign(node) => node.range(),
Self::For(node) => node.range(),
Self::AsyncFor(node) => node.range(),
Self::While(node) => node.range(),
Self::If(node) => node.range(),
Self::With(node) => node.range(),
Self::AsyncWith(node) => node.range(),
Self::Match(node) => node.range(),
Self::Raise(node) => node.range(),
Self::Try(node) => node.range(),
@ -3110,8 +3054,7 @@ mod size_assertions {
use static_assertions::assert_eq_size;
assert_eq_size!(Stmt, [u8; 144]);
assert_eq_size!(StmtFunctionDef, [u8; 136]);
assert_eq_size!(StmtAsyncFunctionDef, [u8; 136]);
assert_eq_size!(StmtFunctionDef, [u8; 144]);
assert_eq_size!(StmtClassDef, [u8; 104]);
assert_eq_size!(StmtTry, [u8; 104]);
assert_eq_size!(Expr, [u8; 80]);

10
crates/ruff_python_ast/src/statement_visitor.rs
View file

@ -32,9 +32,6 @@ pub fn walk_stmt<'a, V: StatementVisitor<'a> + ?Sized>(visitor: &mut V, stmt: &'
Stmt::FunctionDef(ast::StmtFunctionDef { body, .. }) => {
visitor.visit_body(body);
}
Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { body, .. }) => {
visitor.visit_body(body);
}
Stmt::For(ast::StmtFor { body, orelse, .. }) => {
visitor.visit_body(body);
visitor.visit_body(orelse);
@ -42,10 +39,6 @@ pub fn walk_stmt<'a, V: StatementVisitor<'a> + ?Sized>(visitor: &mut V, stmt: &'
Stmt::ClassDef(ast::StmtClassDef { body, .. }) => {
visitor.visit_body(body);
}
Stmt::AsyncFor(ast::StmtAsyncFor { body, orelse, .. }) => {
visitor.visit_body(body);
visitor.visit_body(orelse);
}
Stmt::While(ast::StmtWhile { body, orelse, .. }) => {
visitor.visit_body(body);
visitor.visit_body(orelse);
@ -63,9 +56,6 @@ pub fn walk_stmt<'a, V: StatementVisitor<'a> + ?Sized>(visitor: &mut V, stmt: &'
Stmt::With(ast::StmtWith { body, .. }) => {
visitor.visit_body(body);
}
Stmt::AsyncWith(ast::StmtAsyncWith { body, .. }) => {
visitor.visit_body(body);
}
Stmt::Match(ast::StmtMatch { cases, .. }) => {
for match_case in cases {
visitor.visit_match_case(match_case);

11
crates/ruff_python_ast/src/traversal.rs
View file

@ -5,7 +5,6 @@ use crate::{self as ast, ExceptHandler, Stmt, Suite};
pub fn suite<'a>(stmt: &'a Stmt, parent: &'a Stmt) -> Option<&'a Suite> {
match parent {
Stmt::FunctionDef(ast::StmtFunctionDef { body, .. }) => Some(body),
Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { body, .. }) => Some(body),
Stmt::ClassDef(ast::StmtClassDef { body, .. }) => Some(body),
Stmt::For(ast::StmtFor { body, orelse, .. }) => {
if body.contains(stmt) {
@ -16,15 +15,6 @@ pub fn suite<'a>(stmt: &'a Stmt, parent: &'a Stmt) -> Option<&'a Suite> {
None
}
}
Stmt::AsyncFor(ast::StmtAsyncFor { body, orelse, .. }) => {
if body.contains(stmt) {
Some(body)
} else if orelse.contains(stmt) {
Some(orelse)
} else {
None
}
}
Stmt::While(ast::StmtWhile { body, orelse, .. }) => {
if body.contains(stmt) {
Some(body)
@ -49,7 +39,6 @@ pub fn suite<'a>(stmt: &'a Stmt, parent: &'a Stmt) -> Option<&'a Suite> {
}
}
Stmt::With(ast::StmtWith { body, .. }) => Some(body),
Stmt::AsyncWith(ast::StmtAsyncWith { body, .. }) => Some(body),
Stmt::Match(ast::StmtMatch { cases, .. }) => cases
.iter()
.map(|case| &case.body)

38
crates/ruff_python_ast/src/visitor.rs
View file

@ -128,26 +128,6 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
}
visitor.visit_body(body);
}
Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
parameters,
body,
decorator_list,
returns,
type_params,
..
}) => {
for decorator in decorator_list {
visitor.visit_decorator(decorator);
}
if let Some(type_params) = type_params {
visitor.visit_type_params(type_params);
}
visitor.visit_parameters(parameters);
for expr in returns {
visitor.visit_annotation(expr);
}
visitor.visit_body(body);
}
Stmt::ClassDef(ast::StmtClassDef {
arguments,
body,
@ -228,18 +208,6 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
visitor.visit_body(body);
visitor.visit_body(orelse);
}
Stmt::AsyncFor(ast::StmtAsyncFor {
target,
iter,
body,
orelse,
..
}) => {
visitor.visit_expr(iter);
visitor.visit_expr(target);
visitor.visit_body(body);
visitor.visit_body(orelse);
}
Stmt::While(ast::StmtWhile {
test,
body,
@ -271,12 +239,6 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
}
visitor.visit_body(body);
}
Stmt::AsyncWith(ast::StmtAsyncWith { items, body, .. }) => {
for with_item in items {
visitor.visit_with_item(with_item);
}
visitor.visit_body(body);
}
Stmt::Match(ast::StmtMatch {
subject,
cases,

21
crates/ruff_python_ast/src/visitor/preorder.rs
View file

@ -145,14 +145,6 @@ where
returns,
type_params,
..
})
| Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
parameters,
body,
decorator_list,
returns,
type_params,
..
}) => {
for decorator in decorator_list {
visitor.visit_decorator(decorator);
@ -261,13 +253,6 @@ where
body,
orelse,
..
})
| Stmt::AsyncFor(ast::StmtAsyncFor {
target,
iter,
body,
orelse,
..
}) => {
visitor.visit_expr(target);
visitor.visit_expr(iter);
@ -302,11 +287,7 @@ where
Stmt::With(ast::StmtWith {
items,
body,
range: _,
})
| Stmt::AsyncWith(ast::StmtAsyncWith {
items,
body,
is_async: _,
range: _,
}) => {
for with_item in items {