Call chain formatting in fluent style

crates/ruff_python_formatter/resources/test/fixtures/ruff/call_chains.py

@@ -0,0 +1,152 @@
+# Test cases for call chains and optional parentheses, with and without fluent style
+
+raise OsError("") from a.aaaaa(
+    aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa
+).a(aaaa)
+
+raise OsError(
+    "sökdjffffsldkfjlhsakfjhalsökafhsöfdahsödfjösaaksjdllllllllllllll"
+) from a.aaaaa(
+    aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa
+).a(
+    aaaa
+)
+
+a1 = Blog.objects.filter(entry__headline__contains="Lennon").filter(
+    entry__pub_date__year=2008
+)
+
+a2 = Blog.objects.filter(
+    entry__headline__contains="Lennon",
+).filter(
+    entry__pub_date__year=2008,
+)
+
+raise OsError("") from (
+    Blog.objects.filter(
+        entry__headline__contains="Lennon",
+    )
+    .filter(
+        entry__pub_date__year=2008,
+    )
+    .filter(
+        entry__pub_date__year=2008,
+    )
+)
+
+raise OsError("sökdjffffsldkfjlhsakfjhalsökafhsöfdahsödfjösaaksjdllllllllllllll") from (
+    Blog.objects.filter(
+        entry__headline__contains="Lennon",
+    )
+    .filter(
+        entry__pub_date__year=2008,
+    )
+    .filter(
+        entry__pub_date__year=2008,
+    )
+)
+
+# Break only after calls and indexing
+b1 = (
+    session.query(models.Customer.id)
+    .filter(
+        models.Customer.account_id == account_id, models.Customer.email == email_address
+    )
+    .count()
+)
+
+b2 = (
+    Blog.objects.filter(
+        entry__headline__contains="Lennon",
+    )
+    .limit_results[:10]
+    .filter(
+        entry__pub_date__month=10,
+    )
+)
+
+# Nested call chains
+c1 = (
+    Blog.objects.filter(
+        entry__headline__contains="Lennon",
+    ).filter(
+        entry__pub_date__year=2008,
+    )
+    + Blog.objects.filter(
+        entry__headline__contains="McCartney",
+    )
+    .limit_results[:10]
+    .filter(
+        entry__pub_date__year=2010,
+    )
+).all()
+
+# Test different cases with trailing end of line comments:
+# * fluent style, fits: no parentheses -> ignore the expand_parent
+# * fluent style, doesn't fit: break all soft line breaks
+# * default, fits: no parentheses
+# * default, doesn't fit: parentheses but no soft line breaks
+
+# Fits, either style
+d11 = x.e().e().e() #
+d12 = (x.e().e().e()) #
+d13 = (
+    x.e() #
+    .e()
+    .e()
+)
+
+# Doesn't fit, default
+d2 = (
+    x.e().esadjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkfsdddd()  #
+)
+
+# Doesn't fit, fluent style
+d3 = (
+    x.e()  #
+    .esadjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk()
+    .esadjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk()
+)
+
+# Don't drop the bin op parentheses
+e1 = (1 + 2).w().t()
+e2 = (1 + 2)().w().t()
+e3 = (1 + 2)[1].w().t()
+
+# Treat preserved parentheses correctly
+f1 = a.w().t(1,)
+f2 = (a).w().t(1,)
+
+# Indent in the parentheses without breaking
+g1 = (
+    queryset.distinct().order_by(field.name).values_list(field_name_flat_long_long=True)
+)
+
+# Fluent style in subexpressions
+if (
+    not a()
+    .b()
+    .cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc()
+):
+    pass
+h2 = (
+    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+    + ccccccccccccccccccccccccc()
+    .dddddddddddddddddddddd()
+    .eeeeeeeeee()
+    .ffffffffffffffffffffff()
+)
+
+# Parentheses aren't allowed on statement level, don't use fluent style here
+if True:
+    (alias).filter(content_typeold_content_type).update(
+        content_typenew_contesadfasfdant_type
+    )
+
+zero(
+    one,
+).two(
+    three,
+).four(
+    five,
+)

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

@@ -52,7 +52,7 @@ def f(*args, **kwargs):
     hey_this_is_a_very_long_call=1, it_has_funny_attributes_asdf_asdf=1, too_long_for_the_line=1, really=True
 )
 
-# TODO(konstin): Call chains/fluent interface (https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#call-chains)
+# Call chains/fluent interface (https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#call-chains)
 result = (
     session.query(models.Customer.id)
     .filter(

crates/ruff_python_formatter/src/comments/placement.rs

@@ -1021,15 +1021,15 @@ fn handle_attribute_comment<'a>(
             .contains(comment.slice().start())
     );
     if comment.line_position().is_end_of_line() {
-        // Attach to node with b
+        // Attach as trailing comment to a. The specific placement is only relevant for fluent style
         // ```python
         // x322 = (
         //     a
         //     . # end-of-line dot comment 2
         //     b
         // )
         // ```
-        CommentPlacement::trailing(comment.enclosing_node(), comment)
+        CommentPlacement::trailing(attribute.value.as_ref(), comment)
     } else {
         CommentPlacement::dangling(attribute, comment)
     }

crates/ruff_python_formatter/src/expression/expr_attribute.rs

@@ -1,15 +1,26 @@
-use ruff_python_ast::{Constant, Expr, ExprAttribute, ExprConstant};
-
-use ruff_formatter::write;
+use ruff_formatter::{write, FormatRuleWithOptions};
 use ruff_python_ast::node::AnyNodeRef;
+use ruff_python_ast::{Constant, Expr, ExprAttribute, ExprConstant};
 
 use crate::comments::{leading_comments, trailing_comments};
 use crate::expression::parentheses::{NeedsParentheses, OptionalParentheses, Parentheses};
+use crate::expression::CallChainLayout;
 use crate::prelude::*;
 use crate::FormatNodeRule;
 
 #[derive(Default)]
-pub struct FormatExprAttribute;
+pub struct FormatExprAttribute {
+    call_chain_layout: CallChainLayout,
+}
+
+impl FormatRuleWithOptions<ExprAttribute, PyFormatContext<'_>> for FormatExprAttribute {
+    type Options = CallChainLayout;
+
+    fn with_options(mut self, options: Self::Options) -> Self {
+        self.call_chain_layout = options;
+        self
+    }
+}
 
 impl FormatNodeRule<ExprAttribute> for FormatExprAttribute {
     fn fmt_fields(&self, item: &ExprAttribute, f: &mut PyFormatter) -> FormatResult<()> {
@@ -37,29 +48,78 @@ impl FormatNodeRule<ExprAttribute> for FormatExprAttribute {
 
         if needs_parentheses {
             value.format().with_options(Parentheses::Always).fmt(f)?;
-        } else if let Expr::Attribute(expr_attribute) = value.as_ref() {
-            // We're in a attribute chain (`a.b.c`). The outermost node adds parentheses if
-            // required, the inner ones don't need them so we skip the `Expr` formatting that
-            // normally adds the parentheses.
-            expr_attribute.format().fmt(f)?;
         } else {
-            value.format().fmt(f)?;
+            match value.as_ref() {
+                Expr::Attribute(expr) => {
+                    expr.format().with_options(self.call_chain_layout).fmt(f)?;
+                }
+                Expr::Call(expr) => {
+                    expr.format().with_options(self.call_chain_layout).fmt(f)?;
+                    if self.call_chain_layout == CallChainLayout::Fluent {
+                        // Format the dot on its own line
+                        soft_line_break().fmt(f)?;
+                    }
+                }
+                Expr::Subscript(expr) => {
+                    expr.format().with_options(self.call_chain_layout).fmt(f)?;
+                    if self.call_chain_layout == CallChainLayout::Fluent {
+                        // Format the dot on its own line
+                        soft_line_break().fmt(f)?;
+                    }
+                }
+                _ => value.format().fmt(f)?,
+            }
         }
 
         if comments.has_trailing_own_line_comments(value.as_ref()) {
             hard_line_break().fmt(f)?;
         }
 
-        write!(
-            f,
-            [
-                text("."),
-                trailing_comments(trailing_dot_comments),
-                (!leading_attribute_comments.is_empty()).then_some(hard_line_break()),
-                leading_comments(leading_attribute_comments),
-                attr.format()
-            ]
-        )
+        if self.call_chain_layout == CallChainLayout::Fluent {
+            // Fluent style has line breaks before the dot
+            // ```python
+            // blogs3 = (
+            //     Blog.objects.filter(
+            //         entry__headline__contains="Lennon",
+            //     )
+            //     .filter(
+            //         entry__pub_date__year=2008,
+            //     )
+            //     .filter(
+            //         entry__pub_date__year=2008,
+            //     )
+            // )
+            // ```
+            write!(
+                f,
+                [
+                    (!leading_attribute_comments.is_empty()).then_some(hard_line_break()),
+                    leading_comments(leading_attribute_comments),
+                    text("."),
+                    trailing_comments(trailing_dot_comments),
+                    attr.format()
+                ]
+            )
+        } else {
+            // Regular style
+            // ```python
+            // blogs2 = Blog.objects.filter(
+            //     entry__headline__contains="Lennon",
+            // ).filter(
+            //     entry__pub_date__year=2008,
+            // )
+            // ```
+            write!(
+                f,
+                [
+                    text("."),
+                    trailing_comments(trailing_dot_comments),
+                    (!leading_attribute_comments.is_empty()).then_some(hard_line_break()),
+                    leading_comments(leading_attribute_comments),
+                    attr.format()
+                ]
+            )
+        }
     }
 
     fn fmt_dangling_comments(

crates/ruff_python_formatter/src/expression/expr_bin_op.rs

@@ -5,9 +5,7 @@ use ruff_python_ast::{
 };
 use smallvec::SmallVec;
 
-use ruff_formatter::{
-    format_args, write, FormatOwnedWithRule, FormatRefWithRule, FormatRuleWithOptions,
-};
+use ruff_formatter::{format_args, write, FormatOwnedWithRule, FormatRefWithRule};
 use ruff_python_ast::node::{AnyNodeRef, AstNode};
 use ruff_python_ast::str::is_implicit_concatenation;
 
@@ -19,23 +17,11 @@ use crate::expression::parentheses::{
     NeedsParentheses, OptionalParentheses,
 };
 use crate::expression::string::StringLayout;
-use crate::expression::Parentheses;
 use crate::prelude::*;
 use crate::FormatNodeRule;
 
 #[derive(Default)]
-pub struct FormatExprBinOp {
-    parentheses: Option<Parentheses>,
-}
-
-impl FormatRuleWithOptions<ExprBinOp, PyFormatContext<'_>> for FormatExprBinOp {
-    type Options = Option<Parentheses>;
-
-    fn with_options(mut self, options: Self::Options) -> Self {
-        self.parentheses = options;
-        self
-    }
-}
+pub struct FormatExprBinOp;
 
 impl FormatNodeRule<ExprBinOp> for FormatExprBinOp {
     fn fmt_fields(&self, item: &ExprBinOp, f: &mut PyFormatter) -> FormatResult<()> {

crates/ruff_python_formatter/src/expression/expr_call.rs

@@ -1,13 +1,25 @@
-use ruff_formatter::write;
+use crate::expression::CallChainLayout;
+use ruff_formatter::{write, FormatRuleWithOptions};
 use ruff_python_ast::node::AnyNodeRef;
-use ruff_python_ast::ExprCall;
+use ruff_python_ast::{Expr, ExprCall};
 
 use crate::expression::parentheses::{NeedsParentheses, OptionalParentheses};
 use crate::prelude::*;
 use crate::FormatNodeRule;
 
 #[derive(Default)]
-pub struct FormatExprCall;
+pub struct FormatExprCall {
+    call_chain_layout: CallChainLayout,
+}
+
+impl FormatRuleWithOptions<ExprCall, PyFormatContext<'_>> for FormatExprCall {
+    type Options = CallChainLayout;
+
+    fn with_options(mut self, options: Self::Options) -> Self {
+        self.call_chain_layout = options;
+        self
+    }
+}
 
 impl FormatNodeRule<ExprCall> for FormatExprCall {
     fn fmt_fields(&self, item: &ExprCall, f: &mut PyFormatter) -> FormatResult<()> {
@@ -17,7 +29,14 @@ impl FormatNodeRule<ExprCall> for FormatExprCall {
             arguments,
         } = item;
 
-        write!(f, [func.format(), arguments.format()])
+        match func.as_ref() {
+            Expr::Attribute(expr) => expr.format().with_options(self.call_chain_layout).fmt(f)?,
+            Expr::Call(expr) => expr.format().with_options(self.call_chain_layout).fmt(f)?,
+            Expr::Subscript(expr) => expr.format().with_options(self.call_chain_layout).fmt(f)?,
+            _ => func.format().fmt(f)?,
+        }
+
+        write!(f, [arguments.format()])
     }
 }