feat: support wrapping call chains with long elements

Author: calebcartwright

Configurations.md

@@ -17,6 +17,34 @@ To enable unstable options, set `unstable_features = true` in `rustfmt.toml` or
 
 Below you find a detailed visual guide on all the supported configuration options of rustfmt:
 
+## `allow_chain_call_overflow`
+
+Wrap elements of a call chain even if one or more lines exceed the `max_width`
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: ...)
+
+#### `false` (default):
+
+```rust
+fn example() {
+    foo("This text is under the max_width limit, and shouldn't cause any problems on its own.").long("But this line is extra long, and doesn't fit within 100 max_width. 1234567890123456789").baz().collect().unwrap();
+}
+```
+
+#### `true`:
+
+```rust
+fn example() {
+    foo("This text is under the max_width limit, and shouldn't cause any problems on its own.")
+        .long("But this line is extra long, and doesn't fit within 100 max_width. 1234567890123456789")
+        .baz()
+        .collect()
+        .unwrap();
+}
+```
+
 
 ## `binop_separator`
 

src/chains.rs

@@ -413,12 +413,8 @@ impl Chain {
             _ => expr.clone(),
         }
     }
-}
-
-impl Rewrite for Chain {
-    fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
-        debug!("rewrite chain {:?} {:?}", self, shape);
 
+    fn format(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
         let mut formatter = match context.config.indent_style() {
             IndentStyle::Block => {
                 Box::new(ChainFormatterBlock::new(self)) as Box<dyn ChainFormatter>
@@ -439,8 +435,39 @@ impl Rewrite for Chain {
         formatter.format_children(context, child_shape)?;
         formatter.format_last_child(context, shape, child_shape)?;
 
-        let result = formatter.join_rewrites(context, child_shape)?;
-        wrap_str(result, context.config.max_width(), shape)
+        formatter.join_rewrites(context, child_shape)
+    }
+}
+
+impl Rewrite for Chain {
+    fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+        debug!("rewrite chain {:?} {:?}", self, shape);
+
+        let result = self.format(context, shape)?;
+        if context.config.allow_chain_call_overflow() {
+            match context.config.indent_style() {
+                IndentStyle::Block => Some(result),
+                IndentStyle::Visual => match wrap_str(result, context.config.max_width(), shape) {
+                    Some(r) => Some(r),
+                    None => {
+                        let new_shape = Shape::indented(
+                            shape.indent.block_indent(context.config),
+                            context.config,
+                        );
+                        if let Some(result) = self.format(context, new_shape) {
+                            let prefix = shape
+                                .indent
+                                .block_indent(context.config)
+                                .to_string_with_newline(context.config);
+                            return Some(format!("{}{}", prefix, result));
+                        }
+                        None
+                    }
+                },
+            }
+        } else {
+            wrap_str(result, context.config.max_width(), shape)
+        }
     }
 }
 
@@ -693,7 +720,13 @@ impl<'a> ChainFormatter for ChainFormatterBlock<'a> {
         context: &RewriteContext<'_>,
         shape: Shape,
     ) -> Option<()> {
-        let mut root_rewrite: String = parent.rewrite(context, shape)?;
+        let mut root_rewrite = if context.config.allow_chain_call_overflow() {
+            parent
+                .rewrite(context, shape)
+                .unwrap_or_else(|| context.snippet(parent.span).to_owned())
+        } else {
+            parent.rewrite(context, shape)?
+        };
 
         let mut root_ends_with_block = parent.kind.is_block_like(context, &root_rewrite);
         let tab_width = context.config.tab_spaces().saturating_sub(shape.offset);
@@ -733,8 +766,14 @@ impl<'a> ChainFormatter for ChainFormatterBlock<'a> {
     }
 
     fn format_children(&mut self, context: &RewriteContext<'_>, child_shape: Shape) -> Option<()> {
+        let allow_chain_call_overflow = context.config.allow_chain_call_overflow();
         for item in &self.shared.children[..self.shared.children.len() - 1] {
-            let rewrite = item.rewrite(context, child_shape)?;
+            let rewrite = if allow_chain_call_overflow {
+                item.rewrite(context, child_shape)
+                    .unwrap_or_else(|| context.snippet(item.span).to_owned())
+            } else {
+                item.rewrite(context, child_shape)?
+            };
             self.shared.rewrites.push(rewrite);
         }
         Some(())
@@ -827,8 +866,14 @@ impl<'a> ChainFormatter for ChainFormatterVisual<'a> {
     }
 
     fn format_children(&mut self, context: &RewriteContext<'_>, child_shape: Shape) -> Option<()> {
+        let allow_chain_call_overflow = context.config.allow_chain_call_overflow();
         for item in &self.shared.children[..self.shared.children.len() - 1] {
-            let rewrite = item.rewrite(context, child_shape)?;
+            let rewrite = if allow_chain_call_overflow {
+                item.rewrite(context, child_shape)
+                    .unwrap_or_else(|| context.snippet(item.span).to_owned())
+            } else {
+                item.rewrite(context, child_shape)?
+            };
             self.shared.rewrites.push(rewrite);
         }
         Some(())

src/config/mod.rs

@@ -112,6 +112,8 @@ create_config! {
     inline_attribute_width: usize, 0, false,
         "Write an item and its attribute on the same line \
         if their combined width is below a threshold";
+    allow_chain_call_overflow: bool, false, false,
+        "Format chains even if it includes a chain call which exceeds the max width";
 
     // Options that can change the source code beyond whitespace/blocks (somewhat linty things)
     merge_derives: bool, true, true, "Merge multiple `#[derive(...)]` into a single one";
@@ -532,6 +534,7 @@ blank_lines_lower_bound = 0
 edition = "2015"
 version = "One"
 inline_attribute_width = 0
+allow_chain_call_overflow = false
 merge_derives = true
 use_try_shorthand = false
 use_field_init_shorthand = false

src/expr.rs

@@ -1957,7 +1957,11 @@ fn choose_rhs<R: Rewrite>(
                     if wrap_str(new_rhs.clone(), context.config.max_width(), new_shape)
                         .is_none() =>
                 {
-                    Some(format!("{}{}", before_space_str, orig_rhs))
+                    let prefix = if orig_rhs.starts_with('\n') || has_rhs_comment {
+                        ""
+                    } else {
+                        " "
+                    };
                 }
                 (Some(ref orig_rhs), Some(ref new_rhs))
                     if prefer_next_line(orig_rhs, new_rhs, rhs_tactics) =>
@@ -1971,7 +1975,14 @@ fn choose_rhs<R: Rewrite>(
                         .map(|s| format!("{}{}", before_space_str, s))
                 }
                 (None, None) => None,
-                (Some(orig_rhs), _) => Some(format!("{}{}", before_space_str, orig_rhs)),
+                (Some(orig_rhs), _) => {
+                    let prefix = if orig_rhs.starts_with('\n') || has_rhs_comment {
+                        ""
+                    } else {
+                        " "
+                    };
+                    Some(format!("{}{}", prefix, orig_rhs))
+                }
             }
         }
     }

tests/source/chains_long_calls.rs

@@ -0,0 +1,5 @@
+// rustfmt-allow_chain_call_overflow: true
+// https://github.com/rust-lang/rustfmt/issues/3863
+fn f() {
+    foo("This text is under the max_width limit, and shouldn't cause any problems on its own.").long("But this line is extra long, and doesn't fit within 100 max_width. 1234567890123456789 aBcDeFgHiJ").baz().collect().unwrap();
+}

tests/target/chains_long_calls.rs

@@ -0,0 +1,9 @@
+// rustfmt-allow_chain_call_overflow: true
+// https://github.com/rust-lang/rustfmt/issues/3863
+fn f() {
+    foo("This text is under the max_width limit, and shouldn't cause any problems on its own.")
+        .long("But this line is extra long, and doesn't fit within 100 max_width. 1234567890123456789 aBcDeFgHiJ")
+        .baz()
+        .collect()
+        .unwrap();
+}