X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Futils.rs;h=a3d0ed050e3f8743a22ba87e19588531900d5c78;hb=269584634a7657d1026cee2db1c38d75cebbbd31;hp=86c01af39fba5bda8f7841e027555ecaba4efe9b;hpb=2d718a3fc23fbe9a27c71709c54128b5305609c7;p=rust.git diff --git a/src/utils.rs b/src/utils.rs index 86c01af39fb..a3d0ed050e3 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,39 +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 bytecount; - -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 crate::comment::{filter_normal_code, CharClasses, FullCodeCharKind, LineClasses}; +use crate::config::{Config, Version}; +use crate::rewrite::RewriteContext; +use crate::shape::{Indent, Shape}; -use comment::{filter_normal_code, CharClasses, FullCodeCharKind, LineClasses}; -use config::Config; -use rewrite::RewriteContext; -use shape::{Indent, Shape}; +#[inline] +pub(crate) fn depr_skip_annotation() -> Symbol { + Symbol::intern("rustfmt_skip") +} -pub const DEPR_SKIP_ANNOTATION: &str = "rustfmt_skip"; -pub const SKIP_ANNOTATION: &str = "rustfmt::skip"; +#[inline] +pub(crate) fn skip_annotation() -> Symbol { + Symbol::intern("rustfmt::skip") +} -pub fn rewrite_ident<'a>(context: &'a RewriteContext, ident: ast::Ident) -> &'a str { +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()), @@ -41,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, .. }, - ) => p.to_string() == q.to_string(), + ) => pprust::path_to_string(&p) == pprust::path_to_string(&q), (VisibilityKind::Public, VisibilityKind::Public) | (VisibilityKind::Inherited, VisibilityKind::Inherited) | ( @@ -62,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) "), @@ -86,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 fn format_constness(constness: ast::Constness) -> &'static str { +pub(crate) fn format_constness(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_constness_right(constness: ast::Const) -> &'static str { + match constness { + ast::Const::Yes(..) => " const", + ast::Const::No => "", + } +} + +#[inline] +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 => "", @@ -126,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) @@ -160,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; } @@ -243,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, } @@ -257,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() } @@ -281,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() } @@ -299,15 +320,30 @@ 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 { +/// 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') } @@ -320,18 +356,18 @@ 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. +// 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)) }; } @@ -354,7 +390,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 { @@ -369,11 +405,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 @@ -386,7 +426,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) => " :", @@ -396,13 +438,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, _) @@ -413,31 +455,32 @@ 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 fn is_block_expr(context: &RewriteContext, expr: &ast::Expr, repr: &str) -> bool { - match expr.node { - ast::ExprKind::Mac(..) +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::WhileLet(..) | ast::ExprKind::If(..) - | ast::ExprKind::IfLet(..) | 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) @@ -450,13 +493,33 @@ pub fn is_block_expr(context: &RewriteContext, expr: &ast::Expr, repr: &str) -> ast::ExprKind::Lit(_) => { repr.contains('\n') && trimmed_last_line_width(repr) <= context.config.tab_spaces() } - _ => false, + 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, } } -/// Remove trailing spaces from the specified snippet. We do not remove spaces +/// Removes trailing spaces from the specified snippet. We do not remove spaces /// inside strings or comments. -pub fn remove_trailing_white_spaces(text: &str) -> String { +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()) { @@ -486,7 +549,7 @@ pub fn remove_trailing_white_spaces(text: &str) -> String { /// Indent each line according to the specified `indent`. /// e.g. /// -/// ```rust,ignore +/// ```rust,compile_fail /// foo!{ /// x, /// y, @@ -500,7 +563,7 @@ pub fn remove_trailing_white_spaces(text: &str) -> String { /// /// will become /// -/// ```rust,ignore +/// ```rust,compile_fail /// foo!{ /// x, /// y, @@ -511,9 +574,13 @@ pub fn remove_trailing_white_spaces(text: &str) -> String { /// ), /// } /// ``` -pub fn trim_left_preserve_layout(orig: &str, indent: &Indent, config: &Config) -> Option { +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_right().to_owned())?; + 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; @@ -526,8 +593,13 @@ pub fn trim_left_preserve_layout(orig: &str, indent: &Indent, config: &Config) - Some(get_prefix_space_width(config, &line)) }; - let line = if veto_trim || (kind.is_string() && !line.ends_with('\\')) { - veto_trim = kind.is_string() && !line.ends_with('\\'); + // 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 { @@ -535,9 +607,14 @@ pub fn trim_left_preserve_layout(orig: &str, indent: &Indent, config: &Config) - }; trimmed_lines.push((trimmed, line, prefix_space_width)); - // When computing the minimum, do not consider lines within a string. - // The reason is there is a veto against trimming and indenting such lines + // 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, } @@ -566,7 +643,13 @@ pub fn trim_left_preserve_layout(orig: &str, indent: &Indent, config: &Config) - ) } -pub fn is_empty_line(s: &str) -> bool { +/// 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) } @@ -582,6 +665,20 @@ fn get_prefix_space_width(config: &Config, s: &str) -> usize { 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::*; @@ -598,7 +695,7 @@ fn test_trim_left_preserve_layout() { let config = Config::default(); let indent = Indent::new(4, 0); assert_eq!( - trim_left_preserve_layout(&s, &indent, &config), + trim_left_preserve_layout(&s, indent, &config), Some("aaa\n bbb\n ccc".to_string()) ); }