src/tools/rustfmt/src/utils.rs

   1 use std::borrow::Cow;
   2
   3 use rustc_ast::ast::{
   4     self, Attribute, CrateSugar, MetaItem, MetaItemKind, NestedMetaItem, NodeId, Path, Visibility,
   5     VisibilityKind,
   6 };
   7 use rustc_ast::ptr;
   8 use rustc_ast_pretty::pprust;
   9 use rustc_span::{sym, symbol, BytePos, LocalExpnId, Span, Symbol, SyntaxContext};
  10 use unicode_width::UnicodeWidthStr;
  11
  12 use crate::comment::{filter_normal_code, CharClasses, FullCodeCharKind, LineClasses};
  13 use crate::config::{Config, Version};
  14 use crate::rewrite::RewriteContext;
  15 use crate::shape::{Indent, Shape};
  16
  17 #[inline]
  18 pub(crate) fn depr_skip_annotation() -> Symbol {
  19     Symbol::intern("rustfmt_skip")
  20 }
  21
  22 #[inline]
  23 pub(crate) fn skip_annotation() -> Symbol {
  24     Symbol::intern("rustfmt::skip")
  25 }
  26
  27 pub(crate) fn rewrite_ident<'a>(context: &'a RewriteContext<'_>, ident: symbol::Ident) -> &'a str {
  28     context.snippet(ident.span)
  29 }
  30
  31 // Computes the length of a string's last line, minus offset.
  32 pub(crate) fn extra_offset(text: &str, shape: Shape) -> usize {
  33     match text.rfind('\n') {
  34         // 1 for newline character
  35         Some(idx) => text.len().saturating_sub(idx + 1 + shape.used_width()),
  36         None => text.len(),
  37     }
  38 }
  39
  40 pub(crate) fn is_same_visibility(a: &Visibility, b: &Visibility) -> bool {
  41     match (&a.kind, &b.kind) {
  42         (
  43             VisibilityKind::Restricted { path: p, .. },
  44             VisibilityKind::Restricted { path: q, .. },
  45         ) => pprust::path_to_string(&p) == pprust::path_to_string(&q),
  46         (VisibilityKind::Public, VisibilityKind::Public)
  47         | (VisibilityKind::Inherited, VisibilityKind::Inherited)
  48         | (
  49             VisibilityKind::Crate(CrateSugar::PubCrate),
  50             VisibilityKind::Crate(CrateSugar::PubCrate),
  51         )
  52         | (
  53             VisibilityKind::Crate(CrateSugar::JustCrate),
  54             VisibilityKind::Crate(CrateSugar::JustCrate),
  55         ) => true,
  56         _ => false,
  57     }
  58 }
  59
  60 // Uses Cow to avoid allocating in the common cases.
  61 pub(crate) fn format_visibility(
  62     context: &RewriteContext<'_>,
  63     vis: &Visibility,
  64 ) -> Cow<'static, str> {
  65     match vis.kind {
  66         VisibilityKind::Public => Cow::from("pub "),
  67         VisibilityKind::Inherited => Cow::from(""),
  68         VisibilityKind::Crate(CrateSugar::PubCrate) => Cow::from("pub(crate) "),
  69         VisibilityKind::Crate(CrateSugar::JustCrate) => Cow::from("crate "),
  70         VisibilityKind::Restricted { ref path, .. } => {
  71             let Path { ref segments, .. } = **path;
  72             let mut segments_iter = segments.iter().map(|seg| rewrite_ident(context, seg.ident));
  73             if path.is_global() {
  74                 segments_iter
  75                     .next()
  76                     .expect("Non-global path in pub(restricted)?");
  77             }
  78             let is_keyword = |s: &str| s == "self" || s == "super";
  79             let path = segments_iter.collect::<Vec<_>>().join("::");
  80             let in_str = if is_keyword(&path) { "" } else { "in " };
  81
  82             Cow::from(format!("pub({}{}) ", in_str, path))
  83         }
  84     }
  85 }
  86
  87 #[inline]
  88 pub(crate) fn format_async(is_async: &ast::Async) -> &'static str {
  89     match is_async {
  90         ast::Async::Yes { .. } => "async ",
  91         ast::Async::No => "",
  92     }
  93 }
  94
  95 #[inline]
  96 pub(crate) fn format_constness(constness: ast::Const) -> &'static str {
  97     match constness {
  98         ast::Const::Yes(..) => "const ",
  99         ast::Const::No => "",
 100     }
 101 }
 102
 103 #[inline]
 104 pub(crate) fn format_constness_right(constness: ast::Const) -> &'static str {
 105     match constness {
 106         ast::Const::Yes(..) => " const",
 107         ast::Const::No => "",
 108     }
 109 }
 110
 111 #[inline]
 112 pub(crate) fn format_defaultness(defaultness: ast::Defaultness) -> &'static str {
 113     match defaultness {
 114         ast::Defaultness::Default(..) => "default ",
 115         ast::Defaultness::Final => "",
 116     }
 117 }
 118
 119 #[inline]
 120 pub(crate) fn format_unsafety(unsafety: ast::Unsafe) -> &'static str {
 121     match unsafety {
 122         ast::Unsafe::Yes(..) => "unsafe ",
 123         ast::Unsafe::No => "",
 124     }
 125 }
 126
 127 #[inline]
 128 pub(crate) fn format_auto(is_auto: ast::IsAuto) -> &'static str {
 129     match is_auto {
 130         ast::IsAuto::Yes => "auto ",
 131         ast::IsAuto::No => "",
 132     }
 133 }
 134
 135 #[inline]
 136 pub(crate) fn format_mutability(mutability: ast::Mutability) -> &'static str {
 137     match mutability {
 138         ast::Mutability::Mut => "mut ",
 139         ast::Mutability::Not => "",
 140     }
 141 }
 142
 143 #[inline]
 144 pub(crate) fn format_extern(
 145     ext: ast::Extern,
 146     explicit_abi: bool,
 147     is_mod: bool,
 148 ) -> Cow<'static, str> {
 149     let abi = match ext {
 150         ast::Extern::None => "Rust".to_owned(),
 151         ast::Extern::Implicit => "C".to_owned(),
 152         ast::Extern::Explicit(abi) => abi.symbol_unescaped.to_string(),
 153     };
 154
 155     if abi == "Rust" && !is_mod {
 156         Cow::from("")
 157     } else if abi == "C" && !explicit_abi {
 158         Cow::from("extern ")
 159     } else {
 160         Cow::from(format!(r#"extern "{}" "#, abi))
 161     }
 162 }
 163
 164 #[inline]
 165 // Transform `Vec<rustc_ast::ptr::P<T>>` into `Vec<&T>`
 166 pub(crate) fn ptr_vec_to_ref_vec<T>(vec: &[ptr::P<T>]) -> Vec<&T> {
 167     vec.iter().map(|x| &**x).collect::<Vec<_>>()
 168 }
 169
 170 #[inline]
 171 pub(crate) fn filter_attributes(
 172     attrs: &[ast::Attribute],
 173     style: ast::AttrStyle,
 174 ) -> Vec<ast::Attribute> {
 175     attrs
 176         .iter()
 177         .filter(|a| a.style == style)
 178         .cloned()
 179         .collect::<Vec<_>>()
 180 }
 181
 182 #[inline]
 183 pub(crate) fn inner_attributes(attrs: &[ast::Attribute]) -> Vec<ast::Attribute> {
 184     filter_attributes(attrs, ast::AttrStyle::Inner)
 185 }
 186
 187 #[inline]
 188 pub(crate) fn outer_attributes(attrs: &[ast::Attribute]) -> Vec<ast::Attribute> {
 189     filter_attributes(attrs, ast::AttrStyle::Outer)
 190 }
 191
 192 #[inline]
 193 pub(crate) fn is_single_line(s: &str) -> bool {
 194     s.chars().find(|&c| c == '\n').is_none()
 195 }
 196
 197 #[inline]
 198 pub(crate) fn first_line_contains_single_line_comment(s: &str) -> bool {
 199     s.lines().next().map_or(false, |l| l.contains("//"))
 200 }
 201
 202 #[inline]
 203 pub(crate) fn last_line_contains_single_line_comment(s: &str) -> bool {
 204     s.lines().last().map_or(false, |l| l.contains("//"))
 205 }
 206
 207 #[inline]
 208 pub(crate) fn is_attributes_extendable(attrs_str: &str) -> bool {
 209     !attrs_str.contains('\n') && !last_line_contains_single_line_comment(attrs_str)
 210 }
 211
 212 /// The width of the first line in s.
 213 #[inline]
 214 pub(crate) fn first_line_width(s: &str) -> usize {
 215     unicode_str_width(s.splitn(2, '\n').next().unwrap_or(""))
 216 }
 217
 218 /// The width of the last line in s.
 219 #[inline]
 220 pub(crate) fn last_line_width(s: &str) -> usize {
 221     unicode_str_width(s.rsplitn(2, '\n').next().unwrap_or(""))
 222 }
 223
 224 /// The total used width of the last line.
 225 #[inline]
 226 pub(crate) fn last_line_used_width(s: &str, offset: usize) -> usize {
 227     if s.contains('\n') {
 228         last_line_width(s)
 229     } else {
 230         offset + unicode_str_width(s)
 231     }
 232 }
 233
 234 #[inline]
 235 pub(crate) fn trimmed_last_line_width(s: &str) -> usize {
 236     unicode_str_width(match s.rfind('\n') {
 237         Some(n) => s[(n + 1)..].trim(),
 238         None => s.trim(),
 239     })
 240 }
 241
 242 #[inline]
 243 pub(crate) fn last_line_extendable(s: &str) -> bool {
 244     if s.ends_with("\"#") {
 245         return true;
 246     }
 247     for c in s.chars().rev() {
 248         match c {
 249             '(' | ')' | ']' | '}' | '?' | '>' => continue,
 250             '\n' => break,
 251             _ if c.is_whitespace() => continue,
 252             _ => return false,
 253         }
 254     }
 255     true
 256 }
 257
 258 #[inline]
 259 fn is_skip(meta_item: &MetaItem) -> bool {
 260     match meta_item.kind {
 261         MetaItemKind::Word => {
 262             let path_str = pprust::path_to_string(&meta_item.path);
 263             path_str == &*skip_annotation().as_str()
 264                 || path_str == &*depr_skip_annotation().as_str()
 265         }
 266         MetaItemKind::List(ref l) => {
 267             meta_item.has_name(sym::cfg_attr) && l.len() == 2 && is_skip_nested(&l[1])
 268         }
 269         _ => false,
 270     }
 271 }
 272
 273 #[inline]
 274 fn is_skip_nested(meta_item: &NestedMetaItem) -> bool {
 275     match meta_item {
 276         NestedMetaItem::MetaItem(ref mi) => is_skip(mi),
 277         NestedMetaItem::Literal(_) => false,
 278     }
 279 }
 280
 281 #[inline]
 282 pub(crate) fn contains_skip(attrs: &[Attribute]) -> bool {
 283     attrs
 284         .iter()
 285         .any(|a| a.meta().map_or(false, |a| is_skip(&a)))
 286 }
 287
 288 #[inline]
 289 pub(crate) fn semicolon_for_expr(context: &RewriteContext<'_>, expr: &ast::Expr) -> bool {
 290     // Never try to insert semicolons on expressions when we're inside
 291     // a macro definition - this can prevent the macro from compiling
 292     // when used in expression position
 293     if context.is_macro_def {
 294         return false;
 295     }
 296
 297     match expr.kind {
 298         ast::ExprKind::Ret(..) | ast::ExprKind::Continue(..) | ast::ExprKind::Break(..) => {
 299             context.config.trailing_semicolon()
 300         }
 301         _ => false,
 302     }
 303 }
 304
 305 #[inline]
 306 pub(crate) fn semicolon_for_stmt(context: &RewriteContext<'_>, stmt: &ast::Stmt) -> bool {
 307     match stmt.kind {
 308         ast::StmtKind::Semi(ref expr) => match expr.kind {
 309             ast::ExprKind::While(..) | ast::ExprKind::Loop(..) | ast::ExprKind::ForLoop(..) => {
 310                 false
 311             }
 312             ast::ExprKind::Break(..) | ast::ExprKind::Continue(..) | ast::ExprKind::Ret(..) => {
 313                 context.config.trailing_semicolon()
 314             }
 315             _ => true,
 316         },
 317         ast::StmtKind::Expr(..) => false,
 318         _ => true,
 319     }
 320 }
 321
 322 #[inline]
 323 pub(crate) fn stmt_expr(stmt: &ast::Stmt) -> Option<&ast::Expr> {
 324     match stmt.kind {
 325         ast::StmtKind::Expr(ref expr) => Some(expr),
 326         _ => None,
 327     }
 328 }
 329
 330 /// Returns the number of LF and CRLF respectively.
 331 pub(crate) fn count_lf_crlf(input: &str) -> (usize, usize) {
 332     let mut lf = 0;
 333     let mut crlf = 0;
 334     let mut is_crlf = false;
 335     for c in input.as_bytes() {
 336         match c {
 337             b'\r' => is_crlf = true,
 338             b'\n' if is_crlf => crlf += 1,
 339             b'\n' => lf += 1,
 340             _ => is_crlf = false,
 341         }
 342     }
 343     (lf, crlf)
 344 }
 345
 346 pub(crate) fn count_newlines(input: &str) -> usize {
 347     // Using bytes to omit UTF-8 decoding
 348     bytecount::count(input.as_bytes(), b'\n')
 349 }
 350
 351 // For format_missing and last_pos, need to use the source callsite (if applicable).
 352 // Required as generated code spans aren't guaranteed to follow on from the last span.
 353 macro_rules! source {
 354     ($this:ident, $sp:expr) => {
 355         $sp.source_callsite()
 356     };
 357 }
 358
 359 pub(crate) fn mk_sp(lo: BytePos, hi: BytePos) -> Span {
 360     Span::new(lo, hi, SyntaxContext::root())
 361 }
 362
 363 pub(crate) fn mk_sp_lo_plus_one(lo: BytePos) -> Span {
 364     Span::new(lo, lo + BytePos(1), SyntaxContext::root())
 365 }
 366
 367 // Returns `true` if the given span does not intersect with file lines.
 368 macro_rules! out_of_file_lines_range {
 369     ($self:ident, $span:expr) => {
 370         !$self.config.file_lines().is_all()
 371             && !$self
 372                 .config
 373                 .file_lines()
 374                 .intersects(&$self.parse_sess.lookup_line_range($span))
 375     };
 376 }
 377
 378 macro_rules! skip_out_of_file_lines_range {
 379     ($self:ident, $span:expr) => {
 380         if out_of_file_lines_range!($self, $span) {
 381             return None;
 382         }
 383     };
 384 }
 385
 386 macro_rules! skip_out_of_file_lines_range_visitor {
 387     ($self:ident, $span:expr) => {
 388         if out_of_file_lines_range!($self, $span) {
 389             $self.push_rewrite($span, None);
 390             return;
 391         }
 392     };
 393 }
 394
 395 // Wraps String in an Option. Returns Some when the string adheres to the
 396 // Rewrite constraints defined for the Rewrite trait and None otherwise.
 397 pub(crate) fn wrap_str(s: String, max_width: usize, shape: Shape) -> Option<String> {
 398     if is_valid_str(&filter_normal_code(&s), max_width, shape) {
 399         Some(s)
 400     } else {
 401         None
 402     }
 403 }
 404
 405 fn is_valid_str(snippet: &str, max_width: usize, shape: Shape) -> bool {
 406     if !snippet.is_empty() {
 407         // First line must fits with `shape.width`.
 408         if first_line_width(snippet) > shape.width {
 409             return false;
 410         }
 411         // If the snippet does not include newline, we are done.
 412         if is_single_line(snippet) {
 413             return true;
 414         }
 415         // The other lines must fit within the maximum width.
 416         if snippet
 417             .lines()
 418             .skip(1)
 419             .any(|line| unicode_str_width(line) > max_width)
 420         {
 421             return false;
 422         }
 423         // A special check for the last line, since the caller may
 424         // place trailing characters on this line.
 425         if last_line_width(snippet) > shape.used_width() + shape.width {
 426             return false;
 427         }
 428     }
 429     true
 430 }
 431
 432 #[inline]
 433 pub(crate) fn colon_spaces(config: &Config) -> &'static str {
 434     let before = config.space_before_colon();
 435     let after = config.space_after_colon();
 436     match (before, after) {
 437         (true, true) => " : ",
 438         (true, false) => " :",
 439         (false, true) => ": ",
 440         (false, false) => ":",
 441     }
 442 }
 443
 444 #[inline]
 445 pub(crate) fn left_most_sub_expr(e: &ast::Expr) -> &ast::Expr {
 446     match e.kind {
 447         ast::ExprKind::Call(ref e, _)
 448         | ast::ExprKind::Binary(_, ref e, _)
 449         | ast::ExprKind::Cast(ref e, _)
 450         | ast::ExprKind::Type(ref e, _)
 451         | ast::ExprKind::Assign(ref e, _, _)
 452         | ast::ExprKind::AssignOp(_, ref e, _)
 453         | ast::ExprKind::Field(ref e, _)
 454         | ast::ExprKind::Index(ref e, _)
 455         | ast::ExprKind::Range(Some(ref e), _, _)
 456         | ast::ExprKind::Try(ref e) => left_most_sub_expr(e),
 457         _ => e,
 458     }
 459 }
 460
 461 #[inline]
 462 pub(crate) fn starts_with_newline(s: &str) -> bool {
 463     s.starts_with('\n') || s.starts_with("\r\n")
 464 }
 465
 466 #[inline]
 467 pub(crate) fn first_line_ends_with(s: &str, c: char) -> bool {
 468     s.lines().next().map_or(false, |l| l.ends_with(c))
 469 }
 470
 471 // States whether an expression's last line exclusively consists of closing
 472 // parens, braces, and brackets in its idiomatic formatting.
 473 pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr: &str) -> bool {
 474     match expr.kind {
 475         ast::ExprKind::MacCall(..)
 476         | ast::ExprKind::Call(..)
 477         | ast::ExprKind::MethodCall(..)
 478         | ast::ExprKind::Array(..)
 479         | ast::ExprKind::Struct(..)
 480         | ast::ExprKind::While(..)
 481         | ast::ExprKind::If(..)
 482         | ast::ExprKind::Block(..)
 483         | ast::ExprKind::ConstBlock(..)
 484         | ast::ExprKind::Async(..)
 485         | ast::ExprKind::Loop(..)
 486         | ast::ExprKind::ForLoop(..)
 487         | ast::ExprKind::TryBlock(..)
 488         | ast::ExprKind::Match(..) => repr.contains('\n'),
 489         ast::ExprKind::Paren(ref expr)
 490         | ast::ExprKind::Binary(_, _, ref expr)
 491         | ast::ExprKind::Index(_, ref expr)
 492         | ast::ExprKind::Unary(_, ref expr)
 493         | ast::ExprKind::Closure(_, _, _, _, ref expr, _)
 494         | ast::ExprKind::Try(ref expr)
 495         | ast::ExprKind::Yield(Some(ref expr)) => is_block_expr(context, expr, repr),
 496         // This can only be a string lit
 497         ast::ExprKind::Lit(_) => {
 498             repr.contains('\n') && trimmed_last_line_width(repr) <= context.config.tab_spaces()
 499         }
 500         ast::ExprKind::AddrOf(..)
 501         | ast::ExprKind::Assign(..)
 502         | ast::ExprKind::AssignOp(..)
 503         | ast::ExprKind::Await(..)
 504         | ast::ExprKind::Box(..)
 505         | ast::ExprKind::Break(..)
 506         | ast::ExprKind::Cast(..)
 507         | ast::ExprKind::Continue(..)
 508         | ast::ExprKind::Err
 509         | ast::ExprKind::Field(..)
 510         | ast::ExprKind::InlineAsm(..)
 511         | ast::ExprKind::LlvmInlineAsm(..)
 512         | ast::ExprKind::Let(..)
 513         | ast::ExprKind::Path(..)
 514         | ast::ExprKind::Range(..)
 515         | ast::ExprKind::Repeat(..)
 516         | ast::ExprKind::Ret(..)
 517         | ast::ExprKind::Tup(..)
 518         | ast::ExprKind::Type(..)
 519         | ast::ExprKind::Yield(None)
 520         | ast::ExprKind::Underscore => false,
 521     }
 522 }
 523
 524 /// Removes trailing spaces from the specified snippet. We do not remove spaces
 525 /// inside strings or comments.
 526 pub(crate) fn remove_trailing_white_spaces(text: &str) -> String {
 527     let mut buffer = String::with_capacity(text.len());
 528     let mut space_buffer = String::with_capacity(128);
 529     for (char_kind, c) in CharClasses::new(text.chars()) {
 530         match c {
 531             '\n' => {
 532                 if char_kind == FullCodeCharKind::InString {
 533                     buffer.push_str(&space_buffer);
 534                 }
 535                 space_buffer.clear();
 536                 buffer.push('\n');
 537             }
 538             _ if c.is_whitespace() => {
 539                 space_buffer.push(c);
 540             }
 541             _ => {
 542                 if !space_buffer.is_empty() {
 543                     buffer.push_str(&space_buffer);
 544                     space_buffer.clear();
 545                 }
 546                 buffer.push(c);
 547             }
 548         }
 549     }
 550     buffer
 551 }
 552
 553 /// Indent each line according to the specified `indent`.
 554 /// e.g.
 555 ///
 556 /// ```rust,compile_fail
 557 /// foo!{
 558 /// x,
 559 /// y,
 560 /// foo(
 561 ///     a,
 562 ///     b,
 563 ///     c,
 564 /// ),
 565 /// }
 566 /// ```
 567 ///
 568 /// will become
 569 ///
 570 /// ```rust,compile_fail
 571 /// foo!{
 572 ///     x,
 573 ///     y,
 574 ///     foo(
 575 ///         a,
 576 ///         b,
 577 ///         c,
 578 ///     ),
 579 /// }
 580 /// ```
 581 pub(crate) fn trim_left_preserve_layout(
 582     orig: &str,
 583     indent: Indent,
 584     config: &Config,
 585 ) -> Option<String> {
 586     let mut lines = LineClasses::new(orig);
 587     let first_line = lines.next().map(|(_, s)| s.trim_end().to_owned())?;
 588     let mut trimmed_lines = Vec::with_capacity(16);
 589
 590     let mut veto_trim = false;
 591     let min_prefix_space_width = lines
 592         .filter_map(|(kind, line)| {
 593             let mut trimmed = true;
 594             let prefix_space_width = if is_empty_line(&line) {
 595                 None
 596             } else {
 597                 Some(get_prefix_space_width(config, &line))
 598             };
 599
 600             // just InString{Commented} in order to allow the start of a string to be indented
 601             let new_veto_trim_value = (kind == FullCodeCharKind::InString
 602                 || (config.version() == Version::Two
 603                     && kind == FullCodeCharKind::InStringCommented))
 604                 && !line.ends_with('\\');
 605             let line = if veto_trim || new_veto_trim_value {
 606                 veto_trim = new_veto_trim_value;
 607                 trimmed = false;
 608                 line
 609             } else {
 610                 line.trim().to_owned()
 611             };
 612             trimmed_lines.push((trimmed, line, prefix_space_width));
 613
 614             // Because there is a veto against trimming and indenting lines within a string,
 615             // such lines should not be taken into account when computing the minimum.
 616             match kind {
 617                 FullCodeCharKind::InStringCommented | FullCodeCharKind::EndStringCommented
 618                     if config.version() == Version::Two =>
 619                 {
 620                     None
 621                 }
 622                 FullCodeCharKind::InString | FullCodeCharKind::EndString => None,
 623                 _ => prefix_space_width,
 624             }
 625         })
 626         .min()?;
 627
 628     Some(
 629         first_line
 630             + "\n"
 631             + &trimmed_lines
 632                 .iter()
 633                 .map(
 634                     |&(trimmed, ref line, prefix_space_width)| match prefix_space_width {
 635                         _ if !trimmed => line.to_owned(),
 636                         Some(original_indent_width) => {
 637                             let new_indent_width = indent.width()
 638                                 + original_indent_width.saturating_sub(min_prefix_space_width);
 639                             let new_indent = Indent::from_width(config, new_indent_width);
 640                             format!("{}{}", new_indent.to_string(config), line)
 641                         }
 642                         None => String::new(),
 643                     },
 644                 )
 645                 .collect::<Vec<_>>()
 646                 .join("\n"),
 647     )
 648 }
 649
 650 /// Based on the given line, determine if the next line can be indented or not.
 651 /// This allows to preserve the indentation of multi-line literals.
 652 pub(crate) fn indent_next_line(kind: FullCodeCharKind, _line: &str, config: &Config) -> bool {
 653     !(kind.is_string() || (config.version() == Version::Two && kind.is_commented_string()))
 654 }
 655
 656 pub(crate) fn is_empty_line(s: &str) -> bool {
 657     s.is_empty() || s.chars().all(char::is_whitespace)
 658 }
 659
 660 fn get_prefix_space_width(config: &Config, s: &str) -> usize {
 661     let mut width = 0;
 662     for c in s.chars() {
 663         match c {
 664             ' ' => width += 1,
 665             '\t' => width += config.tab_spaces(),
 666             _ => return width,
 667         }
 668     }
 669     width
 670 }
 671
 672 pub(crate) trait NodeIdExt {
 673     fn root() -> Self;
 674 }
 675
 676 impl NodeIdExt for NodeId {
 677     fn root() -> NodeId {
 678         NodeId::placeholder_from_expn_id(LocalExpnId::ROOT)
 679     }
 680 }
 681
 682 pub(crate) fn unicode_str_width(s: &str) -> usize {
 683     s.width()
 684 }
 685
 686 #[cfg(test)]
 687 mod test {
 688     use super::*;
 689
 690     #[test]
 691     fn test_remove_trailing_white_spaces() {
 692         let s = "    r#\"\n        test\n    \"#";
 693         assert_eq!(remove_trailing_white_spaces(&s), s);
 694     }
 695
 696     #[test]
 697     fn test_trim_left_preserve_layout() {
 698         let s = "aaa\n\tbbb\n    ccc";
 699         let config = Config::default();
 700         let indent = Indent::new(4, 0);
 701         assert_eq!(
 702             trim_left_preserve_layout(&s, indent, &config),
 703             Some("aaa\n    bbb\n    ccc".to_string())
 704         );
 705     }
 706 }