Expand expressions to include parentheses in E712 (#6575)

## Summary

This PR exposes our `is_expression_parenthesized` logic such that we can
use it to expand expressions when autofixing to include their
parenthesized ranges.

This solution has a few drawbacks: (1) we need to compute parenthesized
ranges in more places, which also relies on backwards lexing; and (2) we
need to make use of this in any relevant fixes.

However, I still think it's worth pursuing. On (1), the implementation
is very contained, so IMO we can easily swap this out for a more
performant solution in the future if needed. On (2), this improves
correctness and fixes some bad syntax errors detected by fuzzing, which
means it has value even if it's not as robust as an _actual_
`ParenthesizedExpression` node in the AST itself.

Closes https://github.com/astral-sh/ruff/issues/4925.

## Test Plan

`cargo test` with new cases that previously failed the fuzzer.

crates/ruff_python_ast/src/lib.rs

@@ -12,6 +12,7 @@ pub mod identifier;
 pub mod imports;
 pub mod node;
 mod nodes;
+pub mod parenthesize;
 pub mod relocate;
 pub mod statement_visitor;
 pub mod stmt_if;

crates/ruff_python_ast/src/parenthesize.rs

@@ -0,0 +1,47 @@
+use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
+use ruff_text_size::{TextRange, TextSize};
+
+use crate::node::AnyNodeRef;
+use crate::{ExpressionRef, Ranged};
+
+/// Returns the [`TextRange`] of a given expression including parentheses, if the expression is
+/// parenthesized; or `None`, if the expression is not parenthesized.
+pub fn parenthesized_range(
+    expr: ExpressionRef,
+    parent: AnyNodeRef,
+    contents: &str,
+) -> Option<TextRange> {
+    // If the parent is a node that brings its own parentheses, exclude the closing parenthesis
+    // from our search range. Otherwise, we risk matching on calls, like `func(x)`, for which
+    // the open and close parentheses are part of the `Arguments` node.
+    //
+    // There are a few other nodes that may have their own parentheses, but are fine to exclude:
+    // - `Parameters`: The parameters to a function definition. Any expressions would represent
+    //   default arguments, and so must be preceded by _at least_ the parameter name. As such,
+    //   we won't mistake any parentheses for the opening and closing parentheses on the
+    //   `Parameters` node itself.
+    // - `Tuple`: The elements of a tuple. The only risk is a single-element tuple (e.g., `(x,)`),
+    //    which must have a trailing comma anyway.
+    let exclusive_parent_end = if parent.is_arguments() {
+        parent.end() - TextSize::new(1)
+    } else {
+        parent.end()
+    };
+
+    // First, test if there's a closing parenthesis because it tends to be cheaper.
+    let tokenizer =
+        SimpleTokenizer::new(contents, TextRange::new(expr.end(), exclusive_parent_end));
+    let right = tokenizer.skip_trivia().next()?;
+
+    if right.kind == SimpleTokenKind::RParen {
+        // Next, test for the opening parenthesis.
+        let mut tokenizer =
+            SimpleTokenizer::up_to_without_back_comment(expr.start(), contents).skip_trivia();
+        let left = tokenizer.next_back()?;
+        if left.kind == SimpleTokenKind::LParen {
+            return Some(TextRange::new(left.start(), right.end()));
+        }
+    }
+
+    None
+}

crates/ruff_python_ast/src/stmt_if.rs

@@ -46,6 +46,3 @@ pub fn if_elif_branches(stmt_if: &StmtIf) -> impl Iterator<Item = IfElifBranch>
         })
     }))
 }
-
-#[cfg(test)]
-mod test {}