Add parenthesized flag to ExprTuple and ExprGenerator (#9614)

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