Move ExprSequence to sequence.rs

crates/ruff_python_formatter/src/expression/expr_tuple.rs

@@ -10,6 +10,8 @@ use ruff_text_size::TextRange;
 use rustpython_parser::ast::ExprTuple;
 use rustpython_parser::ast::{Expr, Ranged};
 
+use super::sequence::ExprSequence;
+
 #[derive(Eq, PartialEq, Debug, Default)]
 pub enum TupleParentheses {
     /// Effectively `None` in `Option<Parentheses>`
@@ -93,23 +95,6 @@ impl FormatNodeRule<ExprTuple> for FormatExprTuple {
     }
 }
 
-#[derive(Debug)]
-struct ExprSequence<'a> {
-    elts: &'a [Expr],
-}
-
-impl<'a> ExprSequence<'a> {
-    const fn new(elts: &'a [Expr]) -> Self {
-        Self { elts }
-    }
-}
-
-impl Format<PyFormatContext<'_>> for ExprSequence<'_> {
-    fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> {
-        f.join_comma_separated().nodes(self.elts.iter()).finish()
-    }
-}
-
 impl NeedsParentheses for ExprTuple {
     fn needs_parentheses(
         &self,

crates/ruff_python_formatter/src/expression/mod.rs

@@ -39,6 +39,7 @@ pub(crate) mod expr_unary_op;
 pub(crate) mod expr_yield;
 pub(crate) mod expr_yield_from;
 pub(crate) mod parentheses;
+pub(crate) mod sequence;
 pub(crate) mod string;
 
 #[derive(Default)]

crates/ruff_python_formatter/src/expression/sequence.rs

@@ -0,0 +1,21 @@
+use ruff_formatter::{prelude::Formatter, Format, FormatResult};
+use rustpython_parser::ast::Expr;
+
+use crate::{builders::PyFormatterExtensions, context::PyFormatContext};
+
+#[derive(Debug)]
+pub(crate) struct ExprSequence<'a> {
+    elts: &'a [Expr],
+}
+
+impl<'a> ExprSequence<'a> {
+    pub(crate) const fn new(elts: &'a [Expr]) -> Self {
+        Self { elts }
+    }
+}
+
+impl Format<PyFormatContext<'_>> for ExprSequence<'_> {
+    fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> {
+        f.join_comma_separated().nodes(self.elts.iter()).finish()
+    }
+}

crates/ruff_python_formatter/src/statement/stmt_delete.rs

@@ -1,13 +1,11 @@
-use crate::builders::{optional_parentheses, PyFormatterExtensions};
-use crate::comments::{dangling_node_comments, Comments};
-use crate::expression::parentheses::{
-    default_expression_needs_parentheses, NeedsParentheses, Parentheses, Parenthesize,
-};
-use crate::prelude::PyFormatContext;
+use crate::builders::optional_parentheses;
+use crate::comments::dangling_node_comments;
+use crate::expression::parentheses::Parenthesize;
+use crate::expression::sequence::ExprSequence;
 use crate::{AsFormat, FormatNodeRule, PyFormatter};
-use ruff_formatter::prelude::{block_indent, space, text, Formatter};
+use ruff_formatter::prelude::{block_indent, space, text};
 use ruff_formatter::{write, Buffer, Format, FormatResult};
-use rustpython_parser::ast::{Expr, StmtDelete};
+use rustpython_parser::ast::StmtDelete;
 
 #[derive(Default)]
 pub struct FormatStmtDelete;
@@ -43,36 +41,3 @@ impl FormatNodeRule<StmtDelete> for FormatStmtDelete {
         }
     }
 }
-
-// TODO(cnpryer): Shared `ExprSequence` (see expr_tuple.rs)
-#[derive(Debug)]
-struct ExprSequence<'a> {
-    targets: &'a [Expr],
-}
-
-impl<'a> ExprSequence<'a> {
-    const fn new(targets: &'a [Expr]) -> Self {
-        Self { targets }
-    }
-}
-
-impl Format<PyFormatContext<'_>> for ExprSequence<'_> {
-    fn fmt(&self, f: &mut Formatter<PyFormatContext<'_>>) -> FormatResult<()> {
-        f.join_comma_separated().nodes(self.targets.iter()).finish()
-    }
-}
-
-// NOTE: `default_expression_needs_parentheses` is reserved for expression nodes.
-impl NeedsParentheses for StmtDelete {
-    fn needs_parentheses(
-        &self,
-        parenthesize: Parenthesize,
-        source: &str,
-        comments: &Comments,
-    ) -> Parentheses {
-        match default_expression_needs_parentheses(self.into(), parenthesize, source, comments) {
-            Parentheses::Optional => Parentheses::Never,
-            parentheses => parentheses,
-        }
-    }
-}