language-servers/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-08-03 02:13:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

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

9
crates/ruff/src/autofix/edits.rs
View file

@ -209,14 +209,7 @@ fn is_lone_child(child: &Stmt, parent: &Stmt) -> bool {
handlers,
orelse,
finalbody,
range: _,
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
..
}) => {
if is_only(body, child)
|| is_only(orelse, child)

9
crates/ruff/src/checkers/ast/analyze/statement.rs
View file

@ -1225,14 +1225,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
handlers,
orelse,
finalbody,
range: _,
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
..
}) => {
if checker.enabled(Rule::JumpStatementInFinally) {
flake8_bugbear::rules::jump_statement_in_finally(checker, finalbody);

9
crates/ruff/src/checkers/ast/mod.rs
View file

@ -599,14 +599,7 @@ where
handlers,
orelse,
finalbody,
range: _,
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
..
}) => {
let mut handled_exceptions = Exceptions::empty();
for type_ in extract_handled_exceptions(handlers) {

1
crates/ruff/src/rules/flake8_bugbear/rules/jump_statement_in_finally.rs
View file

@ -74,7 +74,6 @@ fn walk_stmt(checker: &mut Checker, body: &[Stmt], f: fn(&Stmt) -> bool) {
}
Stmt::If(ast::StmtIf { body, .. })
| Stmt::Try(ast::StmtTry { body, .. })
| Stmt::TryStar(ast::StmtTryStar { body, .. })
| Stmt::With(ast::StmtWith { body, .. }) => {
walk_stmt(checker, body, f);
}

2
crates/ruff/src/rules/flake8_return/rules/function.rs
View file

@ -457,7 +457,7 @@ fn implicit_return(checker: &mut Checker, stmt: &Stmt) {
implicit_return(checker, last_stmt);
}
}
Stmt::Return(_) | Stmt::Raise(_) | Stmt::Try(_) | Stmt::TryStar(_) => {}
Stmt::Return(_) | Stmt::Raise(_) | Stmt::Try(_) => {}
Stmt::Expr(ast::StmtExpr { value, .. })
if matches!(
value.as_ref(),

9
crates/ruff/src/rules/isort/block.rs
View file

@ -254,14 +254,7 @@ where
handlers,
orelse,
finalbody,
range: _,
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
..
}) => {
for except_handler in handlers {
self.visit_except_handler(except_handler);

9
crates/ruff/src/rules/mccabe/rules/function_is_too_complex.rs
View file

@ -106,14 +106,7 @@ fn get_complexity_number(stmts: &[Stmt]) -> usize {
handlers,
orelse,
finalbody,
range: _,
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
..
}) => {
complexity += get_complexity_number(body);
if !orelse.is_empty() {

3
crates/ruff/src/rules/pylint/rules/continue_in_finally.rs
View file

@ -64,8 +64,7 @@ fn traverse_body(checker: &mut Checker, body: &[Stmt]) {
traverse_body(checker, &clause.body);
}
}
Stmt::Try(ast::StmtTry { body, orelse, .. })
| Stmt::TryStar(ast::StmtTryStar { body, orelse, .. }) => {
Stmt::Try(ast::StmtTry { body, orelse, .. }) => {
traverse_body(checker, body);
traverse_body(checker, orelse);
}

9
crates/ruff/src/rules/pylint/rules/too_many_branches.rs
View file

@ -121,14 +121,7 @@ fn num_branches(stmts: &[Stmt]) -> usize {
handlers,
orelse,
finalbody,
range: _,
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
..
}) => {
1 + num_branches(body)
+ (if orelse.is_empty() {

9
crates/ruff/src/rules/pylint/rules/too_many_statements.rs
View file

@ -98,14 +98,7 @@ fn num_statements(stmts: &[Stmt]) -> usize {
handlers,
orelse,
finalbody,
range: _,
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
..
}) => {
count += 1;
count += num_statements(body);

7
crates/ruff/src/rules/pylint/rules/useless_else_on_loop.rs
View file

@ -73,13 +73,6 @@ fn loop_exits_early(body: &[Stmt]) -> bool {
orelse,
finalbody,
..
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
..
}) => {
loop_exits_early(body)
|| loop_exits_early(orelse)

11
crates/ruff/src/rules/ruff/rules/unreachable.rs
View file

@ -3,7 +3,7 @@ use std::{fmt, iter, usize};
use log::error;
use ruff_python_ast::{
Expr, Identifier, MatchCase, Pattern, PatternMatchAs, Ranged, Stmt, StmtFor, StmtMatch,
StmtReturn, StmtTry, StmtTryStar, StmtWhile, StmtWith,
StmtReturn, StmtTry, StmtWhile, StmtWith,
};
use ruff_text_size::{TextRange, TextSize};
@ -541,13 +541,6 @@ impl<'stmt> BasicBlocksBuilder<'stmt> {
orelse,
finalbody,
..
})
| Stmt::TryStar(StmtTryStar {
body,
handlers,
orelse,
finalbody,
..
}) => {
// TODO: handle `try` statements. The `try` control flow is very
// complex, what blocks are and aren't taken and from which
@ -900,7 +893,6 @@ fn needs_next_block(stmts: &[Stmt]) -> bool {
| Stmt::With(_)
| Stmt::Match(_)
| Stmt::Try(_)
| Stmt::TryStar(_)
| Stmt::Assert(_) => true,
Stmt::TypeAlias(_) => todo!(),
Stmt::IpyEscapeCommand(_) => todo!(),
@ -931,7 +923,6 @@ fn is_control_flow_stmt(stmt: &Stmt) -> bool {
| Stmt::Match(_)
| Stmt::Raise(_)
| Stmt::Try(_)
| Stmt::TryStar(_)
| Stmt::Assert(_)
| Stmt::Break(_)
| Stmt::Continue(_) => true,

2
crates/ruff/src/rules/tryceratops/rules/raise_within_try.rs
View file

@ -70,7 +70,7 @@ where
fn visit_stmt(&mut self, stmt: &'b Stmt) {
match stmt {
Stmt::Raise(_) => self.raises.push(stmt),
Stmt::Try(_) | Stmt::TryStar(_) => (),
Stmt::Try(_) => (),
_ => walk_stmt(self, stmt),
}
}

3
crates/ruff/src/rules/tryceratops/rules/verbose_raise.rs
View file

@ -61,9 +61,6 @@ where
}
Stmt::Try(ast::StmtTry {
body, finalbody, ..
})
| Stmt::TryStar(ast::StmtTryStar {
body, finalbody, ..
}) => {
for stmt in body.iter().chain(finalbody.iter()) {
walk_stmt(self, stmt);

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

34
crates/ruff_python_codegen/src/generator.rs
View file

@ -513,6 +513,7 @@ impl<'a> Generator<'a> {
handlers,
orelse,
finalbody,
is_star,
range: _,
}) => {
statement!({
@ -522,38 +523,7 @@ impl<'a> Generator<'a> {
for handler in handlers {
statement!({
self.unparse_except_handler(handler, false);
});
}
if !orelse.is_empty() {
statement!({
self.p("else:");
});
self.body(orelse);
}
if !finalbody.is_empty() {
statement!({
self.p("finally:");
});
self.body(finalbody);
}
}
Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
range: _,
}) => {
statement!({
self.p("try:");
});
self.body(body);
for handler in handlers {
statement!({
self.unparse_except_handler(handler, true);
self.unparse_except_handler(handler, *is_star);
});
}

19
crates/ruff_python_formatter/src/comments/placement.rs
View file

@ -196,12 +196,6 @@ fn is_first_statement_in_body(statement: AnyNodeRef, has_body: AnyNodeRef) -> bo
orelse,
finalbody,
..
})
| AnyNodeRef::StmtTryStar(ast::StmtTryStar {
body,
orelse,
finalbody,
..
}) => {
are_same_optional(statement, body.first())
|| are_same_optional(statement, orelse.first())
@ -1418,13 +1412,6 @@ fn last_child_in_body(node: AnyNodeRef) -> Option<AnyNodeRef> {
orelse,
finalbody,
..
})
| AnyNodeRef::StmtTryStar(ast::StmtTryStar {
body,
handlers,
orelse,
finalbody,
..
}) => {
if finalbody.is_empty() {
if orelse.is_empty() {
@ -1461,12 +1448,6 @@ fn is_first_statement_in_alternate_body(statement: AnyNodeRef, has_body: AnyNode
orelse,
finalbody,
..
})
| AnyNodeRef::StmtTryStar(ast::StmtTryStar {
handlers,
orelse,
finalbody,
..
}) => {
are_same_optional(statement, handlers.first())
|| are_same_optional(statement, orelse.first())

36
crates/ruff_python_formatter/src/generated.rs
View file

@ -582,42 +582,6 @@ impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::StmtTry {
}
}
impl FormatRule<ast::StmtTryStar, PyFormatContext<'_>>
for crate::statement::stmt_try_star::FormatStmtTryStar
{
#[inline]
fn fmt(&self, node: &ast::StmtTryStar, f: &mut PyFormatter) -> FormatResult<()> {
FormatNodeRule::<ast::StmtTryStar>::fmt(self, node, f)
}
}
impl<'ast> AsFormat<PyFormatContext<'ast>> for ast::StmtTryStar {
type Format<'a> = FormatRefWithRule<
'a,
ast::StmtTryStar,
crate::statement::stmt_try_star::FormatStmtTryStar,
PyFormatContext<'ast>,
>;
fn format(&self) -> Self::Format<'_> {
FormatRefWithRule::new(
self,
crate::statement::stmt_try_star::FormatStmtTryStar::default(),
)
}
}
impl<'ast> IntoFormat<PyFormatContext<'ast>> for ast::StmtTryStar {
type Format = FormatOwnedWithRule<
ast::StmtTryStar,
crate::statement::stmt_try_star::FormatStmtTryStar,
PyFormatContext<'ast>,
>;
fn into_format(self) -> Self::Format {
FormatOwnedWithRule::new(
self,
crate::statement::stmt_try_star::FormatStmtTryStar::default(),
)
}
}
impl FormatRule<ast::StmtAssert, PyFormatContext<'_>>
for crate::statement::stmt_assert::FormatStmtAssert
{

2
crates/ruff_python_formatter/src/statement/mod.rs
View file

@ -24,7 +24,6 @@ pub(crate) mod stmt_pass;
pub(crate) mod stmt_raise;
pub(crate) mod stmt_return;
pub(crate) mod stmt_try;
pub(crate) mod stmt_try_star;
pub(crate) mod stmt_type_alias;
pub(crate) mod stmt_while;
pub(crate) mod stmt_with;
@ -50,7 +49,6 @@ impl FormatRule<Stmt, PyFormatContext<'_>> for FormatStmt {
Stmt::Match(x) => x.format().fmt(f),
Stmt::Raise(x) => x.format().fmt(f),
Stmt::Try(x) => x.format().fmt(f),
Stmt::TryStar(x) => x.format().fmt(f),
Stmt::Assert(x) => x.format().fmt(f),
Stmt::Import(x) => x.format().fmt(f),
Stmt::ImportFrom(x) => x.format().fmt(f),

126
crates/ruff_python_formatter/src/statement/stmt_try.rs
View file

@ -1,86 +1,13 @@
use crate::comments;
use crate::comments::SourceComment;
use crate::comments::{leading_alternate_branch_comments, trailing_comments};
use crate::other::except_handler_except_handler::ExceptHandlerKind;
use crate::prelude::*;
use crate::statement::FormatRefWithRule;
use crate::statement::Stmt;
use crate::{FormatNodeRule, PyFormatter};
use ruff_formatter::FormatRuleWithOptions;
use ruff_formatter::{write, Buffer, FormatResult};
use ruff_python_ast::node::AnyNodeRef;
use ruff_python_ast::{ExceptHandler, Ranged, StmtTry, StmtTryStar, Suite};
use ruff_text_size::TextRange;
use ruff_python_ast::{ExceptHandler, Ranged, StmtTry, Suite};
pub(super) enum AnyStatementTry<'a> {
Try(&'a StmtTry),
TryStar(&'a StmtTryStar),
}
impl<'a> AnyStatementTry<'a> {
const fn except_handler_kind(&self) -> ExceptHandlerKind {
match self {
AnyStatementTry::Try(_) => ExceptHandlerKind::Regular,
AnyStatementTry::TryStar(_) => ExceptHandlerKind::Starred,
}
}
fn body(&self) -> &Suite {
match self {
AnyStatementTry::Try(try_) => &try_.body,
AnyStatementTry::TryStar(try_) => &try_.body,
}
}
fn handlers(&self) -> &[ExceptHandler] {
match self {
AnyStatementTry::Try(try_) => try_.handlers.as_slice(),
AnyStatementTry::TryStar(try_) => try_.handlers.as_slice(),
}
}
fn orelse(&self) -> &Suite {
match self {
AnyStatementTry::Try(try_) => &try_.orelse,
AnyStatementTry::TryStar(try_) => &try_.orelse,
}
}
fn finalbody(&self) -> &Suite {
match self {
AnyStatementTry::Try(try_) => &try_.finalbody,
AnyStatementTry::TryStar(try_) => &try_.finalbody,
}
}
}
impl Ranged for AnyStatementTry<'_> {
fn range(&self) -> TextRange {
match self {
AnyStatementTry::Try(with) => with.range(),
AnyStatementTry::TryStar(with) => with.range(),
}
}
}
impl<'a> From<&'a StmtTry> for AnyStatementTry<'a> {
fn from(value: &'a StmtTry) -> Self {
AnyStatementTry::Try(value)
}
}
impl<'a> From<&'a StmtTryStar> for AnyStatementTry<'a> {
fn from(value: &'a StmtTryStar) -> Self {
AnyStatementTry::TryStar(value)
}
}
impl<'a> From<&AnyStatementTry<'a>> for AnyNodeRef<'a> {
fn from(value: &AnyStatementTry<'a>) -> Self {
match value {
AnyStatementTry::Try(with) => AnyNodeRef::StmtTry(with),
AnyStatementTry::TryStar(with) => AnyNodeRef::StmtTryStar(with),
}
}
}
use crate::comments;
use crate::comments::{leading_alternate_branch_comments, trailing_comments, SourceComment};
use crate::other::except_handler_except_handler::ExceptHandlerKind;
use crate::prelude::*;
use crate::statement::{FormatRefWithRule, Stmt};
use crate::{FormatNodeRule, PyFormatter};
#[derive(Default)]
pub struct FormatStmtTry;
@ -102,9 +29,10 @@ impl FormatRuleWithOptions<ExceptHandler, PyFormatContext<'_>> for FormatExceptH
impl FormatRule<ExceptHandler, PyFormatContext<'_>> for FormatExceptHandler {
fn fmt(&self, item: &ExceptHandler, f: &mut PyFormatter) -> FormatResult<()> {
match item {
ExceptHandler::ExceptHandler(x) => {
x.format().with_options(self.except_handler_kind).fmt(f)
}
ExceptHandler::ExceptHandler(except_handler) => except_handler
.format()
.with_options(self.except_handler_kind)
.fmt(f),
}
}
}
@ -121,14 +49,20 @@ impl<'ast> AsFormat<PyFormatContext<'ast>> for ExceptHandler {
FormatRefWithRule::new(self, FormatExceptHandler::default())
}
}
impl Format<PyFormatContext<'_>> for AnyStatementTry<'_> {
fn fmt(&self, f: &mut PyFormatter) -> FormatResult<()> {
impl FormatNodeRule<StmtTry> for FormatStmtTry {
fn fmt_fields(&self, item: &StmtTry, f: &mut PyFormatter) -> FormatResult<()> {
let StmtTry {
body,
handlers,
orelse,
finalbody,
is_star,
range: _,
} = item;
let comments_info = f.context().comments().clone();
let mut dangling_comments = comments_info.dangling_comments(self);
let body = self.body();
let handlers = self.handlers();
let orelse = self.orelse();
let finalbody = self.finalbody();
let mut dangling_comments = comments_info.dangling_comments(item);
(_, dangling_comments) = format_case("try", body, None, dangling_comments, f)?;
let mut previous_node = body.last();
@ -139,7 +73,11 @@ impl Format<PyFormatContext<'_>> for AnyStatementTry<'_> {
f,
[
leading_alternate_branch_comments(handler_comments, previous_node),
&handler.format().with_options(self.except_handler_kind()),
&handler.format().with_options(if *is_star {
ExceptHandlerKind::Starred
} else {
ExceptHandlerKind::Regular
}),
]
)?;
previous_node = match handler {
@ -154,12 +92,6 @@ impl Format<PyFormatContext<'_>> for AnyStatementTry<'_> {
write!(f, [comments::dangling_comments(dangling_comments)])
}
}
impl FormatNodeRule<StmtTry> for FormatStmtTry {
fn fmt_fields(&self, item: &StmtTry, f: &mut PyFormatter) -> FormatResult<()> {
AnyStatementTry::from(item).fmt(f)
}
fn fmt_dangling_comments(&self, _node: &StmtTry, _f: &mut PyFormatter) -> FormatResult<()> {
// dangling comments are formatted as part of AnyStatementTry::fmt

19
crates/ruff_python_formatter/src/statement/stmt_try_star.rs
View file

@ -1,19 +0,0 @@
use crate::statement::stmt_try::AnyStatementTry;
use crate::{FormatNodeRule, PyFormatter};
use ruff_formatter::Format;
use ruff_formatter::FormatResult;
use ruff_python_ast::StmtTryStar;
#[derive(Default)]
pub struct FormatStmtTryStar;
impl FormatNodeRule<StmtTryStar> for FormatStmtTryStar {
fn fmt_fields(&self, item: &StmtTryStar, f: &mut PyFormatter) -> FormatResult<()> {
AnyStatementTry::from(item).fmt(f)
}
fn fmt_dangling_comments(&self, _node: &StmtTryStar, _f: &mut PyFormatter) -> FormatResult<()> {
// dangling comments are formatted as part of AnyStatementTry::fmt
Ok(())
}
}

7
crates/ruff_python_parser/src/python.lalrpop
View file

@ -952,6 +952,7 @@ TryStatement: ast::Stmt = {
handlers,
orelse,
finalbody,
is_star: false,
range: (location..end_location).into()
},
)
@ -965,12 +966,13 @@ TryStatement: ast::Stmt = {
.map(Ranged::end)
.or_else(|| handlers.last().map(Ranged::end))
.unwrap();
ast::Stmt::TryStar(
ast::StmtTryStar {
ast::Stmt::Try(
ast::StmtTry {
body,
handlers,
orelse,
finalbody,
is_star: true,
range: (location..end_location).into()
},
)
@ -985,6 +987,7 @@ TryStatement: ast::Stmt = {
handlers,
orelse,
finalbody,
is_star: false,
range: (location..end_location).into()
},
)

9
crates/ruff_python_parser/src/python.rs
View file

@ -1,5 +1,5 @@
// auto-generated: "lalrpop 0.20.0"
// sha3: eea7f30d1f9d5648f73bb9aeb9c0d61be448c1d648b743eb3155da459e4e6038
// sha3: d7e633596695f78340d0d083cd0561185ac7f8efadb0297003c81a41031f6e24
use num_bigint::BigInt;
use ruff_text_size::TextSize;
use ruff_python_ast::{self as ast, Ranged, IpyEscapeKind};
@ -35125,6 +35125,7 @@ fn __action150<
handlers,
orelse,
finalbody,
is_star: false,
range: (location..end_location).into()
},
)
@ -35155,12 +35156,13 @@ fn __action151<
.map(Ranged::end)
.or_else(|| handlers.last().map(Ranged::end))
.unwrap();
ast::Stmt::TryStar(
ast::StmtTryStar {
ast::Stmt::Try(
ast::StmtTry {
body,
handlers,
orelse,
finalbody,
is_star: true,
range: (location..end_location).into()
},
)
@ -35189,6 +35191,7 @@ fn __action152<
handlers,
orelse,
finalbody,
is_star: false,
range: (location..end_location).into()
},
)

1
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try.snap
View file

@ -243,6 +243,7 @@ expression: parse_ast
],
orelse: [],
finalbody: [],
is_star: false,
},
),
]

5
crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try_star.snap
View file

@ -3,8 +3,8 @@ source: crates/ruff_python_parser/src/parser.rs
expression: parse_ast
---
[
TryStar(
StmtTryStar {
Try(
StmtTry {
range: 0..260,
body: [
Raise(
@ -436,6 +436,7 @@ expression: parse_ast
],
orelse: [],
finalbody: [],
is_star: true,
},
),
]

6
crates/ruff_python_semantic/src/analyze/branch_detection.rs
View file

@ -59,12 +59,6 @@ fn alternatives(stmt: &Stmt) -> Vec<Vec<&Stmt>> {
handlers,
orelse,
..
})
| Stmt::TryStar(ast::StmtTryStar {
body,
handlers,
orelse,
..
}) => vec![body.iter().chain(orelse.iter()).collect()]
.into_iter()
.chain(handlers.iter().map(|handler| {