From 120fd2426e271afea0332bbbd5c408c5d0e88412 Mon Sep 17 00:00:00 2001 From: Marcus Klaas Date: Fri, 21 Aug 2015 13:31:09 +0200 Subject: [PATCH] Format assignment --- src/comment.rs | 5 +- src/expr.rs | 134 +++++++++++++++++++++++++---- src/issues.rs | 5 +- src/items.rs | 74 +++++++++++++++- src/lib.rs | 2 + src/lists.rs | 17 ++-- src/visitor.rs | 42 ++++++--- tests/source/assignment.rs | 16 ++++ tests/source/expr.rs | 11 ++- tests/source/paths.rs | 2 - tests/target/assignment.rs | 18 ++++ tests/target/expr.rs | 4 +- tests/target/multiple.rs | 4 +- tests/target/paths.rs | 2 - tests/target/string-lit.rs | 15 ++-- tests/target/struct_lits_visual.rs | 9 +- 16 files changed, 284 insertions(+), 76 deletions(-) create mode 100644 tests/source/assignment.rs create mode 100644 tests/target/assignment.rs diff --git a/src/comment.rs b/src/comment.rs index 14ca718e318..4cee78f271d 100644 --- a/src/comment.rs +++ b/src/comment.rs @@ -104,14 +104,13 @@ fn format_comments() { let input = "// comment"; let expected = "/* com\n \ - * men\n * \ - t */"; + * men\n \ + * t */"; assert_eq!(expected, rewrite_comment(input, true, 9, 69)); assert_eq!("/* trimmed */", rewrite_comment("/* trimmed */", true, 100, 100)); } - pub trait FindUncommented { fn find_uncommented(&self, pat: &str) -> Option; } diff --git a/src/expr.rs b/src/expr.rs index 4f58c19c8fd..f1279d93a5a 100644 --- a/src/expr.rs +++ b/src/expr.rs @@ -106,6 +106,12 @@ fn rewrite(&self, context: &RewriteContext, width: usize, offset: usize) -> Opti ast::Expr_::ExprPath(ref qself, ref path) => { rewrite_path(context, qself.as_ref(), path, width, offset) } + ast::Expr_::ExprAssign(ref lhs, ref rhs) => { + rewrite_assignment(context, lhs, rhs, None, width, offset) + } + ast::Expr_::ExprAssignOp(ref op, ref lhs, ref rhs) => { + rewrite_assignment(context, lhs, rhs, Some(op), width, offset) + } // FIXME #184 Note that this formatting is broken due to a bad span // from the parser. // `continue` @@ -116,10 +122,47 @@ fn rewrite(&self, context: &RewriteContext, width: usize, offset: usize) -> Opti }; Some(format!("continue{}", id_str)) } + ast::Expr_::ExprBreak(ref opt_ident) => { + let id_str = match *opt_ident { + Some(ident) => format!(" {}", ident), + None => String::new(), + }; + Some(format!("break{}", id_str)) + } ast::Expr_::ExprClosure(capture, ref fn_decl, ref body) => { rewrite_closure(capture, fn_decl, body, self.span, context, width, offset) } - _ => context.codemap.span_to_snippet(self.span).ok(), + _ => { + // We do not format these expressions yet, but they should still + // satisfy our width restrictions. + let snippet = context.codemap.span_to_snippet(self.span).unwrap(); + + { + let mut lines = snippet.lines(); + + // The caller of this function has already placed `offset` + // characters on the first line. + let first_line_max_len = try_opt!(context.config.max_width.checked_sub(offset)); + if lines.next().unwrap().len() > first_line_max_len { + return None; + } + + // The other lines must fit within the maximum width. + if lines.find(|line| line.len() > context.config.max_width).is_some() { + return None; + } + + // `width` is the maximum length of the last line, excluding + // indentation. + // A special check for the last line, since the caller may + // place trailing characters on this line. + if snippet.lines().rev().next().unwrap().len() > offset + width { + return None; + } + } + + Some(snippet) + } } } } @@ -402,7 +445,7 @@ fn rewrite_match(context: &RewriteContext, width: usize, offset: usize) -> Option { - if arms.len() == 0 { + if arms.is_empty() { return None; } @@ -440,7 +483,7 @@ fn rewrite_match(context: &RewriteContext, result.push('\n'); } let missed_str = missed_str.trim(); - if missed_str.len() > 0 { + if !missed_str.is_empty() { result.push('\n'); result.push_str(&arm_indent_str); result.push_str(missed_str); @@ -473,7 +516,7 @@ fn rewrite_match(context: &RewriteContext, fn arm_start_pos(arm: &ast::Arm) -> BytePos { let &ast::Arm { ref attrs, ref pats, .. } = arm; - if attrs.len() > 0 { + if !attrs.is_empty() { return attrs[0].span.lo } @@ -492,7 +535,7 @@ fn rewrite(&self, context: &RewriteContext, width: usize, offset: usize) -> Opti // FIXME this is all a bit grotty, would be nice to abstract out the // treatment of attributes. - let attr_str = if attrs.len() > 0 { + let attr_str = if !attrs.is_empty() { // We only use this visitor for the attributes, should we use it for // more? let mut attr_visitor = FmtVisitor::from_codemap(context.codemap, context.config); @@ -539,7 +582,7 @@ fn rewrite(&self, context: &RewriteContext, width: usize, offset: usize) -> Opti let mut pats_str = String::new(); for p in pat_strs { - if pats_str.len() > 0 { + if !pats_str.is_empty() { if vertical { pats_str.push_str(" |\n"); pats_str.push_str(&indent_str); @@ -584,7 +627,7 @@ fn rewrite(&self, context: &RewriteContext, width: usize, offset: usize) -> Opti } // We have to push the body to the next line. - if comma.len() == 0 { + if comma.is_empty() { // We're trying to fit a block in, but it still failed, give up. return None; } @@ -645,6 +688,8 @@ fn rewrite_pat_expr(context: &RewriteContext, pat: Option<&ast::Pat>, expr: &ast::Expr, matcher: &str, + // Connecting piece between pattern and expression, + // *without* trailing space. connector: &str, width: usize, offset: usize) @@ -665,18 +710,18 @@ fn rewrite_pat_expr(context: &RewriteContext, // The expression may (partionally) fit on the current line. if width > extra_offset + 1 { - let mut corrected_offset = extra_offset; - - if pat.is_some() { - result.push(' '); - corrected_offset += 1; - } + let spacer = if pat.is_some() { + " " + } else { + "" + }; let expr_rewrite = expr.rewrite(context, - width - corrected_offset, - offset + corrected_offset); + width - extra_offset - spacer.len(), + offset + extra_offset + spacer.len()); if let Some(expr_string) = expr_rewrite { + result.push_str(spacer); result.push_str(&expr_string); return Some(result); } @@ -810,7 +855,7 @@ enum StructLitField<'a> { let path_str = try_opt!(path.rewrite(context, width - 2, offset)); // Foo { a: Foo } - indent is +3, width is -5. - let h_budget = width.checked_sub(path_str.len() + 5).unwrap_or(0); + let h_budget = try_opt!(width.checked_sub(path_str.len() + 5)); let (indent, v_budget) = match context.config.struct_lit_style { StructLitStyle::VisualIndent => { (offset + path_str.len() + 3, h_budget) @@ -1008,7 +1053,62 @@ fn rewrite_unary_op(context: &RewriteContext, ast::UnOp::UnNeg => "-", }; - let subexpr = try_opt!(expr.rewrite(context, try_opt!(width.checked_sub(operator_str.len())), offset)); + let subexpr = + try_opt!(expr.rewrite(context, try_opt!(width.checked_sub(operator_str.len())), offset)); Some(format!("{}{}", operator_str, subexpr)) } + +fn rewrite_assignment(context: &RewriteContext, + lhs: &ast::Expr, + rhs: &ast::Expr, + op: Option<&ast::BinOp>, + width: usize, + offset: usize) + -> Option { + let operator_str = match op { + Some(op) => context.codemap.span_to_snippet(op.span).unwrap(), + None => "=".to_owned(), + }; + + // 1 = space between lhs and operator. + let max_width = try_opt!(width.checked_sub(operator_str.len() + 1)); + let lhs_str = format!("{} {}", try_opt!(lhs.rewrite(context, max_width, offset)), operator_str); + + rewrite_assign_rhs(&context, lhs_str, rhs, width, offset) +} + +// The left hand side must contain everything up to, and including, the +// assignment operator. +pub fn rewrite_assign_rhs>(context: &RewriteContext, + lhs: S, + ex: &ast::Expr, + width: usize, + offset: usize) + -> Option { + let mut result = lhs.into(); + + // 1 = space between operator and rhs. + let max_width = try_opt!(width.checked_sub(result.len() + 1)); + let rhs = ex.rewrite(&context, max_width, offset + result.len() + 1); + + match rhs { + Some(new_str) => { + result.push(' '); + result.push_str(&new_str) + } + None => { + // Expression did not fit on the same line as the identifier. Retry + // on the next line. + let new_offset = offset + context.config.tab_spaces; + result.push_str(&format!("\n{}", make_indent(new_offset))); + + let max_width = try_opt!(context.config.max_width.checked_sub(new_offset + 1)); + let rhs = try_opt!(ex.rewrite(&context, max_width, new_offset)); + + result.push_str(&rhs); + } + } + + Some(result) +} diff --git a/src/issues.rs b/src/issues.rs index e9f8255cc91..7d100d6db2a 100644 --- a/src/issues.rs +++ b/src/issues.rs @@ -214,10 +214,7 @@ fn inspect_number(&mut self, NumberPart::CloseParen => {} } - self.state = Seeking::Number { - part: part, - issue: issue - }; + self.state = Seeking::Number { part: part, issue: issue }; IssueClassification::None } diff --git a/src/items.rs b/src/items.rs index e39638ba427..1501a904fdf 100644 --- a/src/items.rs +++ b/src/items.rs @@ -14,8 +14,10 @@ use utils::{format_mutability, format_visibility, make_indent, contains_skip, span_after, end_typaram}; use lists::{write_list, itemize_list, ListItem, ListFormatting, SeparatorTactic, ListTactic}; +use expr::rewrite_assign_rhs; use comment::FindUncommented; use visitor::FmtVisitor; + use rewrite::Rewrite; use config::Config; @@ -25,6 +27,67 @@ use syntax::parse::token; impl<'a> FmtVisitor<'a> { + pub fn visit_let(&mut self, local: &ast::Local, span: Span) { + self.format_missing_with_indent(span.lo); + + // String that is placed within the assignment pattern and expression. + let infix = { + let mut infix = String::new(); + + if let Some(ref ty) = local.ty { + infix.push_str(": "); + infix.push_str(&pprust::ty_to_string(ty)); + } + + if local.init.is_some() { + infix.push_str(" ="); + } + + infix + }; + + // New scope so we drop the borrow of self (context) in time to mutably + // borrow self to mutate its buffer. + let result = { + let context = self.get_context(); + let mut result = "let ".to_owned(); + let pattern_offset = self.block_indent + result.len() + infix.len(); + // 1 = ; + let pattern_width = match self.config.max_width.checked_sub(pattern_offset + 1) { + Some(width) => width, + None => return, + }; + + match local.pat.rewrite(&context, pattern_offset, pattern_width) { + Some(ref pat_string) => result.push_str(pat_string), + None => return, + } + + result.push_str(&infix); + + if let Some(ref ex) = local.init { + let max_width = match self.config.max_width.checked_sub(context.block_indent + 1) { + Some(width) => width, + None => return, + }; + + // 1 = trailing semicolon; + let rhs = rewrite_assign_rhs(&context, result, ex, max_width, context.block_indent); + + match rhs { + Some(result) => result, + None => return, + } + } else { + result + } + }; + + self.buffer.push_str(&result); + self.buffer.push_str(";"); + self.last_pos = span.hi; + } + pub fn rewrite_fn(&mut self, indent: usize, ident: ast::Ident, @@ -51,9 +114,11 @@ pub fn rewrite_fn(&mut self, span, newline_brace); - // Prepare for the function body by possibly adding a newline and indent. - // FIXME we'll miss anything between the end of the signature and the start - // of the body, but we need more spans from the compiler to solve this. + // Prepare for the function body by possibly adding a newline and + // indent. + // FIXME we'll miss anything between the end of the signature and the + // start of the body, but we need more spans from the compiler to solve + // this. if newline_brace { result.push('\n'); result.push_str(&make_indent(indent)); @@ -783,7 +848,8 @@ fn rewrite_explicit_self(explicit_self: &ast::ExplicitSelf, args: &[ast::Arg]) - // this hacky solution caused by absence of `Mutability` in `SelfValue`. let mut_str = { - if let ast::Pat_::PatIdent(ast::BindingMode::BindByValue(mutability), _, _) = args[0].pat.node { + if let ast::Pat_::PatIdent(ast::BindingMode::BindByValue(mutability), _, _) = + args[0].pat.node { format_mutability(mutability) } else { panic!("there is a bug or change in structure of AST, aborting."); diff --git a/src/lib.rs b/src/lib.rs index 4efd919649a..f410f7e5468 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -325,6 +325,8 @@ fn no_input(&mut self, panic!("No input supplied to RustFmt"); } + #[rustfmt_skip] + // FIXME(#195): closure is formatted poorly. fn build_controller(&mut self, _: &Session) -> driver::CompileController<'a> { let write_mode = self.write_mode; diff --git a/src/lists.rs b/src/lists.rs index 12c8d14574a..931baaa1073 100644 --- a/src/lists.rs +++ b/src/lists.rs @@ -99,7 +99,7 @@ pub fn write_list<'b>(items: &[ListItem], formatting: &ListFormatting<'b>) -> St let mut tactic = formatting.tactic; // Conservatively overestimates because of the changing separator tactic. - let sep_count = if formatting.trailing_separator != SeparatorTactic::Never { + let sep_count = if formatting.trailing_separator == SeparatorTactic::Always { items.len() } else { items.len() - 1 @@ -113,8 +113,7 @@ pub fn write_list<'b>(items: &[ListItem], formatting: &ListFormatting<'b>) -> St if tactic == ListTactic::HorizontalVertical { debug!("write_list: total_width: {}, total_sep_len: {}, h_width: {}", total_width, total_sep_len, formatting.h_width); - tactic = if fits_single && - !items.iter().any(ListItem::is_multiline) { + tactic = if fits_single && !items.iter().any(ListItem::is_multiline) { ListTactic::Horizontal } else { ListTactic::Vertical @@ -187,13 +186,11 @@ pub fn write_list<'b>(items: &[ListItem], formatting: &ListFormatting<'b>) -> St // Pre-comments if let Some(ref comment) = item.pre_comment { - result.push_str(&rewrite_comment(comment, - // Block style in non-vertical mode - tactic != ListTactic::Vertical, - // Width restriction is only - // relevant in vertical mode. - formatting.v_width, - formatting.indent)); + // Block style in non-vertical mode. + let block_mode = tactic != ListTactic::Vertical; + // Width restriction is only relevant in vertical mode. + let max_width = formatting.v_width; + result.push_str(&rewrite_comment(comment, block_mode, max_width, formatting.indent)); if tactic == ListTactic::Vertical { result.push('\n'); diff --git a/src/visitor.rs b/src/visitor.rs index fccd619d403..e479b49f06a 100644 --- a/src/visitor.rs +++ b/src/visitor.rs @@ -28,6 +28,8 @@ pub struct FmtVisitor<'a> { } impl<'a, 'v> visit::Visitor<'v> for FmtVisitor<'a> { + // FIXME: We'd rather not format expressions here, as we have little + // context. How are we still reaching this? fn visit_expr(&mut self, ex: &'v ast::Expr) { debug!("visit_expr: {:?} {:?}", self.codemap.lookup_char_pos(ex.span.lo), @@ -44,23 +46,37 @@ fn visit_expr(&mut self, ex: &'v ast::Expr) { } fn visit_stmt(&mut self, stmt: &'v ast::Stmt) { - // If the stmt is actually an item, then we'll handle any missing spans - // there. This is important because of annotations. - // Although it might make more sense for the statement span to include - // any annotations on the item. - let skip_missing = match stmt.node { + match stmt.node { ast::Stmt_::StmtDecl(ref decl, _) => { - match decl.node { - ast::Decl_::DeclItem(_) => true, - _ => false, + return match decl.node { + ast::Decl_::DeclLocal(ref local) => self.visit_let(local, stmt.span), + ast::Decl_::DeclItem(..) => visit::walk_stmt(self, stmt), + }; + } + ast::Stmt_::StmtExpr(ref ex, _) | ast::Stmt_::StmtSemi(ref ex, _) => { + self.format_missing_with_indent(stmt.span.lo); + let suffix = if let ast::Stmt_::StmtExpr(..) = stmt.node { + "" + } else { + ";" + }; + + // 1 = trailing semicolon; + let rewrite = ex.rewrite(&self.get_context(), + self.config.max_width - self.block_indent - suffix.len(), + self.block_indent); + + if let Some(new_str) = rewrite { + self.buffer.push_str(&new_str); + self.buffer.push_str(suffix); + self.last_pos = stmt.span.hi; } } - _ => false, - }; - if !skip_missing { - self.format_missing_with_indent(stmt.span.lo); + ast::Stmt_::StmtMac(..) => { + self.format_missing_with_indent(stmt.span.lo); + visit::walk_stmt(self, stmt); + } } - visit::walk_stmt(self, stmt); } fn visit_block(&mut self, b: &'v ast::Block) { diff --git a/tests/source/assignment.rs b/tests/source/assignment.rs new file mode 100644 index 00000000000..347966cf555 --- /dev/null +++ b/tests/source/assignment.rs @@ -0,0 +1,16 @@ +// Test assignment + +fn main() { + let some_var : Type ; + + let mut mutable; + + let variable = AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA::BBBBBBBBBBBBBBBBBBBBBB::CCCCCCCCCCCCCCCCCCCCCC::EEEEEE; + + variable = LOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOONG; + + let single_line_fit = + DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; + + single_line_fit = 5;single_lit_fit >>= 10; +} diff --git a/tests/source/expr.rs b/tests/source/expr.rs index 6b3b3daf0a9..d304093ebb2 100644 --- a/tests/source/expr.rs +++ b/tests/source/expr.rs @@ -2,23 +2,22 @@ fn foo() -> bool { let boxed: Box = box 5; - let referenced = &5; + let referenced = &5 ; let very_long_variable_name = ( a + first + simple + test ); let very_long_variable_name = (a + first + simple + test + AAAAAAAAAAAAA + BBBBBBBBBBBBBBBBB + b + c); - //FIXME this exceeds width limit. Needs assignments reformatting let is_internalxxxx = self.codemap.span_to_filename(s) == self.codemap.span_to_filename(m.inner); let some_val = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbb / (bbbbbb - function_call(x, *very_long_pointer, y)) - + 1000; + + 1000 ; some_ridiculously_loooooooooooooooooooooong_function(10000 * 30000000000 + 40000 / 1002200000000 - 50000 * sqrt(-1), trivial_value); (((((((((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + a + - aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaa))))))))); + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaa))))))))) ; { for _ in 0..10 {} } @@ -64,9 +63,9 @@ fn bar() { syntactically_correct(loop { sup( '?'); }, if cond { 0 } else { 1 }); let third = ..10; - let infi_range = ..; + let infi_range = .. ; let foo = 1..; - let bar = 5; + let bar = 5 ; let nonsense = (10 .. 0)..(0..10); let x = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && diff --git a/tests/source/paths.rs b/tests/source/paths.rs index 4225aa9dab3..51edf707645 100644 --- a/tests/source/paths.rs +++ b/tests/source/paths.rs @@ -15,8 +15,6 @@ fn main() { Quux::::some_func(); - - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA::BBBBBBBBBBBBBBBBBBBBBBBBBBBB::CCCCCCCCCCCCCCCCCCCCCC::quux(); } fn op(foo: Bar, key : &[u8], upd : Fn(Option<&memcache::Item> , Baz ) -> Result) -> MapResult {} diff --git a/tests/target/assignment.rs b/tests/target/assignment.rs new file mode 100644 index 00000000000..72b85a53e55 --- /dev/null +++ b/tests/target/assignment.rs @@ -0,0 +1,18 @@ +// Test assignment + +fn main() { + let some_var: Type; + + let mut mutable; + + let variable = + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA::BBBBBBBBBBBBBBBBBBBBBB::CCCCCCCCCCCCCCCCCCCCCC::EEEEEE; + + variable = + LOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOONG; + + let single_line_fit = DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD; + + single_line_fit = 5; + single_lit_fit >>= 10; +} diff --git a/tests/target/expr.rs b/tests/target/expr.rs index dfbf0032011..df5e98e4f1b 100644 --- a/tests/target/expr.rs +++ b/tests/target/expr.rs @@ -8,8 +8,8 @@ fn foo() -> bool { let very_long_variable_name = (a + first + simple + test + AAAAAAAAAAAAA + BBBBBBBBBBBBBBBBB + b + c); - //FIXME this exceeds width limit. Needs assignments reformatting - let is_internalxxxx = self.codemap.span_to_filename(s) == self.codemap.span_to_filename(m.inner); + let is_internalxxxx = self.codemap.span_to_filename(s) == + self.codemap.span_to_filename(m.inner); let some_val = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbb / (bbbbbb - function_call(x, *very_long_pointer, y)) + 1000; diff --git a/tests/target/multiple.rs b/tests/target/multiple.rs index 5573ea7e96e..b6e4750d886 100644 --- a/tests/target/multiple.rs +++ b/tests/target/multiple.rs @@ -134,7 +134,7 @@ fn main() { 42usize); let rc = RefCell::new(42usize, remaining_width, remaining_width); // a comment let x = "Hello!!!!!!!!! abcd abcd abcd abcd abcd abcd\n abcd abcd abcd abcd abcd abcd abcd \ - abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd \ + abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd \ abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd abcd \ - abcd"; + abcd abcd"; } diff --git a/tests/target/paths.rs b/tests/target/paths.rs index c358104e1fa..c69275c7ff9 100644 --- a/tests/target/paths.rs +++ b/tests/target/paths.rs @@ -13,8 +13,6 @@ fn main() { supports_clipboard); Quux::::some_func(); - - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA::BBBBBBBBBBBBBBBBBBBBBBBBBBBB::CCCCCCCCCCCCCCCCCCCCCC::quux(); } fn op(foo: Bar, key: &[u8], upd: Fn(Option<&memcache::Item>, Baz) -> Result) -> MapResult { diff --git a/tests/target/string-lit.rs b/tests/target/string-lit.rs index 2ccb3480d6f..f90461030ac 100644 --- a/tests/target/string-lit.rs +++ b/tests/target/string-lit.rs @@ -3,21 +3,22 @@ fn main() -> &'static str { let str = "AAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAaAA \ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAa"; - let str = "AAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAAAAAAA\ - AAAAAAAAAAAaAa"; + let str = "AAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAAAAAA\ + AAAAAAAAAAAAaAa"; let str = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; let too_many_lines = "Hello"; // Make sure we don't break after an escape character. - let odd_length_name = "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\ - \n\n"; + let odd_length_name = "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\ + \n\n\n"; let even_length_name = "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\ \n\n\n"; - let really_long_variable_name = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\ - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\ - AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + let really_long_variable_name = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\ + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\ + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\ + AA"; let raw_string = r#"Do not diff --git a/tests/target/struct_lits_visual.rs b/tests/target/struct_lits_visual.rs index bf73db5a815..77467a40ce7 100644 --- a/tests/target/struct_lits_visual.rs +++ b/tests/target/struct_lits_visual.rs @@ -13,10 +13,10 @@ fn main() { b: bar(), ..something }; - Fooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo { a: foo(), - b: bar(), }; + Fooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo { a: foo(), b: bar() }; - Foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo { // Comment + Foooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo { // Commen + // t a: foo(), /* C * o * m @@ -24,7 +24,8 @@ fn main() { * e * n * t */ - // Comment + // Commen + // t b: bar(), /* C * o * m