X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Futils.rs;h=d3c349fb701e18050e574a9d35e69debf5845799;hb=612e8d5b9be72713a081370c85cc5bed30b6fae6;hp=421ab38e3f839be435015ccef6bfe7c8b225920a;hpb=cbd568083d87a90dfe5ab0e90f404454946c9f20;p=rust.git diff --git a/src/utils.rs b/src/utils.rs index 421ab38e3f8..d3c349fb701 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,36 +1,35 @@ -// 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. - use std::borrow::Cow; -use rustc_target::spec::abi; -use syntax::ast::{ - self, Attribute, CrateSugar, MetaItem, MetaItemKind, NestedMetaItem, NestedMetaItemKind, Path, - Visibility, VisibilityKind, +use rustc_ast::ast::{ + self, Attribute, CrateSugar, MetaItem, MetaItemKind, NestedMetaItem, NodeId, Path, Visibility, + VisibilityKind, }; -use syntax::ptr; -use syntax::source_map::{BytePos, Span, NO_EXPANSION}; +use rustc_ast::ptr; +use rustc_ast_pretty::pprust; +use rustc_span::{sym, symbol, BytePos, ExpnId, Span, Symbol, SyntaxContext}; +use unicode_width::UnicodeWidthStr; -use comment::filter_normal_code; -use rewrite::RewriteContext; -use shape::Shape; +use crate::comment::{filter_normal_code, CharClasses, FullCodeCharKind, LineClasses}; +use crate::config::{Config, Version}; +use crate::rewrite::RewriteContext; +use crate::shape::{Indent, Shape}; -pub const DEPR_SKIP_ANNOTATION: &str = "rustfmt_skip"; -pub const SKIP_ANNOTATION: &str = "rustfmt::skip"; +#[inline] +pub(crate) fn depr_skip_annotation() -> Symbol { + Symbol::intern("rustfmt_skip") +} -pub fn rewrite_ident<'a>(context: &'a RewriteContext, ident: ast::Ident) -> &'a str { +#[inline] +pub(crate) fn skip_annotation() -> Symbol { + Symbol::intern("rustfmt::skip") +} + +pub(crate) fn rewrite_ident<'a>(context: &'a RewriteContext<'_>, ident: symbol::Ident) -> &'a str { context.snippet(ident.span) } // Computes the length of a string's last line, minus offset. -pub fn extra_offset(text: &str, shape: Shape) -> usize { +pub(crate) fn extra_offset(text: &str, shape: Shape) -> usize { match text.rfind('\n') { // 1 for newline character Some(idx) => text.len().saturating_sub(idx + 1 + shape.used_width()), @@ -38,12 +37,12 @@ pub fn extra_offset(text: &str, shape: Shape) -> usize { } } -pub fn is_same_visibility(a: &Visibility, b: &Visibility) -> bool { - match (&a.node, &b.node) { +pub(crate) fn is_same_visibility(a: &Visibility, b: &Visibility) -> bool { + match (&a.kind, &b.kind) { ( VisibilityKind::Restricted { path: p, .. }, VisibilityKind::Restricted { path: q, .. }, - ) => format!("{}", p) == format!("{}", q), + ) => pprust::path_to_string(&p) == pprust::path_to_string(&q), (VisibilityKind::Public, VisibilityKind::Public) | (VisibilityKind::Inherited, VisibilityKind::Inherited) | ( @@ -59,8 +58,11 @@ pub fn is_same_visibility(a: &Visibility, b: &Visibility) -> bool { } // Uses Cow to avoid allocating in the common cases. -pub fn format_visibility(context: &RewriteContext, vis: &Visibility) -> Cow<'static, str> { - match vis.node { +pub(crate) fn format_visibility( + context: &RewriteContext<'_>, + vis: &Visibility, +) -> Cow<'static, str> { + match vis.kind { VisibilityKind::Public => Cow::from("pub "), VisibilityKind::Inherited => Cow::from(""), VisibilityKind::Crate(CrateSugar::PubCrate) => Cow::from("pub(crate) "), @@ -83,39 +85,47 @@ pub fn format_visibility(context: &RewriteContext, vis: &Visibility) -> Cow<'sta } #[inline] -pub fn format_async(is_async: ast::IsAsync) -> &'static str { +pub(crate) fn format_async(is_async: &ast::Async) -> &'static str { match is_async { - ast::IsAsync::Async { .. } => "async ", - ast::IsAsync::NotAsync => "", + ast::Async::Yes { .. } => "async ", + ast::Async::No => "", + } +} + +#[inline] +pub(crate) fn format_constness(constness: ast::Const) -> &'static str { + match constness { + ast::Const::Yes(..) => "const ", + ast::Const::No => "", } } #[inline] -pub fn format_constness(constness: ast::Constness) -> &'static str { +pub(crate) fn format_constness_right(constness: ast::Const) -> &'static str { match constness { - ast::Constness::Const => "const ", - ast::Constness::NotConst => "", + ast::Const::Yes(..) => " const", + ast::Const::No => "", } } #[inline] -pub fn format_defaultness(defaultness: ast::Defaultness) -> &'static str { +pub(crate) fn format_defaultness(defaultness: ast::Defaultness) -> &'static str { match defaultness { - ast::Defaultness::Default => "default ", + ast::Defaultness::Default(..) => "default ", ast::Defaultness::Final => "", } } #[inline] -pub fn format_unsafety(unsafety: ast::Unsafety) -> &'static str { +pub(crate) fn format_unsafety(unsafety: ast::Unsafe) -> &'static str { match unsafety { - ast::Unsafety::Unsafe => "unsafe ", - ast::Unsafety::Normal => "", + ast::Unsafe::Yes(..) => "unsafe ", + ast::Unsafe::No => "", } } #[inline] -pub fn format_auto(is_auto: ast::IsAuto) -> &'static str { +pub(crate) fn format_auto(is_auto: ast::IsAuto) -> &'static str { match is_auto { ast::IsAuto::Yes => "auto ", ast::IsAuto::No => "", @@ -123,32 +133,45 @@ pub fn format_auto(is_auto: ast::IsAuto) -> &'static str { } #[inline] -pub fn format_mutability(mutability: ast::Mutability) -> &'static str { +pub(crate) fn format_mutability(mutability: ast::Mutability) -> &'static str { match mutability { - ast::Mutability::Mutable => "mut ", - ast::Mutability::Immutable => "", + ast::Mutability::Mut => "mut ", + ast::Mutability::Not => "", } } #[inline] -pub fn format_abi(abi: abi::Abi, explicit_abi: bool, is_mod: bool) -> Cow<'static, str> { - if abi == abi::Abi::Rust && !is_mod { +pub(crate) fn format_extern( + ext: ast::Extern, + explicit_abi: bool, + is_mod: bool, +) -> Cow<'static, str> { + let abi = match ext { + ast::Extern::None => "Rust".to_owned(), + ast::Extern::Implicit => "C".to_owned(), + ast::Extern::Explicit(abi) => abi.symbol_unescaped.to_string(), + }; + + if abi == "Rust" && !is_mod { Cow::from("") - } else if abi == abi::Abi::C && !explicit_abi { + } else if abi == "C" && !explicit_abi { Cow::from("extern ") } else { - Cow::from(format!("extern {} ", abi)) + Cow::from(format!(r#"extern "{}" "#, abi)) } } #[inline] -// Transform `Vec>` into `Vec<&T>` -pub fn ptr_vec_to_ref_vec(vec: &[ptr::P]) -> Vec<&T> { +// Transform `Vec>` into `Vec<&T>` +pub(crate) fn ptr_vec_to_ref_vec(vec: &[ptr::P]) -> Vec<&T> { vec.iter().map(|x| &**x).collect::>() } #[inline] -pub fn filter_attributes(attrs: &[ast::Attribute], style: ast::AttrStyle) -> Vec { +pub(crate) fn filter_attributes( + attrs: &[ast::Attribute], + style: ast::AttrStyle, +) -> Vec { attrs .iter() .filter(|a| a.style == style) @@ -157,73 +180,67 @@ pub fn filter_attributes(attrs: &[ast::Attribute], style: ast::AttrStyle) -> Vec } #[inline] -pub fn inner_attributes(attrs: &[ast::Attribute]) -> Vec { +pub(crate) fn inner_attributes(attrs: &[ast::Attribute]) -> Vec { filter_attributes(attrs, ast::AttrStyle::Inner) } #[inline] -pub fn outer_attributes(attrs: &[ast::Attribute]) -> Vec { +pub(crate) fn outer_attributes(attrs: &[ast::Attribute]) -> Vec { filter_attributes(attrs, ast::AttrStyle::Outer) } #[inline] -pub fn is_single_line(s: &str) -> bool { +pub(crate) fn is_single_line(s: &str) -> bool { s.chars().find(|&c| c == '\n').is_none() } #[inline] -pub fn first_line_contains_single_line_comment(s: &str) -> bool { +pub(crate) fn first_line_contains_single_line_comment(s: &str) -> bool { s.lines().next().map_or(false, |l| l.contains("//")) } #[inline] -pub fn last_line_contains_single_line_comment(s: &str) -> bool { +pub(crate) fn last_line_contains_single_line_comment(s: &str) -> bool { s.lines().last().map_or(false, |l| l.contains("//")) } #[inline] -pub fn is_attributes_extendable(attrs_str: &str) -> bool { +pub(crate) fn is_attributes_extendable(attrs_str: &str) -> bool { !attrs_str.contains('\n') && !last_line_contains_single_line_comment(attrs_str) } -// The width of the first line in s. +/// The width of the first line in s. #[inline] -pub fn first_line_width(s: &str) -> usize { - match s.find('\n') { - Some(n) => n, - None => s.len(), - } +pub(crate) fn first_line_width(s: &str) -> usize { + unicode_str_width(s.splitn(2, '\n').next().unwrap_or("")) } -// The width of the last line in s. +/// The width of the last line in s. #[inline] -pub fn last_line_width(s: &str) -> usize { - match s.rfind('\n') { - Some(n) => s.len() - n - 1, - None => s.len(), - } +pub(crate) fn last_line_width(s: &str) -> usize { + unicode_str_width(s.rsplitn(2, '\n').next().unwrap_or("")) } -// The total used width of the last line. +/// The total used width of the last line. #[inline] -pub fn last_line_used_width(s: &str, offset: usize) -> usize { +pub(crate) fn last_line_used_width(s: &str, offset: usize) -> usize { if s.contains('\n') { last_line_width(s) } else { - offset + s.len() + offset + unicode_str_width(s) } } #[inline] -pub fn trimmed_last_line_width(s: &str) -> usize { - match s.rfind('\n') { - Some(n) => s[(n + 1)..].trim().len(), - None => s.trim().len(), - } +pub(crate) fn trimmed_last_line_width(s: &str) -> usize { + unicode_str_width(match s.rfind('\n') { + Some(n) => s[(n + 1)..].trim(), + None => s.trim(), + }) } #[inline] -pub fn last_line_extendable(s: &str) -> bool { +pub(crate) fn last_line_extendable(s: &str) -> bool { if s.ends_with("\"#") { return true; } @@ -240,13 +257,14 @@ pub fn last_line_extendable(s: &str) -> bool { #[inline] fn is_skip(meta_item: &MetaItem) -> bool { - match meta_item.node { + match meta_item.kind { MetaItemKind::Word => { - let path_str = meta_item.ident.to_string(); - path_str == SKIP_ANNOTATION || path_str == DEPR_SKIP_ANNOTATION + let path_str = pprust::path_to_string(&meta_item.path); + path_str == &*skip_annotation().as_str() + || path_str == &*depr_skip_annotation().as_str() } MetaItemKind::List(ref l) => { - meta_item.name() == "cfg_attr" && l.len() == 2 && is_skip_nested(&l[1]) + meta_item.has_name(sym::cfg_attr) && l.len() == 2 && is_skip_nested(&l[1]) } _ => false, } @@ -254,22 +272,29 @@ fn is_skip(meta_item: &MetaItem) -> bool { #[inline] fn is_skip_nested(meta_item: &NestedMetaItem) -> bool { - match meta_item.node { - NestedMetaItemKind::MetaItem(ref mi) => is_skip(mi), - NestedMetaItemKind::Literal(_) => false, + match meta_item { + NestedMetaItem::MetaItem(ref mi) => is_skip(mi), + NestedMetaItem::Literal(_) => false, } } #[inline] -pub fn contains_skip(attrs: &[Attribute]) -> bool { +pub(crate) fn contains_skip(attrs: &[Attribute]) -> bool { attrs .iter() .any(|a| a.meta().map_or(false, |a| is_skip(&a))) } #[inline] -pub fn semicolon_for_expr(context: &RewriteContext, expr: &ast::Expr) -> bool { - match expr.node { +pub(crate) fn semicolon_for_expr(context: &RewriteContext<'_>, expr: &ast::Expr) -> bool { + // Never try to insert semicolons on expressions when we're inside + // a macro definition - this can prevent the macro from compiling + // when used in expression position + if context.is_macro_def { + return false; + } + + match expr.kind { ast::ExprKind::Ret(..) | ast::ExprKind::Continue(..) | ast::ExprKind::Break(..) => { context.config.trailing_semicolon() } @@ -278,13 +303,12 @@ pub fn semicolon_for_expr(context: &RewriteContext, expr: &ast::Expr) -> bool { } #[inline] -pub fn semicolon_for_stmt(context: &RewriteContext, stmt: &ast::Stmt) -> bool { - match stmt.node { - ast::StmtKind::Semi(ref expr) => match expr.node { - ast::ExprKind::While(..) - | ast::ExprKind::WhileLet(..) - | ast::ExprKind::Loop(..) - | ast::ExprKind::ForLoop(..) => false, +pub(crate) fn semicolon_for_stmt(context: &RewriteContext<'_>, stmt: &ast::Stmt) -> bool { + match stmt.kind { + ast::StmtKind::Semi(ref expr) => match expr.kind { + ast::ExprKind::While(..) | ast::ExprKind::Loop(..) | ast::ExprKind::ForLoop(..) => { + false + } ast::ExprKind::Break(..) | ast::ExprKind::Continue(..) | ast::ExprKind::Ret(..) => { context.config.trailing_semicolon() } @@ -296,17 +320,32 @@ pub fn semicolon_for_stmt(context: &RewriteContext, stmt: &ast::Stmt) -> bool { } #[inline] -pub fn stmt_expr(stmt: &ast::Stmt) -> Option<&ast::Expr> { - match stmt.node { +pub(crate) fn stmt_expr(stmt: &ast::Stmt) -> Option<&ast::Expr> { + match stmt.kind { ast::StmtKind::Expr(ref expr) => Some(expr), _ => None, } } -#[inline] -pub fn count_newlines(input: &str) -> usize { - // Using `as_bytes` to omit UTF-8 decoding - input.as_bytes().iter().filter(|&&c| c == b'\n').count() +/// Returns the number of LF and CRLF respectively. +pub(crate) fn count_lf_crlf(input: &str) -> (usize, usize) { + let mut lf = 0; + let mut crlf = 0; + let mut is_crlf = false; + for c in input.as_bytes() { + match c { + b'\r' => is_crlf = true, + b'\n' if is_crlf => crlf += 1, + b'\n' => lf += 1, + _ => is_crlf = false, + } + } + (lf, crlf) +} + +pub(crate) fn count_newlines(input: &str) -> usize { + // Using bytes to omit UTF-8 decoding + bytecount::count(input.as_bytes(), b'\n') } // For format_missing and last_pos, need to use the source callsite (if applicable). @@ -317,18 +356,22 @@ macro_rules! source { }; } -pub fn mk_sp(lo: BytePos, hi: BytePos) -> Span { - Span::new(lo, hi, NO_EXPANSION) +pub(crate) fn mk_sp(lo: BytePos, hi: BytePos) -> Span { + Span::new(lo, hi, SyntaxContext::root()) } -// Return true if the given span does not intersect with file lines. +pub(crate) fn mk_sp_lo_plus_one(lo: BytePos) -> Span { + Span::new(lo, lo + BytePos(1), SyntaxContext::root()) +} + +// Returns `true` if the given span does not intersect with file lines. macro_rules! out_of_file_lines_range { ($self:ident, $span:expr) => { !$self.config.file_lines().is_all() && !$self .config .file_lines() - .intersects(&$self.source_map.lookup_line_range($span)) + .intersects(&$self.parse_sess.lookup_line_range($span)) }; } @@ -351,7 +394,7 @@ macro_rules! skip_out_of_file_lines_range_visitor { // Wraps String in an Option. Returns Some when the string adheres to the // Rewrite constraints defined for the Rewrite trait and None otherwise. -pub fn wrap_str(s: String, max_width: usize, shape: Shape) -> Option { +pub(crate) fn wrap_str(s: String, max_width: usize, shape: Shape) -> Option { if is_valid_str(&filter_normal_code(&s), max_width, shape) { Some(s) } else { @@ -366,11 +409,15 @@ fn is_valid_str(snippet: &str, max_width: usize, shape: Shape) -> bool { return false; } // If the snippet does not include newline, we are done. - if first_line_width(snippet) == snippet.len() { + if is_single_line(snippet) { return true; } // The other lines must fit within the maximum width. - if snippet.lines().skip(1).any(|line| line.len() > max_width) { + if snippet + .lines() + .skip(1) + .any(|line| unicode_str_width(line) > max_width) + { return false; } // A special check for the last line, since the caller may @@ -383,7 +430,9 @@ fn is_valid_str(snippet: &str, max_width: usize, shape: Shape) -> bool { } #[inline] -pub fn colon_spaces(before: bool, after: bool) -> &'static str { +pub(crate) fn colon_spaces(config: &Config) -> &'static str { + let before = config.space_before_colon(); + let after = config.space_after_colon(); match (before, after) { (true, true) => " : ", (true, false) => " :", @@ -393,13 +442,13 @@ pub fn colon_spaces(before: bool, after: bool) -> &'static str { } #[inline] -pub fn left_most_sub_expr(e: &ast::Expr) -> &ast::Expr { - match e.node { +pub(crate) fn left_most_sub_expr(e: &ast::Expr) -> &ast::Expr { + match e.kind { ast::ExprKind::Call(ref e, _) | ast::ExprKind::Binary(_, ref e, _) | ast::ExprKind::Cast(ref e, _) | ast::ExprKind::Type(ref e, _) - | ast::ExprKind::Assign(ref e, _) + | ast::ExprKind::Assign(ref e, _, _) | ast::ExprKind::AssignOp(_, ref e, _) | ast::ExprKind::Field(ref e, _) | ast::ExprKind::Index(ref e, _) @@ -410,11 +459,248 @@ pub fn left_most_sub_expr(e: &ast::Expr) -> &ast::Expr { } #[inline] -pub fn starts_with_newline(s: &str) -> bool { +pub(crate) fn starts_with_newline(s: &str) -> bool { s.starts_with('\n') || s.starts_with("\r\n") } #[inline] -pub fn first_line_ends_with(s: &str, c: char) -> bool { +pub(crate) fn first_line_ends_with(s: &str, c: char) -> bool { s.lines().next().map_or(false, |l| l.ends_with(c)) } + +// States whether an expression's last line exclusively consists of closing +// parens, braces, and brackets in its idiomatic formatting. +pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr: &str) -> bool { + match expr.kind { + ast::ExprKind::MacCall(..) + | ast::ExprKind::Call(..) + | ast::ExprKind::MethodCall(..) + | ast::ExprKind::Array(..) + | ast::ExprKind::Struct(..) + | ast::ExprKind::While(..) + | ast::ExprKind::If(..) + | ast::ExprKind::Block(..) + | ast::ExprKind::ConstBlock(..) + | ast::ExprKind::Async(..) + | ast::ExprKind::Loop(..) + | ast::ExprKind::ForLoop(..) + | ast::ExprKind::TryBlock(..) + | ast::ExprKind::Match(..) => repr.contains('\n'), + ast::ExprKind::Paren(ref expr) + | ast::ExprKind::Binary(_, _, ref expr) + | ast::ExprKind::Index(_, ref expr) + | ast::ExprKind::Unary(_, ref expr) + | ast::ExprKind::Closure(_, _, _, _, ref expr, _) + | ast::ExprKind::Try(ref expr) + | ast::ExprKind::Yield(Some(ref expr)) => is_block_expr(context, expr, repr), + // This can only be a string lit + ast::ExprKind::Lit(_) => { + repr.contains('\n') && trimmed_last_line_width(repr) <= context.config.tab_spaces() + } + ast::ExprKind::AddrOf(..) + | ast::ExprKind::Assign(..) + | ast::ExprKind::AssignOp(..) + | ast::ExprKind::Await(..) + | ast::ExprKind::Box(..) + | ast::ExprKind::Break(..) + | ast::ExprKind::Cast(..) + | ast::ExprKind::Continue(..) + | ast::ExprKind::Err + | ast::ExprKind::Field(..) + | ast::ExprKind::InlineAsm(..) + | ast::ExprKind::LlvmInlineAsm(..) + | ast::ExprKind::Let(..) + | ast::ExprKind::Path(..) + | ast::ExprKind::Range(..) + | ast::ExprKind::Repeat(..) + | ast::ExprKind::Ret(..) + | ast::ExprKind::Tup(..) + | ast::ExprKind::Type(..) + | ast::ExprKind::Yield(None) + | ast::ExprKind::Underscore => false, + } +} + +/// Removes trailing spaces from the specified snippet. We do not remove spaces +/// inside strings or comments. +pub(crate) 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 +} + +/// Indent each line according to the specified `indent`. +/// e.g. +/// +/// ```rust,compile_fail +/// foo!{ +/// x, +/// y, +/// foo( +/// a, +/// b, +/// c, +/// ), +/// } +/// ``` +/// +/// will become +/// +/// ```rust,compile_fail +/// foo!{ +/// x, +/// y, +/// foo( +/// a, +/// b, +/// c, +/// ), +/// } +/// ``` +pub(crate) fn trim_left_preserve_layout( + orig: &str, + indent: Indent, + config: &Config, +) -> Option { + let mut lines = LineClasses::new(orig); + let first_line = lines.next().map(|(_, s)| s.trim_end().to_owned())?; + let mut trimmed_lines = Vec::with_capacity(16); + + let mut veto_trim = false; + let min_prefix_space_width = lines + .filter_map(|(kind, line)| { + let mut trimmed = true; + let prefix_space_width = if is_empty_line(&line) { + None + } else { + Some(get_prefix_space_width(config, &line)) + }; + + // just InString{Commented} in order to allow the start of a string to be indented + let new_veto_trim_value = (kind == FullCodeCharKind::InString + || (config.version() == Version::Two + && kind == FullCodeCharKind::InStringCommented)) + && !line.ends_with('\\'); + let line = if veto_trim || new_veto_trim_value { + veto_trim = new_veto_trim_value; + trimmed = false; + line + } else { + line.trim().to_owned() + }; + trimmed_lines.push((trimmed, line, prefix_space_width)); + + // Because there is a veto against trimming and indenting lines within a string, + // such lines should not be taken into account when computing the minimum. + match kind { + FullCodeCharKind::InStringCommented | FullCodeCharKind::EndStringCommented + if config.version() == Version::Two => + { + None + } + FullCodeCharKind::InString | FullCodeCharKind::EndString => None, + _ => prefix_space_width, + } + }) + .min()?; + + Some( + first_line + + "\n" + + &trimmed_lines + .iter() + .map( + |&(trimmed, ref line, prefix_space_width)| match prefix_space_width { + _ if !trimmed => line.to_owned(), + Some(original_indent_width) => { + let new_indent_width = indent.width() + + original_indent_width.saturating_sub(min_prefix_space_width); + let new_indent = Indent::from_width(config, new_indent_width); + format!("{}{}", new_indent.to_string(config), line) + } + None => String::new(), + }, + ) + .collect::>() + .join("\n"), + ) +} + +/// Based on the given line, determine if the next line can be indented or not. +/// This allows to preserve the indentation of multi-line literals. +pub(crate) fn indent_next_line(kind: FullCodeCharKind, _line: &str, config: &Config) -> bool { + !(kind.is_string() || (config.version() == Version::Two && kind.is_commented_string())) +} + +pub(crate) fn is_empty_line(s: &str) -> bool { + s.is_empty() || s.chars().all(char::is_whitespace) +} + +fn get_prefix_space_width(config: &Config, s: &str) -> usize { + let mut width = 0; + for c in s.chars() { + match c { + ' ' => width += 1, + '\t' => width += config.tab_spaces(), + _ => return width, + } + } + width +} + +pub(crate) trait NodeIdExt { + fn root() -> Self; +} + +impl NodeIdExt for NodeId { + fn root() -> NodeId { + NodeId::placeholder_from_expn_id(ExpnId::root()) + } +} + +pub(crate) fn unicode_str_width(s: &str) -> usize { + s.width() +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn test_remove_trailing_white_spaces() { + let s = " r#\"\n test\n \"#"; + assert_eq!(remove_trailing_white_spaces(&s), s); + } + + #[test] + fn test_trim_left_preserve_layout() { + let s = "aaa\n\tbbb\n ccc"; + let config = Config::default(); + let indent = Indent::new(4, 0); + assert_eq!( + trim_left_preserve_layout(&s, indent, &config), + Some("aaa\n bbb\n ccc".to_string()) + ); + } +}