Fix f-string formatting in assignment statement

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

@@ -313,6 +313,94 @@
     # comment 28
 } woah {x}"
 
+# Assignment statement
+
+# Even though this f-string has multiline expression, thus allowing us to break it at the
+# curly braces, the f-string fits on a single line if it's moved inside the parentheses.
+# We should prefer doing that instead.
+aaaaaaaaaaaaaaaaaa = f"testeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee{
+    expression}moreeeeeeeeeeeeeeeee"
+
+# Same as above
+xxxxxxx = f"{
+    {'aaaaaaaaaaaaaaaaaaa', 'bbbbbbbbbbbbbbbbbbb', 'cccccccccccccccccccccccccc'}
+}"
+
+# Similar to the previous example, but the f-string will exceed the line length limit,
+# we shouldn't add any parentheses here.
+xxxxxxx = f"{
+    {'aaaaaaaaaaaaaaaaaaaaaaaaa', 'bbbbbbbbbbbbbbbbbbbbbbbbbbb', 'cccccccccccccccccccccccccc'}
+}"
+
+# Same as above but with an inline comment. The f-string should be formatted inside the
+# parentheses and the comment should be part of the line inside the parentheses.
+aaaaaaaaaaaaaaaaaa = f"testeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee{
+    expression}moreeeeeeeeeeeeeeeee"  # comment
+
+# Similar to the previous example but this time parenthesizing doesn't work because it
+# exceeds the line length. So, avoid parenthesizing this f-string.
+aaaaaaaaaaaaaaaaaa = f"testeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee{
+    expression}moreeeeeeeeeeeeeeeee"  # comment loooooooong
+
+# Similar to the previous example but we start with the parenthesized layout. This should
+# remove the parentheses and format the f-string on a single line. This shows that the
+# final layout for the formatter is same for this and the previous case. The only
+# difference is that in the previous case the expression is already mulitline which means
+# the formatter can break it further at the curly braces.
+aaaaaaaaaaaaaaaaaa = (
+    f"testeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee{expression}moreeeeeeeeeeeeeeeee"  # comment loooooooong
+)
+
+# The following f-strings are going to break because of the trailing comma so we should
+# avoid using the best fit layout and instead use the default layout.
+# left-to-right
+aaaa = f"aaaa {[
+    1, 2,
+]} bbbb"
+# right-to-left
+aaaa, bbbb = f"aaaa {[
+    1, 2,
+]} bbbb"
+
+# Using the right-to-left assignment statement variant.
+aaaaaaaaaaaaaaaaaa, bbbbbbbbbbb = f"testeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee{
+    expression}moreeeeeeeeeeeeeeeee"  # comment
+
+# Here, the f-string layout is flat but it exceeds the line length limit. This shouldn't
+# try the custom best fit layout because the f-string doesn't have any split points.
+aaaaaaaaaaaa["bbbbbbbbbbbbbbbb"] = (
+    f"aaaaaaaaaaaaaaaaaaa {aaaaaaaaa + bbbbbbbbbbb + cccccccccccccc} ddddddddddddddddddd"
+)
+# Same as above but without the parentheses to test that it gets formatted to the same
+# layout as the previous example.
+aaaaaaaaaaaa["bbbbbbbbbbbbbbbb"] = f"aaaaaaaaaaaaaaaaaaa {aaaaaaaaa + bbbbbbbbbbb + cccccccccccccc} ddddddddddddddddddd"
+
+# But, the following f-string does have a split point because of the multiline expression.
+aaaaaaaaaaaa["bbbbbbbbbbbbbbbb"] = (
+    f"aaaaaaaaaaaaaaaaaaa {
+        aaaaaaaaa + bbbbbbbbbbb + cccccccccccccc} ddddddddddddddddddd"
+)
+aaaaaaaaaaaa["bbbbbbbbbbbbbbbb"] = (
+    f"aaaaaaaaaaaaaaaaaaa {
+        aaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccc + dddddddddddddddddddddddddddd} ddddddddddddddddddd"
+)
+
+# This is an implicitly concatenated f-string but it cannot be joined because otherwise
+# it'll exceed the line length limit. So, the two f-strings will be inside parentheses
+# instead and the inline comment should be outside the parentheses.
+a = f"test{
+    expression
+}flat" f"can be {
+    joined
+} togethereeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" # inline
+
+# Similar to the above example but this fits within the line length limit.
+a = f"test{
+    expression
+}flat" f"can be {
+    joined
+} togethereeeeeeeeeeeeeeeeeeeeeeeeeee" # inline
+
 # Indentation
 
 # What should be the indentation?

crates/ruff_python_formatter/src/expression/expr_bin_op.rs

@@ -28,7 +28,7 @@ impl NeedsParentheses for ExprBinOp {
         } else if let Ok(string) = StringLike::try_from(&*self.left) {
             // Multiline strings are guaranteed to never fit, avoid adding unnecessary parentheses
             if !string.is_implicit_concatenated()
-                && string.is_multiline(context.source())
+                && string.is_multiline(context)
                 && has_parentheses(&self.right, context).is_some()
                 && !context.comments().has_dangling(self)
                 && !context.comments().has(string)

crates/ruff_python_formatter/src/expression/expr_bytes_literal.rs

@@ -40,7 +40,7 @@ impl NeedsParentheses for ExprBytesLiteral {
     ) -> OptionalParentheses {
         if self.value.is_implicit_concatenated() {
             OptionalParentheses::Multiline
-        } else if StringLike::Bytes(self).is_multiline(context.source()) {
+        } else if StringLike::Bytes(self).is_multiline(context) {
             OptionalParentheses::Never
         } else {
             OptionalParentheses::BestFit

crates/ruff_python_formatter/src/expression/expr_compare.rs

@@ -29,7 +29,7 @@ impl NeedsParentheses for ExprCompare {
         } else if let Ok(string) = StringLike::try_from(&*self.left) {
             // Multiline strings are guaranteed to never fit, avoid adding unnecessary parentheses
             if !string.is_implicit_concatenated()
-                && string.is_multiline(context.source())
+                && string.is_multiline(context)
                 && !context.comments().has(string)
                 && self.comparators.first().is_some_and(|right| {
                     has_parentheses(right, context).is_some() && !context.comments().has(right)

crates/ruff_python_formatter/src/expression/expr_f_string.rs

@@ -6,8 +6,10 @@ use crate::expression::parentheses::{
 };
 use crate::other::f_string::FormatFString;
 use crate::prelude::*;
-use crate::string::implicit::FormatImplicitConcatenatedStringFlat;
-use crate::string::{implicit::FormatImplicitConcatenatedString, Quoting, StringLikeExtensions};
+use crate::string::implicit::{
+    FormatImplicitConcatenatedString, FormatImplicitConcatenatedStringFlat,
+};
+use crate::string::{Quoting, StringLikeExtensions};
 
 #[derive(Default)]
 pub struct FormatExprFString;
@@ -45,26 +47,7 @@ impl NeedsParentheses for ExprFString {
     ) -> OptionalParentheses {
         if self.value.is_implicit_concatenated() {
             OptionalParentheses::Multiline
-        }
-        // TODO(dhruvmanila): Ideally what we want here is a new variant which
-        // is something like:
-        // - If the expression fits by just adding the parentheses, then add them and
-        //   avoid breaking the f-string expression. So,
-        //   ```
-        //   xxxxxxxxx = (
-        //       f"aaaaaaaaaaaa { xxxxxxx + yyyyyyyy } bbbbbbbbbbbbb"
-        //   )
-        //   ```
-        // - But, if the expression is too long to fit even with parentheses, then
-        //   don't add the parentheses and instead break the expression at `soft_line_break`.
-        //   ```
-        //   xxxxxxxxx = f"aaaaaaaaaaaa {
-        //       xxxxxxxxx + yyyyyyyyyy
-        //   } bbbbbbbbbbbbb"
-        //   ```
-        // This isn't decided yet, refer to the relevant discussion:
-        // https://github.com/astral-sh/ruff/discussions/9785
-        else if StringLike::FString(self).is_multiline(context.source()) {
+        } else if StringLike::FString(self).is_multiline(context) {
             OptionalParentheses::Never
         } else {
             OptionalParentheses::BestFit

crates/ruff_python_formatter/src/expression/expr_string_literal.rs

@@ -53,7 +53,7 @@ impl NeedsParentheses for ExprStringLiteral {
     ) -> OptionalParentheses {
         if self.value.is_implicit_concatenated() {
             OptionalParentheses::Multiline
-        } else if StringLike::String(self).is_multiline(context.source()) {
+        } else if StringLike::String(self).is_multiline(context) {
             OptionalParentheses::Never
         } else {
             OptionalParentheses::BestFit

crates/ruff_python_formatter/src/other/arguments.rs

@@ -223,7 +223,7 @@ fn is_huggable_string_argument(
     arguments: &Arguments,
     context: &PyFormatContext,
 ) -> bool {
-    if string.is_implicit_concatenated() || !string.is_multiline(context.source()) {
+    if string.is_implicit_concatenated() || !string.is_multiline(context) {
         return false;
     }
 

crates/ruff_python_formatter/src/other/f_string.rs

@@ -140,6 +140,10 @@ impl FStringLayout {
         }
     }
 
+    pub(crate) const fn is_flat(self) -> bool {
+        matches!(self, FStringLayout::Flat)
+    }
+
     pub(crate) const fn is_multiline(self) -> bool {
         matches!(self, FStringLayout::Multiline)
     }