Add fn_call_layout configuration option

Closes 5218

The `fn_call_layout` was added to give users more control over how
function calls are formatted.

The values are identical to those for `fn_args_layout`, which  is a
stable option that controls how function declarations are laid out.

Author: ytmimi

Configurations.md

@@ -753,6 +753,75 @@ trait Lorem {
 }
 ```
 
+## `fn_call_layout`
+
+Control the layout of arguments in function calls
+
+- **Default value**: `"Tall"`
+- **Possible values**: `"Compressed"`, `"Tall"`, `"Vertical"`
+- **Stable**: No (tracking issue: N/A)
+
+#### `"Tall"` (default):
+
+```rust
+fn main() {
+    lorem(ipsum, dolor, sit, amet);
+    ipsum(
+        dolor,
+        sit,
+        amet,
+        consectetur,
+        adipiscing,
+        elit,
+        vivamus,
+        ipsum,
+        orci,
+        rhoncus,
+        vel,
+        imperdiet,
+    );
+}
+```
+
+#### `"Compressed"`:
+
+```rust
+fn main() {
+    lorem(ipsum, dolor, sit, amet);
+    ipsum(
+        dolor, sit, amet, consectetur, adipiscing, elit, vivamus, ipsum, orci, rhoncus, vel,
+        imperdiet,
+    );
+}
+```
+
+#### `"Vertical"`:
+
+```rust
+fn main() {
+    lorem(
+        ipsum,
+        dolor,
+        sit,
+        amet,
+    );
+    ipsum(
+        dolor,
+        sit,
+        amet,
+        consectetur,
+        adipiscing,
+        elit,
+        vivamus,
+        ipsum,
+        orci,
+        rhoncus,
+        vel,
+        imperdiet,
+    );
+}
+```
+
 ## `fn_call_width`
 
 Maximum width of the args of a function call before falling back to vertical formatting.

src/attr.rs

@@ -309,6 +309,7 @@ impl Rewrite for ast::MetaItem {
                     } else {
                         SeparatorTactic::Never
                     }),
+                    None,
                 )?
             }
             ast::MetaItemKind::NameValue(ref literal) => {

src/config/mod.rs

@@ -122,6 +122,8 @@ create_config! {
         "Force multiline closure bodies and match arms to be wrapped in a block";
     fn_args_layout: Density, Density::Tall, true,
         "Control the layout of arguments in a function";
+    fn_call_layout: Density, Density::Tall, false,
+        "Control the layout of arguments in a function call";
     brace_style: BraceStyle, BraceStyle::SameLineWhere, false, "Brace style for items";
     control_brace_style: ControlBraceStyle, ControlBraceStyle::AlwaysSameLine, false,
         "Brace style for control flow constructs";
@@ -601,6 +603,7 @@ match_arm_blocks = true
 match_arm_leading_pipes = "Never"
 force_multiline_blocks = false
 fn_args_layout = "Tall"
+fn_call_layout = "Tall"
 brace_style = "SameLineWhere"
 control_brace_style = "AlwaysSameLine"
 trailing_semicolon = true

src/expr.rs

@@ -1312,6 +1312,12 @@ pub(crate) fn rewrite_call(
     span: Span,
     shape: Shape,
 ) -> Option<String> {
+    let force_list_tactic = if context.config.was_set().fn_call_layout() {
+        Some(context.config.fn_call_layout().to_list_tactic(args.len()))
+    } else {
+        None
+    };
+
     overflow::rewrite_with_parens(
         context,
         callee,
@@ -1320,6 +1326,7 @@ pub(crate) fn rewrite_call(
         span,
         context.config.fn_call_width(),
         choose_separator_tactic(context, span),
+        force_list_tactic,
     )
 }
 
@@ -1857,6 +1864,7 @@ pub(crate) fn rewrite_tuple<'a, T: 'a + IntoOverflowableItem<'a>>(
             span,
             context.config.fn_call_width(),
             force_tactic,
+            None,
         )
     } else {
         rewrite_tuple_in_visual_indent_style(context, items, span, shape, is_singleton_tuple)

src/items.rs

@@ -1485,6 +1485,7 @@ fn format_tuple_struct(
             mk_sp(lo, span.hi()),
             context.config.fn_call_width(),
             None,
+            None,
         )?;
     }
 

src/macros.rs

@@ -279,6 +279,7 @@ fn rewrite_macro_inner(
                     } else {
                         Some(SeparatorTactic::Never)
                     },
+                    None,
                 )
                 .map(|rw| match position {
                     MacroPosition::Item => format!("{};", rw),

src/overflow.rs

@@ -252,6 +252,7 @@ pub(crate) fn rewrite_with_parens<'a, T: 'a + IntoOverflowableItem<'a>>(
     span: Span,
     item_max_width: usize,
     force_separator_tactic: Option<SeparatorTactic>,
+    force_list_tactic: Option<ListTactic>,
 ) -> Option<String> {
     Context::new(
         context,
@@ -263,6 +264,7 @@ pub(crate) fn rewrite_with_parens<'a, T: 'a + IntoOverflowableItem<'a>>(
         ")",
         item_max_width,
         force_separator_tactic,
+        force_list_tactic,
         None,
     )
     .rewrite(shape)
@@ -286,6 +288,7 @@ pub(crate) fn rewrite_with_angle_brackets<'a, T: 'a + IntoOverflowableItem<'a>>(
         context.config.max_width(),
         None,
         None,
+        None,
     )
     .rewrite(shape)
 }
@@ -314,6 +317,7 @@ pub(crate) fn rewrite_with_square_brackets<'a, T: 'a + IntoOverflowableItem<'a>>
         rhs,
         context.config.array_width(),
         force_separator_tactic,
+        None,
         Some(("[", "]")),
     )
     .rewrite(shape)
@@ -331,6 +335,7 @@ struct Context<'a> {
     item_max_width: usize,
     one_line_width: usize,
     force_separator_tactic: Option<SeparatorTactic>,
+    force_list_tactic: Option<ListTactic>,
     custom_delims: Option<(&'a str, &'a str)>,
 }
 
@@ -345,6 +350,7 @@ impl<'a> Context<'a> {
         suffix: &'static str,
         item_max_width: usize,
         force_separator_tactic: Option<SeparatorTactic>,
+        force_list_tactic: Option<ListTactic>,
         custom_delims: Option<(&'a str, &'a str)>,
     ) -> Context<'a> {
         let used_width = extra_offset(ident, shape);
@@ -369,6 +375,7 @@ impl<'a> Context<'a> {
             item_max_width,
             one_line_width,
             force_separator_tactic,
+            force_list_tactic,
             custom_delims,
         }
     }
@@ -584,6 +591,23 @@ impl<'a> Context<'a> {
             _ => (),
         }
 
+        match self.force_list_tactic {
+            Some(list_tactic) if list_tactic == ListTactic::Mixed => {
+                if tactic != DefinitiveListTactic::Horizontal {
+                    tactic = DefinitiveListTactic::Mixed
+                }
+            }
+            Some(list_tactic) if list_tactic != ListTactic::Mixed => {
+                tactic = definitive_tactic(
+                    &*list_items,
+                    list_tactic,
+                    Separator::Comma,
+                    self.one_line_width,
+                )
+            }
+            _ => {}
+        };
+
         tactic
     }
 

src/patterns.rs

@@ -494,6 +494,7 @@ fn rewrite_tuple_pat(
         } else {
             None
         },
+        None,
     )
 }
 

tests/source/configs/fn_call_layout/compressed.rs

@@ -0,0 +1,55 @@
+// rustfmt-fn_call_layout:Compressed
+// rustfmt-version:Two
+
+fn main() {
+    lorem(ipsum, dolor, sit, amet);
+    lorem(ipsum, // some inine comment
+        dolor, sit, amet);
+    lorem(ipsum, /* some inine comment */
+        dolor, sit, amet);
+    ipsum(dolor, sit, amet, consectetur, adipiscing, elit, vivamus, ipsum, orci, rhoncus, vel, imperdiet);
+
+    // issue 2010
+    let a = i8x32::new(
+                0, 1, -1, 2,
+                -2, 3, -3, 4,
+                -4, 5, -5, std::i8::MAX,
+                std::i8::MIN + 1, 100, -100, -32,
+                0, 1, -1, 2,
+                -2, 3, -3, 4,
+                -4, 5, -5, std::i8::MAX,
+                std::i8::MIN + 1, 100, -100, -32);
+
+    // issue 4146
+    return_monitor_err(
+        e,
+        channel_state,
+        chan,
+        order,
+        commitment_update.is_some(),
+        revoke_and_ack.is_some(),
+    );
+
+
+    // other examples with more complex args
+    more_complex_args(
+        |a, b, c| {if a == 998765390 {- b * 3 } else  {c} },
+        std::ops::Range { start: 3, end: 5 },
+        std::i8::MAX, String::from(" hello world!!").as_bytes(),
+        thread::Builder::new()
+            .name("thread1".to_string())
+            .spawn(move || {
+                use std::sync::Arc;
+
+                let mut values = Arc::<[u32]>::new_uninit_slice(3);
+
+                // Deferred initialization:
+                let data = Arc::get_mut(&mut values).unwrap();
+                data[0].write(1);
+                data[1].write(2);
+                data[2].write(3);
+
+                let values = unsafe { values.assume_init() };
+            }), "another argument"
+    )
+}

tests/source/configs/fn_call_layout/tall.rs

@@ -0,0 +1,55 @@
+// rustfmt-fn_call_layout:Tall
+// rustfmt-version:Two
+
+fn main() {
+    lorem(ipsum, dolor, sit, amet);
+    lorem(ipsum, // some inine comment
+        dolor, sit, amet);
+    lorem(ipsum, /* some inine comment */
+        dolor, sit, amet);
+    ipsum(dolor, sit, amet, consectetur, adipiscing, elit, vivamus, ipsum, orci, rhoncus, vel, imperdiet);
+
+    // issue 2010
+    let a = i8x32::new(
+                0, 1, -1, 2,
+                -2, 3, -3, 4,
+                -4, 5, -5, std::i8::MAX,
+                std::i8::MIN + 1, 100, -100, -32,
+                0, 1, -1, 2,
+                -2, 3, -3, 4,
+                -4, 5, -5, std::i8::MAX,
+                std::i8::MIN + 1, 100, -100, -32);
+
+    // issue 4146
+    return_monitor_err(
+        e,
+        channel_state,
+        chan,
+        order,
+        commitment_update.is_some(),
+        revoke_and_ack.is_some(),
+    );
+
+
+    // other examples with more complex args
+    more_complex_args(
+        |a, b, c| {if a == 998765390 {- b * 3 } else  {c} },
+        std::ops::Range { start: 3, end: 5 },
+        std::i8::MAX, String::from(" hello world!!").as_bytes(),
+        thread::Builder::new()
+            .name("thread1".to_string())
+            .spawn(move || {
+                use std::sync::Arc;
+
+                let mut values = Arc::<[u32]>::new_uninit_slice(3);
+
+                // Deferred initialization:
+                let data = Arc::get_mut(&mut values).unwrap();
+                data[0].write(1);
+                data[1].write(2);
+                data[2].write(3);
+
+                let values = unsafe { values.assume_init() };
+            }), "another argument"
+    )
+}