Overflow the last rhs of a 'simple' binary expr

Author: topecongiro

src/expr.rs

@@ -50,6 +50,18 @@ pub enum ExprType {
     SubExpression,
 }
 
+fn is_nested_binary(context: &RewriteContext, expr: &ast::Expr) -> bool {
+    if let ast::ExprKind::Binary(op, ..) = expr.node {
+        if let Some(upper_op) = *context.upper_binop.borrow() {
+            op.node == upper_op
+        } else {
+            false
+        }
+    } else {
+        false
+    }
+}
+
 pub fn format_expr(
     expr: &ast::Expr,
     expr_type: ExprType,
@@ -62,6 +74,9 @@ pub fn format_expr(
         return Some(context.snippet(expr.span()).to_owned());
     }
 
+    let is_nested_binary = is_nested_binary(context, expr);
+    context.set_upper_binop(expr);
+
     let expr_rw = match expr.node {
         ast::ExprKind::Array(ref expr_vec) => rewrite_array(
             &ptr_vec_to_ref_vec(expr_vec),
@@ -89,6 +104,7 @@ pub fn format_expr(
                 context,
                 shape,
                 context.config.binop_separator(),
+                is_nested_binary,
             )
         }
         ast::ExprKind::Unary(ref op, ref subexpr) => rewrite_unary_op(context, op, subexpr, shape),
@@ -201,6 +217,7 @@ pub fn format_expr(
             context,
             shape,
             SeparatorPlace::Front,
+            false,
         ),
         ast::ExprKind::Type(ref expr, ref ty) => rewrite_pair(
             &**expr,
@@ -209,6 +226,7 @@ pub fn format_expr(
             context,
             shape,
             SeparatorPlace::Back,
+            false,
         ),
         ast::ExprKind::Index(ref expr, ref index) => {
             rewrite_index(&**expr, &**index, context, shape)
@@ -226,6 +244,7 @@ pub fn format_expr(
                 context,
                 shape,
                 SeparatorPlace::Back,
+                false,
             )
         }
         ast::ExprKind::Range(ref lhs, ref rhs, limits) => {
@@ -262,6 +281,7 @@ pub fn format_expr(
                         context,
                         shape,
                         context.config.binop_separator(),
+                        false,
                     )
                 }
                 (None, Some(rhs)) => {
@@ -323,17 +343,34 @@ pub struct PairParts<'a> {
     suffix: &'a str,
 }
 
+/// Returns true if the given expression is a chain with 0 or more prefixes or
+/// suffixes (e.g. `&x.y`, `x.y.z()?` or `x.0 as usize`).
+fn is_chain(expr: &ast::Expr) -> bool {
+    match expr.node {
+        ast::ExprKind::AddrOf(_, ref expr)
+        | ast::ExprKind::Box(ref expr)
+        | ast::ExprKind::Try(ref expr)
+        | ast::ExprKind::Unary(_, ref expr)
+        | ast::ExprKind::Cast(ref expr, _) => is_chain(expr),
+        ast::ExprKind::MethodCall(..) | ast::ExprKind::Field(..) | ast::ExprKind::TupField(..) => {
+            true
+        }
+        _ => false,
+    }
+}
+
 pub fn rewrite_pair<LHS, RHS>(
     lhs: &LHS,
     rhs: &RHS,
     pp: PairParts,
     context: &RewriteContext,
     shape: Shape,
     separator_place: SeparatorPlace,
+    is_nested_binary: bool,
 ) -> Option<String>
 where
     LHS: Rewrite,
-    RHS: Rewrite,
+    RHS: ToExpr + Rewrite,
 {
     let lhs_overhead = match separator_place {
         SeparatorPlace::Back => shape.used_width() + pp.prefix.len() + pp.infix.trim_right().len(),
@@ -392,6 +429,20 @@ where
         rhs_shape = rhs_shape.offset_left(infix.len())?;
     }
     let rhs_result = rhs.rewrite(context, rhs_shape)?;
+    // Put the rhs on the same line as the lhs if:
+    // 1. it is not inside the other binary expression
+    // 2. the lhs fits in a single line
+    // 3. putting the rhs on the next line needs multiple lines as well
+    if !is_nested_binary && !lhs_result.contains('\n') && rhs_result.contains('\n') {
+        if let Some(ref orig_rhs_result) = rhs_orig_result {
+            if rhs.to_expr().map_or(false, is_chain) {
+                return Some(format!(
+                    "{}{}{}{}",
+                    lhs_result, pp.infix, orig_rhs_result, pp.suffix
+                ));
+            }
+        }
+    }
     let indent_str = rhs_shape.indent.to_string_with_newline(context.config);
     let infix_with_sep = match separator_place {
         SeparatorPlace::Back => format!("{}{}", infix, indent_str),

src/patterns.rs

@@ -78,6 +78,7 @@ impl Rewrite for Pat {
                     context,
                     shape,
                     SeparatorPlace::Front,
+                    false,
                 )
             }
             PatKind::Ref(ref pat, mutability) => {

src/rewrite.rs

@@ -10,13 +10,16 @@
 
 // A generic trait to abstract the rewriting of an element (of the AST).
 
+use syntax::ast;
 use syntax::codemap::{CodeMap, Span};
 use syntax::parse::ParseSess;
 
 use config::{Config, IndentStyle};
 use shape::Shape;
 use visitor::SnippetProvider;
 
+use std::cell::RefCell;
+
 pub trait Rewrite {
     /// Rewrite self into shape.
     fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String>;
@@ -36,6 +39,8 @@ pub struct RewriteContext<'a> {
     // When rewriting chain, veto going multi line except the last element
     pub force_one_line_chain: bool,
     pub snippet_provider: &'a SnippetProvider<'a>,
+    // Holds a binary operator of the parent AST node if is a binary expression.
+    pub upper_binop: RefCell<Option<ast::BinOpKind>>,
 }
 
 impl<'a> RewriteContext<'a> {
@@ -51,4 +56,12 @@ impl<'a> RewriteContext<'a> {
     pub fn budget(&self, used_width: usize) -> usize {
         self.config.max_width().checked_sub(used_width).unwrap_or(0)
     }
+
+    pub fn set_upper_binop(&self, expr: &ast::Expr) {
+        if let ast::ExprKind::Binary(op, ..) = expr.node {
+            self.upper_binop.replace(Some(op.node));
+        } else {
+            self.upper_binop.replace(None);
+        }
+    }
 }

src/types.rs

@@ -708,6 +708,7 @@ impl Rewrite for ast::Ty {
                     context,
                     shape,
                     SeparatorPlace::Back,
+                    false,
                 )
             }
             ast::TyKind::Infer => {

src/visitor.rs

@@ -26,6 +26,8 @@ use shape::{Indent, Shape};
 use spanned::Spanned;
 use utils::{self, contains_skip, count_newlines, inner_attributes, mk_sp, ptr_vec_to_ref_vec};
 
+use std::cell::RefCell;
+
 /// Creates a string slice corresponding to the specified span.
 pub struct SnippetProvider<'a> {
     /// A pointer to the content of the file we are formatting.
@@ -695,6 +697,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
             is_if_else_block: false,
             force_one_line_chain: false,
             snippet_provider: self.snippet_provider,
+            upper_binop: RefCell::new(None),
         }
     }
 }