diff --git a/src/expr.rs b/src/expr.rs index f2c98129cd6..fcb2ae1ff05 100644 --- a/src/expr.rs +++ b/src/expr.rs @@ -111,15 +111,6 @@ impl Rewrite for ast::Expr { offset, true) } - // We reformat it ourselves because rustc gives us a bad span - // for ranges, see rust#27162 - ast::Expr_::ExprRange(ref left, ref right) => { - rewrite_range(context, - left.as_ref().map(|e| &**e), - right.as_ref().map(|e| &**e), - width, - offset) - } ast::Expr_::ExprMatch(ref cond, ref arms, _) => { rewrite_match(context, cond, arms, width, offset, self.span) } @@ -177,15 +168,40 @@ impl Rewrite for ast::Expr { rewrite_unary_prefix(context, "box ", expr, width, offset) } ast::Expr_::ExprAddrOf(mutability, ref expr) => { - rewrite_expr_addrof(context, mutability, &expr, width, offset) + rewrite_expr_addrof(context, mutability, expr, width, offset) + } + ast::Expr_::ExprCast(ref expr, ref ty) => { + rewrite_pair(&**expr, &**ty, "", " as ", "", context, width, offset) + } + ast::Expr_::ExprIndex(ref expr, ref index) => { + rewrite_pair(&**expr, &**index, "", "[", "]", context, width, offset) + } + ast::Expr_::ExprRepeat(ref expr, ref repeats) => { + rewrite_pair(&**expr, &**repeats, "[", "; ", "]", context, width, offset) + } + ast::Expr_::ExprRange(Some(ref lhs), Some(ref rhs)) => { + rewrite_pair(&**lhs, &**rhs, "", "..", "", context, width, offset) + } + ast::Expr_::ExprRange(None, Some(ref rhs)) => { + rewrite_unary_prefix(context, "..", &**rhs, width, offset) + } + ast::Expr_::ExprRange(Some(ref lhs), None) => { + Some(format!("{}..", + try_opt!(lhs.rewrite(context, + try_opt!(width.checked_sub(2)), + offset)))) + } + ast::Expr_::ExprRange(None, None) => { + if width >= 2 { + Some("..".into()) + } else { + None + } } // We do not format these expressions yet, but they should still // satisfy our width restrictions. ast::Expr_::ExprInPlace(..) | - ast::Expr_::ExprCast(..) | - ast::Expr_::ExprIndex(..) | - ast::Expr_::ExprInlineAsm(..) | - ast::Expr_::ExprRepeat(..) => { + ast::Expr_::ExprInlineAsm(..) => { wrap_str(context.snippet(self.span), context.config.max_width, width, @@ -195,6 +211,45 @@ impl Rewrite for ast::Expr { } } +fn rewrite_pair(lhs: &LHS, + rhs: &RHS, + prefix: &str, + infix: &str, + suffix: &str, + context: &RewriteContext, + width: usize, + offset: Indent) + -> Option + where LHS: Rewrite, + RHS: Rewrite +{ + let max_width = try_opt!(width.checked_sub(prefix.len() + infix.len() + suffix.len())); + + binary_search(1, + max_width, + |lhs_budget| { + let lhs_offset = offset + prefix.len(); + let lhs_str = match lhs.rewrite(context, lhs_budget, lhs_offset) { + Some(result) => result, + None => return Err(Ordering::Greater), + }; + + let last_line_width = last_line_width(&lhs_str); + let rhs_budget = match max_width.checked_sub(last_line_width) { + Some(b) => b, + None => return Err(Ordering::Less), + }; + let rhs_indent = offset + last_line_width + prefix.len() + infix.len(); + + let rhs_str = match rhs.rewrite(context, rhs_budget, rhs_indent) { + Some(result) => result, + None => return Err(Ordering::Less), + }; + + Ok(format!("{}{}{}{}{}", prefix, lhs_str, infix, rhs_str, suffix)) + }) +} + pub fn rewrite_array<'a, I>(expr_iter: I, span: Span, context: &RewriteContext, @@ -537,33 +592,6 @@ fn rewrite_label(label: Option) -> String { } } -// FIXME: this doesn't play well with line breaks -fn rewrite_range(context: &RewriteContext, - left: Option<&ast::Expr>, - right: Option<&ast::Expr>, - width: usize, - offset: Indent) - -> Option { - let left_string = match left { - Some(expr) => { - // 2 = .. - let max_width = try_opt!(width.checked_sub(2)); - try_opt!(expr.rewrite(context, max_width, offset)) - } - None => String::new(), - }; - - let right_string = match right { - Some(expr) => { - let max_width = try_opt!(width.checked_sub(left_string.len() + 2)); - try_opt!(expr.rewrite(context, max_width, offset + 2 + left_string.len())) - } - None => String::new(), - }; - - Some(format!("{}..{}", left_string, right_string)) -} - // Rewrites if-else blocks. If let Some(_) = pat, the expression is // treated as an if-let-else expression. fn rewrite_if_else(context: &RewriteContext, @@ -690,7 +718,7 @@ fn rewrite_match_arm_comment(context: &RewriteContext, -> Option { // The leading "," is not part of the arm-comment let missed_str = match missed_str.find_uncommented(",") { - Some(n) => &missed_str[n+1..], + Some(n) => &missed_str[n + 1..], None => &missed_str[..], }; @@ -750,7 +778,7 @@ fn rewrite_match(context: &RewriteContext, let missed_str = if i == 0 { context.snippet(mk_sp(open_brace_pos, arm_start_pos(arm))) } else { - context.snippet(mk_sp(arm_end_pos(&arms[i-1]), arm_start_pos(arm))) + context.snippet(mk_sp(arm_end_pos(&arms[i - 1]), arm_start_pos(arm))) }; let comment = try_opt!(rewrite_match_arm_comment(context, &missed_str, diff --git a/src/items.rs b/src/items.rs index e6a334d9ad3..827b528771e 100644 --- a/src/items.rs +++ b/src/items.rs @@ -476,7 +476,7 @@ impl<'a> FmtVisitor<'a> { }; let more_items = itemize_list(self.codemap, - args[min_args-1..].iter(), + args[min_args - 1..].iter(), ")", |arg| span_lo_for_arg(arg), |arg| arg.ty.span.hi, diff --git a/src/lists.rs b/src/lists.rs index 12eebb7b691..9a169c15ce1 100644 --- a/src/lists.rs +++ b/src/lists.rs @@ -379,7 +379,7 @@ impl<'a, T, I, F1, F2, F3> Iterator for ListItems<'a, I, F1, F2, F3> // because of the way we divide pre- and post- comments. // Everything from the separator to the next item. - let test_snippet = &post_snippet[comment_end-1..]; + let test_snippet = &post_snippet[comment_end - 1..]; 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..]; diff --git a/src/missed_spans.rs b/src/missed_spans.rs index 135e6c3815b..5c5565c6596 100644 --- a/src/missed_spans.rs +++ b/src/missed_spans.rs @@ -78,7 +78,7 @@ impl<'a> FmtVisitor<'a> { self.buffer.push_str(&snippet[line_start..lw]); self.buffer.push_str("\n"); } else { - self.buffer.push_str(&snippet[line_start..i+1]); + self.buffer.push_str(&snippet[line_start..i + 1]); } line_start = i + 1; diff --git a/src/visitor.rs b/src/visitor.rs index 883d46a22d4..21dc2cde2a5 100644 --- a/src/visitor.rs +++ b/src/visitor.rs @@ -407,7 +407,7 @@ impl<'a> Rewrite for [ast::Attribute] { let a_str = context.snippet(a.span); if i > 0 { - let comment = context.snippet(codemap::mk_sp(self[i-1].span.hi, a.span.lo)); + let comment = context.snippet(codemap::mk_sp(self[i - 1].span.hi, a.span.lo)); // This particular horror show is to preserve line breaks in between doc // comments. An alternative would be to force such line breaks to start // with the usual doc comment token. diff --git a/tests/source/expr.rs b/tests/source/expr.rs index 96ad42cd77d..45f688693f6 100644 --- a/tests/source/expr.rs +++ b/tests/source/expr.rs @@ -184,3 +184,26 @@ fn addrof() { & mut(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb); & (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb); } + +fn casts() { + fn unpack(packed: u32) -> [u16; 2] { + [ + (packed >> 16) as u16, + (packed >> 0) as u16, + ] + } + + let some_trait_xxx = xxxxxxxxxxx + xxxxxxxxxxxxx + as SomeTraitXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX; + let slightly_longer_trait = yyyyyyyyy + yyyyyyyyyyy as SomeTraitYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY; +} + +fn indices() { + let x = (aaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb+cccccccccccccccc) [ x + y + z ]; + let y = (aaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccc)[ xxxxx + yyyyy + zzzzz ]; +} + +fn repeats() { + let x = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb+cccccccccccccccc; x + y + z ]; + let y = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccc; xxxxx + yyyyy + zzzzz ]; +} diff --git a/tests/target/expr.rs b/tests/target/expr.rs index f31f27f59d4..6fe472c114e 100644 --- a/tests/target/expr.rs +++ b/tests/target/expr.rs @@ -198,3 +198,29 @@ fn addrof() { &(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb); } + +fn casts() { + fn unpack(packed: u32) -> [u16; 2] { + [(packed >> 16) as u16, (packed >> 0) as u16] + } + + let some_trait_xxx = xxxxxxxxxxx + xxxxxxxxxxxxx as SomeTraitXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX; + let slightly_longer_trait = yyyyyyyyy + + yyyyyyyyyyy as SomeTraitYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY; +} + +fn indices() { + let x = (aaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccc)[x + + y + + z]; + let y = (aaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + + cccccccccccccccc)[xxxxx + yyyyy + zzzzz]; +} + +fn repeats() { + let x = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccc; x + + y + + z]; + let y = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + + cccccccccccccccc; xxxxx + yyyyy + zzzzz]; +}