Add parenthesized flag to ExprTuple and ExprGenerator (#9614)

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -134,6 +134,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             elts,
             ctx,
             range: _,
+            parenthesized: _,
         })
         | Expr::List(ast::ExprList {
             elts,
@@ -1451,6 +1452,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 generators,
                 elt: _,
                 range: _,
+                parenthesized: _,
             },
         ) => {
             if checker.enabled(Rule::UnnecessaryListIndexLookup) {

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -1007,6 +1007,7 @@ where
                 elt,
                 generators,
                 range: _,
+                parenthesized: _,
             }) => {
                 self.visit_generators(generators);
                 self.visit_expr(elt);
@@ -1327,6 +1328,7 @@ where
                                 elts,
                                 ctx,
                                 range: _,
+                                parenthesized: _,
                             }) = slice.as_ref()
                             {
                                 let mut iter = elts.iter();

crates/ruff_linter/src/rules/flake8_bugbear/rules/duplicate_exceptions.rs

@@ -109,6 +109,7 @@ fn type_pattern(elts: Vec<&Expr>) -> Expr {
         elts: elts.into_iter().cloned().collect(),
         ctx: ExprContext::Load,
         range: TextRange::default(),
+        parenthesized: true,
     }
     .into()
 }

crates/ruff_linter/src/rules/flake8_pie/rules/multiple_starts_ends_with.rs

@@ -173,6 +173,7 @@ pub(crate) fn multiple_starts_ends_with(checker: &mut Checker, expr: &Expr) {
                     .collect(),
                 ctx: ExprContext::Load,
                 range: TextRange::default(),
+                parenthesized: true,
             });
             let node1 = Expr::Name(ast::ExprName {
                 id: arg_name.into(),

crates/ruff_linter/src/rules/flake8_pyi/rules/unnecessary_literal_union.rs

@@ -72,6 +72,7 @@ pub(crate) fn unnecessary_literal_union<'a>(checker: &mut Checker, expr: &'a Exp
                     elts,
                     range: _,
                     ctx: _,
+                    parenthesized: _,
                 }) = slice.as_ref()
                 {
                     for expr in elts {
@@ -123,6 +124,7 @@ pub(crate) fn unnecessary_literal_union<'a>(checker: &mut Checker, expr: &'a Exp
                 elts: literal_exprs.into_iter().cloned().collect(),
                 range: TextRange::default(),
                 ctx: ExprContext::Load,
+                parenthesized: true,
             })),
             range: TextRange::default(),
             ctx: ExprContext::Load,
@@ -148,6 +150,7 @@ pub(crate) fn unnecessary_literal_union<'a>(checker: &mut Checker, expr: &'a Exp
                             elts,
                             range: TextRange::default(),
                             ctx: ExprContext::Load,
+                            parenthesized: true,
                         })),
                         range: TextRange::default(),
                         ctx: ExprContext::Load,

crates/ruff_linter/src/rules/flake8_pyi/rules/unnecessary_type_union.rs

@@ -130,6 +130,7 @@ pub(crate) fn unnecessary_type_union<'a>(checker: &mut Checker, union: &'a Expr)
                                 .collect(),
                             ctx: ExprContext::Load,
                             range: TextRange::default(),
+                            parenthesized: true,
                         })),
                         ctx: ExprContext::Load,
                         range: TextRange::default(),
@@ -151,6 +152,7 @@ pub(crate) fn unnecessary_type_union<'a>(checker: &mut Checker, union: &'a Expr)
                             elts: exprs.into_iter().cloned().collect(),
                             ctx: ExprContext::Load,
                             range: TextRange::default(),
+                            parenthesized: true,
                         })),
                         ctx: ExprContext::Load,
                         range: TextRange::default(),

crates/ruff_linter/src/rules/flake8_pytest_style/rules/parametrize.rs

@@ -337,6 +337,7 @@ fn check_names(checker: &mut Checker, decorator: &Decorator, expr: &Expr) {
                                 .collect(),
                             ctx: ExprContext::Load,
                             range: TextRange::default(),
+                            parenthesized: true,
                         });
                         diagnostic.set_fix(Fix::unsafe_edit(Edit::range_replacement(
                             format!("({})", checker.generator().expr(&node)),
@@ -444,6 +445,7 @@ fn check_names(checker: &mut Checker, decorator: &Decorator, expr: &Expr) {
                             elts: elts.clone(),
                             ctx: ExprContext::Load,
                             range: TextRange::default(),
+                            parenthesized: true,
                         });
                         diagnostic.set_fix(Fix::unsafe_edit(Edit::range_replacement(
                             format!("({})", checker.generator().expr(&node)),

crates/ruff_linter/src/rules/flake8_simplify/rules/ast_bool_op.rs

@@ -428,6 +428,7 @@ pub(crate) fn duplicate_isinstance_call(checker: &mut Checker, expr: &Expr) {
                         .collect(),
                     ctx: ExprContext::Load,
                     range: TextRange::default(),
+                    parenthesized: true,
                 };
                 let node1 = ast::ExprName {
                     id: "isinstance".into(),
@@ -543,6 +544,7 @@ pub(crate) fn compare_with_tuple(checker: &mut Checker, expr: &Expr) {
             elts: comparators.into_iter().map(Clone::clone).collect(),
             ctx: ExprContext::Load,
             range: TextRange::default(),
+            parenthesized: true,
         };
         let node1 = ast::ExprName {
             id: id.into(),
@@ -718,7 +720,7 @@ fn get_short_circuit_edit(
         generator.expr(expr)
     };
     Edit::range_replacement(
-        if matches!(expr, Expr::Tuple(ast::ExprTuple { elts, ctx: _, range: _}) if !elts.is_empty())
+        if matches!(expr, Expr::Tuple(ast::ExprTuple { elts, ctx: _, range: _, parenthesized: _}) if !elts.is_empty())
         {
             format!("({content})")
         } else {

crates/ruff_linter/src/rules/flake8_simplify/rules/reimplemented_builtin.rs

@@ -382,6 +382,7 @@ fn return_stmt(id: &str, test: &Expr, target: &Expr, iter: &Expr, generator: Gen
             range: TextRange::default(),
         }],
         range: TextRange::default(),
+        parenthesized: false,
     };
     let node1 = ast::ExprName {
         id: id.into(),

crates/ruff_linter/src/rules/pylint/rules/redefined_loop_name.rs

@@ -305,6 +305,7 @@ fn assignment_targets_from_expr<'a>(
             ctx: ExprContext::Store,
             elts,
             range: _,
+            parenthesized: _,
         }) => Box::new(
             elts.iter()
                 .flat_map(|elt| assignment_targets_from_expr(elt, dummy_variable_rgx)),

crates/ruff_linter/src/rules/pylint/rules/repeated_equality_comparison.rs

@@ -145,6 +145,7 @@ pub(crate) fn repeated_equality_comparison(checker: &mut Checker, bool_op: &ast:
                         elts: comparators.iter().copied().cloned().collect(),
                         range: TextRange::default(),
                         ctx: ExprContext::Load,
+                        parenthesized: true,
                     })]),
                     range: bool_op.range(),
                 })),

crates/ruff_linter/src/rules/pyupgrade/rules/os_error_alias.rs

@@ -127,6 +127,7 @@ fn tuple_diagnostic(checker: &mut Checker, tuple: &ast::ExprTuple, aliases: &[&E
                 elts: remaining,
                 ctx: ExprContext::Load,
                 range: TextRange::default(),
+                parenthesized: true,
             };
             format!("({})", checker.generator().expr(&node.into()))
         };

crates/ruff_linter/src/rules/pyupgrade/rules/timeout_error_alias.rs

@@ -141,6 +141,7 @@ fn tuple_diagnostic(checker: &mut Checker, tuple: &ast::ExprTuple, aliases: &[&E
                 elts: remaining,
                 ctx: ExprContext::Load,
                 range: TextRange::default(),
+                parenthesized: true,
             };
             format!("({})", checker.generator().expr(&node.into()))
         };

crates/ruff_linter/src/rules/pyupgrade/rules/use_pep695_type_alias.rs

@@ -127,6 +127,7 @@ pub(crate) fn non_pep695_type_alias(checker: &mut Checker, stmt: &StmtAnnAssign)
                                     range: TextRange::default(),
                                     elts: constraints.into_iter().cloned().collect(),
                                     ctx: ast::ExprContext::Load,
+                                    parenthesized: true,
                                 })))
                             }
                             None => None,

crates/ruff_linter/src/rules/refurb/rules/repeated_append.rs

@@ -347,6 +347,7 @@ fn make_suggestion(group: &AppendGroup, generator: Generator) -> String {
         elts,
         ctx: ast::ExprContext::Load,
         range: TextRange::default(),
+        parenthesized: true,
     };
     // Make `var.extend`.
     // NOTE: receiver is the same for all appends and that's why we can take the first.

crates/ruff_linter/src/rules/ruff/rules/collection_literal_concatenation.rs

@@ -162,6 +162,7 @@ fn concatenate_expressions(expr: &Expr) -> Option<(Expr, Type)> {
             elts: new_elts,
             ctx: ExprContext::Load,
             range: TextRange::default(),
+            parenthesized: true,
         }
         .into(),
     };

crates/ruff_linter/src/rules/ruff/rules/never_union.rs

@@ -116,6 +116,7 @@ pub(crate) fn never_union(checker: &mut Checker, expr: &Expr) {
                 elts,
                 ctx: _,
                 range: _,
+                parenthesized: _,
             }) = slice.as_ref()
             else {
                 return;
@@ -157,6 +158,7 @@ pub(crate) fn never_union(checker: &mut Checker, expr: &Expr) {
                                         elts: rest,
                                         ctx: ast::ExprContext::Load,
                                         range: TextRange::default(),
+                                        parenthesized: true,
                                     })),
                                     ctx: ast::ExprContext::Load,
                                     range: TextRange::default(),

crates/ruff_linter/src/rules/ruff/rules/sequence_sorting.rs

@@ -134,23 +134,23 @@ impl InferredMemberType {
 /// single-line tuple literals *can* be unparenthesized.
 /// We keep the original AST node around for the
 /// Tuple variant so that this can be queried later.
-#[derive(Debug)]
+#[derive(Copy, Clone, Debug)]
-pub(super) enum SequenceKind<'a> {
+pub(super) enum SequenceKind {
     List,
     Set,
-    Tuple(&'a ast::ExprTuple),
+    Tuple { parenthesized: bool },
 }
 
-impl SequenceKind<'_> {
+impl SequenceKind {
     // N.B. We only need the source code for the Tuple variant here,
     // but if you already have a `Locator` instance handy,
     // getting the source code is very cheap.
-    fn surrounding_brackets(&self, source: &str) -> (&'static str, &'static str) {
+    fn surrounding_brackets(self) -> (&'static str, &'static str) {
         match self {
             Self::List => ("[", "]"),
             Self::Set => ("{", "}"),
-            Self::Tuple(ast_node) => {
+            Self::Tuple { parenthesized } => {
-                if ast_node.is_parenthesized(source) {
+                if parenthesized {
                     ("(", ")")
                 } else {
                     ("", "")
@@ -159,19 +159,19 @@ impl SequenceKind<'_> {
         }
     }
 
-    const fn opening_token_for_multiline_definition(&self) -> TokenKind {
+    const fn opening_token_for_multiline_definition(self) -> TokenKind {
         match self {
             Self::List => TokenKind::Lsqb,
             Self::Set => TokenKind::Lbrace,
-            Self::Tuple(_) => TokenKind::Lpar,
+            Self::Tuple { .. } => TokenKind::Lpar,
         }
     }
 
-    const fn closing_token_for_multiline_definition(&self) -> TokenKind {
+    const fn closing_token_for_multiline_definition(self) -> TokenKind {
         match self {
             Self::List => TokenKind::Rsqb,
             Self::Set => TokenKind::Rbrace,
-            Self::Tuple(_) => TokenKind::Rpar,
+            Self::Tuple { .. } => TokenKind::Rpar,
         }
     }
 }
@@ -217,7 +217,7 @@ impl<'a> SequenceElements<'a> {
 /// that can be inserted into the
 /// source code as a `range_replacement` autofix.
 pub(super) fn sort_single_line_elements_sequence(
-    kind: &SequenceKind,
+    kind: SequenceKind,
     elts: &[ast::Expr],
     elements: &[&str],
     locator: &Locator,
@@ -225,7 +225,7 @@ pub(super) fn sort_single_line_elements_sequence(
 ) -> String {
     let element_pairs = SequenceElements::new(elements, elts);
     let last_item_index = element_pairs.last_item_index();
-    let (opening_paren, closing_paren) = kind.surrounding_brackets(locator.contents());
+    let (opening_paren, closing_paren) = kind.surrounding_brackets();
     let mut result = String::from(opening_paren);
     // We grab the original source-code ranges using `locator.slice()`
     // rather than using the expression generator, as this approach allows
@@ -334,7 +334,7 @@ impl MultilineStringSequenceValue {
     /// Return `None` if the analysis fails for whatever reason.
     pub(super) fn from_source_range(
         range: TextRange,
-        kind: &SequenceKind,
+        kind: SequenceKind,
         locator: &Locator,
     ) -> Option<MultilineStringSequenceValue> {
         // Parse the multiline string sequence using the raw tokens.
@@ -486,7 +486,7 @@ impl Ranged for MultilineStringSequenceValue {
 /// in the original source code.
 fn collect_string_sequence_lines(
     range: TextRange,
-    kind: &SequenceKind,
+    kind: SequenceKind,
     locator: &Locator,
 ) -> Option<(Vec<StringSequenceLine>, bool)> {
     // These first two variables are used for keeping track of state

crates/ruff_linter/src/rules/ruff/rules/sort_dunder_all.rs

@@ -152,9 +152,13 @@ fn sort_dunder_all(checker: &mut Checker, target: &ast::Expr, node: &ast::Expr)
 
     let (elts, range, kind) = match node {
         ast::Expr::List(ast::ExprList { elts, range, .. }) => (elts, *range, SequenceKind::List),
-        ast::Expr::Tuple(tuple_node @ ast::ExprTuple { elts, range, .. }) => {
+        ast::Expr::Tuple(tuple_node @ ast::ExprTuple { elts, range, .. }) => (
-            (elts, *range, SequenceKind::Tuple(tuple_node))
+            elts,
-        }
+            *range,
+            SequenceKind::Tuple {
+                parenthesized: tuple_node.parenthesized,
+            },
+        ),
         _ => return,
     };
 
@@ -166,7 +170,7 @@ fn sort_dunder_all(checker: &mut Checker, target: &ast::Expr, node: &ast::Expr)
     let mut diagnostic = Diagnostic::new(UnsortedDunderAll, range);
 
     if let SortClassification::UnsortedAndMaybeFixable { items } = elts_analysis {
-        if let Some(fix) = create_fix(range, elts, &items, &kind, checker) {
+        if let Some(fix) = create_fix(range, elts, &items, kind, checker) {
             diagnostic.set_fix(fix);
         }
     }
@@ -187,7 +191,7 @@ fn create_fix(
     range: TextRange,
     elts: &[ast::Expr],
     string_items: &[&str],
-    kind: &SequenceKind,
+    kind: SequenceKind,
     checker: &Checker,
 ) -> Option<Fix> {
     let locator = checker.locator();

crates/ruff_linter/src/rules/ruff/rules/sort_dunder_slots.rs

@@ -157,7 +157,9 @@ impl<'a> StringLiteralDisplay<'a> {
                 }
             }
             ast::Expr::Tuple(tuple_node @ ast::ExprTuple { elts, range, .. }) => {
-                let display_kind = DisplayKind::Sequence(SequenceKind::Tuple(tuple_node));
+                let display_kind = DisplayKind::Sequence(SequenceKind::Tuple {
+                    parenthesized: tuple_node.parenthesized,
+                });
                 Self {
                     elts: Cow::Borrowed(elts),
                     range: *range,
@@ -211,7 +213,7 @@ impl<'a> StringLiteralDisplay<'a> {
             (DisplayKind::Sequence(sequence_kind), true) => {
                 let analyzed_sequence = MultilineStringSequenceValue::from_source_range(
                     self.range(),
-                    sequence_kind,
+                    *sequence_kind,
                     locator,
                 )?;
                 assert_eq!(analyzed_sequence.len(), self.elts.len());
@@ -220,7 +222,7 @@ impl<'a> StringLiteralDisplay<'a> {
             // Sorting multiline dicts is unsupported
             (DisplayKind::Dict { .. }, true) => return None,
             (DisplayKind::Sequence(sequence_kind), false) => sort_single_line_elements_sequence(
-                sequence_kind,
+                *sequence_kind,
                 &self.elts,
                 items,
                 locator,
@@ -242,7 +244,7 @@ impl<'a> StringLiteralDisplay<'a> {
 /// Python provides for builtin containers.
 #[derive(Debug)]
 enum DisplayKind<'a> {
-    Sequence(SequenceKind<'a>),
+    Sequence(SequenceKind),
     Dict { values: &'a [ast::Expr] },
 }
 

crates/ruff_python_ast/src/comparable.rs

@@ -977,6 +977,7 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
                 elt,
                 generators,
                 range: _,
+                parenthesized: _,
             }) => Self::GeneratorExp(ExprGeneratorExp {
                 elt: elt.into(),
                 generators: generators.iter().map(Into::into).collect(),
@@ -1072,6 +1073,7 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
                 elts,
                 ctx: _,
                 range: _,
+                parenthesized: _,
             }) => Self::Tuple(ExprTuple {
                 elts: elts.iter().map(Into::into).collect(),
             }),

crates/ruff_python_ast/src/helpers.rs

@@ -183,6 +183,7 @@ pub fn any_over_expr(expr: &Expr, func: &dyn Fn(&Expr) -> bool) -> bool {
             elt,
             generators,
             range: _,
+            parenthesized: _,
         }) => {
             any_over_expr(elt, func)
                 || generators.iter().any(|generator| {
@@ -1423,6 +1424,7 @@ pub fn pep_604_union(elts: &[Expr]) -> Expr {
             elts: vec![],
             ctx: ExprContext::Load,
             range: TextRange::default(),
+            parenthesized: true,
         }),
         [Expr::Tuple(ast::ExprTuple { elts, .. })] => pep_604_union(elts),
         [elt] => elt.clone(),
@@ -1457,6 +1459,7 @@ pub fn typing_union(elts: &[Expr], binding: String) -> Expr {
                 elts: vec![],
                 ctx: ExprContext::Load,
                 range: TextRange::default(),
+                parenthesized: true,
             }),
             [Expr::Tuple(ast::ExprTuple { elts, .. })] => typing_union(elts, binding),
             [elt] => elt.clone(),

crates/ruff_python_ast/src/node.rs

@@ -2430,6 +2430,7 @@ impl AstNode for ast::ExprGeneratorExp {
             elt,
             generators,
             range: _,
+            parenthesized: _,
         } = self;
         visitor.visit_expr(elt);
         for comprehension in generators {
@@ -3256,6 +3257,7 @@ impl AstNode for ast::ExprTuple {
             elts,
             ctx: _,
             range: _,
+            parenthesized: _,
         } = self;
 
         for expr in elts {

crates/ruff_python_ast/src/nodes.rs

@@ -8,7 +8,6 @@ use std::slice::{Iter, IterMut};
 
 use itertools::Itertools;
 
-use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
 use crate::{int, LiteralExpressionRef};
@@ -842,6 +841,7 @@ pub struct ExprGeneratorExp {
     pub range: TextRange,
     pub elt: Box<Expr>,
     pub generators: Vec<Comprehension>,
+    pub parenthesized: bool,
 }
 
 impl From<ExprGeneratorExp> for Expr {
@@ -1796,6 +1796,9 @@ pub struct ExprTuple {
     pub range: TextRange,
     pub elts: Vec<Expr>,
     pub ctx: ExprContext,
+
+    /// Whether the tuple is parenthesized in the source code.
+    pub parenthesized: bool,
 }
 
 impl From<ExprTuple> for Expr {
@@ -1804,37 +1807,6 @@ impl From<ExprTuple> for Expr {
     }
 }
 
-impl ExprTuple {
-    /// Return `true` if a tuple is parenthesized in the source code.
-    pub fn is_parenthesized(&self, source: &str) -> bool {
-        let Some(elt) = self.elts.first() else {
-            return true;
-        };
-
-        // Count the number of open parentheses between the start of the tuple and the first element.
-        let open_parentheses_count =
-            SimpleTokenizer::new(source, TextRange::new(self.start(), elt.start()))
-                .skip_trivia()
-                .filter(|token| token.kind() == SimpleTokenKind::LParen)
-                .count();
-        if open_parentheses_count == 0 {
-            return false;
-        }
-
-        // Count the number of parentheses between the end of the first element and its trailing comma.
-        let close_parentheses_count =
-            SimpleTokenizer::new(source, TextRange::new(elt.end(), self.end()))
-                .skip_trivia()
-                .take_while(|token| token.kind() != SimpleTokenKind::Comma)
-                .filter(|token| token.kind() == SimpleTokenKind::RParen)
-                .count();
-
-        // If the number of open parentheses is greater than the number of close parentheses, the tuple
-        // is parenthesized.
-        open_parentheses_count > close_parentheses_count
-    }
-}
-
 /// See also [Slice](https://docs.python.org/3/library/ast.html#ast.Slice)
 #[derive(Clone, Debug, PartialEq)]
 pub struct ExprSlice {
@@ -3911,7 +3883,7 @@ mod tests {
         assert_eq!(std::mem::size_of::<ExprDictComp>(), 48);
         assert_eq!(std::mem::size_of::<ExprEllipsisLiteral>(), 8);
         assert_eq!(std::mem::size_of::<ExprFString>(), 48);
-        assert_eq!(std::mem::size_of::<ExprGeneratorExp>(), 40);
+        assert_eq!(std::mem::size_of::<ExprGeneratorExp>(), 48);
         assert_eq!(std::mem::size_of::<ExprIfExp>(), 32);
         assert_eq!(std::mem::size_of::<ExprIpyEscapeCommand>(), 32);
         assert_eq!(std::mem::size_of::<ExprLambda>(), 24);

crates/ruff_python_ast/src/visitor.rs

@@ -441,6 +441,7 @@ pub fn walk_expr<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) {
             elt,
             generators,
             range: _,
+            parenthesized: _,
         }) => {
             for comprehension in generators {
                 visitor.visit_comprehension(comprehension);
@@ -539,6 +540,7 @@ pub fn walk_expr<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) {
             elts,
             ctx,
             range: _,
+            parenthesized: _,
         }) => {
             for expr in elts {
                 visitor.visit_expr(expr);

crates/ruff_python_ast/src/visitor/transformer.rs

@@ -428,6 +428,7 @@ pub fn walk_expr<V: Transformer + ?Sized>(visitor: &V, expr: &mut Expr) {
             elt,
             generators,
             range: _,
+            parenthesized: _,
         }) => {
             for comprehension in generators {
                 visitor.visit_comprehension(comprehension);
@@ -528,6 +529,7 @@ pub fn walk_expr<V: Transformer + ?Sized>(visitor: &V, expr: &mut Expr) {
             elts,
             ctx,
             range: _,
+            parenthesized: _,
         }) => {
             for expr in elts {
                 visitor.visit_expr(expr);

crates/ruff_python_codegen/src/generator.rs

@@ -970,6 +970,7 @@ impl<'a> Generator<'a> {
             Expr::GeneratorExp(ast::ExprGeneratorExp {
                 elt,
                 generators,
+                parenthesized: _,
                 range: _,
             }) => {
                 self.p("(");
@@ -1037,6 +1038,7 @@ impl<'a> Generator<'a> {
                         elt,
                         generators,
                         range: _,
+                        parenthesized: _,
                     })],
                     [],
                 ) = (arguments.args.as_ref(), arguments.keywords.as_ref())

crates/ruff_python_formatter/src/comments/placement.rs

@@ -12,7 +12,6 @@ use ruff_source_file::Locator;
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 
 use crate::comments::visitor::{CommentPlacement, DecoratedComment};
-use crate::expression::expr_generator_exp::is_generator_parenthesized;
 use crate::expression::expr_slice::{assign_comment_in_slice, ExprSliceCommentSection};
 use crate::other::parameters::{
     assign_argument_separator_comment_placement, find_parameter_separators,
@@ -315,12 +314,11 @@ fn handle_enclosed_comment<'a>(
         | AnyNodeRef::ExprSet(_)
         | AnyNodeRef::ExprListComp(_)
         | AnyNodeRef::ExprSetComp(_) => handle_bracketed_end_of_line_comment(comment, locator),
-        AnyNodeRef::ExprTuple(tuple) if tuple.is_parenthesized(locator.contents()) => {
+        AnyNodeRef::ExprTuple(ast::ExprTuple {
-            handle_bracketed_end_of_line_comment(comment, locator)
+            parenthesized: true,
-        }
+            ..
-        AnyNodeRef::ExprGeneratorExp(generator)
+        }) => handle_bracketed_end_of_line_comment(comment, locator),
-            if is_generator_parenthesized(generator, locator.contents()) =>
+        AnyNodeRef::ExprGeneratorExp(generator) if generator.parenthesized => {
-        {
             handle_bracketed_end_of_line_comment(comment, locator)
         }
         _ => CommentPlacement::Default(comment),

crates/ruff_python_formatter/src/expression/expr_generator_exp.rs

@@ -1,8 +1,6 @@
 use ruff_formatter::{format_args, write, FormatRuleWithOptions};
 use ruff_python_ast::AnyNodeRef;
 use ruff_python_ast::ExprGeneratorExp;
-use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
-use ruff_text_size::{Ranged, TextRange};
 
 use crate::comments::SourceComment;
 use crate::expression::parentheses::{parenthesized, NeedsParentheses, OptionalParentheses};
@@ -42,6 +40,7 @@ impl FormatNodeRule<ExprGeneratorExp> for FormatExprGeneratorExp {
             range: _,
             elt,
             generators,
+            parenthesized: is_parenthesized,
         } = item;
 
         let joined = format_with(|f| {
@@ -55,7 +54,7 @@ impl FormatNodeRule<ExprGeneratorExp> for FormatExprGeneratorExp {
 
         if self.parentheses == GeneratorExpParentheses::Preserve
             && dangling.is_empty()
-            && !is_generator_parenthesized(item, f.context().source())
+            && !is_parenthesized
         {
             write!(
                 f,
@@ -101,37 +100,3 @@ impl NeedsParentheses for ExprGeneratorExp {
         }
     }
 }
-
-/// Return `true` if a generator is parenthesized in the source code.
-pub(crate) fn is_generator_parenthesized(generator: &ExprGeneratorExp, source: &str) -> bool {
-    // Count the number of open parentheses between the start of the generator and the first element.
-    let open_parentheses_count = SimpleTokenizer::new(
-        source,
-        TextRange::new(generator.start(), generator.elt.start()),
-    )
-    .skip_trivia()
-    .filter(|token| token.kind() == SimpleTokenKind::LParen)
-    .count();
-    if open_parentheses_count == 0 {
-        return false;
-    }
-
-    // Count the number of parentheses between the end of the generator and its trailing comma.
-    let close_parentheses_count = SimpleTokenizer::new(
-        source,
-        TextRange::new(
-            generator.elt.end(),
-            generator
-                .generators
-                .first()
-                .map_or(generator.end(), Ranged::start),
-        ),
-    )
-    .skip_trivia()
-    .filter(|token| token.kind() == SimpleTokenKind::RParen)
-    .count();
-
-    // If the number of open parentheses is greater than the number of close parentheses, the
-    // generator is parenthesized.
-    open_parentheses_count > close_parentheses_count
-}

crates/ruff_python_formatter/src/expression/expr_tuple.rs

@@ -116,6 +116,7 @@ impl FormatNodeRule<ExprTuple> for FormatExprTuple {
             elts,
             ctx: _,
             range: _,
+            parenthesized: is_parenthesized,
         } = item;
 
         let comments = f.context().comments().clone();
@@ -136,7 +137,7 @@ impl FormatNodeRule<ExprTuple> for FormatExprTuple {
                 return empty_parenthesized("(", dangling, ")").fmt(f);
             }
             [single] => match self.parentheses {
-                TupleParentheses::Preserve if !item.is_parenthesized(f.context().source()) => {
+                TupleParentheses::Preserve if !is_parenthesized => {
                     write!(f, [single.format(), token(",")])
                 }
                 _ =>
@@ -152,7 +153,7 @@ impl FormatNodeRule<ExprTuple> for FormatExprTuple {
             //
             // Unlike other expression parentheses, tuple parentheses are part of the range of the
             // tuple itself.
-            _ if item.is_parenthesized(f.context().source())
+            _ if *is_parenthesized
                 && !(self.parentheses == TupleParentheses::NeverPreserve
                     && dangling.is_empty()) =>
             {

crates/ruff_python_formatter/src/expression/mod.rs

@@ -14,7 +14,6 @@ use ruff_text_size::Ranged;
 use crate::builders::parenthesize_if_expands;
 use crate::comments::{leading_comments, trailing_comments, LeadingDanglingTrailingComments};
 use crate::context::{NodeLevel, WithNodeLevel};
-use crate::expression::expr_generator_exp::is_generator_parenthesized;
 use crate::expression::parentheses::{
     is_expression_parenthesized, optional_parentheses, parenthesized, NeedsParentheses,
     OptionalParentheses, Parentheses, Parenthesize,
@@ -661,15 +660,16 @@ impl<'input> CanOmitOptionalParenthesesVisitor<'input> {
                 return;
             }
 
-            Expr::Tuple(tuple) if tuple.is_parenthesized(self.context.source()) => {
+            Expr::Tuple(ast::ExprTuple {
+                parenthesized: true,
+                ..
+            }) => {
                 self.any_parenthesized_expressions = true;
                 // The values are always parenthesized, don't visit.
                 return;
             }
 
-            Expr::GeneratorExp(generator)
+            Expr::GeneratorExp(generator) if generator.parenthesized => {
-                if is_generator_parenthesized(generator, self.context.source()) =>
-            {
                 self.any_parenthesized_expressions = true;
                 // The values are always parenthesized, don't visit.
                 return;
@@ -1035,11 +1035,7 @@ pub(crate) fn has_own_parentheses(
             Some(OwnParentheses::NonEmpty)
         }
 
-        Expr::GeneratorExp(generator)
+        Expr::GeneratorExp(generator) if generator.parenthesized => Some(OwnParentheses::NonEmpty),
-            if is_generator_parenthesized(generator, context.source()) =>
-        {
-            Some(OwnParentheses::NonEmpty)
-        }
 
         // These expressions must contain _some_ child or trivia token in order to be non-empty.
         Expr::List(ast::ExprList { elts, .. }) | Expr::Set(ast::ExprSet { elts, .. }) => {
@@ -1050,7 +1046,12 @@ pub(crate) fn has_own_parentheses(
             }
         }
 
-        Expr::Tuple(tuple) if tuple.is_parenthesized(context.source()) => {
+        Expr::Tuple(
+            tuple @ ast::ExprTuple {
+                parenthesized: true,
+                ..
+            },
+        ) => {
             if !tuple.elts.is_empty() || context.comments().has_dangling(AnyNodeRef::from(expr)) {
                 Some(OwnParentheses::NonEmpty)
             } else {

crates/ruff_python_parser/src/context.rs

@@ -3,10 +3,16 @@ use ruff_python_ast::{self as ast, Expr, ExprContext};
 pub(crate) fn set_context(expr: Expr, ctx: ExprContext) -> Expr {
     match expr {
         Expr::Name(ast::ExprName { id, range, .. }) => ast::ExprName { range, id, ctx }.into(),
-        Expr::Tuple(ast::ExprTuple { elts, range, .. }) => ast::ExprTuple {
+        Expr::Tuple(ast::ExprTuple {
+            elts,
+            range,
+            parenthesized: is_parenthesized,
+            ctx: _,
+        }) => ast::ExprTuple {
             elts: elts.into_iter().map(|elt| set_context(elt, ctx)).collect(),
             range,
             ctx,
+            parenthesized: is_parenthesized,
         }
         .into(),
 

crates/ruff_python_parser/src/parser.rs

@@ -1505,4 +1505,20 @@ u"foo" f"bar {baz} really" u"bar" "no"
         let parse_ast = parse_suite(r#"x = "\N{BACKSPACE}another cool trick""#).unwrap();
         insta::assert_debug_snapshot!(parse_ast);
     }
+
+    #[test]
+    fn test_tuple() {
+        let parse_ast = parse_suite(
+            r#"
+a,b
+(a,b)
+()
+(a,)
+((a,b))
+"#
+            .trim(),
+        )
+        .unwrap();
+        insta::assert_debug_snapshot!(parse_ast);
+    }
 }

crates/ruff_python_parser/src/python.lalrpop

@@ -483,7 +483,8 @@ MatchStatement: ast::Stmt = {
                     ast::ExprTuple {
                         elts: vec![subject.into()],
                         ctx: ast::ExprContext::Load,
-                        range: (tuple_location..tuple_end_location).into()
+                        range: (tuple_location..tuple_end_location).into(),
+                        parenthesized: false
                     },
                 )),
                 cases,
@@ -506,7 +507,8 @@ MatchStatement: ast::Stmt = {
                     ast::ExprTuple {
                         elts,
                         ctx: ast::ExprContext::Load,
-                        range: (tuple_location..tuple_end_location).into()
+                        range: (tuple_location..tuple_end_location).into(),
+                        parenthesized: false
                     },
                 )),
                 cases,
@@ -1573,6 +1575,7 @@ SubscriptList: crate::parser::ParenthesizedExpr = {
             elts: vec![s1.into()],
             ctx: ast::ExprContext::Load,
             range: (location..end_location).into(),
+            parenthesized: false
         }.into()
     },
     <location:@L> <elts:TwoOrMoreSep<Subscript, ",">> ","? <end_location:@R> => {
@@ -1581,6 +1584,7 @@ SubscriptList: crate::parser::ParenthesizedExpr = {
             elts,
             ctx: ast::ExprContext::Load,
             range: (location..end_location).into(),
+            parenthesized: false
         }.into()
     }
 };
@@ -1726,7 +1730,12 @@ Atom<Goal>: crate::parser::ParenthesizedExpr = {
             }
         } else {
             let elts = elts.into_iter().map(ast::Expr::from).collect();
-            ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }.into()
+            ast::ExprTuple {
+              elts,
+              ctx: ast::ExprContext::Load,
+              range: (location..end_location).into(),
+              parenthesized: true
+            }.into()
         }
     },
     <location:@L> "(" <left:(<OneOrMore<Test<"all">>> ",")?> <mid:NamedOrStarExpr> <right:("," <TestOrStarNamedExpr>)*> <trailing_comma:","?> ")" <end_location:@R> =>? {
@@ -1743,13 +1752,19 @@ Atom<Goal>: crate::parser::ParenthesizedExpr = {
             })
         } else {
             let elts = left.into_iter().flatten().chain([mid]).chain(right).map(ast::Expr::from).collect();
-            Ok(ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }.into())
+            Ok(ast::ExprTuple {
+              elts,
+              ctx: ast::ExprContext::Load,
+              range: (location..end_location).into(),
+              parenthesized: true
+            }.into())
         }
     },
     <location:@L> "(" ")" <end_location:@R> => ast::ExprTuple {
         elts: Vec::new(),
         ctx: ast::ExprContext::Load,
         range: (location..end_location).into(),
+        parenthesized: true
     }.into(),
     <location:@L> "(" <e:YieldExpr> ")" <end_location:@R> => crate::parser::ParenthesizedExpr {
         expr: e.into(),
@@ -1759,6 +1774,7 @@ Atom<Goal>: crate::parser::ParenthesizedExpr = {
         elt: Box::new(elt.into()),
         generators,
         range: (location..end_location).into(),
+        parenthesized: true
     }.into(),
     "(" <location:@L> "**" <e:Expression<"all">> ")" <end_location:@R> =>? {
         Err(LexicalError::new(
@@ -1852,7 +1868,12 @@ GenericList<Element>: crate::parser::ParenthesizedExpr = {
             }
         } else {
             let elts = elts.into_iter().map(ast::Expr::from).collect();
-            ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }.into()
+            ast::ExprTuple {
+              elts,
+              ctx: ast::ExprContext::Load,
+              range: (location..end_location).into(),
+              parenthesized: false
+            }.into()
         }
     }
 }
@@ -1904,7 +1925,8 @@ FunctionArgument: (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::E
                 ast::ExprGeneratorExp {
                     elt: Box::new(elt.into()),
                     generators,
-                    range: (location..end_location).into()
+                    range: (location..end_location).into(),
+                    parenthesized: false
                 }
             ),
             None => elt.into(),

crates/ruff_python_parser/src/python.rs

@@ -1,5 +1,5 @@
 // auto-generated: "lalrpop 0.20.0"
-// sha3: 8c85e4bbac54760ed8be03b56a428d76e14d18e6dbde62b424d0b2b5e8e65dbe
+// sha3: d64ca7ff27121baee9d7a1b4d0f341932391a365fe75f115987b05bf2aaf538e
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 use ruff_python_ast::{self as ast, Int, IpyEscapeKind};
 use crate::{
@@ -33938,7 +33938,8 @@ fn __action86<
                     ast::ExprTuple {
                         elts: vec![subject.into()],
                         ctx: ast::ExprContext::Load,
-                        range: (tuple_location..tuple_end_location).into()
+                        range: (tuple_location..tuple_end_location).into(),
+                        parenthesized: false
                     },
                 )),
                 cases,
@@ -33982,7 +33983,8 @@ fn __action87<
                     ast::ExprTuple {
                         elts,
                         ctx: ast::ExprContext::Load,
-                        range: (tuple_location..tuple_end_location).into()
+                        range: (tuple_location..tuple_end_location).into(),
+                        parenthesized: false
                     },
                 )),
                 cases,
@@ -36227,6 +36229,7 @@ fn __action208<
             elts: vec![s1.into()],
             ctx: ast::ExprContext::Load,
             range: (location..end_location).into(),
+            parenthesized: false
         }.into()
     }
 }
@@ -36249,6 +36252,7 @@ fn __action209<
             elts,
             ctx: ast::ExprContext::Load,
             range: (location..end_location).into(),
+            parenthesized: false
         }.into()
     }
 }
@@ -36796,7 +36800,8 @@ fn __action242<
                 ast::ExprGeneratorExp {
                     elt: Box::new(elt.into()),
                     generators,
-                    range: (location..end_location).into()
+                    range: (location..end_location).into(),
+                    parenthesized: false
                 }
             ),
             None => elt.into(),
@@ -37049,7 +37054,12 @@ fn __action259<
             }
         } else {
             let elts = elts.into_iter().map(ast::Expr::from).collect();
-            ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }.into()
+            ast::ExprTuple {
+              elts,
+              ctx: ast::ExprContext::Load,
+              range: (location..end_location).into(),
+              parenthesized: false
+            }.into()
         }
     }
 }
@@ -37103,7 +37113,12 @@ fn __action262<
             }
         } else {
             let elts = elts.into_iter().map(ast::Expr::from).collect();
-            ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }.into()
+            ast::ExprTuple {
+              elts,
+              ctx: ast::ExprContext::Load,
+              range: (location..end_location).into(),
+              parenthesized: false
+            }.into()
         }
     }
 }
@@ -41292,7 +41307,12 @@ fn __action553<
             }
         } else {
             let elts = elts.into_iter().map(ast::Expr::from).collect();
-            ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }.into()
+            ast::ExprTuple {
+              elts,
+              ctx: ast::ExprContext::Load,
+              range: (location..end_location).into(),
+              parenthesized: true
+            }.into()
         }
     }
 }
@@ -41327,7 +41347,12 @@ fn __action554<
             })
         } else {
             let elts = left.into_iter().flatten().chain([mid]).chain(right).map(ast::Expr::from).collect();
-            Ok(ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }.into())
+            Ok(ast::ExprTuple {
+              elts,
+              ctx: ast::ExprContext::Load,
+              range: (location..end_location).into(),
+              parenthesized: true
+            }.into())
         }
     }
 }
@@ -41348,6 +41373,7 @@ fn __action555<
         elts: Vec::new(),
         ctx: ast::ExprContext::Load,
         range: (location..end_location).into(),
+        parenthesized: true
     }.into()
 }
 
@@ -41388,6 +41414,7 @@ fn __action557<
         elt: Box::new(elt.into()),
         generators,
         range: (location..end_location).into(),
+        parenthesized: true
     }.into()
 }
 
@@ -42025,7 +42052,12 @@ fn __action596<
             })
         } else {
             let elts = left.into_iter().flatten().chain([mid]).chain(right).map(ast::Expr::from).collect();
-            Ok(ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }.into())
+            Ok(ast::ExprTuple {
+              elts,
+              ctx: ast::ExprContext::Load,
+              range: (location..end_location).into(),
+              parenthesized: true
+            }.into())
         }
     }
 }
@@ -42046,6 +42078,7 @@ fn __action597<
         elts: Vec::new(),
         ctx: ast::ExprContext::Load,
         range: (location..end_location).into(),
+        parenthesized: true
     }.into()
 }
 
@@ -42086,6 +42119,7 @@ fn __action599<
         elt: Box::new(elt.into()),
         generators,
         range: (location..end_location).into(),
+        parenthesized: true
     }.into()
 }
 

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_attribute.snap

@@ -55,6 +55,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_for.snap

@@ -44,6 +44,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
             body: [

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_list.snap

@@ -60,6 +60,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_list_comp.snap

@@ -65,6 +65,7 @@ expression: parse_ast
                                         ),
                                     ],
                                     ctx: Load,
+                                    parenthesized: true,
                                 },
                             ),
                             ifs: [],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_name.snap

@@ -45,6 +45,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_set_comp.snap

@@ -65,6 +65,7 @@ expression: parse_ast
                                         ),
                                     ],
                                     ctx: Load,
+                                    parenthesized: true,
                                 },
                             ),
                             ifs: [],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_starred.snap

@@ -33,6 +33,7 @@ expression: parse_ast
                             ),
                         ],
                         ctx: Store,
+                        parenthesized: true,
                     },
                 ),
             ],
@@ -66,6 +67,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_subscript.snap

@@ -58,6 +58,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__assign_tuple.snap

@@ -27,6 +27,7 @@ expression: parse_ast
                             ),
                         ],
                         ctx: Store,
+                        parenthesized: true,
                     },
                 ),
             ],
@@ -60,6 +61,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__aug_assign_attribute.snap

@@ -54,6 +54,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__context__tests__aug_assign_subscript.snap

@@ -57,6 +57,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__invalid__tests__ok_tuple.snap

@@ -35,6 +35,7 @@ Ok(
                                 ),
                             ],
                             ctx: Store,
+                            parenthesized: true,
                         },
                     ),
                 ],
@@ -68,6 +69,7 @@ Ok(
                             ),
                         ],
                         ctx: Load,
+                        parenthesized: true,
                     },
                 ),
             },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__fstrings.snap

@@ -111,6 +111,7 @@ expression: parse_ast
                                                             ),
                                                         ],
                                                         ctx: Load,
+                                                        parenthesized: false,
                                                     },
                                                 ),
                                                 debug_text: None,
@@ -501,6 +502,7 @@ expression: parse_ast
                                                             ),
                                                         ],
                                                         ctx: Load,
+                                                        parenthesized: false,
                                                     },
                                                 ),
                                                 debug_text: Some(

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__generator_expression_argument.snap

@@ -146,12 +146,14 @@ Call(
                                             ),
                                         ],
                                         ctx: Load,
+                                        parenthesized: true,
                                     },
                                 ),
                                 ifs: [],
                                 is_async: false,
                             },
                         ],
+                        parenthesized: false,
                     },
                 ),
             ],

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__match.snap

@@ -469,6 +469,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
             cases: [
@@ -521,6 +522,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
             cases: [
@@ -573,6 +575,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
             cases: [

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__match_as_identifier.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/parser.rs
-expression: "parse_suite(source, \"<test>\").unwrap()"
+expression: parse_suite(source).unwrap()
 ---
 [
     Expr(
@@ -52,6 +52,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
         },
@@ -105,6 +106,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
         },
@@ -385,6 +387,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                             range: 298..300,
                                             elts: [],
                                             ctx: Load,
+                                            parenthesized: true,
                                         },
                                     ),
                                 ],
@@ -425,6 +428,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                             range: 329..331,
                                             elts: [],
                                             ctx: Load,
+                                            parenthesized: true,
                                         },
                                     ),
                                 ],
@@ -505,6 +509,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                         ),
                                     ],
                                     ctx: Load,
+                                    parenthesized: false,
                                 },
                             ),
                             ctx: Load,
@@ -548,6 +553,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                         ),
                                     ],
                                     ctx: Load,
+                                    parenthesized: true,
                                 },
                             ),
                             ctx: Load,

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parenthesized_with_statement.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/parser.rs
-expression: "parse_suite(source, \"<test>\").unwrap()"
+expression: parse_suite(source).unwrap()
 ---
 [
     With(
@@ -171,6 +171,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: Some(
@@ -220,6 +221,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: Some(

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_class_generic_types.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/parser.rs
-expression: "parse_suite(source, \"<test>\").unwrap()"
+expression: parse_suite(source).unwrap()
 ---
 [
     ClassDef(
@@ -143,6 +143,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                                 ),
                                             ],
                                             ctx: Load,
+                                            parenthesized: true,
                                         },
                                     ),
                                 ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_double_list_comprehension.snap

@@ -35,6 +35,7 @@ ListComp(
                             ),
                         ],
                         ctx: Store,
+                        parenthesized: false,
                     },
                 ),
                 iter: Name(

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_function_definition.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/parser.rs
-expression: "parse_suite(source, \"<test>\").unwrap()"
+expression: parse_suite(source).unwrap()
 ---
 [
     FunctionDef(
@@ -254,6 +254,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                                 ),
                                             ],
                                             ctx: Load,
+                                            parenthesized: true,
                                         },
                                     ),
                                 ),

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_generator_comprehension.snap

@@ -33,5 +33,6 @@ GeneratorExp(
                 is_async: false,
             },
         ],
+        parenthesized: true,
     },
 )

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_if_else_generator_comprehension.snap

@@ -52,5 +52,6 @@ GeneratorExp(
                 is_async: false,
             },
         ],
+        parenthesized: true,
     },
 )

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_named_expression_generator_comprehension.snap

@@ -59,5 +59,6 @@ GeneratorExp(
                 is_async: false,
             },
         ],
+        parenthesized: true,
     },
 )

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_tuples.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/parser.rs
-expression: "parse_suite(source, \"<test>\").unwrap()"
+expression: parse_suite(source).unwrap()
 ---
 [
     Assign(
@@ -27,6 +27,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                             ),
                         ],
                         ctx: Store,
+                        parenthesized: false,
                     },
                 ),
             ],
@@ -52,6 +53,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__parse_type_declaration.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/parser.rs
-expression: "parse_suite(source, \"<test>\").unwrap()"
+expression: parse_suite(source).unwrap()
 ---
 [
     TypeAlias(
@@ -354,6 +354,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },
@@ -438,6 +439,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },
@@ -484,6 +486,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                                 ),
                                             ],
                                             ctx: Load,
+                                            parenthesized: true,
                                         },
                                     ),
                                 ),
@@ -537,6 +540,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
         },

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__patma.snap

@@ -1659,6 +1659,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
             cases: [
@@ -2148,6 +2149,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
             cases: [
@@ -3287,6 +3289,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
             cases: [
@@ -3385,6 +3388,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: true,
                 },
             ),
             cases: [
@@ -3466,6 +3470,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
             cases: [
@@ -3542,6 +3547,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
             cases: [
@@ -3635,6 +3641,7 @@ expression: parse_ast
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
             cases: [

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__star_index.snap

@@ -66,6 +66,7 @@ expression: parse_ast
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: false,
                         },
                     ),
                     ctx: Load,
@@ -128,6 +129,7 @@ expression: parse_ast
                                     ),
                                 ],
                                 ctx: Load,
+                                parenthesized: false,
                             },
                         ),
                         ctx: Store,
@@ -188,6 +190,7 @@ expression: parse_ast
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: false,
                         },
                     ),
                     ctx: Load,
@@ -253,6 +256,7 @@ expression: parse_ast
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: false,
                         },
                     ),
                     ctx: Load,

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__tuple.snap

@@ -0,0 +1,124 @@
+---
+source: crates/ruff_python_parser/src/parser.rs
+expression: parse_ast
+---
+[
+    Expr(
+        StmtExpr {
+            range: 0..3,
+            value: Tuple(
+                ExprTuple {
+                    range: 0..3,
+                    elts: [
+                        Name(
+                            ExprName {
+                                range: 0..1,
+                                id: "a",
+                                ctx: Load,
+                            },
+                        ),
+                        Name(
+                            ExprName {
+                                range: 2..3,
+                                id: "b",
+                                ctx: Load,
+                            },
+                        ),
+                    ],
+                    ctx: Load,
+                    parenthesized: false,
+                },
+            ),
+        },
+    ),
+    Expr(
+        StmtExpr {
+            range: 4..9,
+            value: Tuple(
+                ExprTuple {
+                    range: 4..9,
+                    elts: [
+                        Name(
+                            ExprName {
+                                range: 5..6,
+                                id: "a",
+                                ctx: Load,
+                            },
+                        ),
+                        Name(
+                            ExprName {
+                                range: 7..8,
+                                id: "b",
+                                ctx: Load,
+                            },
+                        ),
+                    ],
+                    ctx: Load,
+                    parenthesized: true,
+                },
+            ),
+        },
+    ),
+    Expr(
+        StmtExpr {
+            range: 10..12,
+            value: Tuple(
+                ExprTuple {
+                    range: 10..12,
+                    elts: [],
+                    ctx: Load,
+                    parenthesized: true,
+                },
+            ),
+        },
+    ),
+    Expr(
+        StmtExpr {
+            range: 13..17,
+            value: Tuple(
+                ExprTuple {
+                    range: 13..17,
+                    elts: [
+                        Name(
+                            ExprName {
+                                range: 14..15,
+                                id: "a",
+                                ctx: Load,
+                            },
+                        ),
+                    ],
+                    ctx: Load,
+                    parenthesized: true,
+                },
+            ),
+        },
+    ),
+    Expr(
+        StmtExpr {
+            range: 18..25,
+            value: Tuple(
+                ExprTuple {
+                    range: 19..24,
+                    elts: [
+                        Name(
+                            ExprName {
+                                range: 20..21,
+                                id: "a",
+                                ctx: Load,
+                            },
+                        ),
+                        Name(
+                            ExprName {
+                                range: 22..23,
+                                id: "b",
+                                ctx: Load,
+                            },
+                        ),
+                    ],
+                    ctx: Load,
+                    parenthesized: true,
+                },
+            ),
+        },
+    ),
+]

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__type_as_identifier.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/parser.rs
-expression: "parse_suite(source, \"<test>\").unwrap()"
+expression: parse_suite(source).unwrap()
 ---
 [
     Expr(
@@ -52,6 +52,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
         },
@@ -105,6 +106,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                         ),
                     ],
                     ctx: Load,
+                    parenthesized: false,
                 },
             ),
         },
@@ -385,6 +387,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                             range: 283..285,
                                             elts: [],
                                             ctx: Load,
+                                            parenthesized: true,
                                         },
                                     ),
                                 ],
@@ -425,6 +428,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                             range: 312..314,
                                             elts: [],
                                             ctx: Load,
+                                            parenthesized: true,
                                         },
                                     ),
                                 ],
@@ -505,6 +509,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                         ),
                                     ],
                                     ctx: Load,
+                                    parenthesized: false,
                                 },
                             ),
                             ctx: Load,
@@ -548,6 +553,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                         ),
                                     ],
                                     ctx: Load,
+                                    parenthesized: true,
                                 },
                             ),
                             ctx: Load,

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__with_statement.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/ruff_python_parser/src/parser.rs
-expression: "parse_suite(source, \"<test>\").unwrap()"
+expression: parse_suite(source).unwrap()
 ---
 [
     With(
@@ -275,6 +275,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                             range: 133..135,
                             elts: [],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: None,
@@ -301,6 +302,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                             range: 147..149,
                             elts: [],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: Some(
@@ -433,6 +435,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: Some(
@@ -523,6 +526,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: Some(
@@ -571,6 +575,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: None,
@@ -611,6 +616,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: Some(
@@ -667,6 +673,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: None,
@@ -715,6 +722,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: Some(
@@ -876,6 +884,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: None,
@@ -943,6 +952,7 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
                                 ),
                             ],
                             ctx: Load,
+                            parenthesized: true,
                         },
                     ),
                     optional_vars: Some(