X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fcomment.rs;h=1da62d176817171b46b433b06978f6c6fc2fcd74;hb=a36e7c7981c2058474734887e83a04de43e741ac;hp=213879e50a1948a0fef958fa194c9aafa8581920;hpb=b82949b36e7fb66162e31066d3d6f6174f680b5b;p=rust.git diff --git a/src/comment.rs b/src/comment.rs index 213879e50a1..1da62d17681 100644 --- a/src/comment.rs +++ b/src/comment.rs @@ -1,26 +1,18 @@ -// Copyright 2015 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - // Formatting and tools for comments. use std::{self, borrow::Cow, iter}; use itertools::{multipeek, MultiPeek}; -use syntax::source_map::Span; +use rustc_span::Span; -use config::Config; -use rewrite::RewriteContext; -use shape::{Indent, Shape}; -use string::{rewrite_string, StringFormat}; -use utils::{count_newlines, first_line_width, last_line_width}; -use {ErrorKind, FormattingError}; +use crate::config::Config; +use crate::rewrite::RewriteContext; +use crate::shape::{Indent, Shape}; +use crate::string::{rewrite_string, StringFormat}; +use crate::utils::{ + count_newlines, first_line_width, last_line_width, trim_left_preserve_layout, unicode_str_width, +}; +use crate::{ErrorKind, FormattingError}; fn is_custom_comment(comment: &str) -> bool { if !comment.starts_with("//") { @@ -33,7 +25,7 @@ fn is_custom_comment(comment: &str) -> bool { } #[derive(Copy, Clone, PartialEq, Eq)] -pub enum CommentStyle<'a> { +pub(crate) enum CommentStyle<'a> { DoubleSlash, TripleSlash, Doc, @@ -52,8 +44,8 @@ fn custom_opener(s: &str) -> &str { } impl<'a> CommentStyle<'a> { - /// Returns true if the commenting style covers a line only. - pub fn is_line_comment(&self) -> bool { + /// Returns `true` if the commenting style covers a line only. + pub(crate) fn is_line_comment(&self) -> bool { match *self { CommentStyle::DoubleSlash | CommentStyle::TripleSlash @@ -63,8 +55,8 @@ pub fn is_line_comment(&self) -> bool { } } - /// Returns true if the commenting style can span over multiple lines. - pub fn is_block_comment(&self) -> bool { + /// Returns `true` if the commenting style can span over multiple lines. + pub(crate) fn is_block_comment(&self) -> bool { match *self { CommentStyle::SingleBullet | CommentStyle::DoubleBullet | CommentStyle::Exclamation => { true @@ -73,15 +65,15 @@ pub fn is_block_comment(&self) -> bool { } } - /// Returns true if the commenting style is for documentation. - pub fn is_doc_comment(&self) -> bool { + /// Returns `true` if the commenting style is for documentation. + pub(crate) fn is_doc_comment(&self) -> bool { match *self { CommentStyle::TripleSlash | CommentStyle::Doc => true, _ => false, } } - pub fn opener(&self) -> &'a str { + pub(crate) fn opener(&self) -> &'a str { match *self { CommentStyle::DoubleSlash => "// ", CommentStyle::TripleSlash => "/// ", @@ -93,34 +85,36 @@ pub fn opener(&self) -> &'a str { } } - pub fn closer(&self) -> &'a str { + pub(crate) fn closer(&self) -> &'a str { match *self { CommentStyle::DoubleSlash | CommentStyle::TripleSlash | CommentStyle::Custom(..) | CommentStyle::Doc => "", - CommentStyle::DoubleBullet => " **/", - CommentStyle::SingleBullet | CommentStyle::Exclamation => " */", + CommentStyle::SingleBullet | CommentStyle::DoubleBullet | CommentStyle::Exclamation => { + " */" + } } } - pub fn line_start(&self) -> &'a str { + pub(crate) fn line_start(&self) -> &'a str { match *self { CommentStyle::DoubleSlash => "// ", CommentStyle::TripleSlash => "/// ", CommentStyle::Doc => "//! ", - CommentStyle::SingleBullet | CommentStyle::Exclamation => " * ", - CommentStyle::DoubleBullet => " ** ", + CommentStyle::SingleBullet | CommentStyle::DoubleBullet | CommentStyle::Exclamation => { + " * " + } CommentStyle::Custom(opener) => opener, } } - pub fn to_str_tuplet(&self) -> (&'a str, &'a str, &'a str) { + pub(crate) fn to_str_tuplet(&self) -> (&'a str, &'a str, &'a str) { (self.opener(), self.closer(), self.line_start()) } } -fn comment_style(orig: &str, normalize_comments: bool) -> CommentStyle { +pub(crate) fn comment_style(orig: &str, normalize_comments: bool) -> CommentStyle<'_> { if !normalize_comments { if orig.starts_with("/**") && !orig.starts_with("/**/") { CommentStyle::DoubleBullet @@ -150,19 +144,32 @@ fn comment_style(orig: &str, normalize_comments: bool) -> CommentStyle { } } +/// Returns true if the last line of the passed string finishes with a block-comment. +pub(crate) fn is_last_comment_block(s: &str) -> bool { + s.trim_end().ends_with("*/") +} + /// Combine `prev_str` and `next_str` into a single `String`. `span` may contain /// comments between two strings. If there are such comments, then that will be /// recovered. If `allow_extend` is true and there is no comment between the two /// strings, then they will be put on a single line as long as doing so does not /// exceed max width. -pub fn combine_strs_with_missing_comments( - context: &RewriteContext, +pub(crate) fn combine_strs_with_missing_comments( + context: &RewriteContext<'_>, prev_str: &str, next_str: &str, span: Span, shape: Shape, allow_extend: bool, ) -> Option { + trace!( + "combine_strs_with_missing_comments `{}` `{}` {:?} {:?}", + prev_str, + next_str, + span, + shape + ); + let mut result = String::with_capacity(prev_str.len() + next_str.len() + shape.indent.width() + 128); result.push_str(prev_str); @@ -234,11 +241,11 @@ pub fn combine_strs_with_missing_comments( Some(result) } -pub fn rewrite_doc_comment(orig: &str, shape: Shape, config: &Config) -> Option { +pub(crate) fn rewrite_doc_comment(orig: &str, shape: Shape, config: &Config) -> Option { identify_comment(orig, false, shape, config, true) } -pub fn rewrite_comment( +pub(crate) fn rewrite_comment( orig: &str, block_style: bool, shape: Shape, @@ -256,7 +263,8 @@ fn identify_comment( ) -> Option { let style = comment_style(orig, false); - // Computes the len of line taking into account a newline if the line is part of a paragraph. + // Computes the byte length of line taking into account a newline if the line is part of a + // paragraph. fn compute_len(orig: &str, line: &str) -> usize { if orig.len() > line.len() { if orig.as_bytes()[line.len()] == b'\r' { @@ -275,7 +283,7 @@ fn compute_len(orig: &str, line: &str) -> usize { // - a boolean indicating if there is a blank line // - a number indicating the size of the first group of comments fn consume_same_line_comments( - style: CommentStyle, + style: CommentStyle<'_>, orig: &str, line_start: &str, ) -> (bool, usize) { @@ -283,7 +291,7 @@ fn consume_same_line_comments( let mut hbl = false; for line in orig.lines() { - let trimmed_line = line.trim_left(); + let trimmed_line = line.trim_start(); if trimmed_line.is_empty() { hbl = true; break; @@ -300,29 +308,41 @@ fn consume_same_line_comments( let (has_bare_lines, first_group_ending) = match style { CommentStyle::DoubleSlash | CommentStyle::TripleSlash | CommentStyle::Doc => { - let line_start = style.line_start().trim_left(); + let line_start = style.line_start().trim_start(); consume_same_line_comments(style, orig, line_start) } CommentStyle::Custom(opener) => { - let trimmed_opener = opener.trim_right(); + let trimmed_opener = opener.trim_end(); consume_same_line_comments(style, orig, trimmed_opener) } // for a block comment, search for the closing symbol CommentStyle::DoubleBullet | CommentStyle::SingleBullet | CommentStyle::Exclamation => { - let closer = style.closer().trim_left(); + let closer = style.closer().trim_start(); + let mut count = orig.matches(closer).count(); let mut closing_symbol_offset = 0; let mut hbl = false; + let mut first = true; for line in orig.lines() { closing_symbol_offset += compute_len(&orig[closing_symbol_offset..], line); - let trimmed_line = line.trim_left(); + let mut trimmed_line = line.trim_start(); if !trimmed_line.starts_with('*') && !trimmed_line.starts_with("//") && !trimmed_line.starts_with("/*") { hbl = true; } + + // Remove opener from consideration when searching for closer + if first { + let opener = style.opener().trim_end(); + trimmed_line = &trimmed_line[opener.len()..]; + first = false; + } if trimmed_line.ends_with(closer) { - break; + count -= 1; + if count == 0 { + break; + } } } (hbl, closing_symbol_offset) @@ -332,12 +352,12 @@ fn consume_same_line_comments( let (first_group, rest) = orig.split_at(first_group_ending); let rewritten_first_group = if !config.normalize_comments() && has_bare_lines && style.is_block_comment() { - light_rewrite_block_comment_with_bare_lines(first_group, shape, config)? + trim_left_preserve_layout(first_group, shape.indent, config)? } else if !config.normalize_comments() && !config.wrap_comments() - && !config.format_doc_comments() + && !config.format_code_in_doc_comments() { - light_rewrite_comment(first_group, shape.indent, config, is_doc_comment)? + light_rewrite_comment(first_group, shape.indent, config, is_doc_comment) } else { rewrite_comment_inner( first_group, @@ -351,64 +371,28 @@ fn consume_same_line_comments( if rest.is_empty() { Some(rewritten_first_group) } else { - identify_comment(rest.trim_left(), block_style, shape, config, is_doc_comment).map( - |rest_str| { - format!( - "{}\n{}{}{}", - rewritten_first_group, - // insert back the blank line - if has_bare_lines && style.is_line_comment() { - "\n" - } else { - "" - }, - shape.indent.to_string(config), - rest_str - ) - }, + identify_comment( + rest.trim_start(), + block_style, + shape, + config, + is_doc_comment, ) - } -} - -/// Trims a minimum of leading whitespaces so that the content layout is kept and aligns to indent. -fn light_rewrite_block_comment_with_bare_lines( - orig: &str, - shape: Shape, - config: &Config, -) -> Option { - let prefix_whitespace_min = orig - .lines() - // skip the line with the starting sigil since the leading whitespace is removed - // otherwise, the minimum would always be zero - .skip(1) - .filter(|line| !line.is_empty()) - .map(|line| { - let mut width = 0; - for c in line.chars() { - match c { - ' ' => width += 1, - '\t' => width += config.tab_spaces(), - _ => break, - } - } - width - }) - .min()?; - - let indent_str = shape.indent.to_string(config); - let mut lines = orig.lines(); - let first_line = lines.next()?; - let rest = lines - .map(|line| { - if line.is_empty() { - line - } else { - &line[prefix_whitespace_min..] - } + .map(|rest_str| { + format!( + "{}\n{}{}{}", + rewritten_first_group, + // insert back the blank line + if has_bare_lines && style.is_line_comment() { + "\n" + } else { + "" + }, + shape.indent.to_string(config), + rest_str + ) }) - .collect::>() - .join(&format!("\n{}", indent_str)); - Some(format!("{}\n{}{}", first_line, indent_str, rest)) + } } /// Attributes for code blocks in rustdoc. @@ -439,8 +423,10 @@ fn new(attribute: &str) -> CodeBlockAttribute { /// Block that is formatted as an item. /// /// An item starts with either a star `*` or a dash `-`. Different level of indentation are -/// handled. +/// handled by shrinking the shape accordingly. struct ItemizedBlock { + /// the lines that are identified as part of an itemized block + lines: Vec, /// the number of whitespaces up to the item sigil indent: usize, /// the string that marks the start of an item @@ -450,9 +436,9 @@ struct ItemizedBlock { } impl ItemizedBlock { - /// Returns true if the line is formatted as an item + /// Returns `true` if the line is formatted as an item fn is_itemized_line(line: &str) -> bool { - let trimmed = line.trim_left(); + let trimmed = line.trim_start(); trimmed.starts_with("* ") || trimmed.starts_with("- ") } @@ -462,14 +448,15 @@ fn new(line: &str) -> ItemizedBlock { let space_to_sigil = line.chars().take_while(|c| c.is_whitespace()).count(); let indent = space_to_sigil + 2; ItemizedBlock { + lines: vec![line[indent..].to_string()], indent, opener: line[..indent].to_string(), line_start: " ".repeat(indent), } } - /// Returns a `StringFormat` used for formatting the content of an item - fn create_string_format<'a>(&'a self, fmt: &'a StringFormat) -> StringFormat<'a> { + /// Returns a `StringFormat` used for formatting the content of an item. + fn create_string_format<'a>(&'a self, fmt: &'a StringFormat<'_>) -> StringFormat<'a> { StringFormat { opener: "", closer: "", @@ -481,266 +468,364 @@ fn create_string_format<'a>(&'a self, fmt: &'a StringFormat) -> StringFormat<'a> } } - /// Returns true if the line is part of the current itemized block - fn in_block(&self, line: &str) -> bool { - !ItemizedBlock::is_itemized_line(line) + /// Returns `true` if the line is part of the current itemized block. + /// If it is, then it is added to the internal lines list. + fn add_line(&mut self, line: &str) -> bool { + if !ItemizedBlock::is_itemized_line(line) && self.indent <= line.chars().take_while(|c| c.is_whitespace()).count() + { + self.lines.push(line.to_string()); + return true; + } + false + } + + /// Returns the block as a string, with each line trimmed at the start. + fn trimmed_block_as_string(&self) -> String { + self.lines + .iter() + .map(|line| format!("{} ", line.trim_start())) + .collect::() + } + + /// Returns the block as a string under its original form. + fn original_block_as_string(&self) -> String { + self.lines.join("\n") } } -fn rewrite_comment_inner( - orig: &str, - block_style: bool, - style: CommentStyle, - shape: Shape, - config: &Config, - is_doc_comment: bool, -) -> Option { - let (opener, closer, line_start) = if block_style { - CommentStyle::SingleBullet.to_str_tuplet() - } else { - comment_style(orig, config.normalize_comments()).to_str_tuplet() - }; +struct CommentRewrite<'a> { + result: String, + code_block_buffer: String, + is_prev_line_multi_line: bool, + code_block_attr: Option, + item_block: Option, + comment_line_separator: String, + indent_str: String, + max_width: usize, + fmt_indent: Indent, + fmt: StringFormat<'a>, - let max_chars = shape - .width - .checked_sub(closer.len() + opener.len()) - .unwrap_or(1); - let indent_str = shape.indent.to_string_with_newline(config); - let fmt_indent = shape.indent + (opener.len() - line_start.len()); - let mut fmt = StringFormat { - opener: "", - closer: "", - line_start, - line_end: "", - shape: Shape::legacy(max_chars, fmt_indent), - trim_end: true, - config, - }; + opener: String, + closer: String, + line_start: String, +} - let line_breaks = count_newlines(orig.trim_right()); - let lines = orig - .lines() - .enumerate() - .map(|(i, mut line)| { - line = trim_right_unless_two_whitespaces(line.trim_left(), is_doc_comment); - // Drop old closer. - if i == line_breaks && line.ends_with("*/") && !line.starts_with("//") { - line = line[..(line.len() - 2)].trim_right(); - } +impl<'a> CommentRewrite<'a> { + fn new( + orig: &'a str, + block_style: bool, + shape: Shape, + config: &'a Config, + ) -> CommentRewrite<'a> { + let (opener, closer, line_start) = if block_style { + CommentStyle::SingleBullet.to_str_tuplet() + } else { + comment_style(orig, config.normalize_comments()).to_str_tuplet() + }; - line - }) - .map(|s| left_trim_comment_line(s, &style)) - .map(|(line, has_leading_whitespace)| { - if orig.starts_with("/*") && line_breaks == 0 { - ( - line.trim_left(), - has_leading_whitespace || config.normalize_comments(), - ) - } else { - (line, has_leading_whitespace || config.normalize_comments()) - } - }); + let max_width = shape + .width + .checked_sub(closer.len() + opener.len()) + .unwrap_or(1); + let indent_str = shape.indent.to_string_with_newline(config).to_string(); + + let mut cr = CommentRewrite { + result: String::with_capacity(orig.len() * 2), + code_block_buffer: String::with_capacity(128), + is_prev_line_multi_line: false, + code_block_attr: None, + item_block: None, + comment_line_separator: format!("{}{}", indent_str, line_start), + max_width, + indent_str, + fmt_indent: shape.indent, + + fmt: StringFormat { + opener: "", + closer: "", + line_start, + line_end: "", + shape: Shape::legacy(max_width, shape.indent), + trim_end: true, + config, + }, + + opener: opener.to_owned(), + closer: closer.to_owned(), + line_start: line_start.to_owned(), + }; + cr.result.push_str(opener); + cr + } - let mut result = String::with_capacity(orig.len() * 2); - result.push_str(opener); - let mut code_block_buffer = String::with_capacity(128); - let mut is_prev_line_multi_line = false; - let mut code_block_attr = None; - let mut item_block_buffer = String::with_capacity(128); - let mut item_block: Option = None; - let comment_line_separator = format!("{}{}", indent_str, line_start); - let join_block = |s: &str, sep: &str| { + fn join_block(s: &str, sep: &str) -> String { let mut result = String::with_capacity(s.len() + 128); let mut iter = s.lines().peekable(); while let Some(line) = iter.next() { result.push_str(line); result.push_str(match iter.peek() { - Some(next_line) if next_line.is_empty() => sep.trim_right(), + Some(next_line) if next_line.is_empty() => sep.trim_end(), Some(..) => &sep, None => "", }); } result - }; + } - for (i, (line, has_leading_whitespace)) in lines.enumerate() { + fn finish(mut self) -> String { + if !self.code_block_buffer.is_empty() { + // There is a code block that is not properly enclosed by backticks. + // We will leave them untouched. + self.result.push_str(&self.comment_line_separator); + self.result.push_str(&Self::join_block( + &trim_custom_comment_prefix(&self.code_block_buffer), + &self.comment_line_separator, + )); + } + + if let Some(ref ib) = self.item_block { + // the last few lines are part of an itemized block + self.fmt.shape = Shape::legacy(self.max_width, self.fmt_indent); + let item_fmt = ib.create_string_format(&self.fmt); + self.result.push_str(&self.comment_line_separator); + self.result.push_str(&ib.opener); + match rewrite_string( + &ib.trimmed_block_as_string(), + &item_fmt, + self.max_width.saturating_sub(ib.indent), + ) { + Some(s) => self.result.push_str(&Self::join_block( + &s, + &format!("{}{}", self.comment_line_separator, ib.line_start), + )), + None => self.result.push_str(&Self::join_block( + &ib.original_block_as_string(), + &self.comment_line_separator, + )), + }; + } + + self.result.push_str(&self.closer); + if self.result.ends_with(&self.opener) && self.opener.ends_with(' ') { + // Trailing space. + self.result.pop(); + } + + self.result + } + + fn handle_line( + &mut self, + orig: &'a str, + i: usize, + line: &'a str, + has_leading_whitespace: bool, + ) -> bool { let is_last = i == count_newlines(orig); - if let Some(ref ib) = item_block { - if ib.in_block(&line) { - item_block_buffer.push_str(&line); - item_block_buffer.push('\n'); - continue; + if let Some(ref mut ib) = self.item_block { + if ib.add_line(&line) { + return false; } - is_prev_line_multi_line = false; - fmt.shape = Shape::legacy(max_chars, fmt_indent); - let item_fmt = ib.create_string_format(&fmt); - result.push_str(&comment_line_separator); - result.push_str(&ib.opener); - match rewrite_string(&item_block_buffer.replace("\n", " "), &item_fmt) { - Some(s) => result.push_str(&join_block( + self.is_prev_line_multi_line = false; + self.fmt.shape = Shape::legacy(self.max_width, self.fmt_indent); + let item_fmt = ib.create_string_format(&self.fmt); + self.result.push_str(&self.comment_line_separator); + self.result.push_str(&ib.opener); + match rewrite_string( + &ib.trimmed_block_as_string(), + &item_fmt, + self.max_width.saturating_sub(ib.indent), + ) { + Some(s) => self.result.push_str(&Self::join_block( &s, - &format!("{}{}", &comment_line_separator, ib.line_start), + &format!("{}{}", self.comment_line_separator, ib.line_start), + )), + None => self.result.push_str(&Self::join_block( + &ib.original_block_as_string(), + &self.comment_line_separator, )), - None => result.push_str(&join_block(&item_block_buffer, &comment_line_separator)), }; - item_block_buffer.clear(); - } else if let Some(ref attr) = code_block_attr { + } else if self.code_block_attr.is_some() { if line.starts_with("```") { - let code_block = match attr { + let code_block = match self.code_block_attr.as_ref().unwrap() { CodeBlockAttribute::Ignore | CodeBlockAttribute::Text => { - trim_custom_comment_prefix(&code_block_buffer) + trim_custom_comment_prefix(&self.code_block_buffer) } - _ if code_block_buffer.is_empty() => String::new(), + _ if self.code_block_buffer.is_empty() => String::new(), _ => { - let mut config = config.clone(); - config.set().format_doc_comments(false); - match ::format_code_block(&code_block_buffer, &config) { - Some(ref s) => trim_custom_comment_prefix(s), - None => trim_custom_comment_prefix(&code_block_buffer), + let mut config = self.fmt.config.clone(); + config.set().wrap_comments(false); + if config.format_code_in_doc_comments() { + if let Some(s) = + crate::format_code_block(&self.code_block_buffer, &config) + { + trim_custom_comment_prefix(&s.snippet) + } else { + trim_custom_comment_prefix(&self.code_block_buffer) + } + } else { + trim_custom_comment_prefix(&self.code_block_buffer) } } }; if !code_block.is_empty() { - result.push_str(&comment_line_separator); - result.push_str(&join_block(&code_block, &comment_line_separator)); + self.result.push_str(&self.comment_line_separator); + self.result + .push_str(&Self::join_block(&code_block, &self.comment_line_separator)); } - code_block_buffer.clear(); - result.push_str(&comment_line_separator); - result.push_str(line); - code_block_attr = None; + self.code_block_buffer.clear(); + self.result.push_str(&self.comment_line_separator); + self.result.push_str(line); + self.code_block_attr = None; } else { - code_block_buffer.push_str(&hide_sharp_behind_comment(line)); - code_block_buffer.push('\n'); + self.code_block_buffer + .push_str(&hide_sharp_behind_comment(line)); + self.code_block_buffer.push('\n'); } - continue; + return false; } - code_block_attr = None; - item_block = None; + self.code_block_attr = None; + self.item_block = None; if line.starts_with("```") { - code_block_attr = Some(CodeBlockAttribute::new(&line[3..])) - } else if config.wrap_comments() && ItemizedBlock::is_itemized_line(&line) { + self.code_block_attr = Some(CodeBlockAttribute::new(&line[3..])) + } else if self.fmt.config.wrap_comments() && ItemizedBlock::is_itemized_line(&line) { let ib = ItemizedBlock::new(&line); - item_block_buffer.push_str(&line[ib.indent..]); - item_block_buffer.push('\n'); - item_block = Some(ib); - continue; + self.item_block = Some(ib); + return false; } - if result == opener { - let force_leading_whitespace = opener == "/* " && count_newlines(orig) == 0; - if !has_leading_whitespace && !force_leading_whitespace && result.ends_with(' ') { - result.pop(); + if self.result == self.opener { + let force_leading_whitespace = &self.opener == "/* " && count_newlines(orig) == 0; + if !has_leading_whitespace && !force_leading_whitespace && self.result.ends_with(' ') { + self.result.pop(); } if line.is_empty() { - continue; + return false; } - } else if is_prev_line_multi_line && !line.is_empty() { - result.push(' ') + } else if self.is_prev_line_multi_line && !line.is_empty() { + self.result.push(' ') } else if is_last && line.is_empty() { // trailing blank lines are unwanted - if !closer.is_empty() { - result.push_str(&indent_str); + if !self.closer.is_empty() { + self.result.push_str(&self.indent_str); } - break; + return true; } else { - result.push_str(&comment_line_separator); - if !has_leading_whitespace && result.ends_with(' ') { - result.pop(); + self.result.push_str(&self.comment_line_separator); + if !has_leading_whitespace && self.result.ends_with(' ') { + self.result.pop(); } } - if config.wrap_comments() && line.len() > fmt.shape.width && !has_url(line) { - match rewrite_string(line, &fmt) { + if self.fmt.config.wrap_comments() + && unicode_str_width(line) > self.fmt.shape.width + && !has_url(line) + { + match rewrite_string(line, &self.fmt, self.max_width) { Some(ref s) => { - is_prev_line_multi_line = s.contains('\n'); - result.push_str(s); + self.is_prev_line_multi_line = s.contains('\n'); + self.result.push_str(s); } - None if is_prev_line_multi_line => { + None if self.is_prev_line_multi_line => { // We failed to put the current `line` next to the previous `line`. // Remove the trailing space, then start rewrite on the next line. - result.pop(); - result.push_str(&comment_line_separator); - fmt.shape = Shape::legacy(max_chars, fmt_indent); - match rewrite_string(line, &fmt) { + self.result.pop(); + self.result.push_str(&self.comment_line_separator); + self.fmt.shape = Shape::legacy(self.max_width, self.fmt_indent); + match rewrite_string(line, &self.fmt, self.max_width) { Some(ref s) => { - is_prev_line_multi_line = s.contains('\n'); - result.push_str(s); + self.is_prev_line_multi_line = s.contains('\n'); + self.result.push_str(s); } None => { - is_prev_line_multi_line = false; - result.push_str(line); + self.is_prev_line_multi_line = false; + self.result.push_str(line); } } } None => { - is_prev_line_multi_line = false; - result.push_str(line); + self.is_prev_line_multi_line = false; + self.result.push_str(line); } } - fmt.shape = if is_prev_line_multi_line { + self.fmt.shape = if self.is_prev_line_multi_line { // 1 = " " - let offset = 1 + last_line_width(&result) - line_start.len(); + let offset = 1 + last_line_width(&self.result) - self.line_start.len(); Shape { - width: max_chars.saturating_sub(offset), - indent: fmt_indent, - offset: fmt.shape.offset + offset, + width: self.max_width.saturating_sub(offset), + indent: self.fmt_indent, + offset: self.fmt.shape.offset + offset, } } else { - Shape::legacy(max_chars, fmt_indent) + Shape::legacy(self.max_width, self.fmt_indent) }; } else { - if line.is_empty() && result.ends_with(' ') && !is_last { + if line.is_empty() && self.result.ends_with(' ') && !is_last { // Remove space if this is an empty comment or a doc comment. - result.pop(); + self.result.pop(); } - result.push_str(line); - fmt.shape = Shape::legacy(max_chars, fmt_indent); - is_prev_line_multi_line = false; + self.result.push_str(line); + self.fmt.shape = Shape::legacy(self.max_width, self.fmt_indent); + self.is_prev_line_multi_line = false; } + + false } - if !code_block_buffer.is_empty() { - // There is a code block that is not properly enclosed by backticks. - // We will leave them untouched. - result.push_str(&comment_line_separator); - result.push_str(&join_block( - &trim_custom_comment_prefix(&code_block_buffer), - &comment_line_separator, - )); - } - if !item_block_buffer.is_empty() { - // the last few lines are part of an itemized block - let ib = item_block.unwrap(); - fmt.shape = Shape::legacy(max_chars, fmt_indent); - let item_fmt = ib.create_string_format(&fmt); - result.push_str(&comment_line_separator); - result.push_str(&ib.opener); - match rewrite_string(&item_block_buffer.replace("\n", " "), &item_fmt) { - Some(s) => result.push_str(&join_block( - &s, - &format!("{}{}", &comment_line_separator, ib.line_start), - )), - None => result.push_str(&join_block(&item_block_buffer, &comment_line_separator)), - }; - } +} + +fn rewrite_comment_inner( + orig: &str, + block_style: bool, + style: CommentStyle<'_>, + shape: Shape, + config: &Config, + is_doc_comment: bool, +) -> Option { + let mut rewriter = CommentRewrite::new(orig, block_style, shape, config); + + let line_breaks = count_newlines(orig.trim_end()); + let lines = orig + .lines() + .enumerate() + .map(|(i, mut line)| { + line = trim_end_unless_two_whitespaces(line.trim_start(), is_doc_comment); + // Drop old closer. + if i == line_breaks && line.ends_with("*/") && !line.starts_with("//") { + line = line[..(line.len() - 2)].trim_end(); + } - result.push_str(closer); - if result.ends_with(opener) && opener.ends_with(' ') { - // Trailing space. - result.pop(); + line + }) + .map(|s| left_trim_comment_line(s, &style)) + .map(|(line, has_leading_whitespace)| { + if orig.starts_with("/*") && line_breaks == 0 { + ( + line.trim_start(), + has_leading_whitespace || config.normalize_comments(), + ) + } else { + (line, has_leading_whitespace || config.normalize_comments()) + } + }); + + for (i, (line, has_leading_whitespace)) in lines.enumerate() { + if rewriter.handle_line(orig, i, line, has_leading_whitespace) { + break; + } } - Some(result) + Some(rewriter.finish()) } const RUSTFMT_CUSTOM_COMMENT_PREFIX: &str = "//#### "; -fn hide_sharp_behind_comment(s: &str) -> Cow { - if s.trim_left().starts_with("# ") { +fn hide_sharp_behind_comment(s: &str) -> Cow<'_, str> { + let s_trimmed = s.trim(); + if s_trimmed.starts_with("# ") || s_trimmed == "#" { Cow::from(format!("{}{}", RUSTFMT_CUSTOM_COMMENT_PREFIX, s)) } else { Cow::from(s) @@ -750,9 +835,9 @@ fn hide_sharp_behind_comment(s: &str) -> Cow { fn trim_custom_comment_prefix(s: &str) -> String { s.lines() .map(|line| { - let left_trimmed = line.trim_left(); + let left_trimmed = line.trim_start(); if left_trimmed.starts_with(RUSTFMT_CUSTOM_COMMENT_PREFIX) { - left_trimmed.trim_left_matches(RUSTFMT_CUSTOM_COMMENT_PREFIX) + left_trimmed.trim_start_matches(RUSTFMT_CUSTOM_COMMENT_PREFIX) } else { line } @@ -761,7 +846,7 @@ fn trim_custom_comment_prefix(s: &str) -> String { .join("\n") } -/// Returns true if the given string MAY include URLs or alike. +/// Returns `true` if the given string MAY include URLs or alike. fn has_url(s: &str) -> bool { // This function may return false positive, but should get its job done in most cases. s.contains("https://") || s.contains("http://") || s.contains("ftp://") || s.contains("file://") @@ -769,14 +854,16 @@ fn has_url(s: &str) -> bool { /// Given the span, rewrite the missing comment inside it if available. /// Note that the given span must only include comments (or leading/trailing whitespaces). -pub fn rewrite_missing_comment( +pub(crate) fn rewrite_missing_comment( span: Span, shape: Shape, - context: &RewriteContext, + context: &RewriteContext<'_>, ) -> Option { let missing_snippet = context.snippet(span); let trimmed_snippet = missing_snippet.trim(); - if !trimmed_snippet.is_empty() { + // check the span starts with a comment + let pos = trimmed_snippet.find('/'); + if !trimmed_snippet.is_empty() && pos.is_some() { rewrite_comment(trimmed_snippet, false, shape, context.config) } else { Some(String::new()) @@ -786,10 +873,10 @@ pub fn rewrite_missing_comment( /// Recover the missing comments in the specified span, if available. /// The layout of the comments will be preserved as long as it does not break the code /// and its total width does not exceed the max width. -pub fn recover_missing_comment_in_span( +pub(crate) fn recover_missing_comment_in_span( span: Span, shape: Shape, - context: &RewriteContext, + context: &RewriteContext<'_>, used_width: usize, ) -> Option { let missing_comment = rewrite_missing_comment(span, shape, context)?; @@ -797,7 +884,7 @@ pub fn recover_missing_comment_in_span( Some(String::new()) } else { let missing_snippet = context.snippet(span); - let pos = missing_snippet.find('/').unwrap_or(0); + let pos = missing_snippet.find('/')?; // 1 = ` ` let total_width = missing_comment.len() + used_width + 1; let force_new_line_before_comment = @@ -812,11 +899,11 @@ pub fn recover_missing_comment_in_span( } /// Trim trailing whitespaces unless they consist of two or more whitespaces. -fn trim_right_unless_two_whitespaces(s: &str, is_doc_comment: bool) -> &str { +fn trim_end_unless_two_whitespaces(s: &str, is_doc_comment: bool) -> &str { if is_doc_comment && s.ends_with(" ") { s } else { - s.trim_right() + s.trim_end() } } @@ -826,7 +913,7 @@ fn light_rewrite_comment( offset: Indent, config: &Config, is_doc_comment: bool, -) -> Option { +) -> String { let lines: Vec<&str> = orig .lines() .map(|l| { @@ -844,16 +931,16 @@ fn light_rewrite_comment( "" }; // Preserve markdown's double-space line break syntax in doc comment. - trim_right_unless_two_whitespaces(left_trimmed, is_doc_comment) + trim_end_unless_two_whitespaces(left_trimmed, is_doc_comment) }) .collect(); - Some(lines.join(&format!("\n{}", offset.to_string(config)))) + lines.join(&format!("\n{}", offset.to_string(config))) } /// Trims comment characters and possibly a single space from the left of a string. /// Does not trim all whitespace. If a single space is trimmed from the left of the string, /// this function returns true. -fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle) -> (&'a str, bool) { +fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle<'_>) -> (&'a str, bool) { if line.starts_with("//! ") || line.starts_with("/// ") || line.starts_with("/*! ") @@ -864,7 +951,7 @@ fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle) -> (&'a str, if line.starts_with(opener) { (&line[opener.len()..], true) } else { - (&line[opener.trim_right().len()..], false) + (&line[opener.trim_end().len()..], false) } } else if line.starts_with("/* ") || line.starts_with("// ") @@ -888,7 +975,7 @@ fn left_trim_comment_line<'a>(line: &'a str, style: &CommentStyle) -> (&'a str, } } -pub trait FindUncommented { +pub(crate) trait FindUncommented { fn find_uncommented(&self, pat: &str) -> Option; } @@ -919,9 +1006,9 @@ fn find_uncommented(&self, pat: &str) -> Option { // Returns the first byte position after the first comment. The given string // is expected to be prefixed by a comment, including delimiters. -// Good: "/* /* inner */ outer */ code();" -// Bad: "code(); // hello\n world!" -pub fn find_comment_end(s: &str) -> Option { +// Good: `/* /* inner */ outer */ code();` +// Bad: `code(); // hello\n world!` +pub(crate) fn find_comment_end(s: &str) -> Option { let mut iter = CharClasses::new(s.char_indices()); for (kind, (i, _c)) in &mut iter { if kind == FullCodeCharKind::Normal || kind == FullCodeCharKind::InString { @@ -929,7 +1016,7 @@ pub fn find_comment_end(s: &str) -> Option { } } - // Handle case where the comment ends at the end of s. + // Handle case where the comment ends at the end of `s`. if iter.status == CharClassesStatus::Normal { Some(s.len()) } else { @@ -937,41 +1024,12 @@ pub fn find_comment_end(s: &str) -> Option { } } -/// Returns true if text contains any comment. -pub fn contains_comment(text: &str) -> bool { +/// Returns `true` if text contains any comment. +pub(crate) fn contains_comment(text: &str) -> bool { CharClasses::new(text.chars()).any(|(kind, _)| kind.is_comment()) } -/// Remove trailing spaces from the specified snippet. We do not remove spaces -/// inside strings or comments. -pub fn remove_trailing_white_spaces(text: &str) -> String { - let mut buffer = String::with_capacity(text.len()); - let mut space_buffer = String::with_capacity(128); - for (char_kind, c) in CharClasses::new(text.chars()) { - match c { - '\n' => { - if char_kind == FullCodeCharKind::InString { - buffer.push_str(&space_buffer); - } - space_buffer.clear(); - buffer.push('\n'); - } - _ if c.is_whitespace() => { - space_buffer.push(c); - } - _ => { - if !space_buffer.is_empty() { - buffer.push_str(&space_buffer); - space_buffer.clear(); - } - buffer.push(c); - } - } - } - buffer -} - -pub struct CharClasses +pub(crate) struct CharClasses where T: Iterator, T::Item: RichChar, @@ -980,7 +1038,7 @@ pub struct CharClasses status: CharClassesStatus, } -pub trait RichChar { +pub(crate) trait RichChar { fn get_char(&self) -> char; } @@ -999,27 +1057,34 @@ fn get_char(&self) -> char { #[derive(PartialEq, Eq, Debug, Clone, Copy)] enum CharClassesStatus { Normal, + /// Character is within a string LitString, LitStringEscape, + /// Character is within a raw string LitRawString(u32), RawStringPrefix(u32), RawStringSuffix(u32), LitChar, LitCharEscape, - // The u32 is the nesting deepness of the comment + /// Character inside a block comment, with the integer indicating the nesting deepness of the + /// comment BlockComment(u32), - // Status when the '/' has been consumed, but not yet the '*', deepness is - // the new deepness (after the comment opening). + /// Character inside a block-commented string, with the integer indicating the nesting deepness + /// of the comment + StringInBlockComment(u32), + /// Status when the '/' has been consumed, but not yet the '*', deepness is + /// the new deepness (after the comment opening). BlockCommentOpening(u32), - // Status when the '*' has been consumed, but not yet the '/', deepness is - // the new deepness (after the comment closing). + /// Status when the '*' has been consumed, but not yet the '/', deepness is + /// the new deepness (after the comment closing). BlockCommentClosing(u32), + /// Character is within a line comment LineComment, } /// Distinguish between functional part of code and comments #[derive(PartialEq, Eq, Debug, Clone, Copy)] -pub enum CodeCharKind { +pub(crate) enum CodeCharKind { Normal, Comment, } @@ -1028,7 +1093,7 @@ pub enum CodeCharKind { /// describing opening and closing of comments for ease when chunking /// code from tagged characters #[derive(PartialEq, Eq, Debug, Clone, Copy)] -pub enum FullCodeCharKind { +pub(crate) enum FullCodeCharKind { Normal, /// The first character of a comment, there is only one for a comment (always '/') StartComment, @@ -1037,6 +1102,12 @@ pub enum FullCodeCharKind { InComment, /// Last character of a comment, '\n' for a line comment, '/' for a block comment. EndComment, + /// Start of a mutlitine string inside a comment + StartStringCommented, + /// End of a mutlitine string inside a comment + EndStringCommented, + /// Inside a commented string + InStringCommented, /// Start of a mutlitine string StartString, /// End of a mutlitine string @@ -1046,19 +1117,39 @@ pub enum FullCodeCharKind { } impl FullCodeCharKind { - pub fn is_comment(self) -> bool { + pub(crate) fn is_comment(self) -> bool { match self { FullCodeCharKind::StartComment | FullCodeCharKind::InComment - | FullCodeCharKind::EndComment => true, + | FullCodeCharKind::EndComment + | FullCodeCharKind::StartStringCommented + | FullCodeCharKind::InStringCommented + | FullCodeCharKind::EndStringCommented => true, _ => false, } } - pub fn is_string(self) -> bool { + /// Returns true if the character is inside a comment + pub(crate) fn inside_comment(self) -> bool { + match self { + FullCodeCharKind::InComment + | FullCodeCharKind::StartStringCommented + | FullCodeCharKind::InStringCommented + | FullCodeCharKind::EndStringCommented => true, + _ => false, + } + } + + pub(crate) fn is_string(self) -> bool { self == FullCodeCharKind::InString || self == FullCodeCharKind::StartString } + /// Returns true if the character is within a commented string + pub(crate) fn is_commented_string(self) -> bool { + self == FullCodeCharKind::InStringCommented + || self == FullCodeCharKind::StartStringCommented + } + fn to_codecharkind(self) -> CodeCharKind { if self.is_comment() { CodeCharKind::Comment @@ -1073,7 +1164,7 @@ impl CharClasses T: Iterator, T::Item: RichChar, { - pub fn new(base: T) -> CharClasses { + pub(crate) fn new(base: T) -> CharClasses { CharClasses { base: multipeek(base), status: CharClassesStatus::Normal, @@ -1163,7 +1254,7 @@ fn next(&mut self) -> Option<(FullCodeCharKind, T::Item)> { }, CharClassesStatus::LitCharEscape => CharClassesStatus::LitChar, CharClassesStatus::Normal => match chr { - 'r' => match self.base.peek().map(|c| c.get_char()) { + 'r' => match self.base.peek().map(RichChar::get_char) { Some('#') | Some('"') => { char_kind = FullCodeCharKind::InString; CharClassesStatus::RawStringPrefix(0) @@ -1202,18 +1293,27 @@ fn next(&mut self) -> Option<(FullCodeCharKind, T::Item)> { }, _ => CharClassesStatus::Normal, }, + CharClassesStatus::StringInBlockComment(deepness) => { + char_kind = FullCodeCharKind::InStringCommented; + if chr == '"' { + CharClassesStatus::BlockComment(deepness) + } else { + CharClassesStatus::StringInBlockComment(deepness) + } + } CharClassesStatus::BlockComment(deepness) => { assert_ne!(deepness, 0); - self.status = match self.base.peek() { + char_kind = FullCodeCharKind::InComment; + match self.base.peek() { Some(next) if next.get_char() == '/' && chr == '*' => { CharClassesStatus::BlockCommentClosing(deepness - 1) } Some(next) if next.get_char() == '*' && chr == '/' => { CharClassesStatus::BlockCommentOpening(deepness + 1) } - _ => CharClassesStatus::BlockComment(deepness), - }; - return Some((FullCodeCharKind::InComment, item)); + _ if chr == '"' => CharClassesStatus::StringInBlockComment(deepness), + _ => self.status, + } } CharClassesStatus::BlockCommentOpening(deepness) => { assert_eq!(chr, '*'); @@ -1247,13 +1347,13 @@ fn next(&mut self) -> Option<(FullCodeCharKind, T::Item)> { /// An iterator over the lines of a string, paired with the char kind at the /// end of the line. -pub struct LineClasses<'a> { +pub(crate) struct LineClasses<'a> { base: iter::Peekable>>, kind: FullCodeCharKind, } impl<'a> LineClasses<'a> { - pub fn new(s: &'a str) -> Self { + pub(crate) fn new(s: &'a str) -> Self { LineClasses { base: CharClasses::new(s.chars()).peekable(), kind: FullCodeCharKind::Normal, @@ -1269,26 +1369,38 @@ fn next(&mut self) -> Option { let mut line = String::new(); - let start_class = match self.base.peek() { + let start_kind = match self.base.peek() { Some((kind, _)) => *kind, - None => FullCodeCharKind::Normal, + None => unreachable!(), }; while let Some((kind, c)) = self.base.next() { + // needed to set the kind of the ending character on the last line + self.kind = kind; if c == '\n' { - self.kind = match (start_class, kind) { + self.kind = match (start_kind, kind) { (FullCodeCharKind::Normal, FullCodeCharKind::InString) => { FullCodeCharKind::StartString } (FullCodeCharKind::InString, FullCodeCharKind::Normal) => { FullCodeCharKind::EndString } + (FullCodeCharKind::InComment, FullCodeCharKind::InStringCommented) => { + FullCodeCharKind::StartStringCommented + } + (FullCodeCharKind::InStringCommented, FullCodeCharKind::InComment) => { + FullCodeCharKind::EndStringCommented + } _ => kind, }; break; - } else { - line.push(c); } + line.push(c); + } + + // Workaround for CRLF newline. + if line.ends_with('\r') { + line.pop(); } Some((self.kind, line)) @@ -1329,7 +1441,12 @@ fn next(&mut self) -> Option { } FullCodeCharKind::StartComment => { // Consume the whole comment - while let Some((FullCodeCharKind::InComment, (_, _))) = self.iter.next() {} + loop { + match self.iter.next() { + Some((kind, ..)) if kind.inside_comment() => continue, + _ => break, + } + } } _ => panic!(), } @@ -1352,14 +1469,14 @@ fn next(&mut self) -> Option { /// Iterator over an alternating sequence of functional and commented parts of /// a string. The first item is always a, possibly zero length, subslice of /// functional text. Line style comments contain their ending newlines. -pub struct CommentCodeSlices<'a> { +pub(crate) struct CommentCodeSlices<'a> { slice: &'a str, last_slice_kind: CodeCharKind, last_slice_end: usize, } impl<'a> CommentCodeSlices<'a> { - pub fn new(slice: &'a str) -> CommentCodeSlices<'a> { + pub(crate) fn new(slice: &'a str) -> CommentCodeSlices<'a> { CommentCodeSlices { slice, last_slice_kind: CodeCharKind::Comment, @@ -1429,21 +1546,21 @@ fn next(&mut self) -> Option { } /// Checks is `new` didn't miss any comment from `span`, if it removed any, return previous text -/// (if it fits in the width/offset, else return None), else return `new` -pub fn recover_comment_removed( +/// (if it fits in the width/offset, else return `None`), else return `new` +pub(crate) fn recover_comment_removed( new: String, span: Span, - context: &RewriteContext, + context: &RewriteContext<'_>, ) -> Option { let snippet = context.snippet(span); if snippet != new && changed_comment_content(snippet, &new) { // We missed some comments. Warn and keep the original text. if context.config.error_on_unformatted() { context.report.append( - context.source_map.span_to_filename(span).into(), + context.parse_sess.span_to_filename(span), vec![FormattingError::from_span( span, - &context.source_map, + &context.parse_sess, ErrorKind::LostComment, )], ); @@ -1454,7 +1571,7 @@ pub fn recover_comment_removed( } } -pub fn filter_normal_code(code: &str) -> String { +pub(crate) fn filter_normal_code(code: &str) -> String { let mut buffer = String::with_capacity(code.len()); LineClasses::new(code).for_each(|(kind, line)| match kind { FullCodeCharKind::Normal @@ -1472,14 +1589,14 @@ pub fn filter_normal_code(code: &str) -> String { buffer } -/// Return true if the two strings of code have the same payload of comments. +/// Returns `true` if the two strings of code have the same payload of comments. /// The payload of comments is everything in the string except: -/// - actual code (not comments) -/// - comment start/end marks -/// - whitespace -/// - '*' at the beginning of lines in block comments +/// - actual code (not comments), +/// - comment start/end marks, +/// - whitespace, +/// - '*' at the beginning of lines in block comments. fn changed_comment_content(orig: &str, new: &str) -> bool { - // Cannot write this as a fn since we cannot return types containing closures + // Cannot write this as a fn since we cannot return types containing closures. let code_comment_content = |code| { let slices = UngroupedCommentCodeSlices::new(code); slices @@ -1514,7 +1631,8 @@ fn new(comment: &'a str) -> CommentReducer<'a> { let comment = remove_comment_header(comment); CommentReducer { is_block, - at_start_line: false, // There are no supplementary '*' on the first line + // There are no supplementary '*' on the first line. + at_start_line: false, iter: comment.chars(), } } @@ -1530,7 +1648,7 @@ fn next(&mut self) -> Option { while c.is_whitespace() { c = self.iter.next()?; } - // Ignore leading '*' + // Ignore leading '*'. if c == '*' { c = self.iter.next()?; } @@ -1565,7 +1683,7 @@ fn remove_comment_header(comment: &str) -> &str { #[cfg(test)] mod test { use super::*; - use shape::{Indent, Shape}; + use crate::shape::{Indent, Shape}; #[test] fn char_classes() { @@ -1626,11 +1744,11 @@ fn comment_code_slices_three() { #[test] #[rustfmt::skip] fn format_doc_comments() { - let mut wrap_normalize_config: ::config::Config = Default::default(); + let mut wrap_normalize_config: crate::config::Config = Default::default(); wrap_normalize_config.set().wrap_comments(true); wrap_normalize_config.set().normalize_comments(true); - let mut wrap_config: ::config::Config = Default::default(); + let mut wrap_config: crate::config::Config = Default::default(); wrap_config.set().wrap_comments(true); let comment = rewrite_comment(" //test", @@ -1666,7 +1784,7 @@ fn format_doc_comments() { &wrap_normalize_config).unwrap(); assert_eq!("/* trimmed */", comment); - // check that different comment style are properly recognised + // Check that different comment style are properly recognised. let comment = rewrite_comment(r#"/// test1 /// test2 /* @@ -1677,7 +1795,7 @@ fn format_doc_comments() { &wrap_normalize_config).unwrap(); assert_eq!("/// test1\n/// test2\n// test3", comment); - // check that the blank line marks the end of a commented paragraph + // Check that the blank line marks the end of a commented paragraph. let comment = rewrite_comment(r#"// test1 // test2"#, @@ -1686,7 +1804,7 @@ fn format_doc_comments() { &wrap_normalize_config).unwrap(); assert_eq!("// test1\n\n// test2", comment); - // check that the blank line marks the end of a custom-commented paragraph + // Check that the blank line marks the end of a custom-commented paragraph. let comment = rewrite_comment(r#"//@ test1 //@ test2"#, @@ -1695,7 +1813,7 @@ fn format_doc_comments() { &wrap_normalize_config).unwrap(); assert_eq!("//@ test1\n\n//@ test2", comment); - // check that bare lines are just indented but left unchanged otherwise + // Check that bare lines are just indented but otherwise left unchanged. let comment = rewrite_comment(r#"// test1 /* a bare line! @@ -1708,8 +1826,8 @@ fn format_doc_comments() { assert_eq!("// test1\n/*\n a bare line!\n\n another bare line!\n*/", comment); } - // This is probably intended to be a non-test fn, but it is not used. I'm - // keeping it around unless it helps us test stuff. + // This is probably intended to be a non-test fn, but it is not used. + // We should keep this around unless it helps us test stuff to remove it. fn uncommented(text: &str) -> String { CharClasses::new(text.chars()) .filter_map(|(s, c)| match s { @@ -1765,12 +1883,6 @@ fn check(haystack: &str, needle: &str, expected: Option) { check("\"/* abc", "abc", Some(4)); } - #[test] - fn test_remove_trailing_white_spaces() { - let s = " r#\"\n test\n \"#"; - assert_eq!(remove_trailing_white_spaces(&s), s); - } - #[test] fn test_filter_normal_code() { let s = r#"