Merge remote-tracking branch 'upstream/master' into win-test-crlf

Author: wada314

src/comment.rs

@@ -464,7 +464,7 @@ impl FindUncommented for str {
                     return Some(i - pat.len());
                 }
                 Some(c) => match kind {
-                    FullCodeCharKind::Normal if b == c => {}
+                    FullCodeCharKind::Normal | FullCodeCharKind::InString if b == c => {}
                     _ => {
                         needle_iter = pat.chars();
                     }
@@ -487,7 +487,7 @@ impl FindUncommented for str {
 pub fn find_comment_end(s: &str) -> Option<usize> {
     let mut iter = CharClasses::new(s.char_indices());
     for (kind, (i, _c)) in &mut iter {
-        if kind == FullCodeCharKind::Normal {
+        if kind == FullCodeCharKind::Normal || kind == FullCodeCharKind::InString {
             return Some(i);
         }
     }
@@ -505,6 +505,35 @@ pub fn contains_comment(text: &str) -> bool {
     CharClasses::new(text.chars()).any(|(kind, _)| kind.is_comment())
 }
 
+/// Remove trailing spaces from the specified snippet. We do not remove spaces
+/// inside strings or comments.
+pub fn remove_trailing_white_spaces(text: &str) -> String {
+    let mut buffer = String::with_capacity(text.len());
+    let mut space_buffer = String::with_capacity(128);
+    for (char_kind, c) in CharClasses::new(text.chars()) {
+        match c {
+            '\n' => {
+                if char_kind == FullCodeCharKind::InString {
+                    buffer.push_str(&space_buffer);
+                }
+                space_buffer.clear();
+                buffer.push('\n');
+            }
+            _ if c.is_whitespace() => {
+                space_buffer.push(c);
+            }
+            _ => {
+                if !space_buffer.is_empty() {
+                    buffer.push_str(&space_buffer);
+                    space_buffer.clear();
+                }
+                buffer.push(c);
+            }
+        }
+    }
+    buffer
+}
+
 struct CharClasses<T>
 where
     T: Iterator,
@@ -568,15 +597,17 @@ enum FullCodeCharKind {
     InComment,
     /// Last character of a comment, '\n' for a line comment, '/' for a block comment.
     EndComment,
+    /// Inside a string.
+    InString,
 }
 
 impl FullCodeCharKind {
     fn is_comment(&self) -> bool {
         match *self {
-            FullCodeCharKind::Normal => false,
             FullCodeCharKind::StartComment |
             FullCodeCharKind::InComment |
             FullCodeCharKind::EndComment => true,
+            _ => false,
         }
     }
 
@@ -612,21 +643,34 @@ where
     fn next(&mut self) -> Option<(FullCodeCharKind, T::Item)> {
         let item = try_opt!(self.base.next());
         let chr = item.get_char();
+        let mut char_kind = FullCodeCharKind::Normal;
         self.status = match self.status {
             CharClassesStatus::LitString => match chr {
                 '"' => CharClassesStatus::Normal,
-                '\\' => CharClassesStatus::LitStringEscape,
-                _ => CharClassesStatus::LitString,
+                '\\' => {
+                    char_kind = FullCodeCharKind::InString;
+                    CharClassesStatus::LitStringEscape
+                }
+                _ => {
+                    char_kind = FullCodeCharKind::InString;
+                    CharClassesStatus::LitString
+                }
             },
-            CharClassesStatus::LitStringEscape => CharClassesStatus::LitString,
+            CharClassesStatus::LitStringEscape => {
+                char_kind = FullCodeCharKind::InString;
+                CharClassesStatus::LitString
+            }
             CharClassesStatus::LitChar => match chr {
                 '\\' => CharClassesStatus::LitCharEscape,
                 '\'' => CharClassesStatus::Normal,
                 _ => CharClassesStatus::LitChar,
             },
             CharClassesStatus::LitCharEscape => CharClassesStatus::LitChar,
             CharClassesStatus::Normal => match chr {
-                '"' => CharClassesStatus::LitString,
+                '"' => {
+                    char_kind = FullCodeCharKind::InString;
+                    CharClassesStatus::LitString
+                }
                 '\'' => CharClassesStatus::LitChar,
                 '/' => match self.base.peek() {
                     Some(next) if next.get_char() == '*' => {
@@ -680,7 +724,7 @@ where
                 }
             },
         };
-        Some((FullCodeCharKind::Normal, item))
+        Some((char_kind, item))
     }
 }
 
@@ -707,9 +751,12 @@ impl<'a> Iterator for UngroupedCommentCodeSlices<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         let (kind, (start_idx, _)) = try_opt!(self.iter.next());
         match kind {
-            FullCodeCharKind::Normal => {
+            FullCodeCharKind::Normal | FullCodeCharKind::InString => {
                 // Consume all the Normal code
-                while let Some(&(FullCodeCharKind::Normal, (_, _))) = self.iter.peek() {
+                while let Some(&(char_kind, _)) = self.iter.peek() {
+                    if char_kind.is_comment() {
+                        break;
+                    }
                     let _ = self.iter.next();
                 }
             }
@@ -1032,7 +1079,7 @@ mod test {
     fn uncommented(text: &str) -> String {
         CharClasses::new(text.chars())
             .filter_map(|(s, c)| match s {
-                FullCodeCharKind::Normal => Some(c),
+                FullCodeCharKind::Normal | FullCodeCharKind::InString => Some(c),
                 _ => None,
             })
             .collect()

src/expr.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::cmp::{min, Ordering};
+use std::cmp::min;
 use std::borrow::Cow;
 use std::fmt::Write;
 use std::iter::{repeat, ExactSizeIterator};
@@ -72,12 +72,7 @@ pub fn format_expr(
             shape,
             false,
         ),
-        ast::ExprKind::Lit(ref l) => match l.node {
-            ast::LitKind::Str(_, ast::StrStyle::Cooked) => {
-                rewrite_string_lit(context, l.span, shape)
-            }
-            _ => Some(context.snippet(expr.span)),
-        },
+        ast::ExprKind::Lit(ref l) => rewrite_literal(context, l, shape),
         ast::ExprKind::Call(ref callee, ref args) => {
             let inner_span = mk_sp(callee.span.hi(), expr.span.hi());
             let callee_str = try_opt!(callee.rewrite(context, shape));
@@ -1938,6 +1933,13 @@ fn rewrite_pat_expr(
         .map(|expr_rw| format!("\n{}{}", nested_indent_str, expr_rw))
 }
 
+pub fn rewrite_literal(context: &RewriteContext, l: &ast::Lit, shape: Shape) -> Option<String> {
+    match l.node {
+        ast::LitKind::Str(_, ast::StrStyle::Cooked) => rewrite_string_lit(context, l.span, shape),
+        _ => Some(context.snippet(l.span)),
+    }
+}
+
 fn rewrite_string_lit(context: &RewriteContext, span: Span, shape: Shape) -> Option<String> {
     let string_lit = context.snippet(span);
 
@@ -1974,20 +1976,10 @@ fn rewrite_string_lit(context: &RewriteContext, span: Span, shape: Shape) -> Opt
         return Some(string_lit);
     }
 
-    let fmt = StringFormat {
-        opener: "\"",
-        closer: "\"",
-        line_start: " ",
-        line_end: "\\",
-        shape: shape,
-        trim_end: false,
-        config: context.config,
-    };
-
     // Remove the quote characters.
     let str_lit = &string_lit[1..string_lit.len() - 1];
 
-    rewrite_string(str_lit, &fmt)
+    rewrite_string(str_lit, &StringFormat::new(shape, context.config))
 }
 
 fn string_requires_rewrite(
@@ -2033,7 +2025,7 @@ pub fn rewrite_call(
         shape,
         context.config.fn_call_width(),
         force_trailing_comma,
-    ).ok()
+    )
 }
 
 pub fn rewrite_call_inner<'a, T>(
@@ -2044,7 +2036,7 @@ pub fn rewrite_call_inner<'a, T>(
     shape: Shape,
     args_max_width: usize,
     force_trailing_comma: bool,
-) -> Result<String, Ordering>
+) -> Option<String>
 where
     T: Rewrite + Spanned + ToExpr + 'a,
 {
@@ -2055,30 +2047,27 @@ where
         1
     };
     let used_width = extra_offset(callee_str, shape);
-    let one_line_width = shape
-        .width
-        .checked_sub(used_width + 2 * paren_overhead)
-        .ok_or(Ordering::Greater)?;
+    let one_line_width = try_opt!(shape.width.checked_sub(used_width + 2 * paren_overhead));
 
-    let nested_shape = shape_from_fn_call_style(
+    let nested_shape = try_opt!(shape_from_fn_call_style(
         context,
         shape,
         used_width + 2 * paren_overhead,
         used_width + paren_overhead,
-    ).ok_or(Ordering::Greater)?;
+    ));
 
     let span_lo = context.codemap.span_after(span, "(");
     let args_span = mk_sp(span_lo, span.hi());
 
-    let (extendable, list_str) = rewrite_call_args(
+    let (extendable, list_str) = try_opt!(rewrite_call_args(
         context,
         args,
         args_span,
         nested_shape,
         one_line_width,
         args_max_width,
         force_trailing_comma,
-    ).ok_or(Ordering::Less)?;
+    ));
 
     if !context.use_block_indent() && need_block_indent(&list_str, nested_shape) && !extendable {
         let mut new_context = context.clone();
@@ -2094,10 +2083,8 @@ where
         );
     }
 
-    let args_shape = shape
-        .sub_width(last_line_width(callee_str))
-        .ok_or(Ordering::Less)?;
-    Ok(format!(
+    let args_shape = try_opt!(shape.sub_width(last_line_width(callee_str)));
+    Some(format!(
         "{}{}",
         callee_str,
         wrap_args_with_parens(context, &list_str, extendable, args_shape, nested_shape)
@@ -2805,7 +2792,7 @@ where
             shape,
             context.config.fn_call_width(),
             force_trailing_comma,
-        ).ok()
+        )
     } else {
         rewrite_tuple_in_visual_indent_style(context, items, span, shape)
     }
@@ -2895,7 +2882,7 @@ pub fn rewrite_assign_rhs<S: Into<String>>(
     let rhs = try_opt!(choose_rhs(
         context,
         ex,
-        shape,
+        orig_shape,
         ex.rewrite(context, orig_shape)
     ));
     Some(lhs + &rhs)
@@ -2908,7 +2895,9 @@ fn choose_rhs(
     orig_rhs: Option<String>,
 ) -> Option<String> {
     match orig_rhs {
-        Some(ref new_str) if !new_str.contains('\n') => Some(format!(" {}", new_str)),
+        Some(ref new_str) if !new_str.contains('\n') && new_str.len() <= shape.width => {
+            Some(format!(" {}", new_str))
+        }
         _ => {
             // Expression did not fit on the same line as the identifier.
             // Try splitting the line and see if that works better.