Avoid hard line break after dangling inner-parenthesis comments

crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/list.py

@@ -44,3 +44,9 @@
 [  # end-of-line comment
     1
 ]
+
+[  # inner comment
+    first,
+    second,
+    third
+]  # outer comment

crates/ruff_python_formatter/src/comments/format.rs

@@ -227,6 +227,46 @@ impl Format<PyFormatContext<'_>> for FormatDanglingComments<'_> {
     }
 }
 
+/// Formats the dangling comments within a parenthetical, for example:
+/// ```python
+/// [  # comment
+///     1,
+///     2,
+///     3,
+/// ]
+/// ```
+pub(crate) fn parenthetical_comments(comments: &[SourceComment]) -> FormatParentheticalComments {
+    FormatParentheticalComments { comments }
+}
+
+pub(crate) struct FormatParentheticalComments<'a> {
+    comments: &'a [SourceComment],
+}
+
+impl Format<PyFormatContext<'_>> for FormatParentheticalComments<'_> {
+    fn fmt(&self, f: &mut Formatter<PyFormatContext>) -> FormatResult<()> {
+        let mut first = true;
+
+        for comment in self
+            .comments
+            .iter()
+            .filter(|comment| comment.is_unformatted())
+        {
+            if first {
+                write!(f, [space(), space()])?;
+            }
+
+            write!(f, [format_comment(comment)])?;
+
+            comment.mark_formatted();
+
+            first = false;
+        }
+
+        Ok(())
+    }
+}
+
 /// Formats the content of the passed comment.
 ///
 /// * Adds a whitespace between `#` and the comment text except if the first character is a `#`, `:`, `'`, or `!`

crates/ruff_python_formatter/src/comments/mod.rs

@@ -96,7 +96,7 @@ use ruff_python_ast::{Mod, Ranged};
 
 pub(crate) use format::{
     dangling_comments, dangling_node_comments, leading_alternate_branch_comments, leading_comments,
-    leading_node_comments, trailing_comments, trailing_node_comments,
+    leading_node_comments, parenthetical_comments, trailing_comments, trailing_node_comments,
 };
 use ruff_formatter::{SourceCode, SourceCodeSlice};
 use ruff_python_ast::node::AnyNodeRef;

crates/ruff_python_formatter/src/expression/parentheses.rs

@@ -4,7 +4,7 @@ use ruff_python_ast::node::AnyNodeRef;
 use ruff_python_ast::Ranged;
 use ruff_python_trivia::{first_non_trivia_token, SimpleToken, SimpleTokenKind, SimpleTokenizer};
 
-use crate::comments::{dangling_comments, SourceComment};
+use crate::comments::{parenthetical_comments, SourceComment};
 use crate::context::{NodeLevel, WithNodeLevel};
 use crate::prelude::*;
 
@@ -117,7 +117,7 @@ where
 }
 
 /// Formats `content` enclosed by the `left` and `right` parentheses, along with any dangling
-/// comments that on the parentheses themselves.
+/// comments on the opening parenthesis itself.
 pub(crate) fn parenthesized_with_dangling_comments<'content, 'ast, Content>(
     left: &'static str,
     comments: &'content [SourceComment],
@@ -155,7 +155,7 @@ impl<'ast> Format<PyFormatContext<'ast>> for FormatParenthesized<'_, 'ast> {
             } else {
                 group(&format_args![
                     text(self.left),
-                    &line_suffix(&dangling_comments(self.comments)),
+                    &line_suffix(&parenthetical_comments(self.comments)),
                     &group(&soft_block_indent(&Arguments::from(&self.content))),
                     text(self.right)
                 ])
@@ -319,10 +319,11 @@ impl<'ast> Format<PyFormatContext<'ast>> for FormatInParenthesesOnlyGroup<'_, 'a
 
 #[cfg(test)]
 mod tests {
-    use crate::expression::parentheses::is_expression_parenthesized;
     use ruff_python_ast::node::AnyNodeRef;
     use ruff_python_parser::parse_expression;
 
+    use crate::expression::parentheses::is_expression_parenthesized;
+
     #[test]
     fn test_has_parentheses() {
         let expression = r#"(b().c("")).d()"#;

crates/ruff_python_formatter/tests/snapshots/format@expression__list.py.snap

@@ -50,6 +50,12 @@ c1 = [ # trailing open bracket
 [  # end-of-line comment
     1
 ]
+
+[  # inner comment
+    first,
+    second,
+    third
+]  # outer comment
 ```
 
 ## Output
@@ -94,6 +100,8 @@ c1 = [  # trailing open bracket
 ]
 
 [1]  # end-of-line comment
+
+[first, second, third]  # inner comment  # outer comment
 ```