rewrite_string: retain blank lines that are trailing

[rust.git] / src / chains.rs

diff --git a/src/chains.rs b/src/chains.rs
index 3acb8e2eac31b72bda951997a2e90af227e0508b..b7619c0a18af49a65bee7bc253211cad1d9817fe 100644 (file)
--- a/src/chains.rs
+++ b/src/chains.rs
@@ -80,7 +80,6 @@
 
 use std::borrow::Cow;
 use std::cmp::min;
-use std::iter;
 
 use syntax::source_map::{BytePos, Span};
 use syntax::{ast, ptr};
@@ -132,8 +131,8 @@ impl ChainItemKind {
     fn is_block_like(&self, context: &RewriteContext, reps: &str) -> bool {
         match self {
             ChainItemKind::Parent(ref expr) => is_block_expr(context, expr, reps),
-            ChainItemKind::MethodCall(..) => reps.contains('\n'),
-            ChainItemKind::StructField(..)
+            ChainItemKind::MethodCall(..)
+            | ChainItemKind::StructField(..)
             | ChainItemKind::TupleField(..)
             | ChainItemKind::Comment(..) => false,
         }
@@ -559,7 +558,8 @@ fn format_last_child(
             shape.width
         } else {
             min(shape.width, context.config.width_heuristics().chain_width)
-        }.saturating_sub(almost_total);
+        }
+        .saturating_sub(almost_total);
 
         let all_in_one_line = !self.children.iter().any(ChainItem::is_comment)
             && self.rewrites.iter().all(|s| !s.contains('\n'))
@@ -576,7 +576,15 @@ fn format_last_child(
         if all_in_one_line || extendable {
             // First we try to 'overflow' the last child and see if it looks better than using
             // vertical layout.
-            if let Some(one_line_shape) = last_shape.offset_left(almost_total) {
+            let one_line_shape = if context.use_block_indent() {
+                last_shape.offset_left(almost_total)
+            } else {
+                last_shape
+                    .visual_indent(almost_total)
+                    .sub_width(almost_total)
+            };
+
+            if let Some(one_line_shape) = one_line_shape {
                 if let Some(rw) = last.rewrite(context, one_line_shape) {
                     // We allow overflowing here only if both of the following conditions match:
                     // 1. The entire chain fits in a single line except the last child.
@@ -614,17 +622,18 @@ fn format_last_child(
             }
         }
 
+        let last_shape = if context.use_block_indent() {
+            last_shape
+        } else {
+            child_shape.sub_width(shape.rhs_overhead(context.config) + last.tries)?
+        };
+
         last_subexpr_str = last_subexpr_str.or_else(|| last.rewrite(context, last_shape));
         self.rewrites.push(last_subexpr_str?);
         Some(())
     }
 
-    fn join_rewrites(
-        &self,
-        context: &RewriteContext,
-        child_shape: Shape,
-        block_like_iter: impl Iterator<Item = bool>,
-    ) -> Option<String> {
+    fn join_rewrites(&self, context: &RewriteContext, child_shape: Shape) -> Option<String> {
         let connector = if self.fits_single_line {
             // Yay, we can put everything on one line.
             Cow::from("")
@@ -639,17 +648,13 @@ fn join_rewrites(
         let mut rewrite_iter = self.rewrites.iter();
         let mut result = rewrite_iter.next().unwrap().clone();
         let children_iter = self.children.iter();
-        let iter = rewrite_iter.zip(block_like_iter).zip(children_iter);
+        let iter = rewrite_iter.zip(children_iter);
 
-        for ((rewrite, prev_is_block_like), chain_item) in iter {
+        for (rewrite, chain_item) in iter {
             match chain_item.kind {
                 ChainItemKind::Comment(_, CommentPosition::Back) => result.push(' '),
                 ChainItemKind::Comment(_, CommentPosition::Top) => result.push_str(&connector),
-                _ => {
-                    if !prev_is_block_like {
-                        result.push_str(&connector);
-                    }
-                }
+                _ => result.push_str(&connector),
             }
             result.push_str(&rewrite);
         }
@@ -661,15 +666,14 @@ fn join_rewrites(
 // Formats a chain using block indent.
 struct ChainFormatterBlock<'a> {
     shared: ChainFormatterShared<'a>,
-    // For each rewrite, whether the corresponding item is block-like.
-    is_block_like: Vec<bool>,
+    root_ends_with_block: bool,
 }
 
 impl<'a> ChainFormatterBlock<'a> {
     fn new(chain: &'a Chain) -> ChainFormatterBlock<'a> {
         ChainFormatterBlock {
             shared: ChainFormatterShared::new(chain),
-            is_block_like: Vec::with_capacity(chain.children.len() + 1),
+            root_ends_with_block: false,
         }
     }
 }
@@ -697,33 +701,32 @@ fn format_root(
                 None => break,
             }
 
-            root_ends_with_block = item.kind.is_block_like(context, &root_rewrite);
+            root_ends_with_block = last_line_extendable(&root_rewrite);
 
             self.shared.children = &self.shared.children[1..];
             if self.shared.children.is_empty() {
                 break;
             }
         }
-        self.is_block_like.push(root_ends_with_block);
         self.shared.rewrites.push(root_rewrite);
+        self.root_ends_with_block = root_ends_with_block;
         Some(())
     }
 
     fn child_shape(&self, context: &RewriteContext, shape: Shape) -> Option<Shape> {
         Some(
-            if self.is_block_like[0] {
+            if self.root_ends_with_block {
                 shape.block_indent(0)
             } else {
                 shape.block_indent(context.config.tab_spaces())
-            }.with_max_width(context.config),
+            }
+            .with_max_width(context.config),
         )
     }
 
     fn format_children(&mut self, context: &RewriteContext, child_shape: Shape) -> Option<()> {
         for item in &self.shared.children[..self.shared.children.len() - 1] {
             let rewrite = item.rewrite(context, child_shape)?;
-            self.is_block_like
-                .push(item.kind.is_block_like(context, &rewrite));
             self.shared.rewrites.push(rewrite);
         }
         Some(())
@@ -740,8 +743,7 @@ fn format_last_child(
     }
 
     fn join_rewrites(&self, context: &RewriteContext, child_shape: Shape) -> Option<String> {
-        self.shared
-            .join_rewrites(context, child_shape, self.is_block_like.iter().cloned())
+        self.shared.join_rewrites(context, child_shape)
     }
 
     fn pure_root(&mut self) -> Option<String> {
@@ -835,8 +837,7 @@ fn format_last_child(
     }
 
     fn join_rewrites(&self, context: &RewriteContext, child_shape: Shape) -> Option<String> {
-        self.shared
-            .join_rewrites(context, child_shape, iter::repeat(false))
+        self.shared.join_rewrites(context, child_shape)
     }
 
     fn pure_root(&mut self) -> Option<String> {
@@ -851,6 +852,7 @@ fn is_block_expr(context: &RewriteContext, expr: &ast::Expr, repr: &str) -> bool
         ast::ExprKind::Mac(..)
         | ast::ExprKind::Call(..)
         | ast::ExprKind::MethodCall(..)
+        | ast::ExprKind::Array(..)
         | ast::ExprKind::Struct(..)
         | ast::ExprKind::While(..)
         | ast::ExprKind::WhileLet(..)