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.

This change will only impact function calls, and will not have any
affect on method calls.

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

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/chains.rs

@@ -253,7 +253,7 @@ impl ChainItem {
             format!("::<{}>", type_list.join(", "))
         };
         let callee_str = format!(".{}{}", rewrite_ident(context, method_name), type_str);
-        rewrite_call(context, &callee_str, &args[1..], span, shape)
+        rewrite_call(context, &callee_str, &args[1..], None, span, shape)
     }
 }
 

src/config/mod.rs

@@ -118,6 +118,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";
@@ -565,6 +567,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

@@ -138,7 +138,19 @@ fn format_expr_inner(
         ast::ExprKind::Call(ref callee, ref args) => {
             let inner_span = mk_sp(callee.span.hi(), expr.span.hi());
             let callee_str = callee.rewrite(context, shape)?;
-            rewrite_call(context, &callee_str, args, inner_span, shape)
+            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
+            };
+            rewrite_call(
+                context,
+                &callee_str,
+                args,
+                force_list_tactic,
+                inner_span,
+                shape,
+            )
         }
         ast::ExprKind::Paren(ref subexpr) => rewrite_paren(context, subexpr, shape, expr.span),
         ast::ExprKind::Binary(op, ref lhs, ref rhs) => {
@@ -1313,6 +1325,7 @@ pub(crate) fn rewrite_call(
     context: &RewriteContext<'_>,
     callee: &str,
     args: &[ptr::P<ast::Expr>],
+    force_list_tactic: Option<ListTactic>,
     span: Span,
     shape: Shape,
 ) -> Option<String> {
@@ -1324,6 +1337,7 @@ pub(crate) fn rewrite_call(
         span,
         context.config.fn_call_width(),
         choose_separator_tactic(context, span),
+        force_list_tactic,
     )
 }
 
@@ -1861,6 +1875,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

@@ -1484,6 +1484,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,25 @@ impl<'a> Context<'a> {
             _ => (),
         }
 
+        match self.force_list_tactic {
+            Some(list_tactic) if list_tactic == ListTactic::Mixed => {
+                if tactic != DefinitiveListTactic::Horizontal {
+                    tactic = DefinitiveListTactic::Mixed
+                }
+            }
+            // If we need to force a tactic (like Vertical), we should only do it if there are
+            // at least 2 items for us to format. Otherwise, use the tactic already determined.
+            Some(list_tactic) if self.items.len() > 1 => {
+                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,
     )
 }
 

src/types.rs

@@ -844,6 +844,7 @@ impl Rewrite for ast::Ty {
                 context,
                 "typeof",
                 &[anon_const.value.clone()],
+                None,
                 self.span,
                 shape,
             ),

tests/source/configs/fn_call_layout/compressed.rs

@@ -0,0 +1,58 @@
+// rustfmt-fn_call_layout:Compressed
+
+fn main() {
+    empty_args();
+    single_arg(ipsum);
+    two_args(ipsum, dolor);
+
+    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,58 @@
+// rustfmt-fn_call_layout:Tall
+
+fn main() {
+    empty_args();
+    single_arg(ipsum);
+    two_args(ipsum, dolor);
+
+    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"
+    )
+}