refactor: support tuple lit chain parent indent

Author: calebcartwright

Configurations.md

@@ -428,52 +428,114 @@ fn example() {
 Determines whether block-like chain parents are indented
 
 - **Default value**: `"Never"`
-- **Possible values**: `"Always"`, `"Never"`, `"OnlySimpleCalls"`
+- **Possible values**: `"Always"`, `"Never"`, `"OnlySimpleCalls"`, `"OnlyTupleLitsAndSimpleCalls"`
 - **Stable**: No (tracking issue: ...)
 
 #### `"Never"` (default):
+The body of block-like parent chain elements are never indented.
 
 ```rust
 #![rustfmt::skip]
-
 fn example() {
+    let all = very_very_very_very_very_long_fun_name(
+        very_very_very_very_very_very_very_very_very_long_var_name,
+    )
+    .iter()
+    .map(|x| x + very_very_very_very_very_very_long_var_name);
+
     StructA {
         test_test: some_value,
     }
-        .foo()
-        .bar()
-        .baz()
-        .qux();
-
-    let very_very_very_very_very_very_very_very_very_long_var_name = 13;
-    let all = very_very_very_very_very_long_fun_name(
-        very_very_very_very_very_very_very_very_very_long_var_name,
+    .do_stuff(StructB {
+        test_test_b: other_value,
+    })
+    .aaa_aaa()
+    .do_stuff(
+        StructB {
+            test_test_b: other_value,
+        }
+        .ddd_ddd()
+        .eee_eee(),
     )
-        .iter()
-        .map(|x| x + very_very_very_very_very_very_long_var_name);
+    .bbb_bbb()
+    .ccc_ccc();
 
     foo(|x| {
         // ....
     })
-        .bar()
-        .baz()
-        .unwrap();
+    .bar()
+    .baz()
+    .unwrap();
 }
 ```
 
 #### `"Always"`:
+The body of block-like parent chain elements are always indented.
 
 ```rust
 #![rustfmt::skip]
+// chains_block_parent_indent_children: true
 
 fn example() {
+    let all = very_very_very_very_very_long_fun_name(
+            very_very_very_very_very_very_very_very_very_long_var_name,
+        )
+        .iter()
+        .map(|x| x + very_very_very_very_very_very_long_var_name);
+
     StructA {
             test_test: some_value,
         }
-        .foo()
+        .do_stuff(StructB {
+            test_test_b: other_value,
+        })
+        .aaa_aaa()
+        .do_stuff(
+            StructB {
+                    test_test_b: other_value,
+                }
+                .ddd_ddd()
+                .eee_eee(),
+        )
+        .bbb_bbb()
+        .ccc_ccc();
+        
+    foo(|x| {
+            // ....
+        })
         .bar()
         .baz()
-        .qux();
+        .unwrap()
+}
+```
+
+#### `"OnlyTupleLitsAndSimpleCalls"`:
+
+```rust
+#![rustfmt::skip]
+
+fn example() {
+    let all = very_very_very_very_very_long_fun_name(
+            very_very_very_very_very_very_very_very_very_long_var_name,
+        )
+        .iter()
+        .map(|x| x + very_very_very_very_very_very_long_var_name);
+    StructA {
+            test_test: some_value,
+        }
+        .do_stuff(StructB {
+            test_test_b: other_value,
+        })
+        .aaa_aaa()
+        .do_stuff(
+            StructB {
+                    test_test_b: other_value,
+                }
+                .ddd_ddd()
+                .eee_eee(),
+        )
+        .bbb_bbb()
+        .ccc_ccc();
 }
 ```
 

src/chains.rs

@@ -765,6 +765,17 @@ fn format_chain_item(
         }
     }
 
+    fn is_tup_lit_or_simple_call_like(
+        parent_expr_kind: &ast::ExprKind,
+        context: &RewriteContext<'_>,
+        shape: Shape,
+    ) -> bool {
+        match parent_expr_kind {
+            ast::ExprKind::Struct(..) => true,
+            _ => is_simple_call_like(parent_expr_kind, context, shape),
+        }
+    }
+
     let orig_result = item.rewrite(context, shape);
     let new_shape = match Shape::indented(shape.indent.block_indent(context.config), context.config)
         .sub_width(shape.rhs_overhead(context.config))
@@ -783,12 +794,38 @@ fn format_chain_item(
         }
         (Some(orig_result), Some(next_line_result)) => match item.kind {
             ChainItemKind::Parent(ref expr) => match parent_indent_style {
-                ChainsBlockParentElementIndent::Never => Some((orig_result, false)),
-                ChainsBlockParentElementIndent::Always => Some((next_line_result, false)),
+                ChainsBlockParentElementIndent::Never => Some((
+                    orig_result.clone(),
+                    wrap_str(orig_result, context.config.max_width(), shape).is_none(),
+                )),
+                ChainsBlockParentElementIndent::Always => Some((
+                    next_line_result.clone(),
+                    wrap_str(next_line_result, context.config.max_width(), new_shape).is_none(),
+                )),
                 ChainsBlockParentElementIndent::OnlySimpleCalls => {
                     match is_simple_call_like(&expr.kind, &context, shape) {
-                        true => Some((next_line_result, false)),
-                        false => Some((orig_result, false)),
+                        true => Some((
+                            next_line_result.clone(),
+                            wrap_str(next_line_result, context.config.max_width(), new_shape)
+                                .is_none(),
+                        )),
+                        false => Some((
+                            orig_result.clone(),
+                            wrap_str(orig_result, context.config.max_width(), shape).is_none(),
+                        )),
+                    }
+                }
+                ChainsBlockParentElementIndent::OnlyTupleLitsAndSimpleCalls => {
+                    match is_tup_lit_or_simple_call_like(&expr.kind, &context, shape) {
+                        true => Some((
+                            next_line_result.clone(),
+                            wrap_str(next_line_result, context.config.max_width(), new_shape)
+                                .is_none(),
+                        )),
+                        false => Some((
+                            orig_result.clone(),
+                            wrap_str(orig_result, context.config.max_width(), shape).is_none(),
+                        )),
                     }
                 }
             },
@@ -798,7 +835,10 @@ fn format_chain_item(
             )),
         },
         (None, None) => Some((context.snippet(item.span).to_owned(), true)),
-        (Some(orig_result), _) => Some((orig_result, false)),
+        (Some(orig_result), _) => Some((
+            orig_result.clone(),
+            wrap_str(orig_result, context.config.max_width(), shape).is_none(),
+        )),
         // This will only occur when the chain is part of the rhs and
         // will fit with an indent on the next line
         (None, Some(_)) => None,

src/config/options.rs

@@ -178,9 +178,13 @@ pub enum ChainsBlockParentElementIndent {
     /// Always indent the contents of a block-like parent element.
     Always,
     /// Only indent the contents of a block-like parent element if
-    /// it is call-like, such as a function call that does not include
+    /// it is a simple call-like, such as a function call that does not include
     /// any block-like arguments.
     OnlySimpleCalls,
+    /// Only indent the contents of a block-like parent element if
+    /// it is a tuple lit or a simple call-like, such as a function call that does not include
+    /// any block-like arguments.
+    OnlyTupleLitsAndSimpleCalls,
 }
 
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]

tests/source/chains_long_items_block.rs

@@ -54,5 +54,25 @@ fn long_tail() {
     bar().xxxxxxx.map(|x| x + 5).map(|x| x / 2).fold(0, |acc, x| acc + x).doooooooooooooooooooooooooooooooooooooooooooooooooooooo_stufffffffffffffffffffffffffffffffffffffff();
 
     let foo = bar().xxxxxxx.map(|x| x + 5).map(|x| x / 2).fold(0, |acc, x| acc + x).doooooooooooooooooooooooooooooooooooooooooooooooooooooo_stufffffffffffffffffffffffffffffffffffffff();
+}
 
+fn raw_str_lit() {
+    fpo.foo().bar.baz.quz.adfasdfasdfasdfasdfasdfasdfasffffffffffffffffffffffffffffffffffdfasf(r#"
+    if foo {
+        a();
+    }
+    else {
+        b();
+    }
+    "#.trim());
+
+
+    fpo.foo().bar.baz.quz.a999999999999999999999999999999999999999999999999999999999999999(r#"
+    if foo {
+        a();
+    }
+    else {
+        b();
+    }
+    "#.trim().foo().bar.baz.qux().unwrap());
 }

tests/source/chains_multiline_parent_tuples_and_simple_calls.rs

@@ -0,0 +1,33 @@
+// rustfmt-chains_block_parent_indent_children: true
+// rustfmt-chains_block_parent_indent_parent_item: OnlyTupleLitsAndSimpleCalls
+
+fn main() {
+    let very_very_very_very_very_very_very_very_very_long_var_name = 13;
+    let all = very_very_very_very_very_long_fun_name(
+        very_very_very_very_very_very_very_very_very_long_var_name,
+    )
+    .iter()
+    .map(|x| x + very_very_very_very_very_very_long_var_name);
+    StructA {
+        test_test: some_value,
+    }
+    .do_stuff(StructB {
+        test_test_b: other_value,
+    })
+    .aaa_aaa()
+    .do_stuff(StructB {
+        test_test_b: other_value,
+    }.ddd_ddd().eee_eee())
+    .bbb_bbb()
+    .ccc_ccc();
+    let more = 13;
+    let other = vec![1, 2, 3].iter()
+        .map(|x| x + very_very_very_very_very_very_long_var_name);
+
+            foo(|x| {
+        // ....
+    })
+    .bar()
+    .baz()
+    .unwrap()
+}

tests/target/chains_long_items_block.rs

@@ -143,3 +143,42 @@ fn long_tail() {
         .doooooooooooooooooooooooooooooooooooooooooooooooooooooo_stufffffffffffffffffffffffffffffffffffffff(
         );
 }
+
+fn raw_str_lit() {
+    fpo.foo()
+        .bar
+        .baz
+        .quz
+        .adfasdfasdfasdfasdfasdfasdfasffffffffffffffffffffffffffffffffffdfasf(
+            r#"
+    if foo {
+        a();
+    }
+    else {
+        b();
+    }
+    "#
+            .trim(),
+        );
+
+    fpo.foo()
+        .bar
+        .baz
+        .quz
+        .a999999999999999999999999999999999999999999999999999999999999999(
+            r#"
+    if foo {
+        a();
+    }
+    else {
+        b();
+    }
+    "#
+            .trim()
+            .foo()
+            .bar
+            .baz
+            .qux()
+            .unwrap(),
+        );
+}

tests/target/chains_multiline_parent_tuples_and_simple_calls.rs

@@ -0,0 +1,38 @@
+// rustfmt-chains_block_parent_indent_children: true
+// rustfmt-chains_block_parent_indent_parent_item: OnlyTupleLitsAndSimpleCalls
+
+fn main() {
+    let very_very_very_very_very_very_very_very_very_long_var_name = 13;
+    let all = very_very_very_very_very_long_fun_name(
+            very_very_very_very_very_very_very_very_very_long_var_name,
+        )
+        .iter()
+        .map(|x| x + very_very_very_very_very_very_long_var_name);
+    StructA {
+            test_test: some_value,
+        }
+        .do_stuff(StructB {
+            test_test_b: other_value,
+        })
+        .aaa_aaa()
+        .do_stuff(
+            StructB {
+                    test_test_b: other_value,
+                }
+                .ddd_ddd()
+                .eee_eee(),
+        )
+        .bbb_bbb()
+        .ccc_ccc();
+    let more = 13;
+    let other = vec![1, 2, 3]
+        .iter()
+        .map(|x| x + very_very_very_very_very_very_long_var_name);
+
+    foo(|x| {
+        // ....
+    })
+        .bar()
+        .baz()
+        .unwrap()
+}