From 96d310fbab0112f8ab899f6d665f79a5aecdafd5 Mon Sep 17 00:00:00 2001 From: Charlie Marsh Date: Mon, 14 Aug 2023 13:39:44 -0400 Subject: [PATCH] Remove `Stmt::TryStar` (#6566) ## 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` --- crates/ruff/src/autofix/edits.rs | 9 +- .../src/checkers/ast/analyze/statement.rs | 9 +- crates/ruff/src/checkers/ast/mod.rs | 9 +- .../rules/jump_statement_in_finally.rs | 1 - .../src/rules/flake8_return/rules/function.rs | 2 +- crates/ruff/src/rules/isort/block.rs | 9 +- .../mccabe/rules/function_is_too_complex.rs | 9 +- .../rules/pylint/rules/continue_in_finally.rs | 3 +- .../rules/pylint/rules/too_many_branches.rs | 9 +- .../rules/pylint/rules/too_many_statements.rs | 9 +- .../pylint/rules/useless_else_on_loop.rs | 7 - .../ruff/src/rules/ruff/rules/unreachable.rs | 11 +- .../tryceratops/rules/raise_within_try.rs | 2 +- .../rules/tryceratops/rules/verbose_raise.rs | 3 - crates/ruff_python_ast/src/comparable.rs | 24 +--- crates/ruff_python_ast/src/helpers.rs | 13 +- crates/ruff_python_ast/src/node.rs | 83 +----------- crates/ruff_python_ast/src/nodes.rs | 30 +---- .../ruff_python_ast/src/statement_visitor.rs | 16 +-- crates/ruff_python_ast/src/traversal.rs | 21 --- crates/ruff_python_ast/src/visitor.rs | 15 +-- .../ruff_python_ast/src/visitor/preorder.rs | 1 - crates/ruff_python_codegen/src/generator.rs | 34 +---- .../src/comments/placement.rs | 19 --- crates/ruff_python_formatter/src/generated.rs | 36 ----- .../src/statement/mod.rs | 2 - .../src/statement/stmt_try.rs | 126 ++++-------------- .../src/statement/stmt_try_star.rs | 19 --- crates/ruff_python_parser/src/python.lalrpop | 7 +- crates/ruff_python_parser/src/python.rs | 9 +- ...uff_python_parser__parser__tests__try.snap | 1 + ...ython_parser__parser__tests__try_star.snap | 5 +- .../src/analyze/branch_detection.rs | 6 - 33 files changed, 70 insertions(+), 489 deletions(-) delete mode 100644 crates/ruff_python_formatter/src/statement/stmt_try_star.rs diff --git a/crates/ruff/src/autofix/edits.rs b/crates/ruff/src/autofix/edits.rs index 6bdc112ffb..1ab80106af 100644 --- a/crates/ruff/src/autofix/edits.rs +++ b/crates/ruff/src/autofix/edits.rs @@ -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) diff --git a/crates/ruff/src/checkers/ast/analyze/statement.rs b/crates/ruff/src/checkers/ast/analyze/statement.rs index 880bec99dc..c7f2d0223d 100644 --- a/crates/ruff/src/checkers/ast/analyze/statement.rs +++ b/crates/ruff/src/checkers/ast/analyze/statement.rs @@ -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); diff --git a/crates/ruff/src/checkers/ast/mod.rs b/crates/ruff/src/checkers/ast/mod.rs index 4eb0589eb2..fce7af9fbe 100644 --- a/crates/ruff/src/checkers/ast/mod.rs +++ b/crates/ruff/src/checkers/ast/mod.rs @@ -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) { diff --git a/crates/ruff/src/rules/flake8_bugbear/rules/jump_statement_in_finally.rs b/crates/ruff/src/rules/flake8_bugbear/rules/jump_statement_in_finally.rs index 2d796f4706..5c5ca90cb7 100644 --- a/crates/ruff/src/rules/flake8_bugbear/rules/jump_statement_in_finally.rs +++ b/crates/ruff/src/rules/flake8_bugbear/rules/jump_statement_in_finally.rs @@ -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); } diff --git a/crates/ruff/src/rules/flake8_return/rules/function.rs b/crates/ruff/src/rules/flake8_return/rules/function.rs index 90dfb25173..cb470bde87 100644 --- a/crates/ruff/src/rules/flake8_return/rules/function.rs +++ b/crates/ruff/src/rules/flake8_return/rules/function.rs @@ -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(), diff --git a/crates/ruff/src/rules/isort/block.rs b/crates/ruff/src/rules/isort/block.rs index 3832444b4c..cc32b50a50 100644 --- a/crates/ruff/src/rules/isort/block.rs +++ b/crates/ruff/src/rules/isort/block.rs @@ -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); diff --git a/crates/ruff/src/rules/mccabe/rules/function_is_too_complex.rs b/crates/ruff/src/rules/mccabe/rules/function_is_too_complex.rs index 60938d334c..c56ae7e2ed 100644 --- a/crates/ruff/src/rules/mccabe/rules/function_is_too_complex.rs +++ b/crates/ruff/src/rules/mccabe/rules/function_is_too_complex.rs @@ -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() { diff --git a/crates/ruff/src/rules/pylint/rules/continue_in_finally.rs b/crates/ruff/src/rules/pylint/rules/continue_in_finally.rs index 8624f65304..78e4ae85aa 100644 --- a/crates/ruff/src/rules/pylint/rules/continue_in_finally.rs +++ b/crates/ruff/src/rules/pylint/rules/continue_in_finally.rs @@ -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); } diff --git a/crates/ruff/src/rules/pylint/rules/too_many_branches.rs b/crates/ruff/src/rules/pylint/rules/too_many_branches.rs index 1c5615eea9..7c083b10f7 100644 --- a/crates/ruff/src/rules/pylint/rules/too_many_branches.rs +++ b/crates/ruff/src/rules/pylint/rules/too_many_branches.rs @@ -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() { diff --git a/crates/ruff/src/rules/pylint/rules/too_many_statements.rs b/crates/ruff/src/rules/pylint/rules/too_many_statements.rs index a026c6f12b..406f5959fc 100644 --- a/crates/ruff/src/rules/pylint/rules/too_many_statements.rs +++ b/crates/ruff/src/rules/pylint/rules/too_many_statements.rs @@ -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); diff --git a/crates/ruff/src/rules/pylint/rules/useless_else_on_loop.rs b/crates/ruff/src/rules/pylint/rules/useless_else_on_loop.rs index bf290b59c5..ff354860c5 100644 --- a/crates/ruff/src/rules/pylint/rules/useless_else_on_loop.rs +++ b/crates/ruff/src/rules/pylint/rules/useless_else_on_loop.rs @@ -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) diff --git a/crates/ruff/src/rules/ruff/rules/unreachable.rs b/crates/ruff/src/rules/ruff/rules/unreachable.rs index 7549d91053..180bd84e6c 100644 --- a/crates/ruff/src/rules/ruff/rules/unreachable.rs +++ b/crates/ruff/src/rules/ruff/rules/unreachable.rs @@ -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, diff --git a/crates/ruff/src/rules/tryceratops/rules/raise_within_try.rs b/crates/ruff/src/rules/tryceratops/rules/raise_within_try.rs index bdaf9f6e38..7748651468 100644 --- a/crates/ruff/src/rules/tryceratops/rules/raise_within_try.rs +++ b/crates/ruff/src/rules/tryceratops/rules/raise_within_try.rs @@ -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), } } diff --git a/crates/ruff/src/rules/tryceratops/rules/verbose_raise.rs b/crates/ruff/src/rules/tryceratops/rules/verbose_raise.rs index 9c881e1cb3..70ff1e3c21 100644 --- a/crates/ruff/src/rules/tryceratops/rules/verbose_raise.rs +++ b/crates/ruff/src/rules/tryceratops/rules/verbose_raise.rs @@ -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); diff --git a/crates/ruff_python_ast/src/comparable.rs b/crates/ruff_python_ast/src/comparable.rs index f8dbdf2732..a28e6d2190 100644 --- a/crates/ruff_python_ast/src/comparable.rs +++ b/crates/ruff_python_ast/src/comparable.rs @@ -1133,14 +1133,7 @@ pub struct StmtTry<'a> { handlers: Vec>, orelse: Vec>, finalbody: Vec>, -} - -#[derive(Debug, PartialEq, Eq, Hash)] -pub struct StmtTryStar<'a> { - body: Vec>, - handlers: Vec>, - orelse: Vec>, - finalbody: Vec>, + 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, diff --git a/crates/ruff_python_ast/src/helpers.rs b/crates/ruff_python_ast/src/helpers.rs index 2f43d3da1c..ad97566880 100644 --- a/crates/ruff_python_ast/src/helpers.rs +++ b/crates/ruff_python_ast/src/helpers.rs @@ -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) -> bool parents.any(|parent| { matches!( parent, - Stmt::Try(_) | Stmt::TryStar(_) | Stmt::If(_) | Stmt::With(_) | Stmt::Match(_) + Stmt::Try(_) | Stmt::If(_) | Stmt::With(_) | Stmt::Match(_) ) }) } diff --git a/crates/ruff_python_ast/src/node.rs b/crates/ruff_python_ast/src/node.rs index d24d431833..c6a7e7d675 100644 --- a/crates/ruff_python_ast/src/node.rs +++ b/crates/ruff_python_ast/src/node.rs @@ -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 - 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 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 for AnyNode { } } -impl From for AnyNode { - fn from(node: ast::StmtTryStar) -> Self { - AnyNode::StmtTryStar(node) - } -} - impl From 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, diff --git a/crates/ruff_python_ast/src/nodes.rs b/crates/ruff_python_ast/src/nodes.rs index 331968c47e..af9d150f54 100644 --- a/crates/ruff_python_ast/src/nodes.rs +++ b/crates/ruff_python_ast/src/nodes.rs @@ -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 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, pub orelse: Vec, pub finalbody: Vec, + pub is_star: bool, } impl From for Stmt { @@ -378,22 +378,6 @@ impl From 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, - pub handlers: Vec, - pub orelse: Vec, - pub finalbody: Vec, -} - -impl From 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]); diff --git a/crates/ruff_python_ast/src/statement_visitor.rs b/crates/ruff_python_ast/src/statement_visitor.rs index 57f458d8fb..7ab3ebe06c 100644 --- a/crates/ruff_python_ast/src/statement_visitor.rs +++ b/crates/ruff_python_ast/src/statement_visitor.rs @@ -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 { diff --git a/crates/ruff_python_ast/src/traversal.rs b/crates/ruff_python_ast/src/traversal.rs index 6a732aa890..d89e29484b 100644 --- a/crates/ruff_python_ast/src/traversal.rs +++ b/crates/ruff_python_ast/src/traversal.rs @@ -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, } } diff --git a/crates/ruff_python_ast/src/visitor.rs b/crates/ruff_python_ast/src/visitor.rs index d9c9eff67c..db9b856eb6 100644 --- a/crates/ruff_python_ast/src/visitor.rs +++ b/crates/ruff_python_ast/src/visitor.rs @@ -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); diff --git a/crates/ruff_python_ast/src/visitor/preorder.rs b/crates/ruff_python_ast/src/visitor/preorder.rs index 229f111a57..59e8100590 100644 --- a/crates/ruff_python_ast/src/visitor/preorder.rs +++ b/crates/ruff_python_ast/src/visitor/preorder.rs @@ -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), diff --git a/crates/ruff_python_codegen/src/generator.rs b/crates/ruff_python_codegen/src/generator.rs index 9af88721bd..d20d8afa4c 100644 --- a/crates/ruff_python_codegen/src/generator.rs +++ b/crates/ruff_python_codegen/src/generator.rs @@ -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); }); } diff --git a/crates/ruff_python_formatter/src/comments/placement.rs b/crates/ruff_python_formatter/src/comments/placement.rs index 685aa2d3b8..1ad9ffd046 100644 --- a/crates/ruff_python_formatter/src/comments/placement.rs +++ b/crates/ruff_python_formatter/src/comments/placement.rs @@ -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 { 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()) diff --git a/crates/ruff_python_formatter/src/generated.rs b/crates/ruff_python_formatter/src/generated.rs index 13617df622..5541df5c4b 100644 --- a/crates/ruff_python_formatter/src/generated.rs +++ b/crates/ruff_python_formatter/src/generated.rs @@ -582,42 +582,6 @@ impl<'ast> IntoFormat> for ast::StmtTry { } } -impl FormatRule> - for crate::statement::stmt_try_star::FormatStmtTryStar -{ - #[inline] - fn fmt(&self, node: &ast::StmtTryStar, f: &mut PyFormatter) -> FormatResult<()> { - FormatNodeRule::::fmt(self, node, f) - } -} -impl<'ast> AsFormat> 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> 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> for crate::statement::stmt_assert::FormatStmtAssert { diff --git a/crates/ruff_python_formatter/src/statement/mod.rs b/crates/ruff_python_formatter/src/statement/mod.rs index aeaf272ab7..cf39929eb9 100644 --- a/crates/ruff_python_formatter/src/statement/mod.rs +++ b/crates/ruff_python_formatter/src/statement/mod.rs @@ -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> 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), diff --git a/crates/ruff_python_formatter/src/statement/stmt_try.rs b/crates/ruff_python_formatter/src/statement/stmt_try.rs index 7db4372469..f869fdf3bf 100644 --- a/crates/ruff_python_formatter/src/statement/stmt_try.rs +++ b/crates/ruff_python_formatter/src/statement/stmt_try.rs @@ -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> for FormatExceptH impl FormatRule> 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> for ExceptHandler { FormatRefWithRule::new(self, FormatExceptHandler::default()) } } -impl Format> for AnyStatementTry<'_> { - fn fmt(&self, f: &mut PyFormatter) -> FormatResult<()> { + +impl FormatNodeRule 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> 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> for AnyStatementTry<'_> { write!(f, [comments::dangling_comments(dangling_comments)]) } -} - -impl FormatNodeRule 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 diff --git a/crates/ruff_python_formatter/src/statement/stmt_try_star.rs b/crates/ruff_python_formatter/src/statement/stmt_try_star.rs deleted file mode 100644 index 3c20fc42ee..0000000000 --- a/crates/ruff_python_formatter/src/statement/stmt_try_star.rs +++ /dev/null @@ -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 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(()) - } -} diff --git a/crates/ruff_python_parser/src/python.lalrpop b/crates/ruff_python_parser/src/python.lalrpop index 15ab75db65..54b6832ba2 100644 --- a/crates/ruff_python_parser/src/python.lalrpop +++ b/crates/ruff_python_parser/src/python.lalrpop @@ -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() }, ) diff --git a/crates/ruff_python_parser/src/python.rs b/crates/ruff_python_parser/src/python.rs index 209f8c89a1..b45d27805c 100644 --- a/crates/ruff_python_parser/src/python.rs +++ b/crates/ruff_python_parser/src/python.rs @@ -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() }, ) diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try.snap index 78942ef266..e3fd432492 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try.snap @@ -243,6 +243,7 @@ expression: parse_ast ], orelse: [], finalbody: [], + is_star: false, }, ), ] diff --git a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try_star.snap b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try_star.snap index 1f8294f3b2..7940ea7359 100644 --- a/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try_star.snap +++ b/crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__try_star.snap @@ -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, }, ), ] diff --git a/crates/ruff_python_semantic/src/analyze/branch_detection.rs b/crates/ruff_python_semantic/src/analyze/branch_detection.rs index 97c6b2b9f9..e7bbf1b428 100644 --- a/crates/ruff_python_semantic/src/analyze/branch_detection.rs +++ b/crates/ruff_python_semantic/src/analyze/branch_detection.rs @@ -59,12 +59,6 @@ fn alternatives(stmt: &Stmt) -> Vec> { handlers, orelse, .. - }) - | Stmt::TryStar(ast::StmtTryStar { - body, - handlers, - orelse, - .. }) => vec![body.iter().chain(orelse.iter()).collect()] .into_iter() .chain(handlers.iter().map(|handler| {