src/comment.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Formatting and tools for comments.
  12
  13 use std::{self, borrow::Cow, iter};
  14
  15 use itertools::{multipeek, MultiPeek};
  16 use syntax::source_map::Span;
  17
  18 use config::Config;
  19 use rewrite::RewriteContext;
  20 use shape::{Indent, Shape};
  21 use string::{rewrite_string, StringFormat};
  22 use utils::{count_newlines, first_line_width, last_line_width};
  23 use {ErrorKind, FormattingError};
  24
  25 fn is_custom_comment(comment: &str) -> bool {
  26     if !comment.starts_with("//") {
  27         false
  28     } else if let Some(c) = comment.chars().nth(2) {
  29         !c.is_alphanumeric() && !c.is_whitespace()
  30     } else {
  31         false
  32     }
  33 }
  34
  35 #[derive(Copy, Clone, PartialEq, Eq)]
  36 pub enum CommentStyle<'a> {
  37     DoubleSlash,
  38     TripleSlash,
  39     Doc,
  40     SingleBullet,
  41     DoubleBullet,
  42     Exclamation,
  43     Custom(&'a str),
  44 }
  45
  46 fn custom_opener(s: &str) -> &str {
  47     s.lines().next().map_or("", |first_line| {
  48         first_line
  49             .find(' ')
  50             .map_or(first_line, |space_index| &first_line[0..space_index + 1])
  51     })
  52 }
  53
  54 impl<'a> CommentStyle<'a> {
  55     pub fn is_doc_comment(&self) -> bool {
  56         match *self {
  57             CommentStyle::TripleSlash | CommentStyle::Doc => true,
  58             _ => false,
  59         }
  60     }
  61
  62     pub fn opener(&self) -> &'a str {
  63         match *self {
  64             CommentStyle::DoubleSlash => "// ",
  65             CommentStyle::TripleSlash => "/// ",
  66             CommentStyle::Doc => "//! ",
  67             CommentStyle::SingleBullet => "/* ",
  68             CommentStyle::DoubleBullet => "/** ",
  69             CommentStyle::Exclamation => "/*! ",
  70             CommentStyle::Custom(opener) => opener,
  71         }
  72     }
  73
  74     pub fn closer(&self) -> &'a str {
  75         match *self {
  76             CommentStyle::DoubleSlash
  77             | CommentStyle::TripleSlash
  78             | CommentStyle::Custom(..)
  79             | CommentStyle::Doc => "",
  80             CommentStyle::DoubleBullet => " **/",
  81             CommentStyle::SingleBullet | CommentStyle::Exclamation => " */",
  82         }
  83     }
  84
  85     pub fn line_start(&self) -> &'a str {
  86         match *self {
  87             CommentStyle::DoubleSlash => "// ",
  88             CommentStyle::TripleSlash => "/// ",
  89             CommentStyle::Doc => "//! ",
  90             CommentStyle::SingleBullet | CommentStyle::Exclamation => " * ",
  91             CommentStyle::DoubleBullet => " ** ",
  92             CommentStyle::Custom(opener) => opener,
  93         }
  94     }
  95
  96     pub fn to_str_tuplet(&self) -> (&'a str, &'a str, &'a str) {
  97         (self.opener(), self.closer(), self.line_start())
  98     }
  99 }
 100
 101 fn comment_style(orig: &str, normalize_comments: bool) -> CommentStyle {
 102     if !normalize_comments {
 103         if orig.starts_with("/**") && !orig.starts_with("/**/") {
 104             CommentStyle::DoubleBullet
 105         } else if orig.starts_with("/*!") {
 106             CommentStyle::Exclamation
 107         } else if orig.starts_with("/*") {
 108             CommentStyle::SingleBullet
 109         } else if orig.starts_with("///") && orig.chars().nth(3).map_or(true, |c| c != '/') {
 110             CommentStyle::TripleSlash
 111         } else if orig.starts_with("//!") {
 112             CommentStyle::Doc
 113         } else if is_custom_comment(orig) {
 114             CommentStyle::Custom(custom_opener(orig))
 115         } else {
 116             CommentStyle::DoubleSlash
 117         }
 118     } else if (orig.starts_with("///") && orig.chars().nth(3).map_or(true, |c| c != '/'))
 119         || (orig.starts_with("/**") && !orig.starts_with("/**/"))
 120     {
 121         CommentStyle::TripleSlash
 122     } else if orig.starts_with("//!") || orig.starts_with("/*!") {
 123         CommentStyle::Doc
 124     } else if is_custom_comment(orig) {
 125         CommentStyle::Custom(custom_opener(orig))
 126     } else {
 127         CommentStyle::DoubleSlash
 128     }
 129 }
 130
 131 /// Combine `prev_str` and `next_str` into a single `String`. `span` may contain
 132 /// comments between two strings. If there are such comments, then that will be
 133 /// recovered. If `allow_extend` is true and there is no comment between the two
 134 /// strings, then they will be put on a single line as long as doing so does not
 135 /// exceed max width.
 136 pub fn combine_strs_with_missing_comments(
 137     context: &RewriteContext,
 138     prev_str: &str,
 139     next_str: &str,
 140     span: Span,
 141     shape: Shape,
 142     allow_extend: bool,
 143 ) -> Option<String> {
 144     let mut result =
 145         String::with_capacity(prev_str.len() + next_str.len() + shape.indent.width() + 128);
 146     result.push_str(prev_str);
 147     let mut allow_one_line = !prev_str.contains('\n') && !next_str.contains('\n');
 148     let first_sep = if prev_str.is_empty() || next_str.is_empty() {
 149         ""
 150     } else {
 151         " "
 152     };
 153     let mut one_line_width =
 154         last_line_width(prev_str) + first_line_width(next_str) + first_sep.len();
 155
 156     let config = context.config;
 157     let indent = shape.indent;
 158     let missing_comment = rewrite_missing_comment(span, shape, context)?;
 159
 160     if missing_comment.is_empty() {
 161         if allow_extend && prev_str.len() + first_sep.len() + next_str.len() <= shape.width {
 162             result.push_str(first_sep);
 163         } else if !prev_str.is_empty() {
 164             result.push_str(&indent.to_string_with_newline(config))
 165         }
 166         result.push_str(next_str);
 167         return Some(result);
 168     }
 169
 170     // We have a missing comment between the first expression and the second expression.
 171
 172     // Peek the the original source code and find out whether there is a newline between the first
 173     // expression and the second expression or the missing comment. We will preserve the original
 174     // layout whenever possible.
 175     let original_snippet = context.snippet(span);
 176     let prefer_same_line = if let Some(pos) = original_snippet.find('/') {
 177         !original_snippet[..pos].contains('\n')
 178     } else {
 179         !original_snippet.contains('\n')
 180     };
 181
 182     one_line_width -= first_sep.len();
 183     let first_sep = if prev_str.is_empty() || missing_comment.is_empty() {
 184         Cow::from("")
 185     } else {
 186         let one_line_width = last_line_width(prev_str) + first_line_width(&missing_comment) + 1;
 187         if prefer_same_line && one_line_width <= shape.width {
 188             Cow::from(" ")
 189         } else {
 190             indent.to_string_with_newline(config)
 191         }
 192     };
 193     result.push_str(&first_sep);
 194     result.push_str(&missing_comment);
 195
 196     let second_sep = if missing_comment.is_empty() || next_str.is_empty() {
 197         Cow::from("")
 198     } else if missing_comment.starts_with("//") {
 199         indent.to_string_with_newline(config)
 200     } else {
 201         one_line_width += missing_comment.len() + first_sep.len() + 1;
 202         allow_one_line &= !missing_comment.starts_with("//") && !missing_comment.contains('\n');
 203         if prefer_same_line && allow_one_line && one_line_width <= shape.width {
 204             Cow::from(" ")
 205         } else {
 206             indent.to_string_with_newline(config)
 207         }
 208     };
 209     result.push_str(&second_sep);
 210     result.push_str(next_str);
 211
 212     Some(result)
 213 }
 214
 215 pub fn rewrite_doc_comment(orig: &str, shape: Shape, config: &Config) -> Option<String> {
 216     _rewrite_comment(orig, false, shape, config, true)
 217 }
 218
 219 pub fn rewrite_comment(
 220     orig: &str,
 221     block_style: bool,
 222     shape: Shape,
 223     config: &Config,
 224 ) -> Option<String> {
 225     _rewrite_comment(orig, block_style, shape, config, false)
 226 }
 227
 228 fn _rewrite_comment(
 229     orig: &str,
 230     block_style: bool,
 231     shape: Shape,
 232     config: &Config,
 233     is_doc_comment: bool,
 234 ) -> Option<String> {
 235     // If there are lines without a starting sigil, we won't format them correctly
 236     // so in that case we won't even re-align (if !config.normalize_comments()) and
 237     // we should stop now.
 238     let num_bare_lines = orig
 239         .lines()
 240         .map(|line| line.trim())
 241         .filter(|l| !(l.starts_with('*') || l.starts_with("//") || l.starts_with("/*")))
 242         .count();
 243     if num_bare_lines > 0 && !config.normalize_comments() {
 244         return Some(orig.to_owned());
 245     }
 246     if !config.normalize_comments() && !config.wrap_comments() {
 247         return light_rewrite_comment(orig, shape.indent, config, is_doc_comment);
 248     }
 249
 250     identify_comment(orig, block_style, shape, config, is_doc_comment)
 251 }
 252
 253 fn identify_comment(
 254     orig: &str,
 255     block_style: bool,
 256     shape: Shape,
 257     config: &Config,
 258     is_doc_comment: bool,
 259 ) -> Option<String> {
 260     let style = comment_style(orig, false);
 261     let mut first_group_ending = 0;
 262
 263     fn compute_len(orig: &str, line: &str) -> usize {
 264         if orig.len() > line.len() {
 265             if orig.as_bytes()[line.len()] == b'\r' {
 266                 line.len() + 2
 267             } else {
 268                 line.len() + 1
 269             }
 270         } else {
 271             line.len()
 272         }
 273     }
 274
 275     match style {
 276         CommentStyle::DoubleSlash | CommentStyle::TripleSlash | CommentStyle::Doc => {
 277             let line_start = style.line_start().trim_left();
 278             for line in orig.lines() {
 279                 if line.trim_left().starts_with(line_start) || comment_style(line, false) == style {
 280                     first_group_ending += compute_len(&orig[first_group_ending..], line);
 281                 } else {
 282                     break;
 283                 }
 284             }
 285         }
 286         CommentStyle::Custom(opener) => {
 287             let trimmed_opener = opener.trim_right();
 288             for line in orig.lines() {
 289                 if line.trim_left().starts_with(trimmed_opener) {
 290                     first_group_ending += compute_len(&orig[first_group_ending..], line);
 291                 } else {
 292                     break;
 293                 }
 294             }
 295         }
 296         // for a block comment, search for the closing symbol
 297         CommentStyle::DoubleBullet | CommentStyle::SingleBullet | CommentStyle::Exclamation => {
 298             let closer = style.closer().trim_left();
 299             for line in orig.lines() {
 300                 first_group_ending += compute_len(&orig[first_group_ending..], line);
 301                 if line.trim_left().ends_with(closer) {
 302                     break;
 303                 }
 304             }
 305         }
 306     }
 307
 308     let (first_group, rest) = orig.split_at(first_group_ending);
 309     let first_group_str = rewrite_comment_inner(
 310         first_group,
 311         block_style,
 312         style,
 313         shape,
 314         config,
 315         is_doc_comment || style.is_doc_comment(),
 316     )?;
 317     if rest.is_empty() {
 318         Some(first_group_str)
 319     } else {
 320         identify_comment(rest, block_style, shape, config, is_doc_comment).map(|rest_str| {
 321             format!(
 322                 "{}\n{}{}",
 323                 first_group_str,
 324                 shape.indent.to_string(config),
 325                 rest_str
 326             )
 327         })
 328     }
 329 }
 330
 331 fn rewrite_comment_inner(
 332     orig: &str,
 333     block_style: bool,
 334     style: CommentStyle,
 335     shape: Shape,
 336     config: &Config,
 337     is_doc_comment: bool,
 338 ) -> Option<String> {
 339     let (opener, closer, line_start) = if block_style {
 340         CommentStyle::SingleBullet.to_str_tuplet()
 341     } else {
 342         comment_style(orig, config.normalize_comments()).to_str_tuplet()
 343     };
 344
 345     let max_chars = shape
 346         .width
 347         .checked_sub(closer.len() + opener.len())
 348         .unwrap_or(1);
 349     let indent_str = shape.indent.to_string_with_newline(config);
 350     let fmt_indent = shape.indent + (opener.len() - line_start.len());
 351     let mut fmt = StringFormat {
 352         opener: "",
 353         closer: "",
 354         line_start,
 355         line_end: "",
 356         shape: Shape::legacy(max_chars, fmt_indent),
 357         trim_end: true,
 358         config,
 359     };
 360
 361     let line_breaks = count_newlines(orig.trim_right());
 362     let lines = orig
 363         .lines()
 364         .enumerate()
 365         .map(|(i, mut line)| {
 366             line = trim_right_unless_two_whitespaces(line.trim_left(), is_doc_comment);
 367             // Drop old closer.
 368             if i == line_breaks && line.ends_with("*/") && !line.starts_with("//") {
 369                 line = line[..(line.len() - 2)].trim_right();
 370             }
 371
 372             line
 373         }).map(|s| left_trim_comment_line(s, &style))
 374         .map(|(line, has_leading_whitespace)| {
 375             if orig.starts_with("/*") && line_breaks == 0 {
 376                 (
 377                     line.trim_left(),
 378                     has_leading_whitespace || config.normalize_comments(),
 379                 )
 380             } else {
 381                 (line, has_leading_whitespace || config.normalize_comments())
 382             }
 383         });
 384
 385     let mut result = String::with_capacity(orig.len() * 2);
 386     result.push_str(opener);
 387     let mut code_block_buffer = String::with_capacity(128);
 388     let mut is_prev_line_multi_line = false;
 389     let mut inside_code_block = false;
 390     let comment_line_separator = format!("{}{}", indent_str, line_start);
 391     let join_code_block_with_comment_line_separator = |s: &str| {
 392         let mut result = String::with_capacity(s.len() + 128);
 393         let mut iter = s.lines().peekable();
 394         while let Some(line) = iter.next() {
 395             result.push_str(line);
 396             result.push_str(match iter.peek() {
 397                 Some(next_line) if next_line.is_empty() => comment_line_separator.trim_right(),
 398                 Some(..) => &comment_line_separator,
 399                 None => "",
 400             });
 401         }
 402         result
 403     };
 404
 405     for (i, (line, has_leading_whitespace)) in lines.enumerate() {
 406         let is_last = i == count_newlines(orig);
 407
 408         if inside_code_block {
 409             if line.starts_with("```") {
 410                 inside_code_block = false;
 411                 result.push_str(&comment_line_separator);
 412                 let code_block = {
 413                     let mut config = config.clone();
 414                     config.set().wrap_comments(false);
 415                     match ::format_code_block(&code_block_buffer, &config) {
 416                         Some(ref s) => trim_custom_comment_prefix(s),
 417                         None => trim_custom_comment_prefix(&code_block_buffer),
 418                     }
 419                 };
 420                 result.push_str(&join_code_block_with_comment_line_separator(&code_block));
 421                 code_block_buffer.clear();
 422                 result.push_str(&comment_line_separator);
 423                 result.push_str(line);
 424             } else {
 425                 code_block_buffer.push_str(&hide_sharp_behind_comment(line));
 426                 code_block_buffer.push('\n');
 427
 428                 if is_last {
 429                     // There is an code block that is not properly enclosed by backticks.
 430                     // We will leave them untouched.
 431                     result.push_str(&comment_line_separator);
 432                     result.push_str(&join_code_block_with_comment_line_separator(
 433                         &trim_custom_comment_prefix(&code_block_buffer),
 434                     ));
 435                 }
 436             }
 437
 438             continue;
 439         } else {
 440             inside_code_block = line.starts_with("```");
 441
 442             if result == opener {
 443                 let force_leading_whitespace = opener == "/* " && count_newlines(orig) == 0;
 444                 if !has_leading_whitespace && !force_leading_whitespace && result.ends_with(' ') {
 445                     result.pop();
 446                 }
 447                 if line.is_empty() {
 448                     continue;
 449                 }
 450             } else if is_prev_line_multi_line && !line.is_empty() {
 451                 result.push(' ')
 452             } else if is_last && line.is_empty() {
 453                 // trailing blank lines are unwanted
 454                 if !closer.is_empty() {
 455                     result.push_str(&indent_str);
 456                 }
 457                 break;
 458             } else {
 459                 result.push_str(&comment_line_separator);
 460                 if !has_leading_whitespace && result.ends_with(' ') {
 461                     result.pop();
 462                 }
 463             }
 464         }
 465
 466         if config.wrap_comments() && line.len() > fmt.shape.width && !has_url(line) {
 467             match rewrite_string(line, &fmt) {
 468                 Some(ref s) => {
 469                     is_prev_line_multi_line = s.contains('\n');
 470                     result.push_str(s);
 471                 }
 472                 None if is_prev_line_multi_line => {
 473                     // We failed to put the current `line` next to the previous `line`.
 474                     // Remove the trailing space, then start rewrite on the next line.
 475                     result.pop();
 476                     result.push_str(&comment_line_separator);
 477                     fmt.shape = Shape::legacy(max_chars, fmt_indent);
 478                     match rewrite_string(line, &fmt) {
 479                         Some(ref s) => {
 480                             is_prev_line_multi_line = s.contains('\n');
 481                             result.push_str(s);
 482                         }
 483                         None => {
 484                             is_prev_line_multi_line = false;
 485                             result.push_str(line);
 486                         }
 487                     }
 488                 }
 489                 None => {
 490                     is_prev_line_multi_line = false;
 491                     result.push_str(line);
 492                 }
 493             }
 494
 495             fmt.shape = if is_prev_line_multi_line {
 496                 // 1 = " "
 497                 let offset = 1 + last_line_width(&result) - line_start.len();
 498                 Shape {
 499                     width: max_chars.saturating_sub(offset),
 500                     indent: fmt_indent,
 501                     offset: fmt.shape.offset + offset,
 502                 }
 503             } else {
 504                 Shape::legacy(max_chars, fmt_indent)
 505             };
 506         } else {
 507             if line.is_empty() && result.ends_with(' ') && !is_last {
 508                 // Remove space if this is an empty comment or a doc comment.
 509                 result.pop();
 510             }
 511             result.push_str(line);
 512             fmt.shape = Shape::legacy(max_chars, fmt_indent);
 513             is_prev_line_multi_line = false;
 514         }
 515     }
 516
 517     result.push_str(closer);
 518     if result.ends_with(opener) && opener.ends_with(' ') {
 519         // Trailing space.
 520         result.pop();
 521     }
 522
 523     Some(result)
 524 }
 525
 526 const RUSTFMT_CUSTOM_COMMENT_PREFIX: &str = "//#### ";
 527
 528 fn hide_sharp_behind_comment(s: &str) -> Cow<str> {
 529     if s.trim_left().starts_with("# ") {
 530         Cow::from(format!("{}{}", RUSTFMT_CUSTOM_COMMENT_PREFIX, s))
 531     } else {
 532         Cow::from(s)
 533     }
 534 }
 535
 536 fn trim_custom_comment_prefix(s: &str) -> String {
 537     s.lines()
 538         .map(|line| {
 539             let left_trimmed = line.trim_left();
 540             if left_trimmed.starts_with(RUSTFMT_CUSTOM_COMMENT_PREFIX) {
 541                 left_trimmed.trim_left_matches(RUSTFMT_CUSTOM_COMMENT_PREFIX)
 542             } else {
 543                 line
 544             }
 545         }).collect::<Vec<_>>()
 546         .join("\n")
 547 }
 548
 549 /// Returns true if the given string MAY include URLs or alike.
 550 fn has_url(s: &str) -> bool {
 551     // This function may return false positive, but should get its job done in most cases.
 552     s.contains("https://") || s.contains("http://") || s.contains("ftp://") || s.contains("file://")
 553 }
 554
 555 /// Given the span, rewrite the missing comment inside it if available.
 556 /// Note that the given span must only include comments (or leading/trailing whitespaces).
 557 pub fn rewrite_missing_comment(
 558     span: Span,
 559     shape: Shape,
 560     context: &RewriteContext,
 561 ) -> Option<String> {
 562     let missing_snippet = context.snippet(span);
 563     let trimmed_snippet = missing_snippet.trim();
 564     if !trimmed_snippet.is_empty() {
 565         rewrite_comment(trimmed_snippet, false, shape, context.config)
 566     } else {
 567         Some(String::new())
 568     }
 569 }
 570
 571 /// Recover the missing comments in the specified span, if available.
 572 /// The layout of the comments will be preserved as long as it does not break the code
 573 /// and its total width does not exceed the max width.
 574 pub fn recover_missing_comment_in_span(
 575     span: Span,
 576     shape: Shape,
 577     context: &RewriteContext,
 578     used_width: usize,
 579 ) -> Option<String> {
 580     let missing_comment = rewrite_missing_comment(span, shape, context)?;
 581     if missing_comment.is_empty() {
 582         Some(String::new())
 583     } else {
 584         let missing_snippet = context.snippet(span);
 585         let pos = missing_snippet.find('/').unwrap_or(0);
 586         // 1 = ` `
 587         let total_width = missing_comment.len() + used_width + 1;
 588         let force_new_line_before_comment =
 589             missing_snippet[..pos].contains('\n') || total_width > context.config.max_width();
 590         let sep = if force_new_line_before_comment {
 591             shape.indent.to_string_with_newline(context.config)
 592         } else {
 593             Cow::from(" ")
 594         };
 595         Some(format!("{}{}", sep, missing_comment))
 596     }
 597 }
 598
 599 /// Trim trailing whitespaces unless they consist of two or more whitespaces.
 600 fn trim_right_unless_two_whitespaces(s: &str, is_doc_comment: bool) -> &str {
 601     if is_doc_comment && s.ends_with("  ") {
 602         s
 603     } else {
 604         s.trim_right()
 605     }
 606 }
 607
 608 /// Trims whitespace and aligns to indent, but otherwise does not change comments.
 609 fn light_rewrite_comment(
 610     orig: &str,
 611     offset: Indent,
 612     config: &Config,
 613     is_doc_comment: bool,
 614 ) -> Option<String> {
 615     let lines: Vec<&str> = orig
 616         .lines()
 617         .map(|l| {
 618             // This is basically just l.trim(), but in the case that a line starts
 619             // with `*` we want to leave one space before it, so it aligns with the
 620             // `*` in `/*`.
 621             let first_non_whitespace = l.find(|c| !char::is_whitespace(c));
 622             let left_trimmed = if let Some(fnw) = first_non_whitespace {
 623                 if l.as_bytes()[fnw] == b'*' && fnw > 0 {
 624                     &l[fnw - 1..]
 625                 } else {
 626                     &l[fnw..]
 627                 }
 628             } else {
 629                 ""
 630             };
 631             // Preserve markdown's double-space line break syntax in doc comment.
 632             trim_right_unless_two_whitespaces(left_trimmed, is_doc_comment)
 633         }).collect();
 634     Some(lines.join(&format!("\n{}", offset.to_string(config))))
 635 }
 636
 637 /// Trims comment characters and possibly a single space from the left of a string.
 638 /// Does not trim all whitespace. If a single space is trimmed from the left of the string,
 639 /// this function returns true.
 640 fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle) -> (&'a str, bool) {
 641     if line.starts_with("//! ")
 642         || line.starts_with("/// ")
 643         || line.starts_with("/*! ")
 644         || line.starts_with("/** ")
 645     {
 646         (&line[4..], true)
 647     } else if let CommentStyle::Custom(opener) = *style {
 648         if line.starts_with(opener) {
 649             (&line[opener.len()..], true)
 650         } else {
 651             (&line[opener.trim_right().len()..], false)
 652         }
 653     } else if line.starts_with("/* ")
 654         || line.starts_with("// ")
 655         || line.starts_with("//!")
 656         || line.starts_with("///")
 657         || line.starts_with("** ")
 658         || line.starts_with("/*!")
 659         || (line.starts_with("/**") && !line.starts_with("/**/"))
 660     {
 661         (&line[3..], line.chars().nth(2).unwrap() == ' ')
 662     } else if line.starts_with("/*")
 663         || line.starts_with("* ")
 664         || line.starts_with("//")
 665         || line.starts_with("**")
 666     {
 667         (&line[2..], line.chars().nth(1).unwrap() == ' ')
 668     } else if line.starts_with('*') {
 669         (&line[1..], false)
 670     } else {
 671         (line, line.starts_with(' '))
 672     }
 673 }
 674
 675 pub trait FindUncommented {
 676     fn find_uncommented(&self, pat: &str) -> Option<usize>;
 677 }
 678
 679 impl FindUncommented for str {
 680     fn find_uncommented(&self, pat: &str) -> Option<usize> {
 681         let mut needle_iter = pat.chars();
 682         for (kind, (i, b)) in CharClasses::new(self.char_indices()) {
 683             match needle_iter.next() {
 684                 None => {
 685                     return Some(i - pat.len());
 686                 }
 687                 Some(c) => match kind {
 688                     FullCodeCharKind::Normal | FullCodeCharKind::InString if b == c => {}
 689                     _ => {
 690                         needle_iter = pat.chars();
 691                     }
 692                 },
 693             }
 694         }
 695
 696         // Handle case where the pattern is a suffix of the search string
 697         match needle_iter.next() {
 698             Some(_) => None,
 699             None => Some(self.len() - pat.len()),
 700         }
 701     }
 702 }
 703
 704 // Returns the first byte position after the first comment. The given string
 705 // is expected to be prefixed by a comment, including delimiters.
 706 // Good: "/* /* inner */ outer */ code();"
 707 // Bad:  "code(); // hello\n world!"
 708 pub fn find_comment_end(s: &str) -> Option<usize> {
 709     let mut iter = CharClasses::new(s.char_indices());
 710     for (kind, (i, _c)) in &mut iter {
 711         if kind == FullCodeCharKind::Normal || kind == FullCodeCharKind::InString {
 712             return Some(i);
 713         }
 714     }
 715
 716     // Handle case where the comment ends at the end of s.
 717     if iter.status == CharClassesStatus::Normal {
 718         Some(s.len())
 719     } else {
 720         None
 721     }
 722 }
 723
 724 /// Returns true if text contains any comment.
 725 pub fn contains_comment(text: &str) -> bool {
 726     CharClasses::new(text.chars()).any(|(kind, _)| kind.is_comment())
 727 }
 728
 729 /// Remove trailing spaces from the specified snippet. We do not remove spaces
 730 /// inside strings or comments.
 731 pub fn remove_trailing_white_spaces(text: &str) -> String {
 732     let mut buffer = String::with_capacity(text.len());
 733     let mut space_buffer = String::with_capacity(128);
 734     for (char_kind, c) in CharClasses::new(text.chars()) {
 735         match c {
 736             '\n' => {
 737                 if char_kind == FullCodeCharKind::InString {
 738                     buffer.push_str(&space_buffer);
 739                 }
 740                 space_buffer.clear();
 741                 buffer.push('\n');
 742             }
 743             _ if c.is_whitespace() => {
 744                 space_buffer.push(c);
 745             }
 746             _ => {
 747                 if !space_buffer.is_empty() {
 748                     buffer.push_str(&space_buffer);
 749                     space_buffer.clear();
 750                 }
 751                 buffer.push(c);
 752             }
 753         }
 754     }
 755     buffer
 756 }
 757
 758 pub struct CharClasses<T>
 759 where
 760     T: Iterator,
 761     T::Item: RichChar,
 762 {
 763     base: MultiPeek<T>,
 764     status: CharClassesStatus,
 765 }
 766
 767 pub trait RichChar {
 768     fn get_char(&self) -> char;
 769 }
 770
 771 impl RichChar for char {
 772     fn get_char(&self) -> char {
 773         *self
 774     }
 775 }
 776
 777 impl RichChar for (usize, char) {
 778     fn get_char(&self) -> char {
 779         self.1
 780     }
 781 }
 782
 783 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
 784 enum CharClassesStatus {
 785     Normal,
 786     LitString,
 787     LitStringEscape,
 788     LitRawString(u32),
 789     RawStringPrefix(u32),
 790     RawStringSuffix(u32),
 791     LitChar,
 792     LitCharEscape,
 793     // The u32 is the nesting deepness of the comment
 794     BlockComment(u32),
 795     // Status when the '/' has been consumed, but not yet the '*', deepness is
 796     // the new deepness (after the comment opening).
 797     BlockCommentOpening(u32),
 798     // Status when the '*' has been consumed, but not yet the '/', deepness is
 799     // the new deepness (after the comment closing).
 800     BlockCommentClosing(u32),
 801     LineComment,
 802 }
 803
 804 /// Distinguish between functional part of code and comments
 805 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
 806 pub enum CodeCharKind {
 807     Normal,
 808     Comment,
 809 }
 810
 811 /// Distinguish between functional part of code and comments,
 812 /// describing opening and closing of comments for ease when chunking
 813 /// code from tagged characters
 814 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
 815 pub enum FullCodeCharKind {
 816     Normal,
 817     /// The first character of a comment, there is only one for a comment (always '/')
 818     StartComment,
 819     /// Any character inside a comment including the second character of comment
 820     /// marks ("//", "/*")
 821     InComment,
 822     /// Last character of a comment, '\n' for a line comment, '/' for a block comment.
 823     EndComment,
 824     /// Inside a string.
 825     InString,
 826 }
 827
 828 impl FullCodeCharKind {
 829     pub fn is_comment(self) -> bool {
 830         match self {
 831             FullCodeCharKind::StartComment
 832             | FullCodeCharKind::InComment
 833             | FullCodeCharKind::EndComment => true,
 834             _ => false,
 835         }
 836     }
 837
 838     pub fn is_string(self) -> bool {
 839         self == FullCodeCharKind::InString
 840     }
 841
 842     fn to_codecharkind(self) -> CodeCharKind {
 843         if self.is_comment() {
 844             CodeCharKind::Comment
 845         } else {
 846             CodeCharKind::Normal
 847         }
 848     }
 849 }
 850
 851 impl<T> CharClasses<T>
 852 where
 853     T: Iterator,
 854     T::Item: RichChar,
 855 {
 856     pub fn new(base: T) -> CharClasses<T> {
 857         CharClasses {
 858             base: multipeek(base),
 859             status: CharClassesStatus::Normal,
 860         }
 861     }
 862 }
 863
 864 fn is_raw_string_suffix<T>(iter: &mut MultiPeek<T>, count: u32) -> bool
 865 where
 866     T: Iterator,
 867     T::Item: RichChar,
 868 {
 869     for _ in 0..count {
 870         match iter.peek() {
 871             Some(c) if c.get_char() == '#' => continue,
 872             _ => return false,
 873         }
 874     }
 875     true
 876 }
 877
 878 impl<T> Iterator for CharClasses<T>
 879 where
 880     T: Iterator,
 881     T::Item: RichChar,
 882 {
 883     type Item = (FullCodeCharKind, T::Item);
 884
 885     fn next(&mut self) -> Option<(FullCodeCharKind, T::Item)> {
 886         let item = self.base.next()?;
 887         let chr = item.get_char();
 888         let mut char_kind = FullCodeCharKind::Normal;
 889         self.status = match self.status {
 890             CharClassesStatus::LitRawString(sharps) => {
 891                 char_kind = FullCodeCharKind::InString;
 892                 match chr {
 893                     '"' => {
 894                         if is_raw_string_suffix(&mut self.base, sharps) {
 895                             CharClassesStatus::RawStringSuffix(sharps)
 896                         } else {
 897                             CharClassesStatus::LitRawString(sharps)
 898                         }
 899                     }
 900                     _ => CharClassesStatus::LitRawString(sharps),
 901                 }
 902             }
 903             CharClassesStatus::RawStringPrefix(sharps) => {
 904                 char_kind = FullCodeCharKind::InString;
 905                 match chr {
 906                     '#' => CharClassesStatus::RawStringPrefix(sharps + 1),
 907                     '"' => CharClassesStatus::LitRawString(sharps),
 908                     _ => CharClassesStatus::Normal, // Unreachable.
 909                 }
 910             }
 911             CharClassesStatus::RawStringSuffix(sharps) => {
 912                 match chr {
 913                     '#' => {
 914                         if sharps == 1 {
 915                             CharClassesStatus::Normal
 916                         } else {
 917                             char_kind = FullCodeCharKind::InString;
 918                             CharClassesStatus::RawStringSuffix(sharps - 1)
 919                         }
 920                     }
 921                     _ => CharClassesStatus::Normal, // Unreachable
 922                 }
 923             }
 924             CharClassesStatus::LitString => match chr {
 925                 '"' => CharClassesStatus::Normal,
 926                 '\\' => {
 927                     char_kind = FullCodeCharKind::InString;
 928                     CharClassesStatus::LitStringEscape
 929                 }
 930                 _ => {
 931                     char_kind = FullCodeCharKind::InString;
 932                     CharClassesStatus::LitString
 933                 }
 934             },
 935             CharClassesStatus::LitStringEscape => {
 936                 char_kind = FullCodeCharKind::InString;
 937                 CharClassesStatus::LitString
 938             }
 939             CharClassesStatus::LitChar => match chr {
 940                 '\\' => CharClassesStatus::LitCharEscape,
 941                 '\'' => CharClassesStatus::Normal,
 942                 _ => CharClassesStatus::LitChar,
 943             },
 944             CharClassesStatus::LitCharEscape => CharClassesStatus::LitChar,
 945             CharClassesStatus::Normal => match chr {
 946                 'r' => match self.base.peek().map(|c| c.get_char()) {
 947                     Some('#') => {
 948                         char_kind = FullCodeCharKind::InString;
 949                         CharClassesStatus::RawStringPrefix(0)
 950                     }
 951                     Some('"') => {
 952                         char_kind = FullCodeCharKind::InString;
 953                         CharClassesStatus::LitString
 954                     }
 955                     _ => CharClassesStatus::Normal,
 956                 },
 957                 '"' => {
 958                     char_kind = FullCodeCharKind::InString;
 959                     CharClassesStatus::LitString
 960                 }
 961                 '\'' => {
 962                     // HACK: Work around mut borrow.
 963                     match self.base.peek() {
 964                         Some(next) if next.get_char() == '\\' => {
 965                             self.status = CharClassesStatus::LitChar;
 966                             return Some((char_kind, item));
 967                         }
 968                         _ => (),
 969                     }
 970
 971                     match self.base.peek() {
 972                         Some(next) if next.get_char() == '\'' => CharClassesStatus::LitChar,
 973                         _ => CharClassesStatus::Normal,
 974                     }
 975                 }
 976                 '/' => match self.base.peek() {
 977                     Some(next) if next.get_char() == '*' => {
 978                         self.status = CharClassesStatus::BlockCommentOpening(1);
 979                         return Some((FullCodeCharKind::StartComment, item));
 980                     }
 981                     Some(next) if next.get_char() == '/' => {
 982                         self.status = CharClassesStatus::LineComment;
 983                         return Some((FullCodeCharKind::StartComment, item));
 984                     }
 985                     _ => CharClassesStatus::Normal,
 986                 },
 987                 _ => CharClassesStatus::Normal,
 988             },
 989             CharClassesStatus::BlockComment(deepness) => {
 990                 assert_ne!(deepness, 0);
 991                 self.status = match self.base.peek() {
 992                     Some(next) if next.get_char() == '/' && chr == '*' => {
 993                         CharClassesStatus::BlockCommentClosing(deepness - 1)
 994                     }
 995                     Some(next) if next.get_char() == '*' && chr == '/' => {
 996                         CharClassesStatus::BlockCommentOpening(deepness + 1)
 997                     }
 998                     _ => CharClassesStatus::BlockComment(deepness),
 999                 };
1000                 return Some((FullCodeCharKind::InComment, item));
1001             }
1002             CharClassesStatus::BlockCommentOpening(deepness) => {
1003                 assert_eq!(chr, '*');
1004                 self.status = CharClassesStatus::BlockComment(deepness);
1005                 return Some((FullCodeCharKind::InComment, item));
1006             }
1007             CharClassesStatus::BlockCommentClosing(deepness) => {
1008                 assert_eq!(chr, '/');
1009                 if deepness == 0 {
1010                     self.status = CharClassesStatus::Normal;
1011                     return Some((FullCodeCharKind::EndComment, item));
1012                 } else {
1013                     self.status = CharClassesStatus::BlockComment(deepness);
1014                     return Some((FullCodeCharKind::InComment, item));
1015                 }
1016             }
1017             CharClassesStatus::LineComment => match chr {
1018                 '\n' => {
1019                     self.status = CharClassesStatus::Normal;
1020                     return Some((FullCodeCharKind::EndComment, item));
1021                 }
1022                 _ => {
1023                     self.status = CharClassesStatus::LineComment;
1024                     return Some((FullCodeCharKind::InComment, item));
1025                 }
1026             },
1027         };
1028         Some((char_kind, item))
1029     }
1030 }
1031
1032 /// An iterator over the lines of a string, paired with the char kind at the
1033 /// end of the line.
1034 pub struct LineClasses<'a> {
1035     base: iter::Peekable<CharClasses<std::str::Chars<'a>>>,
1036     kind: FullCodeCharKind,
1037 }
1038
1039 impl<'a> LineClasses<'a> {
1040     pub fn new(s: &'a str) -> Self {
1041         LineClasses {
1042             base: CharClasses::new(s.chars()).peekable(),
1043             kind: FullCodeCharKind::Normal,
1044         }
1045     }
1046 }
1047
1048 impl<'a> Iterator for LineClasses<'a> {
1049     type Item = (FullCodeCharKind, String);
1050
1051     fn next(&mut self) -> Option<Self::Item> {
1052         self.base.peek()?;
1053
1054         let mut line = String::new();
1055
1056         while let Some((kind, c)) = self.base.next() {
1057             self.kind = kind;
1058             if c == '\n' {
1059                 break;
1060             } else {
1061                 line.push(c);
1062             }
1063         }
1064
1065         Some((self.kind, line))
1066     }
1067 }
1068
1069 /// Iterator over functional and commented parts of a string. Any part of a string is either
1070 /// functional code, either *one* block comment, either *one* line comment. Whitespace between
1071 /// comments is functional code. Line comments contain their ending newlines.
1072 struct UngroupedCommentCodeSlices<'a> {
1073     slice: &'a str,
1074     iter: iter::Peekable<CharClasses<std::str::CharIndices<'a>>>,
1075 }
1076
1077 impl<'a> UngroupedCommentCodeSlices<'a> {
1078     fn new(code: &'a str) -> UngroupedCommentCodeSlices<'a> {
1079         UngroupedCommentCodeSlices {
1080             slice: code,
1081             iter: CharClasses::new(code.char_indices()).peekable(),
1082         }
1083     }
1084 }
1085
1086 impl<'a> Iterator for UngroupedCommentCodeSlices<'a> {
1087     type Item = (CodeCharKind, usize, &'a str);
1088
1089     fn next(&mut self) -> Option<Self::Item> {
1090         let (kind, (start_idx, _)) = self.iter.next()?;
1091         match kind {
1092             FullCodeCharKind::Normal | FullCodeCharKind::InString => {
1093                 // Consume all the Normal code
1094                 while let Some(&(char_kind, _)) = self.iter.peek() {
1095                     if char_kind.is_comment() {
1096                         break;
1097                     }
1098                     let _ = self.iter.next();
1099                 }
1100             }
1101             FullCodeCharKind::StartComment => {
1102                 // Consume the whole comment
1103                 while let Some((FullCodeCharKind::InComment, (_, _))) = self.iter.next() {}
1104             }
1105             _ => panic!(),
1106         }
1107         let slice = match self.iter.peek() {
1108             Some(&(_, (end_idx, _))) => &self.slice[start_idx..end_idx],
1109             None => &self.slice[start_idx..],
1110         };
1111         Some((
1112             if kind.is_comment() {
1113                 CodeCharKind::Comment
1114             } else {
1115                 CodeCharKind::Normal
1116             },
1117             start_idx,
1118             slice,
1119         ))
1120     }
1121 }
1122
1123 /// Iterator over an alternating sequence of functional and commented parts of
1124 /// a string. The first item is always a, possibly zero length, subslice of
1125 /// functional text. Line style comments contain their ending newlines.
1126 pub struct CommentCodeSlices<'a> {
1127     slice: &'a str,
1128     last_slice_kind: CodeCharKind,
1129     last_slice_end: usize,
1130 }
1131
1132 impl<'a> CommentCodeSlices<'a> {
1133     pub fn new(slice: &'a str) -> CommentCodeSlices<'a> {
1134         CommentCodeSlices {
1135             slice,
1136             last_slice_kind: CodeCharKind::Comment,
1137             last_slice_end: 0,
1138         }
1139     }
1140 }
1141
1142 impl<'a> Iterator for CommentCodeSlices<'a> {
1143     type Item = (CodeCharKind, usize, &'a str);
1144
1145     fn next(&mut self) -> Option<Self::Item> {
1146         if self.last_slice_end == self.slice.len() {
1147             return None;
1148         }
1149
1150         let mut sub_slice_end = self.last_slice_end;
1151         let mut first_whitespace = None;
1152         let subslice = &self.slice[self.last_slice_end..];
1153         let mut iter = CharClasses::new(subslice.char_indices());
1154
1155         for (kind, (i, c)) in &mut iter {
1156             let is_comment_connector = self.last_slice_kind == CodeCharKind::Normal
1157                 && &subslice[..2] == "//"
1158                 && [' ', '\t'].contains(&c);
1159
1160             if is_comment_connector && first_whitespace.is_none() {
1161                 first_whitespace = Some(i);
1162             }
1163
1164             if kind.to_codecharkind() == self.last_slice_kind && !is_comment_connector {
1165                 let last_index = match first_whitespace {
1166                     Some(j) => j,
1167                     None => i,
1168                 };
1169                 sub_slice_end = self.last_slice_end + last_index;
1170                 break;
1171             }
1172
1173             if !is_comment_connector {
1174                 first_whitespace = None;
1175             }
1176         }
1177
1178         if let (None, true) = (iter.next(), sub_slice_end == self.last_slice_end) {
1179             // This was the last subslice.
1180             sub_slice_end = match first_whitespace {
1181                 Some(i) => self.last_slice_end + i,
1182                 None => self.slice.len(),
1183             };
1184         }
1185
1186         let kind = match self.last_slice_kind {
1187             CodeCharKind::Comment => CodeCharKind::Normal,
1188             CodeCharKind::Normal => CodeCharKind::Comment,
1189         };
1190         let res = (
1191             kind,
1192             self.last_slice_end,
1193             &self.slice[self.last_slice_end..sub_slice_end],
1194         );
1195         self.last_slice_end = sub_slice_end;
1196         self.last_slice_kind = kind;
1197
1198         Some(res)
1199     }
1200 }
1201
1202 /// Checks is `new` didn't miss any comment from `span`, if it removed any, return previous text
1203 /// (if it fits in the width/offset, else return None), else return `new`
1204 pub fn recover_comment_removed(
1205     new: String,
1206     span: Span,
1207     context: &RewriteContext,
1208 ) -> Option<String> {
1209     let snippet = context.snippet(span);
1210     if snippet != new && changed_comment_content(snippet, &new) {
1211         // We missed some comments. Warn and keep the original text.
1212         if context.config.error_on_unformatted() {
1213             context.report.append(
1214                 context.source_map.span_to_filename(span).into(),
1215                 vec![FormattingError::from_span(
1216                     &span,
1217                     &context.source_map,
1218                     ErrorKind::LostComment,
1219                 )],
1220             );
1221         }
1222         Some(snippet.to_owned())
1223     } else {
1224         Some(new)
1225     }
1226 }
1227
1228 pub fn filter_normal_code(code: &str) -> String {
1229     let mut buffer = String::with_capacity(code.len());
1230     LineClasses::new(code).for_each(|(kind, line)| match kind {
1231         FullCodeCharKind::Normal | FullCodeCharKind::InString => {
1232             buffer.push_str(&line);
1233             buffer.push('\n');
1234         }
1235         _ => (),
1236     });
1237     if !code.ends_with('\n') && buffer.ends_with('\n') {
1238         buffer.pop();
1239     }
1240     buffer
1241 }
1242
1243 /// Return true if the two strings of code have the same payload of comments.
1244 /// The payload of comments is everything in the string except:
1245 ///     - actual code (not comments)
1246 ///     - comment start/end marks
1247 ///     - whitespace
1248 ///     - '*' at the beginning of lines in block comments
1249 fn changed_comment_content(orig: &str, new: &str) -> bool {
1250     // Cannot write this as a fn since we cannot return types containing closures
1251     let code_comment_content = |code| {
1252         let slices = UngroupedCommentCodeSlices::new(code);
1253         slices
1254             .filter(|&(ref kind, _, _)| *kind == CodeCharKind::Comment)
1255             .flat_map(|(_, _, s)| CommentReducer::new(s))
1256     };
1257     let res = code_comment_content(orig).ne(code_comment_content(new));
1258     debug!(
1259         "comment::changed_comment_content: {}\norig: '{}'\nnew: '{}'\nraw_old: {}\nraw_new: {}",
1260         res,
1261         orig,
1262         new,
1263         code_comment_content(orig).collect::<String>(),
1264         code_comment_content(new).collect::<String>()
1265     );
1266     res
1267 }
1268
1269 /// Iterator over the 'payload' characters of a comment.
1270 /// It skips whitespace, comment start/end marks, and '*' at the beginning of lines.
1271 /// The comment must be one comment, ie not more than one start mark (no multiple line comments,
1272 /// for example).
1273 struct CommentReducer<'a> {
1274     is_block: bool,
1275     at_start_line: bool,
1276     iter: std::str::Chars<'a>,
1277 }
1278
1279 impl<'a> CommentReducer<'a> {
1280     fn new(comment: &'a str) -> CommentReducer<'a> {
1281         let is_block = comment.starts_with("/*");
1282         let comment = remove_comment_header(comment);
1283         CommentReducer {
1284             is_block,
1285             at_start_line: false, // There are no supplementary '*' on the first line
1286             iter: comment.chars(),
1287         }
1288     }
1289 }
1290
1291 impl<'a> Iterator for CommentReducer<'a> {
1292     type Item = char;
1293
1294     fn next(&mut self) -> Option<Self::Item> {
1295         loop {
1296             let mut c = self.iter.next()?;
1297             if self.is_block && self.at_start_line {
1298                 while c.is_whitespace() {
1299                     c = self.iter.next()?;
1300                 }
1301                 // Ignore leading '*'
1302                 if c == '*' {
1303                     c = self.iter.next()?;
1304                 }
1305             } else if c == '\n' {
1306                 self.at_start_line = true;
1307             }
1308             if !c.is_whitespace() {
1309                 return Some(c);
1310             }
1311         }
1312     }
1313 }
1314
1315 fn remove_comment_header(comment: &str) -> &str {
1316     if comment.starts_with("///") || comment.starts_with("//!") {
1317         &comment[3..]
1318     } else if comment.starts_with("//") {
1319         &comment[2..]
1320     } else if (comment.starts_with("/**") && !comment.starts_with("/**/"))
1321         || comment.starts_with("/*!")
1322     {
1323         &comment[3..comment.len() - 2]
1324     } else {
1325         assert!(
1326             comment.starts_with("/*"),
1327             format!("string '{}' is not a comment", comment)
1328         );
1329         &comment[2..comment.len() - 2]
1330     }
1331 }
1332
1333 #[cfg(test)]
1334 mod test {
1335     use super::*;
1336     use shape::{Indent, Shape};
1337
1338     #[test]
1339     fn char_classes() {
1340         let mut iter = CharClasses::new("//\n\n".chars());
1341
1342         assert_eq!((FullCodeCharKind::StartComment, '/'), iter.next().unwrap());
1343         assert_eq!((FullCodeCharKind::InComment, '/'), iter.next().unwrap());
1344         assert_eq!((FullCodeCharKind::EndComment, '\n'), iter.next().unwrap());
1345         assert_eq!((FullCodeCharKind::Normal, '\n'), iter.next().unwrap());
1346         assert_eq!(None, iter.next());
1347     }
1348
1349     #[test]
1350     fn comment_code_slices() {
1351         let input = "code(); /* test */ 1 + 1";
1352         let mut iter = CommentCodeSlices::new(input);
1353
1354         assert_eq!((CodeCharKind::Normal, 0, "code(); "), iter.next().unwrap());
1355         assert_eq!(
1356             (CodeCharKind::Comment, 8, "/* test */"),
1357             iter.next().unwrap()
1358         );
1359         assert_eq!((CodeCharKind::Normal, 18, " 1 + 1"), iter.next().unwrap());
1360         assert_eq!(None, iter.next());
1361     }
1362
1363     #[test]
1364     fn comment_code_slices_two() {
1365         let input = "// comment\n    test();";
1366         let mut iter = CommentCodeSlices::new(input);
1367
1368         assert_eq!((CodeCharKind::Normal, 0, ""), iter.next().unwrap());
1369         assert_eq!(
1370             (CodeCharKind::Comment, 0, "// comment\n"),
1371             iter.next().unwrap()
1372         );
1373         assert_eq!(
1374             (CodeCharKind::Normal, 11, "    test();"),
1375             iter.next().unwrap()
1376         );
1377         assert_eq!(None, iter.next());
1378     }
1379
1380     #[test]
1381     fn comment_code_slices_three() {
1382         let input = "1 // comment\n    // comment2\n\n";
1383         let mut iter = CommentCodeSlices::new(input);
1384
1385         assert_eq!((CodeCharKind::Normal, 0, "1 "), iter.next().unwrap());
1386         assert_eq!(
1387             (CodeCharKind::Comment, 2, "// comment\n    // comment2\n"),
1388             iter.next().unwrap()
1389         );
1390         assert_eq!((CodeCharKind::Normal, 29, "\n"), iter.next().unwrap());
1391         assert_eq!(None, iter.next());
1392     }
1393
1394     #[test]
1395     #[rustfmt::skip]
1396     fn format_comments() {
1397         let mut config: ::config::Config = Default::default();
1398         config.set().wrap_comments(true);
1399         config.set().normalize_comments(true);
1400
1401         let comment = rewrite_comment(" //test",
1402                                       true,
1403                                       Shape::legacy(100, Indent::new(0, 100)),
1404                                       &config).unwrap();
1405         assert_eq!("/* test */", comment);
1406
1407         let comment = rewrite_comment("// comment on a",
1408                                       false,
1409                                       Shape::legacy(10, Indent::empty()),
1410                                       &config).unwrap();
1411         assert_eq!("// comment\n// on a", comment);
1412
1413         let comment = rewrite_comment("//  A multi line comment\n             // between args.",
1414                                       false,
1415                                       Shape::legacy(60, Indent::new(0, 12)),
1416                                       &config).unwrap();
1417         assert_eq!("//  A multi line comment\n            // between args.", comment);
1418
1419         let input = "// comment";
1420         let expected =
1421             "/* comment */";
1422         let comment = rewrite_comment(input,
1423                                       true,
1424                                       Shape::legacy(9, Indent::new(0, 69)),
1425                                       &config).unwrap();
1426         assert_eq!(expected, comment);
1427
1428         let comment = rewrite_comment("/*   trimmed    */",
1429                                       true,
1430                                       Shape::legacy(100, Indent::new(0, 100)),
1431                                       &config).unwrap();
1432         assert_eq!("/* trimmed */", comment);
1433     }
1434
1435     // This is probably intended to be a non-test fn, but it is not used. I'm
1436     // keeping it around unless it helps us test stuff.
1437     fn uncommented(text: &str) -> String {
1438         CharClasses::new(text.chars())
1439             .filter_map(|(s, c)| match s {
1440                 FullCodeCharKind::Normal | FullCodeCharKind::InString => Some(c),
1441                 _ => None,
1442             }).collect()
1443     }
1444
1445     #[test]
1446     fn test_uncommented() {
1447         assert_eq!(&uncommented("abc/*...*/"), "abc");
1448         assert_eq!(
1449             &uncommented("// .... /* \n../* /* *** / */ */a/* // */c\n"),
1450             "..ac\n"
1451         );
1452         assert_eq!(&uncommented("abc \" /* */\" qsdf"), "abc \" /* */\" qsdf");
1453     }
1454
1455     #[test]
1456     fn test_contains_comment() {
1457         assert_eq!(contains_comment("abc"), false);
1458         assert_eq!(contains_comment("abc // qsdf"), true);
1459         assert_eq!(contains_comment("abc /* kqsdf"), true);
1460         assert_eq!(contains_comment("abc \" /* */\" qsdf"), false);
1461     }
1462
1463     #[test]
1464     fn test_find_uncommented() {
1465         fn check(haystack: &str, needle: &str, expected: Option<usize>) {
1466             assert_eq!(expected, haystack.find_uncommented(needle));
1467         }
1468
1469         check("/*/ */test", "test", Some(6));
1470         check("//test\ntest", "test", Some(7));
1471         check("/* comment only */", "whatever", None);
1472         check(
1473             "/* comment */ some text /* more commentary */ result",
1474             "result",
1475             Some(46),
1476         );
1477         check("sup // sup", "p", Some(2));
1478         check("sup", "x", None);
1479         check(r#"π? /**/ π is nice!"#, r#"π is nice"#, Some(9));
1480         check("/*sup yo? \n sup*/ sup", "p", Some(20));
1481         check("hel/*lohello*/lo", "hello", None);
1482         check("acb", "ab", None);
1483         check(",/*A*/ ", ",", Some(0));
1484         check("abc", "abc", Some(0));
1485         check("/* abc */", "abc", None);
1486         check("/**/abc/* */", "abc", Some(4));
1487         check("\"/* abc */\"", "abc", Some(4));
1488         check("\"/* abc", "abc", Some(4));
1489     }
1490
1491     #[test]
1492     fn test_remove_trailing_white_spaces() {
1493         let s = format!("    r#\"\n        test\n    \"#");
1494         assert_eq!(remove_trailing_white_spaces(&s), s);
1495     }
1496
1497     #[test]
1498     fn test_filter_normal_code() {
1499         let s = r#"
1500 fn main() {
1501     println!("hello, world");
1502 }
1503 "#;
1504         assert_eq!(s, filter_normal_code(s));
1505         let s_with_comment = r#"
1506 fn main() {
1507     // hello, world
1508     println!("hello, world");
1509 }
1510 "#;
1511         assert_eq!(s, filter_normal_code(s_with_comment));
1512     }
1513 }