Merge pull request #1680 from topecongiro/tuple-pattern

Use block indent for tuple pattern

src/expr.rs

@@ -25,10 +25,11 @@ use utils::{extra_offset, last_line_width, wrap_str, binary_search, first_line_w
 use visitor::FmtVisitor;
 use config::{Config, IndentStyle, MultilineStyle, ControlBraceStyle, Style};
 use comment::{FindUncommented, rewrite_comment, contains_comment, recover_comment_removed};
-use types::{rewrite_path, PathContext};
+use types::{rewrite_path, PathContext, can_be_overflowed_type};
 use items::{span_lo_for_arg, span_hi_for_arg};
 use chains::rewrite_chain;
 use macros::{rewrite_macro, MacroPosition};
+use patterns::{TuplePatField, can_be_overflowed_pat};
 
 use syntax::{ast, ptr};
 use syntax::codemap::{CodeMap, Span, BytePos};
@@ -110,7 +111,13 @@ fn format_expr(
         }
         ast::ExprKind::Call(ref callee, ref args) => {
             let inner_span = mk_sp(callee.span.hi, expr.span.hi);
-            rewrite_call_with_binary_search(context, &**callee, args, inner_span, shape)
+            rewrite_call_with_binary_search(
+                context,
+                &**callee,
+                &args.iter().map(|x| &**x).collect::<Vec<_>>()[..],
+                inner_span,
+                shape,
+            )
         }
         ast::ExprKind::Paren(ref subexpr) => rewrite_paren(context, subexpr, shape),
         ast::ExprKind::Binary(ref op, ref lhs, ref rhs) => {
@@ -136,7 +143,14 @@ fn format_expr(
                 shape,
             )
         }
-        ast::ExprKind::Tup(ref items) => rewrite_tuple(context, items, expr.span, shape),
+        ast::ExprKind::Tup(ref items) => {
+            rewrite_tuple(
+                context,
+                &items.iter().map(|x| &**x).collect::<Vec<_>>()[..],
+                expr.span,
+                shape,
+            )
+        }
         ast::ExprKind::While(ref cond, ref block, label) => {
             ControlFlow::new_while(None, cond, block, label, expr.span).rewrite(context, shape)
         }
@@ -1800,7 +1814,7 @@ fn string_requires_rewrite(
 pub fn rewrite_call_with_binary_search<R>(
     context: &RewriteContext,
     callee: &R,
-    args: &[ptr::P<ast::Expr>],
+    args: &[&ast::Expr],
     span: Span,
     shape: Shape,
 ) -> Option<String>
@@ -1818,7 +1832,15 @@ where
             Ordering::Greater,
         )?;
 
-        rewrite_call_inner(context, &callee_str, args, span, shape, false)
+        rewrite_call_inner(
+            context,
+            &callee_str,
+            args,
+            span,
+            shape,
+            context.config.fn_call_width(),
+            false,
+        )
     };
 
     binary_search(1, shape.width, closure)
@@ -1831,15 +1853,24 @@ pub fn rewrite_call(
     span: Span,
     shape: Shape,
 ) -> Option<String> {
-    rewrite_call_inner(context, &callee, args, span, shape, false).ok()
+    rewrite_call_inner(
+        context,
+        &callee,
+        &args.iter().map(|x| &**x).collect::<Vec<_>>(),
+        span,
+        shape,
+        context.config.fn_call_width(),
+        false,
+    ).ok()
 }
 
-fn rewrite_call_inner<'a, T>(
+pub fn rewrite_call_inner<'a, T>(
     context: &RewriteContext,
     callee_str: &str,
-    args: &[ptr::P<T>],
+    args: &[&T],
     span: Span,
     shape: Shape,
+    args_max_width: usize,
     force_trailing_comma: bool,
 ) -> Result<String, Ordering>
 where
@@ -1873,6 +1904,7 @@ where
         args_span,
         nested_shape,
         one_line_width,
+        args_max_width,
         force_trailing_comma,
     ).or_else(|| if context.use_block_indent() {
         rewrite_call_args(
@@ -1884,6 +1916,7 @@ where
                 context.config,
             ),
             0,
+            0,
             force_trailing_comma,
         )
     } else {
@@ -1900,6 +1933,7 @@ where
             args,
             span,
             shape,
+            args_max_width,
             force_trailing_comma,
         );
     }
@@ -1930,10 +1964,11 @@ fn need_block_indent(s: &str, shape: Shape) -> bool {
 
 fn rewrite_call_args<'a, T>(
     context: &RewriteContext,
-    args: &[ptr::P<T>],
+    args: &[&T],
     span: Span,
     shape: Shape,
     one_line_width: usize,
+    args_max_width: usize,
     force_trailing_comma: bool,
 ) -> Option<(bool, String)>
 where
@@ -1956,13 +1991,13 @@ where
     // Try letting the last argument overflow to the next line with block
     // indentation. If its first line fits on one line with the other arguments,
     // we format the function arguments horizontally.
-    let args = args.iter().filter_map(|e| e.to_expr()).collect::<Vec<_>>();
     let tactic = try_overflow_last_arg(
         &item_context,
         &mut item_vec,
         &args[..],
         shape,
         one_line_width,
+        args_max_width,
     );
 
     let fmt = ListFormatting {
@@ -1985,38 +2020,45 @@ where
     })
 }
 
-fn try_overflow_last_arg(
+fn try_overflow_last_arg<'a, T>(
     context: &RewriteContext,
     item_vec: &mut Vec<ListItem>,
-    args: &[&ast::Expr],
+    args: &[&T],
     shape: Shape,
     one_line_width: usize,
-) -> DefinitiveListTactic {
+    args_max_width: usize,
+) -> DefinitiveListTactic
+where
+    T: Rewrite + Spanned + ToExpr + 'a,
+{
     let overflow_last = can_be_overflowed(&context, args);
 
     // Replace the last item with its first line to see if it fits with
     // first arguments.
     let (orig_last, placeholder) = if overflow_last {
         let mut context = context.clone();
-        match args[args.len() - 1].node {
-            ast::ExprKind::MethodCall(..) => context.force_one_line_chain = true,
-            _ => (),
+        if let Some(expr) = args[args.len() - 1].to_expr() {
+            match expr.node {
+                ast::ExprKind::MethodCall(..) => context.force_one_line_chain = true,
+                _ => (),
+            }
         }
-        last_arg_shape(&context, &item_vec, shape).map_or((None, None), |arg_shape| {
-            rewrite_last_arg_with_overflow(
-                &context,
-                args[args.len() - 1],
-                &mut item_vec[args.len() - 1],
-                arg_shape,
-            )
-        })
+        last_arg_shape(&context, &item_vec, shape, args_max_width)
+            .map_or((None, None), |arg_shape| {
+                rewrite_last_arg_with_overflow(
+                    &context,
+                    args[args.len() - 1],
+                    &mut item_vec[args.len() - 1],
+                    arg_shape,
+                )
+            })
     } else {
         (None, None)
     };
 
     let tactic = definitive_tactic(
         &*item_vec,
-        ListTactic::LimitedHorizontalVertical(context.config.fn_call_width()),
+        ListTactic::LimitedHorizontalVertical(args_max_width),
         one_line_width,
     );
 
@@ -2035,11 +2077,16 @@ fn try_overflow_last_arg(
     tactic
 }
 
-fn last_arg_shape(context: &RewriteContext, items: &Vec<ListItem>, shape: Shape) -> Option<Shape> {
+fn last_arg_shape(
+    context: &RewriteContext,
+    items: &Vec<ListItem>,
+    shape: Shape,
+    args_max_width: usize,
+) -> Option<Shape> {
     let overhead = items.iter().rev().skip(1).fold(0, |acc, i| {
         acc + i.item.as_ref().map_or(0, |s| first_line_width(&s))
     });
-    let max_width = min(context.config.fn_call_width(), shape.width);
+    let max_width = min(args_max_width, shape.width);
     let arg_indent = if context.use_block_indent() {
         shape.block().indent.block_unindent(context.config)
     } else {
@@ -2052,12 +2099,15 @@ fn last_arg_shape(context: &RewriteContext, items: &Vec<ListItem>, shape: Shape)
     })
 }
 
-fn rewrite_last_arg_with_overflow(
+fn rewrite_last_arg_with_overflow<'a, T>(
     context: &RewriteContext,
-    last_arg: &ast::Expr,
+    last_arg: &T,
     last_item: &mut ListItem,
     shape: Shape,
-) -> (Option<String>, Option<String>) {
+) -> (Option<String>, Option<String>)
+where
+    T: Rewrite + Spanned + ToExpr + 'a,
+{
     let rewrite = last_arg.rewrite(context, shape);
     let orig_last = last_item.item.clone();
 
@@ -2070,13 +2120,17 @@ fn rewrite_last_arg_with_overflow(
     }
 }
 
-fn can_be_overflowed(context: &RewriteContext, args: &[&ast::Expr]) -> bool {
-    args.last().map_or(false, |x| {
-        can_be_overflowed_expr(context, &x, args.len())
-    })
+fn can_be_overflowed<'a, T>(context: &RewriteContext, args: &[&T]) -> bool
+where
+    T: Rewrite + Spanned + ToExpr + 'a,
+{
+    args.last().map_or(
+        false,
+        |x| x.can_be_overflowed(context, args.len()),
+    )
 }
 
-fn can_be_overflowed_expr(context: &RewriteContext, expr: &ast::Expr, args_len: usize) -> bool {
+pub fn can_be_overflowed_expr(context: &RewriteContext, expr: &ast::Expr, args_len: usize) -> bool {
     match expr.node {
         ast::ExprKind::Match(..) => {
             (context.use_block_indent() && args_len == 1) ||
@@ -2117,7 +2171,7 @@ fn paren_overhead(context: &RewriteContext) -> usize {
     }
 }
 
-fn wrap_args_with_parens(
+pub fn wrap_args_with_parens(
     context: &RewriteContext,
     args_str: &str,
     is_extendable: bool,
@@ -2370,7 +2424,7 @@ fn shape_from_fn_call_style(
 
 fn rewrite_tuple_in_visual_indent_style<'a, T>(
     context: &RewriteContext,
-    items: &[ptr::P<T>],
+    items: &[&T],
     span: Span,
     shape: Shape,
 ) -> Option<String>
@@ -2417,7 +2471,7 @@ where
 
 pub fn rewrite_tuple<'a, T>(
     context: &RewriteContext,
-    items: &[ptr::P<T>],
+    items: &[&T],
     span: Span,
     shape: Shape,
 ) -> Option<String>
@@ -2433,6 +2487,7 @@ where
             items,
             span,
             shape,
+            context.config.fn_call_width(),
             items.len() == 1,
         ).ok()
     } else {
@@ -2590,16 +2645,35 @@ fn rewrite_expr_addrof(
 
 pub trait ToExpr {
     fn to_expr(&self) -> Option<&ast::Expr>;
+    fn can_be_overflowed(&self, context: &RewriteContext, len: usize) -> bool;
 }
 
 impl ToExpr for ast::Expr {
     fn to_expr(&self) -> Option<&ast::Expr> {
         Some(self)
     }
+
+    fn can_be_overflowed(&self, context: &RewriteContext, len: usize) -> bool {
+        can_be_overflowed_expr(context, self, len)
+    }
 }
 
 impl ToExpr for ast::Ty {
     fn to_expr(&self) -> Option<&ast::Expr> {
         None
     }
+
+    fn can_be_overflowed(&self, context: &RewriteContext, len: usize) -> bool {
+        can_be_overflowed_type(context, self, len)
+    }
+}
+
+impl<'a> ToExpr for TuplePatField<'a> {
+    fn to_expr(&self) -> Option<&ast::Expr> {
+        None
+    }
+
+    fn can_be_overflowed(&self, context: &RewriteContext, len: usize) -> bool {
+        can_be_overflowed_pat(context, self, len)
+    }
 }

src/items.rs

@@ -684,13 +684,15 @@ fn format_impl_ref_and_type(
     item: &ast::Item,
     offset: Indent,
 ) -> Option<String> {
-    if let ast::ItemKind::Impl(unsafety,
-                               polarity,
-                               _,
-                               ref generics,
-                               ref trait_ref,
-                               ref self_ty,
-                               _) = item.node
+    if let ast::ItemKind::Impl(
+        unsafety,
+        polarity,
+        _,
+        ref generics,
+        ref trait_ref,
+        ref self_ty,
+        _,
+    ) = item.node
     {
         let mut result = String::new();
 

src/patterns.rs

@@ -13,10 +13,9 @@ use codemap::SpanUtils;
 use config::{IndentStyle, MultilineStyle};
 use rewrite::{Rewrite, RewriteContext};
 use utils::{wrap_str, format_mutability, mk_sp};
-use lists::{DefinitiveListTactic, SeparatorTactic, format_item_list, itemize_list, ListItem,
-            struct_lit_shape, struct_lit_tactic, shape_for_tactic, struct_lit_formatting,
-            write_list};
-use expr::{rewrite_unary_prefix, rewrite_pair};
+use lists::{DefinitiveListTactic, SeparatorTactic, itemize_list, struct_lit_shape,
+            struct_lit_tactic, shape_for_tactic, struct_lit_formatting, write_list};
+use expr::{rewrite_call_inner, rewrite_unary_prefix, rewrite_pair, can_be_overflowed_expr};
 use types::{rewrite_path, PathContext};
 use super::Spanned;
 use comment::FindUncommented;
@@ -239,7 +238,7 @@ impl Rewrite for FieldPat {
     }
 }
 
-enum TuplePatField<'a> {
+pub enum TuplePatField<'a> {
     Pat(&'a ptr::P<ast::Pat>),
     Dotdot(Span),
 }
@@ -262,6 +261,25 @@ impl<'a> Spanned for TuplePatField<'a> {
     }
 }
 
+pub fn can_be_overflowed_pat(context: &RewriteContext, pat: &TuplePatField, len: usize) -> bool {
+    match pat {
+        &TuplePatField::Pat(ref pat) => {
+            match pat.node {
+                ast::PatKind::Path(..) |
+                ast::PatKind::Tuple(..) |
+                ast::PatKind::Struct(..) => context.use_block_indent() && len == 1,
+                ast::PatKind::Ref(ref p, _) |
+                ast::PatKind::Box(ref p) => {
+                    can_be_overflowed_pat(context, &TuplePatField::Pat(p), len)
+                }
+                ast::PatKind::Lit(ref expr) => can_be_overflowed_expr(context, expr, len),
+                _ => false,
+            }
+        }
+        &TuplePatField::Dotdot(..) => false,
+    }
+}
+
 fn rewrite_tuple_pat(
     pats: &[ptr::P<ast::Pat>],
     dotdot_pos: Option<usize>,
@@ -286,77 +304,73 @@ fn rewrite_tuple_pat(
         let dot_span = mk_sp(prev, next);
         let snippet = context.snippet(dot_span);
         let lo = dot_span.lo + BytePos(snippet.find_uncommented("..").unwrap() as u32);
-        let span = Span {
+        let dotdot = TuplePatField::Dotdot(Span {
             lo: lo,
             // 2 == "..".len()
             hi: lo + BytePos(2),
             ctxt: codemap::NO_EXPANSION,
-        };
-        let dotdot = TuplePatField::Dotdot(span);
+        });
         pat_vec.insert(pos, dotdot);
     }
 
     if pat_vec.is_empty() {
         return Some(format!("{}()", try_opt!(path_str)));
     }
+
+    let wildcard_suffix_len = count_wildcard_suffix_len(context, &pat_vec, span, shape);
+    let (pat_vec, span) =
+        if context.config.condense_wildcard_suffixes() && wildcard_suffix_len >= 2 {
+            let new_item_count = 1 + pat_vec.len() - wildcard_suffix_len;
+            let sp = pat_vec[new_item_count - 1].span();
+            let snippet = context.snippet(sp);
+            let lo = sp.lo + BytePos(snippet.find_uncommented("_").unwrap() as u32);
+            pat_vec[new_item_count - 1] = TuplePatField::Dotdot(mk_sp(lo, lo + BytePos(1)));
+            (&pat_vec[..new_item_count], mk_sp(span.lo, lo + BytePos(1)))
+        } else {
+            (&pat_vec[..], span)
+        };
+
     // add comma if `(x,)`
     let add_comma = path_str.is_none() && pat_vec.len() == 1 && dotdot_pos.is_none();
+    let mut context = context.clone();
+    if let Some(&TuplePatField::Dotdot(..)) = pat_vec.last() {
+        context.inside_macro = true;
+    }
+    let path_str = path_str.unwrap_or(String::new());
+    let mut pat_ref_vec = Vec::with_capacity(pat_vec.len());
+    for pat in pat_vec {
+        pat_ref_vec.push(pat);
+    }
+    return rewrite_call_inner(
+        &context,
+        &path_str,
+        &pat_ref_vec[..],
+        span,
+        shape,
+        shape.width,
+        add_comma,
+    ).ok();
+}
 
-    let path_len = path_str.as_ref().map(|p| p.len()).unwrap_or(0);
-    // 2 = "()".len(), 3 = "(,)".len()
-    let nested_shape = try_opt!(shape.sub_width(path_len + if add_comma { 3 } else { 2 }));
-    // 1 = "(".len()
-    let nested_shape = nested_shape.visual_indent(path_len + 1);
-    let mut items: Vec<_> = itemize_list(
+fn count_wildcard_suffix_len(
+    context: &RewriteContext,
+    patterns: &[TuplePatField],
+    span: Span,
+    shape: Shape,
+) -> usize {
+    let mut suffix_len = 0;
+
+    let items: Vec<_> = itemize_list(
         context.codemap,
-        pat_vec.iter(),
-        if add_comma { ",)" } else { ")" },
+        patterns.iter(),
+        ")",
         |item| item.span().lo,
         |item| item.span().hi,
-        |item| item.rewrite(context, nested_shape),
+        |item| item.rewrite(context, shape),
         context.codemap.span_after(span, "("),
         span.hi - BytePos(1),
     ).collect();
 
-    // Condense wildcard string suffix into a single ..
-    let wildcard_suffix_len = count_wildcard_suffix_len(&items);
-
-    let list = if context.config.condense_wildcard_suffixes() && wildcard_suffix_len >= 2 {
-        let new_item_count = 1 + pats.len() - wildcard_suffix_len;
-        items[new_item_count - 1].item = Some("..".to_owned());
-
-        let da_iter = items.into_iter().take(new_item_count);
-        try_opt!(format_item_list(da_iter, nested_shape, context.config))
-    } else {
-        try_opt!(format_item_list(
-            items.into_iter(),
-            nested_shape,
-            context.config,
-        ))
-    };
-
-    match path_str {
-        Some(path_str) => {
-            Some(if context.config.spaces_within_parens() {
-                format!("{}( {} )", path_str, list)
-            } else {
-                format!("{}({})", path_str, list)
-            })
-        }
-        None => {
-            let comma = if add_comma { "," } else { "" };
-            Some(if context.config.spaces_within_parens() {
-                format!("( {}{} )", list, comma)
-            } else {
-                format!("({}{})", list, comma)
-            })
-        }
-    }
-}
-
-fn count_wildcard_suffix_len(items: &[ListItem]) -> usize {
-    let mut suffix_len = 0;
-
     for item in items.iter().rev().take_while(|i| match i.item {
         Some(ref internal_string) if internal_string == "_" => true,
         _ => false,

src/types.rs

@@ -371,11 +371,11 @@ impl Rewrite for ast::WherePredicate {
         // TODO: dead spans?
         let result = match *self {
             ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate {
-                                                    ref bound_lifetimes,
-                                                    ref bounded_ty,
-                                                    ref bounds,
-                                                    ..
-                                                }) => {
+                ref bound_lifetimes,
+                ref bounded_ty,
+                ref bounds,
+                ..
+            }) => {
                 let type_str = try_opt!(bounded_ty.rewrite(context, shape));
 
                 let colon = type_bound_colon(context);
@@ -428,10 +428,10 @@ impl Rewrite for ast::WherePredicate {
                 }
             }
             ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate {
-                                                     ref lifetime,
-                                                     ref bounds,
-                                                     ..
-                                                 }) => {
+                ref lifetime,
+                ref bounds,
+                ..
+            }) => {
                 try_opt!(rewrite_bounded_lifetime(
                     lifetime,
                     bounds.iter(),
@@ -440,10 +440,10 @@ impl Rewrite for ast::WherePredicate {
                 ))
             }
             ast::WherePredicate::EqPredicate(ast::WhereEqPredicate {
-                                                 ref lhs_ty,
-                                                 ref rhs_ty,
-                                                 ..
-                                             }) => {
+                ref lhs_ty,
+                ref rhs_ty,
+                ..
+            }) => {
                 let lhs_ty_str = try_opt!(lhs_ty.rewrite(context, shape));
                 // 3 = " = ".len()
                 let used_width = 3 + lhs_ty_str.len();
@@ -689,7 +689,14 @@ impl Rewrite for ast::Ty {
                         format!("[{}]", ty_str)
                     })
             }
-            ast::TyKind::Tup(ref items) => rewrite_tuple(context, items, self.span, shape),
+            ast::TyKind::Tup(ref items) => {
+                rewrite_tuple(
+                    context,
+                    &items.iter().map(|x| &**x).collect::<Vec<_>>()[..],
+                    self.span,
+                    shape,
+                )
+            }
             ast::TyKind::Path(ref q_self, ref path) => {
                 rewrite_path(context, PathContext::Type, q_self.as_ref(), path, shape)
             }
@@ -792,3 +799,13 @@ pub fn join_bounds(context: &RewriteContext, shape: Shape, type_strs: &Vec<Strin
         result
     }
 }
+
+pub fn can_be_overflowed_type(context: &RewriteContext, ty: &ast::Ty, len: usize) -> bool {
+    match ty.node {
+        ast::TyKind::Path(..) |
+        ast::TyKind::Tup(..) => context.use_block_indent() && len == 1,
+        ast::TyKind::Rptr(_, ref mutty) |
+        ast::TyKind::Ptr(ref mutty) => can_be_overflowed_type(context, &*mutty.ty, len),
+        _ => false,
+    }
+}

src/utils.rs

@@ -99,6 +99,7 @@ pub fn last_line_width(s: &str) -> usize {
         None => s.len(),
     }
 }
+
 #[inline]
 pub fn trimmed_last_line_width(s: &str) -> usize {
     match s.rfind('\n') {

tests/target/closure.rs

@@ -128,18 +128,20 @@ fn issue470() {
     {
         {
             {
-                let explicit_arg_decls = explicit_arguments.into_iter().enumerate().map(|(index,
-                  (ty,
-                   pattern))| {
-                    let lvalue = Lvalue::Arg(index as u32);
-                    block = this.pattern(
-                        block,
-                        argument_extent,
-                        hair::PatternRef::Hair(pattern),
-                        &lvalue,
-                    );
-                    ArgDecl { ty: ty }
-                });
+                let explicit_arg_decls =
+                    explicit_arguments.into_iter().enumerate().map(|(
+                        index,
+                        (ty, pattern),
+                    )| {
+                        let lvalue = Lvalue::Arg(index as u32);
+                        block = this.pattern(
+                            block,
+                            argument_extent,
+                            hair::PatternRef::Hair(pattern),
+                            &lvalue,
+                        );
+                        ArgDecl { ty: ty }
+                    });
             }
         }
     }

tests/target/expr.rs

@@ -52,18 +52,22 @@ fn foo() -> bool {
                           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)
     {}
 
-    if let (some_very_large,
-            tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple) = 1 + 2 + 3
-    {
-    }
-
-    if let (some_very_large,
-            tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple) =
-        1111 + 2222
+    if let (
+        some_very_large,
+        tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple,
+    ) = 1 + 2 + 3
     {}
 
-    if let (some_very_large,
-            tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple) = 1 + 2 + 3
+    if let (
+        some_very_large,
+        tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple,
+    ) = 1111 + 2222
+    {}
+
+    if let (
+        some_very_large,
+        tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple,
+    ) = 1 + 2 + 3
     {}
 
     let test = if true { 5 } else { 3 };

tests/target/hard-tabs.rs

@@ -21,8 +21,10 @@ fn main() {
 
 	let str = "AAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAa";
 
-	if let (some_very_large,
-	        tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple) = 1 + 2 + 3
+	if let (
+		some_very_large,
+		tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple,
+	) = 1 + 2 + 3
 	{}
 
 	if cond() {

tests/target/issue-1021.rs

@@ -6,11 +6,15 @@ fn main() {
         S(.., true) => (),
         S(..) => (),
         S(_) => (),
-        S(// ..
-          ..) => (),
-        S(// ..
-          ..,
-          true) => (),
+        S(
+            // ..
+            ..
+        ) => (),
+        S(
+            // ..
+            ..,
+            true,
+        ) => (),
     }
 
     match y {
@@ -19,10 +23,14 @@ fn main() {
         (.., true) => (),
         (..) => (),
         (_,) => (),
-        (// ..
-         ..) => (),
-        (// ..
-         ..,
-         true) => (),
+        (
+            // ..
+            ..
+        ) => (),
+        (
+            // ..
+            ..,
+            true,
+        ) => (),
     }
 }

tests/target/issue-913.rs

@@ -10,11 +10,13 @@ mod client {
             };
 
             let next_state = match self.state {
-                State::V5(v5::State::Command(v5::comand::State::WriteVersion(ref mut response))) => {
+                State::V5(
+                    v5::State::Command(v5::comand::State::WriteVersion(ref mut response)),
+                ) => {
                     // The pattern cannot be formatted in a way that the match stays
                     // within the column limit. The rewrite should therefore be
                     // skipped.
-                    let x =  dont . reformat . meeee();
+                    let x = dont.reformat.meeee();
                 }
             };
         }

tests/target/match.rs

@@ -262,10 +262,12 @@ fn issue507() {
 
 fn issue508() {
     match s.type_id() {
-        Some(NodeTypeId::Element(ElementTypeId::HTMLElement(
-                    HTMLElementTypeId::HTMLCanvasElement))) => true,
-        Some(NodeTypeId::Element(ElementTypeId::HTMLElement(
-                        HTMLElementTypeId::HTMLObjectElement))) => s.has_object_data(),
+        Some(
+            NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLCanvasElement)),
+        ) => true,
+        Some(
+            NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLObjectElement)),
+        ) => s.has_object_data(),
         Some(NodeTypeId::Element(_)) => false,
     }
 }

tests/target/pattern-condense-wildcards.rs

@@ -7,10 +7,12 @@ fn main() {
         Tup(_) => "nah",
         Quad(_, _, x, _) => " also no rewrite",
         Quad(x, ..) => "condense me pls",
-        Weird(x,
-              _,
-              _,
-              // dont condense before
-              ..) => "pls work",
+        Weird(
+            x,
+            _,
+            _,
+            // dont condense before
+            ..
+        ) => "pls work",
     }
 }

tests/target/pattern.rs

@@ -47,8 +47,9 @@ fn main() {
 impl<'a, 'b> ResolveGeneratedContentFragmentMutator<'a, 'b> {
     fn mutate_fragment(&mut self, fragment: &mut Fragment) {
         match **info {
-            GeneratedContentInfo::ContentItem(ContentItem::Counter(ref counter_name,
-                                                                   counter_style)) => {}
+            GeneratedContentInfo::ContentItem(
+                ContentItem::Counter(ref counter_name, counter_style),
+            ) => {}
         }
     }
 }