Source formatting fallout

13 files changed, 101 insertions, 73 deletions

diff --git a/src/bin/cargo-fmt.rs b/src/bin/cargo-fmt.rs
index ceb6af93825..bd52f11bbef 100644
--- a/src/bin/cargo-fmt.rs
+++ b/src/bin/cargo-fmt.rs
@@ -96,7 +96,8 @@ fn format_crate(verbosity: Verbosity) -> Result<ExitStatus, std::io::Error> {
     let targets = try!(get_targets());
 
     // Currently only bin and lib files get formatted
-    let files: Vec<_> = targets.into_iter()
+    let files: Vec<_> = targets
+        .into_iter()
         .filter(|t| t.kind.should_format())
         .inspect(|t| if verbosity == Verbosity::Verbose {
                      println!("[{:?}] {:?}", t.kind, t.path)
@@ -165,11 +166,13 @@ fn get_targets() -> Result<Vec<Target>, std::io::Error> {
 
 fn target_from_json(jtarget: &Json) -> Target {
     let jtarget = jtarget.as_object().unwrap();
-    let path = PathBuf::from(jtarget.get("src_path")
+    let path = PathBuf::from(jtarget
+                                 .get("src_path")
                                  .unwrap()
                                  .as_string()
                                  .unwrap());
-    let kinds = jtarget.get("kind")
+    let kinds = jtarget
+        .get("kind")
         .unwrap()
         .as_array()
         .unwrap();
diff --git a/src/bin/rustfmt.rs b/src/bin/rustfmt.rs
index e97d0219aad..1a1c0c99de3 100644
--- a/src/bin/rustfmt.rs
+++ b/src/bin/rustfmt.rs
@@ -226,7 +226,8 @@ fn execute(opts: &Options) -> FmtResult<Summary> {
             let options = try!(CliOptions::from_matches(&matches));
 
             // Add any additional files that were specified via `--file-lines`.
-            files.extend(options.file_lines
+            files.extend(options
+                             .file_lines
                              .files()
                              .cloned()
                              .map(PathBuf::from));
@@ -338,7 +339,8 @@ fn determine_operation(matches: &Matches) -> FmtResult<Operation> {
     }
 
     // Read the config_path and convert to parent dir if a file is provided.
-    let config_path: Option<PathBuf> = matches.opt_str("config-path")
+    let config_path: Option<PathBuf> = matches
+        .opt_str("config-path")
         .map(PathBuf::from)
         .and_then(|dir| {
                       if dir.is_file() {
@@ -360,7 +362,8 @@ fn determine_operation(matches: &Matches) -> FmtResult<Operation> {
     }
 
     // We append files from `--file-lines` later in `execute()`.
-    let files: Vec<_> = matches.free
+    let files: Vec<_> = matches
+        .free
         .iter()
         .map(PathBuf::from)
         .collect();
diff --git a/src/chains.rs b/src/chains.rs
index 70e6d951c2d..965187c5e07 100644
--- a/src/chains.rs
+++ b/src/chains.rs
@@ -113,8 +113,9 @@ pub fn rewrite_chain(expr: &ast::Expr, context: &RewriteContext, shape: Shape) -
         } else {
             chain_indent(context, shape.add_offset(parent_rewrite.len()))
         };
-        (nested_shape, context.config.chain_indent == IndentStyle::Visual ||
-                       parent_rewrite.len() <= context.config.tab_spaces)
+        (nested_shape,
+         context.config.chain_indent == IndentStyle::Visual ||
+         parent_rewrite.len() <= context.config.tab_spaces)
     } else if is_block_expr(&parent, &parent_rewrite) {
         // The parent is a block, so align the rest of the chain with the closing
         // brace.
@@ -425,7 +426,8 @@ fn rewrite_method_call(method_name: ast::Ident,
             format!("::<{}>", type_list.join(", "))
         };
 
-        (types.last()
+        (types
+             .last()
              .unwrap()
              .span
              .hi,
diff --git a/src/expr.rs b/src/expr.rs
index 5af8742c3b2..9568842e925 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -360,7 +360,8 @@ pub fn rewrite_array<'a, I>(expr_iter: I,
         }
     }
 
-    let has_long_item = try_opt!(items.iter()
+    let has_long_item = try_opt!(items
+                                     .iter()
                                      .map(|li| li.item.as_ref().map(|s| s.len() > 10))
                                      .fold(Some(false),
                                            |acc, x| acc.and_then(|y| x.map(|x| x || y))));
@@ -1308,7 +1309,8 @@ impl Rewrite for ast::Arm {
         // Let's try and get the arm body on the same line as the condition.
         // 4 = ` => `.len()
         if shape.width > pat_width + comma.len() + 4 {
-            let arm_shape = shape.shrink_left(pat_width + 4)
+            let arm_shape = shape
+                .shrink_left(pat_width + 4)
                 .unwrap()
                 .sub_width(comma.len())
                 .unwrap()
@@ -1404,7 +1406,8 @@ fn rewrite_guard(context: &RewriteContext,
         // 4 = ` if `, 5 = ` => {`
         let overhead = pattern_width + 4 + 5;
         if overhead < shape.width {
-            let cond_shape = shape.shrink_left(pattern_width + 4)
+            let cond_shape = shape
+                .shrink_left(pattern_width + 4)
                 .unwrap()
                 .sub_width(5)
                 .unwrap();
@@ -1424,7 +1427,8 @@ fn rewrite_guard(context: &RewriteContext,
                                                        3));
             if let Some(cond_str) = cond_str {
                 return Some(format!("\n{}if {}",
-                                    shape.indent
+                                    shape
+                                        .indent
                                         .block_indent(context.config)
                                         .to_string(context.config),
                                     cond_str));
@@ -1538,7 +1542,8 @@ fn string_requires_rewrite(context: &RewriteContext,
                            string: &str,
                            shape: Shape)
                            -> bool {
-    if context.codemap
+    if context
+           .codemap
            .lookup_char_pos(span.lo)
            .col
            .0 != shape.indent.width() {
@@ -1610,7 +1615,8 @@ fn rewrite_call_inner<R>(context: &RewriteContext,
 
     let nested_shape = match context.config.fn_call_style {
         IndentStyle::Block => {
-            shape.block()
+            shape
+                .block()
                 .block_indent(context.config.tab_spaces)
                 .sub_width(context.config.tab_spaces)
         }
@@ -1781,9 +1787,9 @@ fn rewrite_struct_lit<'a>(context: &RewriteContext,
         return Some(format!("{} {{}}", path_str));
     }
 
-    let field_iter = fields.into_iter()
-        .map(StructLitField::Regular)
-        .chain(base.into_iter().map(StructLitField::Base));
+    let field_iter =
+        fields.into_iter().map(StructLitField::Regular).chain(base.into_iter()
+                                                                  .map(StructLitField::Base));
 
     // Foo { a: Foo } - indent is +3, width is -5.
     let (h_shape, v_shape) = try_opt!(struct_lit_shape(shape, context, path_str.len() + 3, 2));
@@ -1895,7 +1901,8 @@ pub fn rewrite_tuple<'a, I>(context: &RewriteContext,
     if items.len() == 1 {
         // 3 = "(" + ",)"
         let nested_shape = try_opt!(shape.sub_width(3)).visual_indent(1);
-        return items.next()
+        return items
+                   .next()
                    .unwrap()
                    .rewrite(context, nested_shape)
                    .map(|s| if context.config.spaces_within_parens {
diff --git a/src/imports.rs b/src/imports.rs
index c83f821d4a8..1e9226bd56f 100644
--- a/src/imports.rs
+++ b/src/imports.rs
@@ -191,7 +191,8 @@ impl<'a> FmtVisitor<'a> {
     pub fn format_imports(&mut self, use_items: &[ptr::P<ast::Item>]) {
         // Find the location immediately before the first use item in the run. This must not lie
         // before the current `self.last_pos`
-        let pos_before_first_use_item = use_items.first()
+        let pos_before_first_use_item = use_items
+            .first()
             .map(|p_i| {
                      cmp::max(self.last_pos,
                               p_i.attrs
@@ -204,7 +205,8 @@ impl<'a> FmtVisitor<'a> {
         // Construct a list of pairs, each containing a `use` item and the start of span before
         // that `use` item.
         let mut last_pos_of_prev_use_item = pos_before_first_use_item;
-        let mut ordered_use_items = use_items.iter()
+        let mut ordered_use_items = use_items
+            .iter()
             .map(|p_i| {
                      let new_item = (&*p_i, last_pos_of_prev_use_item);
                      last_pos_of_prev_use_item = p_i.span.hi;
diff --git a/src/items.rs b/src/items.rs
index f5118625822..506db369806 100644
--- a/src/items.rs
+++ b/src/items.rs
@@ -1129,7 +1129,8 @@ pub fn rewrite_type_alias(context: &RewriteContext,
     let line_width = last_line_width(&result);
     // This checked_sub may fail as the extra space after '=' is not taken into account
     // In that case the budget is set to 0 which will make ty.rewrite retry on a new line
-    let budget = context.config
+    let budget = context
+        .config
         .max_width
         .checked_sub(indent.width() + line_width + ";".len())
         .unwrap_or(0);
@@ -1720,12 +1721,12 @@ fn rewrite_args(context: &RewriteContext,
     // Account for sugary self.
     // FIXME: the comment for the self argument is dropped. This is blocked
     // on rust issue #27522.
-    let min_args =
-        explicit_self.and_then(|explicit_self| rewrite_explicit_self(explicit_self, args, context))
-            .map_or(1, |self_str| {
-                arg_item_strs[0] = self_str;
-                2
-            });
+    let min_args = explicit_self
+        .and_then(|explicit_self| rewrite_explicit_self(explicit_self, args, context))
+        .map_or(1, |self_str| {
+            arg_item_strs[0] = self_str;
+            2
+        });
 
     // Comments between args.
     let mut arg_items = Vec::new();
@@ -1852,7 +1853,8 @@ fn compute_budgets_for_args(context: &RewriteContext,
         if !newline_brace {
             used_space += 2;
         }
-        let one_line_budget = context.config
+        let one_line_budget = context
+            .config
             .max_width
             .checked_sub(used_space)
             .unwrap_or(0);
@@ -1962,7 +1964,8 @@ fn rewrite_trait_bounds(context: &RewriteContext,
         return Some(String::new());
     }
 
-    let bound_str = try_opt!(bounds.iter()
+    let bound_str = try_opt!(bounds
+                                 .iter()
                                  .map(|ty_bound| ty_bound.rewrite(&context, shape))
                                  .intersperse(Some(" + ".to_string()))
                                  .collect::<Option<String>>());
diff --git a/src/lists.rs b/src/lists.rs
index 2bdb9cee695..1ec1f00073d 100644
--- a/src/lists.rs
+++ b/src/lists.rs
@@ -275,7 +275,8 @@ pub fn write_list<I, T>(items: I, formatting: &ListFormatting) -> Option<String>
 
         if tactic == DefinitiveListTactic::Vertical && item.post_comment.is_some() {
             // 1 = space between item and comment.
-            let width = formatting.shape
+            let width = formatting
+                .shape
                 .width
                 .checked_sub(item_last_line_width + 1)
                 .unwrap_or(1);
@@ -397,8 +398,8 @@ impl<'a, T, I, F1, F2, F3> Iterator for ListItems<'a, I, F1, F2, F3>
                 let first_newline = test_snippet.find('\n').unwrap_or(test_snippet.len());
                 // From the end of the first line of comments.
                 let test_snippet = &test_snippet[first_newline..];
-                let first = test_snippet.find(|c: char| !c.is_whitespace())
-                    .unwrap_or(test_snippet.len());
+                let first =
+                    test_snippet.find(|c: char| !c.is_whitespace()).unwrap_or(test_snippet.len());
                 // From the end of the first line of comments to the next non-whitespace char.
                 let test_snippet = &test_snippet[..first];
 
diff --git a/src/macros.rs b/src/macros.rs
index 607e743380a..f0ddf029aef 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -156,13 +156,13 @@ pub fn rewrite_macro(mac: &ast::Mac,
             // Format macro invocation as array literal.
             let extra_offset = macro_name.len();
             let shape = try_opt!(shape.shrink_left(extra_offset));
-            let rewrite = try_opt!(rewrite_array(expr_vec.iter().map(|x| &**x),
-                                                 mk_sp(context.codemap
-                                                           .span_after(mac.span,
-                                                                       original_style.opener()),
-                                                       mac.span.hi - BytePos(1)),
-                                                 context,
-                                                 shape));
+            let rewrite =
+                try_opt!(rewrite_array(expr_vec.iter().map(|x| &**x),
+                                       mk_sp(context.codemap.span_after(mac.span,
+                                                                        original_style.opener()),
+                                             mac.span.hi - BytePos(1)),
+                                       context,
+                                       shape));
 
             Some(format!("{}{}", macro_name, rewrite))
         }
diff --git a/src/missed_spans.rs b/src/missed_spans.rs
index 1a1371a19ce..3f2d78f35cc 100644
--- a/src/missed_spans.rs
+++ b/src/missed_spans.rs
@@ -83,7 +83,8 @@ impl<'a> FmtVisitor<'a> {
         let local_end = self.codemap.lookup_byte_offset(span.hi);
         let start_index = local_begin.pos.to_usize();
         let end_index = local_end.pos.to_usize();
-        let big_snippet = &local_begin.fm
+        let big_snippet = &local_begin
+                               .fm
                                .src
                                .as_ref()
                                .unwrap()
diff --git a/src/string.rs b/src/string.rs
index 8f51b09b6cc..37a569ce67d 100644
--- a/src/string.rs
+++ b/src/string.rs
@@ -42,7 +42,8 @@ pub fn rewrite_string<'a>(orig: &str, fmt: &StringFormat<'a>) -> Option<String>
 
     // `cur_start` is the position in `orig` of the start of the current line.
     let mut cur_start = 0;
-    let mut result = String::with_capacity(stripped_str.len()
+    let mut result = String::with_capacity(stripped_str
+                                               .len()
                                                .checked_next_power_of_two()
                                                .unwrap_or(usize::max_value()));
     result.push_str(fmt.opener);
diff --git a/src/types.rs b/src/types.rs
index ba6852dbe84..9cac8b4a0e0 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -206,7 +206,8 @@ fn rewrite_segment(path_context: PathContext,
                     .chain(data.bindings.iter().map(|x| SegmentParam::Binding(&*x)))
                     .collect::<Vec<_>>();
 
-                let next_span_lo = param_list.last()
+                let next_span_lo = param_list
+                    .last()
                     .unwrap()
                     .get_span()
                     .hi + BytePos(1);
@@ -297,28 +298,28 @@ fn format_function_type<'a, I>(inputs: I,
     // 1 for (
     let offset = shape.indent + 1;
     let list_lo = context.codemap.span_after(span, "(");
-    let items = itemize_list(context.codemap,
-                             // FIXME Would be nice to avoid this allocation,
-                             // but I couldn't get the types to work out.
-                             inputs.map(|i| ArgumentKind::Regular(Box::new(i)))
-                                 .chain(variadic_arg),
-                             ")",
-                             |arg| match *arg {
-                                 ArgumentKind::Regular(ref ty) => ty.span().lo,
-                                 ArgumentKind::Variadic(start) => start,
-                             },
-                             |arg| match *arg {
-                                 ArgumentKind::Regular(ref ty) => ty.span().hi,
-                                 ArgumentKind::Variadic(start) => start + BytePos(3),
-                             },
-                             |arg| match *arg {
-                                 ArgumentKind::Regular(ref ty) => {
-                                     ty.rewrite(context, Shape::legacy(budget, offset))
-                                 }
-                                 ArgumentKind::Variadic(_) => Some("...".to_owned()),
-                             },
-                             list_lo,
-                             span.hi);
+    let items =
+        itemize_list(context.codemap,
+                     // FIXME Would be nice to avoid this allocation,
+                     // but I couldn't get the types to work out.
+                     inputs.map(|i| ArgumentKind::Regular(Box::new(i))).chain(variadic_arg),
+                     ")",
+                     |arg| match *arg {
+                         ArgumentKind::Regular(ref ty) => ty.span().lo,
+                         ArgumentKind::Variadic(start) => start,
+                     },
+                     |arg| match *arg {
+                         ArgumentKind::Regular(ref ty) => ty.span().hi,
+                         ArgumentKind::Variadic(start) => start + BytePos(3),
+                     },
+                     |arg| match *arg {
+                         ArgumentKind::Regular(ref ty) => {
+                             ty.rewrite(context, Shape::legacy(budget, offset))
+                         }
+                         ArgumentKind::Variadic(_) => Some("...".to_owned()),
+                     },
+                     list_lo,
+                     span.hi);
 
     let list_str = try_opt!(format_fn_args(items, Shape::legacy(budget, offset), context.config));
 
@@ -680,7 +681,8 @@ fn rewrite_bare_fn(bare_fn: &ast::BareFnTy,
         // 6 = "for<> ".len(), 4 = "for<".
         // This doesn't work out so nicely for mutliline situation with lots of
         // rightward drift. If that is a problem, we could use the list stuff.
-        result.push_str(&try_opt!(bare_fn.lifetimes
+        result.push_str(&try_opt!(bare_fn
+                                      .lifetimes
                                       .iter()
                                       .map(|l| {
                                                l.rewrite(context,
diff --git a/src/utils.rs b/src/utils.rs
index 999e1192b5d..1d836d8dc67 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -127,7 +127,8 @@ pub fn contains_skip(attrs: &[Attribute]) -> bool {
 // Find the end of a TyParam
 #[inline]
 pub fn end_typaram(typaram: &ast::TyParam) -> BytePos {
-    typaram.bounds
+    typaram
+        .bounds
         .last()
         .map_or(typaram.span, |bound| match *bound {
             ast::RegionTyParamBound(ref lt) => lt.span,
@@ -278,7 +279,8 @@ pub fn wrap_str<S: AsRef<str>>(s: S, max_width: usize, shape: Shape) -> Option<S
             // indentation.
             // A special check for the last line, since the caller may
             // place trailing characters on this line.
-            if snippet.lines()
+            if snippet
+                   .lines()
                    .rev()
                    .next()
                    .unwrap()
diff --git a/src/visitor.rs b/src/visitor.rs
index 2700287608d..f78b781feff 100644
--- a/src/visitor.rs
+++ b/src/visitor.rs
@@ -476,7 +476,8 @@ impl<'a> FmtVisitor<'a> {
             return true;
         }
 
-        let outers: Vec<_> = attrs.iter()
+        let outers: Vec<_> = attrs
+            .iter()
             .filter(|a| a.style == ast::AttrStyle::Outer)
             .cloned()
             .collect();
@@ -487,10 +488,10 @@ impl<'a> FmtVisitor<'a> {
         let first = &outers[0];
         self.format_missing_with_indent(source!(self, first.span).lo);
 
-        let rewrite = outers.rewrite(&self.get_context(),
-                                     Shape::legacy(self.config.max_width -
-                                                   self.block_indent.width(),
-                                                   self.block_indent))
+        let rewrite = outers
+            .rewrite(&self.get_context(),
+                     Shape::legacy(self.config.max_width - self.block_indent.width(),
+                                   self.block_indent))
             .unwrap();
         self.buffer.push_str(&rewrite);
         let last = outers.last().unwrap();