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 Stmt::TryStar (#6566)

Browse source 
## Summary

Instead, we set an `is_star` flag on `Stmt::Try`. This is similar to the
pattern we've migrated towards for `Stmt::For` (removing
`Stmt::AsyncFor`) and friends. While these are significant differences
for an interpreter, we tend to handle these cases identically or nearly
identically.

## Test Plan

`cargo test`
This commit is contained in:
Charlie Marsh 2023-08-14 13:39:44 -04:00 • committed by GitHub
parent 09c8b17661
commit 96d310fbab
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
33 changed files with 70 additions and 489 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1133,14 +1133,7 @@ pub struct StmtTry<'a> {
handlers: Vec<ComparableExceptHandler<'a>>,
orelse: Vec<ComparableStmt<'a>>,
finalbody: Vec<ComparableStmt<'a>>,
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct StmtTryStar<'a> {
body: Vec<ComparableStmt<'a>>,
handlers: Vec<ComparableExceptHandler<'a>>,
orelse: Vec<ComparableStmt<'a>>,
finalbody: Vec<ComparableStmt<'a>>,
is_star: bool,
}
#[derive(Debug, PartialEq, Eq, Hash)]
@ -1198,7 +1191,6 @@ pub enum ComparableStmt<'a> {
Match(StmtMatch<'a>),
Raise(StmtRaise<'a>),
Try(StmtTry<'a>),
TryStar(StmtTryStar<'a>),
TypeAlias(StmtTypeAlias<'a>),
Assert(StmtAssert<'a>),
Import(StmtImport<'a>),
@ -1358,24 +1350,14 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
handlers,
orelse,
finalbody,
is_star,
range: _,
}) => Self::Try(StmtTry {
body: body.iter().map(Into::into).collect(),
handlers: handlers.iter().map(Into::into).collect(),
orelse: orelse.iter().map(Into::into).collect(),
finalbody: finalbody.iter().map(Into::into).collect(),
}),
ast::Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
}) => Self::TryStar(StmtTryStar {
body: body.iter().map(Into::into).collect(),
handlers: handlers.iter().map(Into::into).collect(),
orelse: orelse.iter().map(Into::into).collect(),
finalbody: finalbody.iter().map(Into::into).collect(),
is_star: *is_star,
}),
ast::Stmt::Assert(ast::StmtAssert {
test,

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

@ -25,7 +25,6 @@ pub const fn is_compound_statement(stmt: &Stmt) -> bool {
| Stmt::With(_)
| Stmt::If(_)
| Stmt::Try(_)
| Stmt::TryStar(_)
)
}
@ -478,13 +477,7 @@ where
handlers,
orelse,
finalbody,
range: _,
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
is_star: _,
range: _,
}) => {
any_over_body(body, func)
@ -920,7 +913,7 @@ where
self.raises
.push((stmt.range(), exc.as_deref(), cause.as_deref()));
}
Stmt::ClassDef(_) | Stmt::FunctionDef(_) | Stmt::Try(_) | Stmt::TryStar(_) => {}
Stmt::ClassDef(_) | Stmt::FunctionDef(_) | Stmt::Try(_) => {}
Stmt::If(ast::StmtIf {
body,
elif_else_clauses,
@ -981,7 +974,7 @@ pub fn in_nested_block<'a>(mut parents: impl Iterator<Item = &'a Stmt>) -> bool
parents.any(|parent| {
matches!(
parent,
Stmt::Try(_) | Stmt::TryStar(_) | Stmt::If(_) | Stmt::With(_) | Stmt::Match(_)
Stmt::Try(_) | Stmt::If(_) | Stmt::With(_) | Stmt::Match(_)
)
})
}

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

@ -43,7 +43,6 @@ pub enum AnyNode {
StmtMatch(ast::StmtMatch),
StmtRaise(ast::StmtRaise),
StmtTry(ast::StmtTry),
StmtTryStar(ast::StmtTryStar),
StmtAssert(ast::StmtAssert),
StmtImport(ast::StmtImport),
StmtImportFrom(ast::StmtImportFrom),
@ -126,7 +125,6 @@ impl AnyNode {
AnyNode::StmtMatch(node) => Some(Stmt::Match(node)),
AnyNode::StmtRaise(node) => Some(Stmt::Raise(node)),
AnyNode::StmtTry(node) => Some(Stmt::Try(node)),
AnyNode::StmtTryStar(node) => Some(Stmt::TryStar(node)),
AnyNode::StmtAssert(node) => Some(Stmt::Assert(node)),
AnyNode::StmtImport(node) => Some(Stmt::Import(node)),
AnyNode::StmtImportFrom(node) => Some(Stmt::ImportFrom(node)),
@ -243,7 +241,6 @@ impl AnyNode {
| AnyNode::StmtMatch(_)
| AnyNode::StmtRaise(_)
| AnyNode::StmtTry(_)
| AnyNode::StmtTryStar(_)
| AnyNode::StmtAssert(_)
| AnyNode::StmtImport(_)
| AnyNode::StmtImportFrom(_)
@ -301,7 +298,6 @@ impl AnyNode {
| AnyNode::StmtMatch(_)
| AnyNode::StmtRaise(_)
| AnyNode::StmtTry(_)
| AnyNode::StmtTryStar(_)
| AnyNode::StmtAssert(_)
| AnyNode::StmtImport(_)
| AnyNode::StmtImportFrom(_)
@ -395,7 +391,6 @@ impl AnyNode {
| AnyNode::StmtMatch(_)
| AnyNode::StmtRaise(_)
| AnyNode::StmtTry(_)
| AnyNode::StmtTryStar(_)
| AnyNode::StmtAssert(_)
| AnyNode::StmtImport(_)
| AnyNode::StmtImportFrom(_)
@ -474,7 +469,6 @@ impl AnyNode {
| AnyNode::StmtMatch(_)
| AnyNode::StmtRaise(_)
| AnyNode::StmtTry(_)
| AnyNode::StmtTryStar(_)
| AnyNode::StmtAssert(_)
| AnyNode::StmtImport(_)
| AnyNode::StmtImportFrom(_)
@ -578,7 +572,6 @@ impl AnyNode {
Self::StmtMatch(node) => AnyNodeRef::StmtMatch(node),
Self::StmtRaise(node) => AnyNodeRef::StmtRaise(node),
Self::StmtTry(node) => AnyNodeRef::StmtTry(node),
Self::StmtTryStar(node) => AnyNodeRef::StmtTryStar(node),
Self::StmtAssert(node) => AnyNodeRef::StmtAssert(node),
Self::StmtImport(node) => AnyNodeRef::StmtImport(node),
Self::StmtImportFrom(node) => AnyNodeRef::StmtImportFrom(node),
@ -1445,54 +1438,7 @@ impl AstNode for ast::StmtTry {
handlers,
orelse,
finalbody,
range: _,
} = self;
visitor.visit_body(body);
for except_handler in handlers {
visitor.visit_except_handler(except_handler);
}
visitor.visit_body(orelse);
visitor.visit_body(finalbody);
}
}
impl AstNode for ast::StmtTryStar {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::StmtTryStar(node) = kind {
Some(node)
} else {
None
}
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::StmtTryStar(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)
}
fn visit_preorder<'a, V>(&'a self, visitor: &mut V)
where
V: PreorderVisitor<'a> + ?Sized,
{
let ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
is_star: _,
range: _,
} = self;
@ -4056,7 +4002,6 @@ impl From<Stmt> for AnyNode {
Stmt::Match(node) => AnyNode::StmtMatch(node),
Stmt::Raise(node) => AnyNode::StmtRaise(node),
Stmt::Try(node) => AnyNode::StmtTry(node),
Stmt::TryStar(node) => AnyNode::StmtTryStar(node),
Stmt::Assert(node) => AnyNode::StmtAssert(node),
Stmt::Import(node) => AnyNode::StmtImport(node),
Stmt::ImportFrom(node) => AnyNode::StmtImportFrom(node),
@ -4246,12 +4191,6 @@ impl From<ast::StmtTry> for AnyNode {
}
}
impl From<ast::StmtTryStar> for AnyNode {
fn from(node: ast::StmtTryStar) -> Self {
AnyNode::StmtTryStar(node)
}
}
impl From<ast::StmtAssert> for AnyNode {
fn from(node: ast::StmtAssert) -> Self {
AnyNode::StmtAssert(node)
@ -4627,7 +4566,6 @@ impl Ranged for AnyNode {
AnyNode::StmtMatch(node) => node.range(),
AnyNode::StmtRaise(node) => node.range(),
AnyNode::StmtTry(node) => node.range(),
AnyNode::StmtTryStar(node) => node.range(),
AnyNode::StmtAssert(node) => node.range(),
AnyNode::StmtImport(node) => node.range(),
AnyNode::StmtImportFrom(node) => node.range(),
@ -4713,7 +4651,6 @@ pub enum AnyNodeRef<'a> {
StmtMatch(&'a ast::StmtMatch),
StmtRaise(&'a ast::StmtRaise),
StmtTry(&'a ast::StmtTry),
StmtTryStar(&'a ast::StmtTryStar),
StmtAssert(&'a ast::StmtAssert),
StmtImport(&'a ast::StmtImport),
StmtImportFrom(&'a ast::StmtImportFrom),
@ -4798,7 +4735,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::StmtMatch(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtRaise(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtTry(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtTryStar(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtAssert(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtImport(node) => NonNull::from(*node).cast(),
AnyNodeRef::StmtImportFrom(node) => NonNull::from(*node).cast(),
@ -4889,7 +4825,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::StmtMatch(_) => NodeKind::StmtMatch,
AnyNodeRef::StmtRaise(_) => NodeKind::StmtRaise,
AnyNodeRef::StmtTry(_) => NodeKind::StmtTry,
AnyNodeRef::StmtTryStar(_) => NodeKind::StmtTryStar,
AnyNodeRef::StmtAssert(_) => NodeKind::StmtAssert,
AnyNodeRef::StmtImport(_) => NodeKind::StmtImport,
AnyNodeRef::StmtImportFrom(_) => NodeKind::StmtImportFrom,
@ -4972,7 +4907,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
| AnyNodeRef::StmtTryStar(_)
| AnyNodeRef::StmtAssert(_)
| AnyNodeRef::StmtImport(_)
| AnyNodeRef::StmtImportFrom(_)
@ -5089,7 +5023,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
| AnyNodeRef::StmtTryStar(_)
| AnyNodeRef::StmtAssert(_)
| AnyNodeRef::StmtImport(_)
| AnyNodeRef::StmtImportFrom(_)
@ -5146,7 +5079,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
| AnyNodeRef::StmtTryStar(_)
| AnyNodeRef::StmtAssert(_)
| AnyNodeRef::StmtImport(_)
| AnyNodeRef::StmtImportFrom(_)
@ -5240,7 +5172,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
| AnyNodeRef::StmtTryStar(_)
| AnyNodeRef::StmtAssert(_)
| AnyNodeRef::StmtImport(_)
| AnyNodeRef::StmtImportFrom(_)
@ -5319,7 +5250,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtMatch(_)
| AnyNodeRef::StmtRaise(_)
| AnyNodeRef::StmtTry(_)
| AnyNodeRef::StmtTryStar(_)
| AnyNodeRef::StmtAssert(_)
| AnyNodeRef::StmtImport(_)
| AnyNodeRef::StmtImportFrom(_)
@ -5395,7 +5325,6 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::StmtFunctionDef(_)
| AnyNodeRef::StmtClassDef(_)
| AnyNodeRef::StmtTry(_)
| AnyNodeRef::StmtTryStar(_)
| AnyNodeRef::ExceptHandlerExceptHandler(_)
| AnyNodeRef::ElifElseClause(_)
)
@ -5433,7 +5362,6 @@ impl AnyNodeRef<'_> {
AnyNodeRef::StmtMatch(node) => node.visit_preorder(visitor),
AnyNodeRef::StmtRaise(node) => node.visit_preorder(visitor),
AnyNodeRef::StmtTry(node) => node.visit_preorder(visitor),
AnyNodeRef::StmtTryStar(node) => node.visit_preorder(visitor),
AnyNodeRef::StmtAssert(node) => node.visit_preorder(visitor),
AnyNodeRef::StmtImport(node) => node.visit_preorder(visitor),
AnyNodeRef::StmtImportFrom(node) => node.visit_preorder(visitor),
@ -5608,12 +5536,6 @@ impl<'a> From<&'a ast::StmtTry> for AnyNodeRef<'a> {
}
}
impl<'a> From<&'a ast::StmtTryStar> for AnyNodeRef<'a> {
fn from(node: &'a ast::StmtTryStar) -> Self {
AnyNodeRef::StmtTryStar(node)
}
}
impl<'a> From<&'a ast::StmtAssert> for AnyNodeRef<'a> {
fn from(node: &'a ast::StmtAssert) -> Self {
AnyNodeRef::StmtAssert(node)
@ -5943,7 +5865,6 @@ impl<'a> From<&'a Stmt> for AnyNodeRef<'a> {
Stmt::Match(node) => AnyNodeRef::StmtMatch(node),
Stmt::Raise(node) => AnyNodeRef::StmtRaise(node),
Stmt::Try(node) => AnyNodeRef::StmtTry(node),
Stmt::TryStar(node) => AnyNodeRef::StmtTryStar(node),
Stmt::Assert(node) => AnyNodeRef::StmtAssert(node),
Stmt::Import(node) => AnyNodeRef::StmtImport(node),
Stmt::ImportFrom(node) => AnyNodeRef::StmtImportFrom(node),
@ -6103,7 +6024,6 @@ impl Ranged for AnyNodeRef<'_> {
AnyNodeRef::StmtMatch(node) => node.range(),
AnyNodeRef::StmtRaise(node) => node.range(),
AnyNodeRef::StmtTry(node) => node.range(),
AnyNodeRef::StmtTryStar(node) => node.range(),
AnyNodeRef::StmtAssert(node) => node.range(),
AnyNodeRef::StmtImport(node) => node.range(),
AnyNodeRef::StmtImportFrom(node) => node.range(),
@ -6191,7 +6111,6 @@ pub enum NodeKind {
StmtMatch,
StmtRaise,
StmtTry,
StmtTryStar,
StmtAssert,
StmtImport,
StmtImportFrom,

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

@ -73,8 +73,6 @@ pub enum Stmt {
Raise(StmtRaise),
#[is(name = "try_stmt")]
Try(StmtTry),
#[is(name = "try_star_stmt")]
TryStar(StmtTryStar),
#[is(name = "assert_stmt")]
Assert(StmtAssert),
#[is(name = "import_stmt")]
@ -362,7 +360,8 @@ impl From<StmtRaise> for Stmt {
}
}
/// See also [Try](https://docs.python.org/3/library/ast.html#ast.Try)
/// See also [Try](https://docs.python.org/3/library/ast.html#ast.Try) and
/// [TryStar](https://docs.python.org/3/library/ast.html#ast.TryStar)
#[derive(Clone, Debug, PartialEq)]
pub struct StmtTry {
pub range: TextRange,
@ -370,6 +369,7 @@ pub struct StmtTry {
pub handlers: Vec<ExceptHandler>,
pub orelse: Vec<Stmt>,
pub finalbody: Vec<Stmt>,
pub is_star: bool,
}
impl From<StmtTry> for Stmt {
@ -378,22 +378,6 @@ impl From<StmtTry> for Stmt {
}
}
/// See also [TryStar](https://docs.python.org/3/library/ast.html#ast.TryStar)
#[derive(Clone, Debug, PartialEq)]
pub struct StmtTryStar {
pub range: TextRange,
pub body: Vec<Stmt>,
pub handlers: Vec<ExceptHandler>,
pub orelse: Vec<Stmt>,
pub finalbody: Vec<Stmt>,
}
impl From<StmtTryStar> for Stmt {
fn from(payload: StmtTryStar) -> Self {
Stmt::TryStar(payload)
}
}
/// See also [Assert](https://docs.python.org/3/library/ast.html#ast.Assert)
#[derive(Clone, Debug, PartialEq)]
pub struct StmtAssert {
@ -2666,11 +2650,6 @@ impl Ranged for crate::nodes::StmtTry {
self.range
}
}
impl Ranged for crate::nodes::StmtTryStar {
fn range(&self) -> TextRange {
self.range
}
}
impl Ranged for crate::nodes::StmtAssert {
fn range(&self) -> TextRange {
self.range
@ -2739,7 +2718,6 @@ impl Ranged for crate::Stmt {
Self::Match(node) => node.range(),
Self::Raise(node) => node.range(),
Self::Try(node) => node.range(),
Self::TryStar(node) => node.range(),
Self::Assert(node) => node.range(),
Self::Import(node) => node.range(),
Self::ImportFrom(node) => node.range(),
@ -3086,7 +3064,7 @@ mod size_assertions {
assert_eq_size!(Stmt, [u8; 144]);
assert_eq_size!(StmtFunctionDef, [u8; 144]);
assert_eq_size!(StmtClassDef, [u8; 104]);
assert_eq_size!(StmtTry, [u8; 104]);
assert_eq_size!(StmtTry, [u8; 112]);
assert_eq_size!(Expr, [u8; 80]);
assert_eq_size!(Constant, [u8; 40]);
assert_eq_size!(Pattern, [u8; 96]);

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

@ -66,21 +66,7 @@ pub fn walk_stmt<'a, V: StatementVisitor<'a> + ?Sized>(visitor: &mut V, stmt: &'
handlers,
orelse,
finalbody,
range: _,
}) => {
visitor.visit_body(body);
for except_handler in handlers {
visitor.visit_except_handler(except_handler);
}
visitor.visit_body(orelse);
visitor.visit_body(finalbody);
}
Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
..
}) => {
visitor.visit_body(body);
for except_handler in handlers {

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

@ -64,27 +64,6 @@ pub fn suite<'a>(stmt: &'a Stmt, parent: &'a Stmt) -> Option<&'a Suite> {
.find(|body| body.contains(stmt))
}
}
Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
..
}) => {
if body.contains(stmt) {
Some(body)
} else if orelse.contains(stmt) {
Some(orelse)
} else if finalbody.contains(stmt) {
Some(finalbody)
} else {
handlers
.iter()
.filter_map(ExceptHandler::as_except_handler)
.map(|handler| &handler.body)
.find(|body| body.contains(stmt))
}
}
_ => None,
}
}

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

@ -266,20 +266,7 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
handlers,
orelse,
finalbody,
range: _,
}) => {
visitor.visit_body(body);
for except_handler in handlers {
visitor.visit_except_handler(except_handler);
}
visitor.visit_body(orelse);
visitor.visit_body(finalbody);
}
Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
is_star: _,
range: _,
}) => {
visitor.visit_body(body);

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

@ -192,7 +192,6 @@ where
Stmt::Match(stmt) => stmt.visit_preorder(visitor),
Stmt::Raise(stmt) => stmt.visit_preorder(visitor),
Stmt::Try(stmt) => stmt.visit_preorder(visitor),
Stmt::TryStar(stmt) => stmt.visit_preorder(visitor),
Stmt::Assert(stmt) => stmt.visit_preorder(visitor),
Stmt::Import(stmt) => stmt.visit_preorder(visitor),
Stmt::ImportFrom(stmt) => stmt.visit_preorder(visitor),