Prohibit long return val from 'rewrite_closure_block'

src/expr.rs

@@ -172,9 +172,8 @@ fn format_expr(expr: &ast::Expr,
         ast::ExprKind::Mac(ref mac) => {
             // Failure to rewrite a marco should not imply failure to
             // rewrite the expression.
-            rewrite_macro(mac, None, context, shape, MacroPosition::Expression).or_else(|| {
-                wrap_str(context.snippet(expr.span), context.config.max_width, shape)
-            })
+            rewrite_macro(mac, None, context, shape, MacroPosition::Expression)
+                .or_else(|| wrap_str(context.snippet(expr.span), context.config.max_width, shape))
         }
         ast::ExprKind::Ret(None) => wrap_str("return".to_owned(), context.config.max_width, shape),
         ast::ExprKind::Ret(Some(ref expr)) => {
@@ -576,14 +575,18 @@ fn rewrite_closure_block(block: &ast::Block,
 
         let block_threshold = context.config.closure_block_indent_threshold;
         if block_threshold < 0 || rewrite.matches('\n').count() <= block_threshold as usize {
-            return Some(format!("{} {}", prefix, rewrite));
+            if let Some(rewrite) = wrap_str(rewrite, context.config.max_width, shape) {
+                return Some(format!("{} {}", prefix, rewrite));
+            }
         }
 
         // The body of the closure is big enough to be block indented, that
         // means we must re-format.
         let block_shape = shape.block();
         let rewrite = try_opt!(block.rewrite(&context, block_shape));
-        Some(format!("{} {}", prefix, rewrite))
+        Some(format!("{} {}",
+                     prefix,
+                     try_opt!(wrap_str(rewrite, block_shape.width, block_shape))))
     }
 }
 

src/file_lines.rs

@@ -194,9 +194,8 @@ impl JsonSpan {
     // To allow `collect()`ing into a `MultiMap`.
     fn into_tuple(self) -> Result<(String, Range), String> {
         let (lo, hi) = self.range;
-        let canonical = try!(canonicalize_path_string(&self.file).map_err(|_| {
-            format!("Can't canonicalize {}", &self.file)
-        }));
+        let canonical = try!(canonicalize_path_string(&self.file)
+                                 .map_err(|_| format!("Can't canonicalize {}", &self.file)));
         Ok((canonical, Range::new(lo, hi)))
     }
 }

src/items.rs

@@ -1326,12 +1326,13 @@ pub fn rewrite_associated_type(ident: ast::Ident,
 
     let type_bounds_str = if let Some(ty_param_bounds) = ty_param_bounds_opt {
         let bounds: &[_] = ty_param_bounds;
-        let bound_str = try_opt!(bounds.iter()
-            .map(|ty_bound| {
-                ty_bound.rewrite(context, Shape::legacy(context.config.max_width, indent))
-            })
-            .intersperse(Some(" + ".to_string()))
-            .collect::<Option<String>>());
+        let bound_str = try_opt!(bounds
+                                     .iter()
+                                     .map(|ty_bound| {
+            ty_bound.rewrite(context, Shape::legacy(context.config.max_width, indent))
+        })
+                                     .intersperse(Some(" + ".to_string()))
+                                     .collect::<Option<String>>());
         if bounds.len() > 0 {
             format!(": {}", bound_str)
         } else {

src/macros.rs

@@ -146,12 +146,11 @@ pub fn rewrite_macro(mac: &ast::Mac,
         MacroStyle::Parens => {
             // Format macro invocation as function call, forcing no trailing
             // comma because not all macros support them.
-            rewrite_call(context, &macro_name, &expr_vec, mac.span, shape, true).map(|rw| {
-                match position {
-                    MacroPosition::Item => format!("{};", rw),
-                    _ => rw,
-                }
-            })
+            rewrite_call(context, &macro_name, &expr_vec, mac.span, shape, true)
+                .map(|rw| match position {
+                         MacroPosition::Item => format!("{};", rw),
+                         _ => rw,
+                     })
         }
         MacroStyle::Brackets => {
             // Format macro invocation as array literal.