X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Futils.rs;h=47f9cd94b8df5b701efa6674628cfbbb5966e4ab;hb=8210cc1c133cd4201143ba1694d00b3e3fcc1183;hp=3c260cae22ee7b1cd92eeb82e2823e1ff0968a86;hpb=d2e91b5b68f4b163ab1c041e72028f33a9e3e075;p=rust.git diff --git a/src/utils.rs b/src/utils.rs index 3c260cae22e..47f9cd94b8d 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,42 +1,37 @@ -// 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, - NodeId, Path, Visibility, VisibilityKind, + self, Attribute, CrateSugar, MetaItem, MetaItemKind, NestedMetaItem, NodeId, Path, Visibility, + VisibilityKind, }; use syntax::ptr; -use syntax::source_map::{BytePos, Span, NO_EXPANSION}; -use syntax_pos::Mark; +use syntax::source_map::{BytePos, Span, SyntaxContext}; +use syntax::symbol::{sym, Symbol}; +use syntax_pos::ExpnId; +use unicode_width::UnicodeWidthStr; -use comment::{filter_normal_code, CharClasses, FullCodeCharKind, LineClasses}; -use config::{Config, Version}; -use rewrite::RewriteContext; -use shape::{Indent, Shape}; +use crate::comment::{filter_normal_code, CharClasses, FullCodeCharKind, LineClasses}; +use crate::config::{Config, Version}; +use crate::rewrite::RewriteContext; +use crate::shape::{Indent, Shape}; -use unicode_width::UnicodeWidthStr; +#[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: ast::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()), @@ -44,7 +39,7 @@ pub fn extra_offset(text: &str, shape: Shape) -> usize { } } -pub fn is_same_visibility(a: &Visibility, b: &Visibility) -> bool { +pub(crate) fn is_same_visibility(a: &Visibility, b: &Visibility) -> bool { match (&a.node, &b.node) { ( VisibilityKind::Restricted { path: p, .. }, @@ -65,7 +60,10 @@ 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> { +pub(crate) fn format_visibility( + context: &RewriteContext<'_>, + vis: &Visibility, +) -> Cow<'static, str> { match vis.node { VisibilityKind::Public => Cow::from("pub "), VisibilityKind::Inherited => Cow::from(""), @@ -89,7 +87,7 @@ 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::IsAsync) -> &'static str { match is_async { ast::IsAsync::Async { .. } => "async ", ast::IsAsync::NotAsync => "", @@ -97,7 +95,7 @@ pub fn format_async(is_async: ast::IsAsync) -> &'static str { } #[inline] -pub fn format_constness(constness: ast::Constness) -> &'static str { +pub(crate) fn format_constness(constness: ast::Constness) -> &'static str { match constness { ast::Constness::Const => "const ", ast::Constness::NotConst => "", @@ -105,7 +103,7 @@ pub fn format_constness(constness: ast::Constness) -> &'static str { } #[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::Final => "", @@ -113,7 +111,7 @@ pub fn format_defaultness(defaultness: ast::Defaultness) -> &'static str { } #[inline] -pub fn format_unsafety(unsafety: ast::Unsafety) -> &'static str { +pub(crate) fn format_unsafety(unsafety: ast::Unsafety) -> &'static str { match unsafety { ast::Unsafety::Unsafe => "unsafe ", ast::Unsafety::Normal => "", @@ -121,7 +119,7 @@ pub fn format_unsafety(unsafety: ast::Unsafety) -> &'static str { } #[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 => "", @@ -129,7 +127,7 @@ 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 => "", @@ -137,7 +135,7 @@ pub fn format_mutability(mutability: ast::Mutability) -> &'static str { } #[inline] -pub fn format_abi(abi: abi::Abi, explicit_abi: bool, is_mod: bool) -> Cow<'static, str> { +pub(crate) fn format_abi(abi: abi::Abi, explicit_abi: bool, is_mod: bool) -> Cow<'static, str> { if abi == abi::Abi::Rust && !is_mod { Cow::from("") } else if abi == abi::Abi::C && !explicit_abi { @@ -149,12 +147,15 @@ pub fn format_abi(abi: abi::Abi, explicit_abi: bool, is_mod: bool) -> Cow<'stati #[inline] // Transform `Vec>` into `Vec<&T>` -pub fn ptr_vec_to_ref_vec(vec: &[ptr::P]) -> 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) @@ -163,50 +164,50 @@ 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 { +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 { +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 { @@ -215,7 +216,7 @@ pub fn last_line_used_width(s: &str, offset: usize) -> usize { } #[inline] -pub fn trimmed_last_line_width(s: &str) -> usize { +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(), @@ -223,7 +224,7 @@ pub fn trimmed_last_line_width(s: &str) -> usize { } #[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 +241,13 @@ 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 = meta_item.path.to_string(); + 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.check_name(sym::cfg_attr) && l.len() == 2 && is_skip_nested(&l[1]) } _ => false, } @@ -254,22 +255,22 @@ 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 { + match expr.kind { ast::ExprKind::Ret(..) | ast::ExprKind::Continue(..) | ast::ExprKind::Break(..) => { context.config.trailing_semicolon() } @@ -278,13 +279,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,15 +296,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') } @@ -317,11 +332,11 @@ 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() @@ -351,7 +366,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 { @@ -387,7 +402,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) => " :", @@ -397,8 +414,8 @@ 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, _) @@ -414,31 +431,31 @@ 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 { +pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr: &str) -> bool { + match expr.kind { ast::ExprKind::Mac(..) | 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::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) @@ -451,13 +468,31 @@ 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::Let(..) + | ast::ExprKind::Path(..) + | ast::ExprKind::Range(..) + | ast::ExprKind::Repeat(..) + | ast::ExprKind::Ret(..) + | ast::ExprKind::Tup(..) + | ast::ExprKind::Type(..) + | ast::ExprKind::Yield(None) => 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()) { @@ -487,7 +522,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, @@ -501,7 +536,7 @@ pub fn remove_trailing_white_spaces(text: &str) -> String { /// /// will become /// -/// ```rust,ignore +/// ```rust,compile_fail /// foo!{ /// x, /// y, @@ -512,7 +547,11 @@ 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_end().to_owned())?; let mut trimmed_lines = Vec::with_capacity(16); @@ -527,8 +566,10 @@ pub fn trim_left_preserve_layout(orig: &str, indent: Indent, config: &Config) -> Some(get_prefix_space_width(config, &line)) }; - let new_veto_trim_value = (kind.is_string() - || (config.version() == Version::Two && kind.is_commented_string())) + // 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; @@ -575,7 +616,14 @@ 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())) + || line.ends_with('\\') +} + +pub(crate) fn is_empty_line(s: &str) -> bool { s.is_empty() || s.chars().all(char::is_whitespace) } @@ -597,7 +645,7 @@ pub(crate) trait NodeIdExt { impl NodeIdExt for NodeId { fn root() -> NodeId { - NodeId::placeholder_from_mark(Mark::root()) + NodeId::placeholder_from_expn_id(ExpnId::root()) } }