failed attempt at re-partitioning dangling comments

see #21410 (comment), but
the short summary is that `if` (and likely other) statement formatting code that
uses `maybe_parenthesize` checks if the condition has any leading or trailing
comments, so if we try to smuggle the comments in as dangling comments, it
thinks the expression won't break, so it doesn't add parentheses when formatting
a case like this:

```py
if (
  not
  # comment
  a):
    pass
```

and we end up with a syntax error:

```py
if
not a:
    pass
```

There may be some other way around this, but this is why I'm giving up for now.
It really feels like we want another CommentPlacement variant or some kind of
dangling tag, like Micha mentioned when I met with him.

Author: ntBre

crates/ruff_python_formatter/src/comments/placement.rs

@@ -1865,8 +1865,10 @@ fn handle_unary_op_comment<'a>(
         .find(|token| token.kind == SimpleTokenKind::LParen)
         .map_or(unary_op.operand.start(), |lparen| lparen.start());
     if comment.end() < up_to {
-        CommentPlacement::leading(unary_op, comment)
+        eprintln!("leading: {}", &source[comment.range()]);
+        CommentPlacement::dangling(unary_op, comment)
     } else {
+        eprintln!("default: {}", &source[comment.range()]);
         CommentPlacement::Default(comment)
     }
 }

crates/ruff_python_formatter/src/expression/expr_unary_op.rs

@@ -1,7 +1,12 @@
 use ruff_python_ast::AnyNodeRef;
 use ruff_python_ast::ExprUnaryOp;
 use ruff_python_ast::UnaryOp;
+use ruff_python_trivia::SimpleTokenKind;
+use ruff_python_trivia::SimpleTokenizer;
+use ruff_text_size::Ranged;
+use ruff_text_size::TextRange;
 
+use crate::comments::leading_comments;
 use crate::comments::trailing_comments;
 use crate::expression::parentheses::{
     NeedsParentheses, OptionalParentheses, Parentheses, is_expression_parenthesized,
@@ -20,24 +25,49 @@ impl FormatNodeRule<ExprUnaryOp> for FormatExprUnaryOp {
             operand,
         } = item;
 
-        let operator = match op {
-            UnaryOp::Invert => "~",
-            UnaryOp::Not => "not",
-            UnaryOp::UAdd => "+",
-            UnaryOp::USub => "-",
-        };
-
-        token(operator).fmt(f)?;
-
         let comments = f.context().comments().clone();
         let dangling = comments.dangling(item);
 
+        let mut tokenizer = SimpleTokenizer::new(
+            f.context().source(),
+            TextRange::new(item.start(), operand.start()),
+        )
+        .skip_trivia();
+        let op_token = tokenizer.next();
+        debug_assert!(op_token.is_some_and(|token| matches!(
+            token.kind,
+            SimpleTokenKind::Tilde
+                | SimpleTokenKind::Not
+                | SimpleTokenKind::Plus
+                | SimpleTokenKind::Minus
+        )));
+        let up_to = tokenizer
+            .find(|token| token.kind == SimpleTokenKind::LParen)
+            .map_or(operand.start(), |lparen| lparen.start());
+
+        let pivot = dangling.partition_point(|comment| comment.end() < up_to);
+        dbg!(pivot);
+        let leading = &dangling[..pivot];
+
         // Split off the comments that follow after the operator and format them as trailing comments.
         // ```python
         // (not # comment
         //      a)
         // ```
-        trailing_comments(dangling).fmt(f)?;
+        if !leading.is_empty() {
+            hard_line_break().fmt(f)?;
+            leading_comments(&dangling[..pivot]).fmt(f)?;
+        }
+        trailing_comments(&dangling[pivot..]).fmt(f)?;
+
+        let operator = match op {
+            UnaryOp::Invert => "~",
+            UnaryOp::Not => "not",
+            UnaryOp::UAdd => "+",
+            UnaryOp::USub => "-",
+        };
+
+        token(operator).fmt(f)?;
 
         // Insert a line break if the operand has comments but itself is not parenthesized.
         // ```python