Use a new parenthesized mode

Author: charliermarsh

crates/ruff_python_formatter/src/expression/expr_named_expr.rs

@@ -46,7 +46,6 @@ impl NeedsParentheses for ExprNamedExpr {
             || parent.is_with_item()
             || parent.is_stmt_delete()
             || parent.is_stmt_for()
-            || parent.is_stmt_function_def()
         {
             OptionalParentheses::Always
         } else {

crates/ruff_python_formatter/src/expression/mod.rs

@@ -183,7 +183,9 @@ impl Format<PyFormatContext<'_>> for MaybeParenthesizeExpression<'_> {
                     needs_parentheses
                 }
             }
-            Parenthesize::Optional | Parenthesize::IfBreaks => needs_parentheses,
+            Parenthesize::Optional
+            | Parenthesize::IfBreaks
+            | Parenthesize::IfBreaksOrIfRequired => needs_parentheses,
         };
 
         match needs_parentheses {
@@ -199,6 +201,10 @@ impl Format<PyFormatContext<'_>> for MaybeParenthesizeExpression<'_> {
             OptionalParentheses::Always => {
                 expression.format().with_options(Parentheses::Always).fmt(f)
             }
+            OptionalParentheses::Never if *parenthesize == Parenthesize::IfBreaksOrIfRequired => {
+                parenthesize_if_expands(&expression.format().with_options(Parentheses::Never))
+                    .fmt(f)
+            }
             OptionalParentheses::Never | OptionalParentheses::Multiline => {
                 expression.format().with_options(Parentheses::Never).fmt(f)
             }

crates/ruff_python_formatter/src/expression/parentheses.rs

@@ -51,6 +51,11 @@ pub(crate) enum Parenthesize {
     /// * The expression is not enclosed by another parenthesized expression and it expands over multiple lines
     /// * The expression has leading or trailing comments. Adding parentheses is desired to prevent the comments from wandering.
     IfRequired,
+
+    /// Parenthesizes the expression if the group doesn't fit on a line (e.g., even name expressions are parenthesized), or if
+    /// the expression doesn't break, but _does_ reports that it always requires parentheses in this position (e.g., walrus
+    /// operators in function return annotations).
+    IfBreaksOrIfRequired,
 }
 
 impl Parenthesize {

crates/ruff_python_formatter/src/statement/stmt_function_def.rs

@@ -1,11 +1,10 @@
 use ruff_formatter::write;
-
 use ruff_python_ast::{Parameters, Ranged, StmtFunctionDef};
 use ruff_python_trivia::{lines_after_ignoring_trivia, SimpleTokenKind, SimpleTokenizer};
 
 use crate::comments::{leading_comments, trailing_comments};
 use crate::expression::maybe_parenthesize_expression;
-use crate::expression::parentheses::{optional_parentheses, Parentheses, Parenthesize};
+use crate::expression::parentheses::Parenthesize;
 use crate::prelude::*;
 use crate::statement::suite::SuiteKind;
 use crate::FormatNodeRule;
@@ -65,37 +64,31 @@ impl FormatNodeRule<StmtFunctionDef> for FormatStmtFunctionDef {
 
             if let Some(return_annotation) = item.returns.as_ref() {
                 write!(f, [space(), text("->"), space()])?;
-
-                if empty_parameters(&item.parameters, f.context().source()) {
-                    // If the parameters are empty, add parentheses if the return annotation
-                    // breaks at all.
-                    write!(
-                        f,
-                        [optional_parentheses(
-                            &return_annotation.format().with_options(Parentheses::Never),
-                        )]
-                    )?;
-                } else {
-                    // Otherwise, use our normal rules for parentheses, which allows us to break
-                    // like:
-                    // ```python
-                    // def f(
-                    //     x,
-                    // ) -> Tuple[
-                    //     int,
-                    //     int,
-                    // ]:
-                    //     ...
-                    // ```
-                    write!(
-                        f,
-                        [maybe_parenthesize_expression(
-                            return_annotation,
-                            item,
+                write!(
+                    f,
+                    [maybe_parenthesize_expression(
+                        return_annotation,
+                        item,
+                        if empty_parameters(&item.parameters, f.context().source()) {
+                            // If the parameters are empty, add parentheses if the return annotation
+                            // breaks at all.
+                            Parenthesize::IfBreaksOrIfRequired
+                        } else {
+                            // Otherwise, use our normal rules for parentheses, which allows us to break
+                            // like:
+                            // ```python
+                            // def f(
+                            //     x,
+                            // ) -> Tuple[
+                            //     int,
+                            //     int,
+                            // ]:
+                            //     ...
+                            // ```
                             Parenthesize::IfBreaks
-                        )]
-                    )?;
-                };
+                        }
+                    )]
+                )?;
             }
             Ok(())
         });