refactor: add chain child indent options

Author: calebcartwright

Configurations.md

@@ -390,44 +390,98 @@ fn example() {
 ```
 
 ## `chains_block_parent_indent_children`
-Determines whether to indent the child chain items of a chain that beings with a block-like parent element when `indent_style` is `Block`.
+Determines whether to indent the child chain items of a chain that begins with a block-like parent element when `indent_style` is `Block`.
 
-- **Default value**: `false`
-- **Possible values**: `true`, `false`
+- **Default value**: `"OnlyWithParent"`
+- **Possible values**: `"Always"`, `"OnlyWithParent"`
 - **Stable**: No (tracking issue: ...)
 
-#### `false` (default):
+#### `OnlyWithParent` (default):
+Only indent the children chain elements of a block-like parent element if the parent's body was indented.
 
 ```rust
+// chains_block_parent_indent_parent_item: "OnlyTupleLitsAndSimpleCalls"
+#![rustfmt::skip]
 fn example() {
-    StructA {
-        test_test: some_value,
-    }
-    .foo()
+    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);
+      
+    foo(|x| {
+        // ....
+    })
     .bar()
     .baz()
-    .qux();
+    .unwrap();
+  
+    StructA {
+            test_test: some_value,
+        }
+        .do_stuff(StructB {
+            test_test_b: other_value,
+        })
+        .foo()
+        .aaa_aaa();
+
+    let y = if some_condition {
+        // foo
+        val1
+    } else {
+        // bar
+        val2
+    }
+    .method_call()
+    .other_call()
+    .another();
 }
 ```
 
-#### `true`:
+#### `Always`:
+Always indent the children chain elements of a block-like parent element, regardless of whether the parent element body was indented.
 
 ```rust
 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);
+
+    foo(|x| {
+        // ....
+    })
+        .bar()
+        .baz()
+        .unwrap();
+
     StructA {
         test_test: some_value,
     }
+        .do_stuff(StructB {
+            test_test_b: other_value,
+        })
         .foo()
-        .bar()
-        .baz()
-        .qux();
+        .aaa_aaa();
+
+    let y = if some_condition {
+        // foo
+        val1
+    } else {
+        // bar
+        val2
+    }
+        .method_call()
+        .other_call()
+        .another();
 }
 ```
 
-See also: [`indent_style`](#indent_style).
+See also: [`indent_style`](#indent_style), [`chains_block_parent_indent_parent_item`](#chains_block_parent_indent_parent_item).
 
 ## `chains_block_parent_indent_parent_item`
-Determines whether block-like chain parents are indented when `indent_style` is `Block`.
+Determines whether the body of block-like chain parents are indented when `indent_style` is `Block`.
 
 - **Default value**: `"Never"`
 - **Possible values**: `"Always"`, `"Never"`, `"OnlySimpleCalls"`, `"OnlyTupleLitsAndSimpleCalls"`
@@ -475,9 +529,6 @@ fn example() {
 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,
@@ -501,7 +552,7 @@ fn example() {
         )
         .bbb_bbb()
         .ccc_ccc();
-        
+
     foo(|x| {
             // ....
         })
@@ -515,9 +566,6 @@ fn example() {
 The body of block-like parent chain elements are only indented when the parent is a simple call-like chain item, such as a method call with no multiline block like arguments (like a closure).
 
 ```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,
@@ -528,36 +576,33 @@ fn example() {
     StructA {
         test_test: some_value,
     }
-        .do_stuff(StructB {
+    .do_stuff(StructB {
+        test_test_b: other_value,
+    })
+    .aaa_aaa()
+    .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();
+        }
+        .ddd_ddd()
+        .eee_eee(),
+    )
+    .bbb_bbb()
+    .ccc_ccc();
 
     foo(|x| {
         // ....
     })
-        .bar()
-        .baz()
-        .unwrap();
+    .bar()
+    .baz()
+    .unwrap();
 }
 ```
 
 #### `"OnlyTupleLitsAndSimpleCalls"`:
 The body of block-like parent chain elements are only indented when the parent is a tuple literal, or a simple call-like chain item, such as a method call with no multiline block like arguments (like a closure).
 
 ```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,
@@ -585,9 +630,9 @@ fn example() {
     foo(|x| {
         // ....
     })
-        .bar()
-        .baz()
-        .unwrap();
+    .bar()
+    .baz()
+    .unwrap();
 }
 ```
 

src/chains.rs

@@ -63,7 +63,7 @@ use syntax::{ast, ptr};
 
 use crate::closures::rewrite_closure;
 use crate::comment::{rewrite_comment, CharClasses, FullCodeCharKind, RichChar};
-use crate::config::{ChainsBlockParentElementIndent, IndentStyle};
+use crate::config::{ChainsBlockParentChildrenIndent, ChainsBlockParentElementIndent, IndentStyle};
 use crate::expr::rewrite_call;
 use crate::lists::extract_pre_comment;
 use crate::macros::convert_try_mac;
@@ -924,12 +924,16 @@ impl<'a> ChainFormatter for ChainFormatterBlock<'a> {
     }
 
     fn child_shape(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<Shape> {
-        let always_indent_children = context.config.chains_block_parent_indent_children();
+        let indent_style = context.config.chains_block_parent_indent_children();
+        let use_indented = match indent_style {
+            ChainsBlockParentChildrenIndent::Always => true,
+            ChainsBlockParentChildrenIndent::OnlyWithParent if self.parent_body_forced_indent => {
+                true
+            }
+            _ => false,
+        };
         Some(
-            if !self.root_ends_with_block
-                || always_indent_children
-                || self.parent_body_forced_indent
-            {
+            if !self.root_ends_with_block || use_indented {
                 shape.block_indent(context.config.tab_spaces())
             } else {
                 shape.block_indent(0)
@@ -974,7 +978,6 @@ impl<'a> ChainFormatter for ChainFormatterBlock<'a> {
             Some(rewrite) => wrap_str(rewrite, context.config.max_width(), shape),
             None => None,
         }
-        // self.shared.join_rewrites(context, child_shape)
     }
 
     fn pure_root(&mut self) -> Option<String> {

src/config/mod.rs

@@ -66,7 +66,10 @@ create_config! {
     merge_imports: bool, false, false, "Merge imports";
 
     // Chains
-    chains_block_parent_indent_children: bool, false, false,
+    chains_block_parent_indent_children:
+        ChainsBlockParentChildrenIndent,
+        ChainsBlockParentChildrenIndent::OnlyWithParent,
+        false,
         "Determines whether to indent the child chain items of a chain that beings with/
         a block-like parent element";
     chains_block_parent_indent_parent_item:
@@ -519,7 +522,7 @@ where_single_line = false
 imports_indent = "Block"
 imports_layout = "Mixed"
 merge_imports = false
-chains_block_parent_indent_children = false
+chains_block_parent_indent_children = "OnlyWithParent"
 chains_block_parent_indent_parent_item = "Never"
 reorder_imports = true
 reorder_modules = true

src/config/options.rs

@@ -187,6 +187,14 @@ pub enum ChainsBlockParentElementIndent {
     OnlyTupleLitsAndSimpleCalls,
 }
 
+#[config_type]
+pub enum ChainsBlockParentChildrenIndent {
+    /// Always indent the children chain elements of a block-like parent element.
+    Always,
+    /// Only indent the children chain elements if the block-like parent body is indented.
+    OnlyWithParent,
+}
+
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
 pub struct WidthHeuristics {
     // Maximum width of the args of a function call before falling back