Merge pull request #3129 from otavio/issue-3104

[rust.git] / src / chains.rs

diff --git a/src/chains.rs b/src/chains.rs
index 56bd8574fc9dde1c9ab6b08609980d1fa5d97474..be38300619641dee0ff06d0adae036ffe8d4b9f6 100644 (file)
--- a/src/chains.rs
+++ b/src/chains.rs
@@ -74,7 +74,7 @@
 use shape::Shape;
 use source_map::SpanUtils;
 use utils::{
-    first_line_width, last_line_extendable, last_line_width, mk_sp, rewrite_ident,
+    self, first_line_width, last_line_extendable, last_line_width, mk_sp, rewrite_ident,
     trimmed_last_line_width, wrap_str,
 };
 
@@ -130,7 +130,7 @@ enum ChainItemKind {
 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::Parent(ref expr) => utils::is_block_expr(context, expr, reps),
             ChainItemKind::MethodCall(..)
             | ChainItemKind::StructField(..)
             | ChainItemKind::TupleField(..)
@@ -447,7 +447,7 @@ trait ChainFormatter {
     // Parent is the first item in the chain, e.g., `foo` in `foo.bar.baz()`.
     // Root is the parent plus any other chain items placed on the first line to
     // avoid an orphan. E.g.,
-    // ```
+    // ```ignore
     // foo.bar
     //     .baz()
     // ```
@@ -509,7 +509,7 @@ fn pure_root(&mut self) -> Option<String> {
     // know whether 'overflowing' the last child make a better formatting:
     //
     // A chain with overflowing the last child:
-    // ```
+    // ```ignore
     // parent.child1.child2.last_child(
     //     a,
     //     b,
@@ -518,7 +518,7 @@ fn pure_root(&mut self) -> Option<String> {
     // ```
     //
     // A chain without overflowing the last child (in vertical layout):
-    // ```
+    // ```ignore
     // parent
     //     .child1
     //     .child2
@@ -527,7 +527,7 @@ fn pure_root(&mut self) -> Option<String> {
     //
     // In particular, overflowing is effective when the last child is a method with a multi-lined
     // block-like argument (e.g. closure):
-    // ```
+    // ```ignore
     // parent.child1.child2.last_child(|a, b, c| {
     //     let x = foo(a, b, c);
     //     let y = bar(a, b, c);
@@ -558,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'))
@@ -575,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.
@@ -710,7 +719,8 @@ fn child_shape(&self, context: &RewriteContext, shape: Shape) -> Option<Shape> {
                 shape.block_indent(0)
             } else {
                 shape.block_indent(context.config.tab_spaces())
-            }.with_max_width(context.config),
+            }
+            .with_max_width(context.config),
         )
     }
 
@@ -835,37 +845,6 @@ fn pure_root(&mut self) -> Option<String> {
     }
 }
 
-// States whether an expression's last line exclusively consists of closing
-// parens, braces, and brackets in its idiomatic formatting.
-fn is_block_expr(context: &RewriteContext, expr: &ast::Expr, repr: &str) -> bool {
-    match expr.node {
-        ast::ExprKind::Mac(..)
-        | ast::ExprKind::Call(..)
-        | ast::ExprKind::MethodCall(..)
-        | ast::ExprKind::Struct(..)
-        | ast::ExprKind::While(..)
-        | ast::ExprKind::WhileLet(..)
-        | ast::ExprKind::If(..)
-        | ast::ExprKind::IfLet(..)
-        | ast::ExprKind::Block(..)
-        | ast::ExprKind::Loop(..)
-        | ast::ExprKind::ForLoop(..)
-        | ast::ExprKind::Match(..) => repr.contains('\n'),
-        ast::ExprKind::Paren(ref expr)
-        | ast::ExprKind::Binary(_, _, ref expr)
-        | ast::ExprKind::Index(_, ref expr)
-        | ast::ExprKind::Unary(_, ref expr)
-        | ast::ExprKind::Closure(_, _, _, _, ref expr, _)
-        | ast::ExprKind::Try(ref expr)
-        | ast::ExprKind::Yield(Some(ref expr)) => is_block_expr(context, expr, repr),
-        // This can only be a string lit
-        ast::ExprKind::Lit(_) => {
-            repr.contains('\n') && trimmed_last_line_width(repr) <= context.config.tab_spaces()
-        }
-        _ => false,
-    }
-}
-
 /// Remove try operators (`?`s) that appear in the given string. If removing
 /// them leaves an empty line, remove that line as well unless it is the first
 /// line (we need the first newline for detecting pre/post comment).