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])
  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 sharps == 0 {
 895                             char_kind = FullCodeCharKind::Normal;
 896                             CharClassesStatus::Normal
 897                         } else if is_raw_string_suffix(&mut self.base, sharps) {
 898                             CharClassesStatus::RawStringSuffix(sharps)
 899                         } else {
 900                             CharClassesStatus::LitRawString(sharps)
 901                         }
 902                     }
 903                     _ => CharClassesStatus::LitRawString(sharps),
 904                 }
 905             }
 906             CharClassesStatus::RawStringPrefix(sharps) => {
 907                 char_kind = FullCodeCharKind::InString;
 908                 match chr {
 909                     '#' => CharClassesStatus::RawStringPrefix(sharps + 1),
 910                     '"' => CharClassesStatus::LitRawString(sharps),
 911                     _ => CharClassesStatus::Normal, // Unreachable.
 912                 }
 913             }
 914             CharClassesStatus::RawStringSuffix(sharps) => {
 915                 match chr {
 916                     '#' => {
 917                         if sharps == 1 {
 918                             CharClassesStatus::Normal
 919                         } else {
 920                             char_kind = FullCodeCharKind::InString;
 921                             CharClassesStatus::RawStringSuffix(sharps - 1)
 922                         }
 923                     }
 924                     _ => CharClassesStatus::Normal, // Unreachable
 925                 }
 926             }
 927             CharClassesStatus::LitString => match chr {
 928                 '"' => CharClassesStatus::Normal,
 929                 '\\' => {
 930                     char_kind = FullCodeCharKind::InString;
 931                     CharClassesStatus::LitStringEscape
 932                 }
 933                 _ => {
 934                     char_kind = FullCodeCharKind::InString;
 935                     CharClassesStatus::LitString
 936                 }
 937             },
 938             CharClassesStatus::LitStringEscape => {
 939                 char_kind = FullCodeCharKind::InString;
 940                 CharClassesStatus::LitString
 941             }
 942             CharClassesStatus::LitChar => match chr {
 943                 '\\' => CharClassesStatus::LitCharEscape,
 944                 '\'' => CharClassesStatus::Normal,
 945                 _ => CharClassesStatus::LitChar,
 946             },
 947             CharClassesStatus::LitCharEscape => CharClassesStatus::LitChar,
 948             CharClassesStatus::Normal => match chr {
 949                 'r' => match self.base.peek().map(|c| c.get_char()) {
 950                     Some('#') | Some('"') => {
 951                         char_kind = FullCodeCharKind::InString;
 952                         CharClassesStatus::RawStringPrefix(0)
 953                     }
 954                     _ => CharClassesStatus::Normal,
 955                 },
 956                 '"' => {
 957                     char_kind = FullCodeCharKind::InString;
 958                     CharClassesStatus::LitString
 959                 }
 960                 '\'' => {
 961                     // HACK: Work around mut borrow.
 962                     match self.base.peek() {
 963                         Some(next) if next.get_char() == '\\' => {
 964                             self.status = CharClassesStatus::LitChar;
 965                             return Some((char_kind, item));
 966                         }
 967                         _ => (),
 968                     }
 969
 970                     match self.base.peek() {
 971                         Some(next) if next.get_char() == '\'' => CharClassesStatus::LitChar,
 972                         _ => CharClassesStatus::Normal,
 973                     }
 974                 }
 975                 '/' => match self.base.peek() {
 976                     Some(next) if next.get_char() == '*' => {
 977                         self.status = CharClassesStatus::BlockCommentOpening(1);
 978                         return Some((FullCodeCharKind::StartComment, item));
 979                     }
 980                     Some(next) if next.get_char() == '/' => {
 981                         self.status = CharClassesStatus::LineComment;
 982                         return Some((FullCodeCharKind::StartComment, item));
 983                     }
 984                     _ => CharClassesStatus::Normal,
 985                 },
 986                 _ => CharClassesStatus::Normal,
 987             },
 988             CharClassesStatus::BlockComment(deepness) => {
 989                 assert_ne!(deepness, 0);
 990                 self.status = match self.base.peek() {
 991                     Some(next) if next.get_char() == '/' && chr == '*' => {
 992                         CharClassesStatus::BlockCommentClosing(deepness - 1)
 993                     }
 994                     Some(next) if next.get_char() == '*' && chr == '/' => {
 995                         CharClassesStatus::BlockCommentOpening(deepness + 1)
 996                     }
 997                     _ => CharClassesStatus::BlockComment(deepness),
 998                 };
 999                 return Some((FullCodeCharKind::InComment, item));
1000             }
1001             CharClassesStatus::BlockCommentOpening(deepness) => {
1002                 assert_eq!(chr, '*');
1003                 self.status = CharClassesStatus::BlockComment(deepness);
1004                 return Some((FullCodeCharKind::InComment, item));
1005             }
1006             CharClassesStatus::BlockCommentClosing(deepness) => {
1007                 assert_eq!(chr, '/');
1008                 if deepness == 0 {
1009                     self.status = CharClassesStatus::Normal;
1010                     return Some((FullCodeCharKind::EndComment, item));
1011                 } else {
1012                     self.status = CharClassesStatus::BlockComment(deepness);
1013                     return Some((FullCodeCharKind::InComment, item));
1014                 }
1015             }
1016             CharClassesStatus::LineComment => match chr {
1017                 '\n' => {
1018                     self.status = CharClassesStatus::Normal;
1019                     return Some((FullCodeCharKind::EndComment, item));
1020                 }
1021                 _ => {
1022                     self.status = CharClassesStatus::LineComment;
1023                     return Some((FullCodeCharKind::InComment, item));
1024                 }
1025             },
1026         };
1027         Some((char_kind, item))
1028     }
1029 }
1030
1031 /// An iterator over the lines of a string, paired with the char kind at the
1032 /// end of the line.
1033 pub struct LineClasses<'a> {
1034     base: iter::Peekable<CharClasses<std::str::Chars<'a>>>,
1035     kind: FullCodeCharKind,
1036 }
1037
1038 impl<'a> LineClasses<'a> {
1039     pub fn new(s: &'a str) -> Self {
1040         LineClasses {
1041             base: CharClasses::new(s.chars()).peekable(),
1042             kind: FullCodeCharKind::Normal,
1043         }
1044     }
1045 }
1046
1047 impl<'a> Iterator for LineClasses<'a> {
1048     type Item = (FullCodeCharKind, String);
1049
1050     fn next(&mut self) -> Option<Self::Item> {
1051         self.base.peek()?;
1052
1053         let mut line = String::new();
1054
1055         while let Some((kind, c)) = self.base.next() {
1056             self.kind = kind;
1057             if c == '\n' {
1058                 break;
1059             } else {
1060                 line.push(c);
1061             }
1062         }
1063
1064         Some((self.kind, line))
1065     }
1066 }
1067
1068 /// Iterator over functional and commented parts of a string. Any part of a string is either
1069 /// functional code, either *one* block comment, either *one* line comment. Whitespace between
1070 /// comments is functional code. Line comments contain their ending newlines.
1071 struct UngroupedCommentCodeSlices<'a> {
1072     slice: &'a str,
1073     iter: iter::Peekable<CharClasses<std::str::CharIndices<'a>>>,
1074 }
1075
1076 impl<'a> UngroupedCommentCodeSlices<'a> {
1077     fn new(code: &'a str) -> UngroupedCommentCodeSlices<'a> {
1078         UngroupedCommentCodeSlices {
1079             slice: code,
1080             iter: CharClasses::new(code.char_indices()).peekable(),
1081         }
1082     }
1083 }
1084
1085 impl<'a> Iterator for UngroupedCommentCodeSlices<'a> {
1086     type Item = (CodeCharKind, usize, &'a str);
1087
1088     fn next(&mut self) -> Option<Self::Item> {
1089         let (kind, (start_idx, _)) = self.iter.next()?;
1090         match kind {
1091             FullCodeCharKind::Normal | FullCodeCharKind::InString => {
1092                 // Consume all the Normal code
1093                 while let Some(&(char_kind, _)) = self.iter.peek() {
1094                     if char_kind.is_comment() {
1095                         break;
1096                     }
1097                     let _ = self.iter.next();
1098                 }
1099             }
1100             FullCodeCharKind::StartComment => {
1101                 // Consume the whole comment
1102                 while let Some((FullCodeCharKind::InComment, (_, _))) = self.iter.next() {}
1103             }
1104             _ => panic!(),
1105         }
1106         let slice = match self.iter.peek() {
1107             Some(&(_, (end_idx, _))) => &self.slice[start_idx..end_idx],
1108             None => &self.slice[start_idx..],
1109         };
1110         Some((
1111             if kind.is_comment() {
1112                 CodeCharKind::Comment
1113             } else {
1114                 CodeCharKind::Normal
1115             },
1116             start_idx,
1117             slice,
1118         ))
1119     }
1120 }
1121
1122 /// Iterator over an alternating sequence of functional and commented parts of
1123 /// a string. The first item is always a, possibly zero length, subslice of
1124 /// functional text. Line style comments contain their ending newlines.
1125 pub struct CommentCodeSlices<'a> {
1126     slice: &'a str,
1127     last_slice_kind: CodeCharKind,
1128     last_slice_end: usize,
1129 }
1130
1131 impl<'a> CommentCodeSlices<'a> {
1132     pub fn new(slice: &'a str) -> CommentCodeSlices<'a> {
1133         CommentCodeSlices {
1134             slice,
1135             last_slice_kind: CodeCharKind::Comment,
1136             last_slice_end: 0,
1137         }
1138     }
1139 }
1140
1141 impl<'a> Iterator for CommentCodeSlices<'a> {
1142     type Item = (CodeCharKind, usize, &'a str);
1143
1144     fn next(&mut self) -> Option<Self::Item> {
1145         if self.last_slice_end == self.slice.len() {
1146             return None;
1147         }
1148
1149         let mut sub_slice_end = self.last_slice_end;
1150         let mut first_whitespace = None;
1151         let subslice = &self.slice[self.last_slice_end..];
1152         let mut iter = CharClasses::new(subslice.char_indices());
1153
1154         for (kind, (i, c)) in &mut iter {
1155             let is_comment_connector = self.last_slice_kind == CodeCharKind::Normal
1156                 && &subslice[..2] == "//"
1157                 && [' ', '\t'].contains(&c);
1158
1159             if is_comment_connector && first_whitespace.is_none() {
1160                 first_whitespace = Some(i);
1161             }
1162
1163             if kind.to_codecharkind() == self.last_slice_kind && !is_comment_connector {
1164                 let last_index = match first_whitespace {
1165                     Some(j) => j,
1166                     None => i,
1167                 };
1168                 sub_slice_end = self.last_slice_end + last_index;
1169                 break;
1170             }
1171
1172             if !is_comment_connector {
1173                 first_whitespace = None;
1174             }
1175         }
1176
1177         if let (None, true) = (iter.next(), sub_slice_end == self.last_slice_end) {
1178             // This was the last subslice.
1179             sub_slice_end = match first_whitespace {
1180                 Some(i) => self.last_slice_end + i,
1181                 None => self.slice.len(),
1182             };
1183         }
1184
1185         let kind = match self.last_slice_kind {
1186             CodeCharKind::Comment => CodeCharKind::Normal,
1187             CodeCharKind::Normal => CodeCharKind::Comment,
1188         };
1189         let res = (
1190             kind,
1191             self.last_slice_end,
1192             &self.slice[self.last_slice_end..sub_slice_end],
1193         );
1194         self.last_slice_end = sub_slice_end;
1195         self.last_slice_kind = kind;
1196
1197         Some(res)
1198     }
1199 }
1200
1201 /// Checks is `new` didn't miss any comment from `span`, if it removed any, return previous text
1202 /// (if it fits in the width/offset, else return None), else return `new`
1203 pub fn recover_comment_removed(
1204     new: String,
1205     span: Span,
1206     context: &RewriteContext,
1207 ) -> Option<String> {
1208     let snippet = context.snippet(span);
1209     if snippet != new && changed_comment_content(snippet, &new) {
1210         // We missed some comments. Warn and keep the original text.
1211         if context.config.error_on_unformatted() {
1212             context.report.append(
1213                 context.source_map.span_to_filename(span).into(),
1214                 vec![FormattingError::from_span(
1215                     span,
1216                     &context.source_map,
1217                     ErrorKind::LostComment,
1218                 )],
1219             );
1220         }
1221         Some(snippet.to_owned())
1222     } else {
1223         Some(new)
1224     }
1225 }
1226
1227 pub fn filter_normal_code(code: &str) -> String {
1228     let mut buffer = String::with_capacity(code.len());
1229     LineClasses::new(code).for_each(|(kind, line)| match kind {
1230         FullCodeCharKind::Normal | FullCodeCharKind::InString => {
1231             buffer.push_str(&line);
1232             buffer.push('\n');
1233         }
1234         _ => (),
1235     });
1236     if !code.ends_with('\n') && buffer.ends_with('\n') {
1237         buffer.pop();
1238     }
1239     buffer
1240 }
1241
1242 /// Return true if the two strings of code have the same payload of comments.
1243 /// The payload of comments is everything in the string except:
1244 ///     - actual code (not comments)
1245 ///     - comment start/end marks
1246 ///     - whitespace
1247 ///     - '*' at the beginning of lines in block comments
1248 fn changed_comment_content(orig: &str, new: &str) -> bool {
1249     // Cannot write this as a fn since we cannot return types containing closures
1250     let code_comment_content = |code| {
1251         let slices = UngroupedCommentCodeSlices::new(code);
1252         slices
1253             .filter(|&(ref kind, _, _)| *kind == CodeCharKind::Comment)
1254             .flat_map(|(_, _, s)| CommentReducer::new(s))
1255     };
1256     let res = code_comment_content(orig).ne(code_comment_content(new));
1257     debug!(
1258         "comment::changed_comment_content: {}\norig: '{}'\nnew: '{}'\nraw_old: {}\nraw_new: {}",
1259         res,
1260         orig,
1261         new,
1262         code_comment_content(orig).collect::<String>(),
1263         code_comment_content(new).collect::<String>()
1264     );
1265     res
1266 }
1267
1268 /// Iterator over the 'payload' characters of a comment.
1269 /// It skips whitespace, comment start/end marks, and '*' at the beginning of lines.
1270 /// The comment must be one comment, ie not more than one start mark (no multiple line comments,
1271 /// for example).
1272 struct CommentReducer<'a> {
1273     is_block: bool,
1274     at_start_line: bool,
1275     iter: std::str::Chars<'a>,
1276 }
1277
1278 impl<'a> CommentReducer<'a> {
1279     fn new(comment: &'a str) -> CommentReducer<'a> {
1280         let is_block = comment.starts_with("/*");
1281         let comment = remove_comment_header(comment);
1282         CommentReducer {
1283             is_block,
1284             at_start_line: false, // There are no supplementary '*' on the first line
1285             iter: comment.chars(),
1286         }
1287     }
1288 }
1289
1290 impl<'a> Iterator for CommentReducer<'a> {
1291     type Item = char;
1292
1293     fn next(&mut self) -> Option<Self::Item> {
1294         loop {
1295             let mut c = self.iter.next()?;
1296             if self.is_block && self.at_start_line {
1297                 while c.is_whitespace() {
1298                     c = self.iter.next()?;
1299                 }
1300                 // Ignore leading '*'
1301                 if c == '*' {
1302                     c = self.iter.next()?;
1303                 }
1304             } else if c == '\n' {
1305                 self.at_start_line = true;
1306             }
1307             if !c.is_whitespace() {
1308                 return Some(c);
1309             }
1310         }
1311     }
1312 }
1313
1314 fn remove_comment_header(comment: &str) -> &str {
1315     if comment.starts_with("///") || comment.starts_with("//!") {
1316         &comment[3..]
1317     } else if comment.starts_with("//") {
1318         &comment[2..]
1319     } else if (comment.starts_with("/**") && !comment.starts_with("/**/"))
1320         || comment.starts_with("/*!")
1321     {
1322         &comment[3..comment.len() - 2]
1323     } else {
1324         assert!(
1325             comment.starts_with("/*"),
1326             format!("string '{}' is not a comment", comment)
1327         );
1328         &comment[2..comment.len() - 2]
1329     }
1330 }
1331
1332 #[cfg(test)]
1333 mod test {
1334     use super::*;
1335     use shape::{Indent, Shape};
1336
1337     #[test]
1338     fn char_classes() {
1339         let mut iter = CharClasses::new("//\n\n".chars());
1340
1341         assert_eq!((FullCodeCharKind::StartComment, '/'), iter.next().unwrap());
1342         assert_eq!((FullCodeCharKind::InComment, '/'), iter.next().unwrap());
1343         assert_eq!((FullCodeCharKind::EndComment, '\n'), iter.next().unwrap());
1344         assert_eq!((FullCodeCharKind::Normal, '\n'), iter.next().unwrap());
1345         assert_eq!(None, iter.next());
1346     }
1347
1348     #[test]
1349     fn comment_code_slices() {
1350         let input = "code(); /* test */ 1 + 1";
1351         let mut iter = CommentCodeSlices::new(input);
1352
1353         assert_eq!((CodeCharKind::Normal, 0, "code(); "), iter.next().unwrap());
1354         assert_eq!(
1355             (CodeCharKind::Comment, 8, "/* test */"),
1356             iter.next().unwrap()
1357         );
1358         assert_eq!((CodeCharKind::Normal, 18, " 1 + 1"), iter.next().unwrap());
1359         assert_eq!(None, iter.next());
1360     }
1361
1362     #[test]
1363     fn comment_code_slices_two() {
1364         let input = "// comment\n    test();";
1365         let mut iter = CommentCodeSlices::new(input);
1366
1367         assert_eq!((CodeCharKind::Normal, 0, ""), iter.next().unwrap());
1368         assert_eq!(
1369             (CodeCharKind::Comment, 0, "// comment\n"),
1370             iter.next().unwrap()
1371         );
1372         assert_eq!(
1373             (CodeCharKind::Normal, 11, "    test();"),
1374             iter.next().unwrap()
1375         );
1376         assert_eq!(None, iter.next());
1377     }
1378
1379     #[test]
1380     fn comment_code_slices_three() {
1381         let input = "1 // comment\n    // comment2\n\n";
1382         let mut iter = CommentCodeSlices::new(input);
1383
1384         assert_eq!((CodeCharKind::Normal, 0, "1 "), iter.next().unwrap());
1385         assert_eq!(
1386             (CodeCharKind::Comment, 2, "// comment\n    // comment2\n"),
1387             iter.next().unwrap()
1388         );
1389         assert_eq!((CodeCharKind::Normal, 29, "\n"), iter.next().unwrap());
1390         assert_eq!(None, iter.next());
1391     }
1392
1393     #[test]
1394     #[rustfmt::skip]
1395     fn format_comments() {
1396         let mut config: ::config::Config = Default::default();
1397         config.set().wrap_comments(true);
1398         config.set().normalize_comments(true);
1399
1400         let comment = rewrite_comment(" //test",
1401                                       true,
1402                                       Shape::legacy(100, Indent::new(0, 100)),
1403                                       &config).unwrap();
1404         assert_eq!("/* test */", comment);
1405
1406         let comment = rewrite_comment("// comment on a",
1407                                       false,
1408                                       Shape::legacy(10, Indent::empty()),
1409                                       &config).unwrap();
1410         assert_eq!("// comment\n// on a", comment);
1411
1412         let comment = rewrite_comment("//  A multi line comment\n             // between args.",
1413                                       false,
1414                                       Shape::legacy(60, Indent::new(0, 12)),
1415                                       &config).unwrap();
1416         assert_eq!("//  A multi line comment\n            // between args.", comment);
1417
1418         let input = "// comment";
1419         let expected =
1420             "/* comment */";
1421         let comment = rewrite_comment(input,
1422                                       true,
1423                                       Shape::legacy(9, Indent::new(0, 69)),
1424                                       &config).unwrap();
1425         assert_eq!(expected, comment);
1426
1427         let comment = rewrite_comment("/*   trimmed    */",
1428                                       true,
1429                                       Shape::legacy(100, Indent::new(0, 100)),
1430                                       &config).unwrap();
1431         assert_eq!("/* trimmed */", comment);
1432     }
1433
1434     // This is probably intended to be a non-test fn, but it is not used. I'm
1435     // keeping it around unless it helps us test stuff.
1436     fn uncommented(text: &str) -> String {
1437         CharClasses::new(text.chars())
1438             .filter_map(|(s, c)| match s {
1439                 FullCodeCharKind::Normal | FullCodeCharKind::InString => Some(c),
1440                 _ => None,
1441             }).collect()
1442     }
1443
1444     #[test]
1445     fn test_uncommented() {
1446         assert_eq!(&uncommented("abc/*...*/"), "abc");
1447         assert_eq!(
1448             &uncommented("// .... /* \n../* /* *** / */ */a/* // */c\n"),
1449             "..ac\n"
1450         );
1451         assert_eq!(&uncommented("abc \" /* */\" qsdf"), "abc \" /* */\" qsdf");
1452     }
1453
1454     #[test]
1455     fn test_contains_comment() {
1456         assert_eq!(contains_comment("abc"), false);
1457         assert_eq!(contains_comment("abc // qsdf"), true);
1458         assert_eq!(contains_comment("abc /* kqsdf"), true);
1459         assert_eq!(contains_comment("abc \" /* */\" qsdf"), false);
1460     }
1461
1462     #[test]
1463     fn test_find_uncommented() {
1464         fn check(haystack: &str, needle: &str, expected: Option<usize>) {
1465             assert_eq!(expected, haystack.find_uncommented(needle));
1466         }
1467
1468         check("/*/ */test", "test", Some(6));
1469         check("//test\ntest", "test", Some(7));
1470         check("/* comment only */", "whatever", None);
1471         check(
1472             "/* comment */ some text /* more commentary */ result",
1473             "result",
1474             Some(46),
1475         );
1476         check("sup // sup", "p", Some(2));
1477         check("sup", "x", None);
1478         check(r#"π? /**/ π is nice!"#, r#"π is nice"#, Some(9));
1479         check("/*sup yo? \n sup*/ sup", "p", Some(20));
1480         check("hel/*lohello*/lo", "hello", None);
1481         check("acb", "ab", None);
1482         check(",/*A*/ ", ",", Some(0));
1483         check("abc", "abc", Some(0));
1484         check("/* abc */", "abc", None);
1485         check("/**/abc/* */", "abc", Some(4));
1486         check("\"/* abc */\"", "abc", Some(4));
1487         check("\"/* abc", "abc", Some(4));
1488     }
1489
1490     #[test]
1491     fn test_remove_trailing_white_spaces() {
1492         let s = "    r#\"\n        test\n    \"#";
1493         assert_eq!(remove_trailing_white_spaces(&s), s);
1494     }
1495
1496     #[test]
1497     fn test_filter_normal_code() {
1498         let s = r#"
1499 fn main() {
1500     println!("hello, world");
1501 }
1502 "#;
1503         assert_eq!(s, filter_normal_code(s));
1504         let s_with_comment = r#"
1505 fn main() {
1506     // hello, world
1507     println!("hello, world");
1508 }
1509 "#;
1510         assert_eq!(s, filter_normal_code(s_with_comment));
1511     }
1512 }