-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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("//") {
}
#[derive(Copy, Clone, PartialEq, Eq)]
-pub enum CommentStyle<'a> {
+pub(crate) enum CommentStyle<'a> {
DoubleSlash,
TripleSlash,
Doc,
}
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
}
}
- /// 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
}
}
- /// 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 => "/// ",
}
}
- 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
}
}
+/// 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<String> {
+ 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);
Some(result)
}
-pub fn rewrite_doc_comment(orig: &str, shape: Shape, config: &Config) -> Option<String> {
+pub(crate) fn rewrite_doc_comment(orig: &str, shape: Shape, config: &Config) -> Option<String> {
identify_comment(orig, false, shape, config, true)
}
-pub fn rewrite_comment(
+pub(crate) fn rewrite_comment(
orig: &str,
block_style: bool,
shape: Shape,
) -> Option<String> {
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' {
// - 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) {
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;
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)
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,
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<String> {
- 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::<Vec<&str>>()
- .join(&format!("\n{}", indent_str));
- Some(format!("{}\n{}{}", first_line, indent_str, rest))
+ }
}
/// Attributes for code blocks in rustdoc.
/// 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<String>,
/// the number of whitespaces up to the item sigil
indent: usize,
/// the string that marks the start of an item
}
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("- ")
}
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: "",
}
}
- /// 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::<String>()
+ }
+
+ /// 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<String> {
- 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<CodeBlockAttribute>,
+ item_block: Option<ItemizedBlock>,
+ 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<ItemizedBlock> = 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<String> {
+ 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<str> {
- 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)
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
}
.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://")
/// 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<String> {
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())
/// 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<String> {
let missing_comment = rewrite_missing_comment(span, shape, context)?;
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 =
}
/// 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()
}
}
offset: Indent,
config: &Config,
is_doc_comment: bool,
-) -> Option<String> {
+) -> String {
let lines: Vec<&str> = orig
.lines()
.map(|l| {
""
};
// 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("/*! ")
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("// ")
}
}
-pub trait FindUncommented {
+pub(crate) trait FindUncommented {
fn find_uncommented(&self, pat: &str) -> Option<usize>;
}
// 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<usize> {
+// Good: `/* /* inner */ outer */ code();`
+// Bad: `code(); // hello\n world!`
+pub(crate) fn find_comment_end(s: &str) -> Option<usize> {
let mut iter = CharClasses::new(s.char_indices());
for (kind, (i, _c)) in &mut iter {
if kind == FullCodeCharKind::Normal || kind == FullCodeCharKind::InString {
}
}
- // 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 {
}
}
-/// 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<T>
+pub(crate) struct CharClasses<T>
where
T: Iterator,
T::Item: RichChar,
status: CharClassesStatus,
}
-pub trait RichChar {
+pub(crate) trait RichChar {
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,
}
/// 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,
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
}
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
T: Iterator,
T::Item: RichChar,
{
- pub fn new(base: T) -> CharClasses<T> {
+ pub(crate) fn new(base: T) -> CharClasses<T> {
CharClasses {
base: multipeek(base),
status: CharClassesStatus::Normal,
},
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)
},
_ => 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, '*');
/// 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<CharClasses<std::str::Chars<'a>>>,
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,
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))
}
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!(),
}
/// 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,
}
/// 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<String> {
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,
)],
);
}
}
-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
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
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(),
}
}
while c.is_whitespace() {
c = self.iter.next()?;
}
- // Ignore leading '*'
+ // Ignore leading '*'.
if c == '*' {
c = self.iter.next()?;
}
#[cfg(test)]
mod test {
use super::*;
- use shape::{Indent, Shape};
+ use crate::shape::{Indent, Shape};
#[test]
fn char_classes() {
#[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",
&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
/*
&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"#,
&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"#,
&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!
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 {
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#"
projects / rust.git / blobdiff