X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Futils.rs;h=a3d0ed050e3f8743a22ba87e19588531900d5c78;hb=269584634a7657d1026cee2db1c38d75cebbbd31;hp=9a0a29dc5c347413bb0a6960d7d4ccd2dc57e8b7;hpb=cc97eaf9f9181aec5a1ba6459b204ed4a7fba62a;p=rust.git diff --git a/src/utils.rs b/src/utils.rs index 9a0a29dc5c3..a3d0ed050e3 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,15 +1,12 @@ 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, +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 syntax_pos::Mark; +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}; @@ -17,10 +14,17 @@ use crate::rewrite::RewriteContext; use crate::shape::{Indent, Shape}; -pub(crate) const DEPR_SKIP_ANNOTATION: &str = "rustfmt_skip"; -pub(crate) const SKIP_ANNOTATION: &str = "rustfmt::skip"; +#[inline] +pub(crate) fn depr_skip_annotation() -> Symbol { + Symbol::intern("rustfmt_skip") +} + +#[inline] +pub(crate) fn skip_annotation() -> Symbol { + Symbol::intern("rustfmt::skip") +} -pub(crate) 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) } @@ -34,11 +38,11 @@ pub(crate) fn extra_offset(text: &str, shape: Shape) -> usize { } pub(crate) fn is_same_visibility(a: &Visibility, b: &Visibility) -> bool { - match (&a.node, &b.node) { + 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) | ( @@ -58,7 +62,7 @@ pub(crate) fn format_visibility( context: &RewriteContext<'_>, vis: &Visibility, ) -> Cow<'static, str> { - match vis.node { + match vis.kind { VisibilityKind::Public => Cow::from("pub "), VisibilityKind::Inherited => Cow::from(""), VisibilityKind::Crate(CrateSugar::PubCrate) => Cow::from("pub(crate) "), @@ -81,34 +85,42 @@ pub(crate) fn format_visibility( } #[inline] -pub(crate) 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(crate) 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(crate) fn format_defaultness(defaultness: ast::Defaultness) -> &'static str { match defaultness { - ast::Defaultness::Default => "default ", + ast::Defaultness::Default(..) => "default ", ast::Defaultness::Final => "", } } #[inline] -pub(crate) 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 => "", } } @@ -123,24 +135,34 @@ pub(crate) fn format_auto(is_auto: ast::IsAuto) -> &'static str { #[inline] 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(crate) 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>` +// Transform `Vec>` into `Vec<&T>` pub(crate) fn ptr_vec_to_ref_vec(vec: &[ptr::P]) -> Vec<&T> { vec.iter().map(|x| &**x).collect::>() } @@ -187,19 +209,19 @@ 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(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(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(crate) fn last_line_used_width(s: &str, offset: usize) -> usize { if s.contains('\n') { @@ -235,13 +257,14 @@ pub(crate) 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, } @@ -249,9 +272,9 @@ 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, } } @@ -264,7 +287,14 @@ pub(crate) fn contains_skip(attrs: &[Attribute]) -> bool { #[inline] pub(crate) fn semicolon_for_expr(context: &RewriteContext<'_>, expr: &ast::Expr) -> bool { - match expr.node { + // 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() } @@ -274,12 +304,11 @@ pub(crate) fn semicolon_for_expr(context: &RewriteContext<'_>, expr: &ast::Expr) #[inline] pub(crate) 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, + 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() } @@ -292,13 +321,28 @@ pub(crate) fn semicolon_for_stmt(context: &RewriteContext<'_>, stmt: &ast::Stmt) #[inline] pub(crate) fn stmt_expr(stmt: &ast::Stmt) -> Option<&ast::Expr> { - match stmt.node { + match stmt.kind { ast::StmtKind::Expr(ref expr) => Some(expr), _ => None, } } -#[inline] +/// 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') @@ -313,7 +357,7 @@ macro_rules! source { } pub(crate) fn mk_sp(lo: BytePos, hi: BytePos) -> Span { - Span::new(lo, hi, NO_EXPANSION) + Span::new(lo, hi, SyntaxContext::root()) } // Returns `true` if the given span does not intersect with file lines. @@ -323,7 +367,7 @@ macro_rules! out_of_file_lines_range { && !$self .config .file_lines() - .intersects(&$self.source_map.lookup_line_range($span)) + .intersects(&$self.parse_sess.lookup_line_range($span)) }; } @@ -395,12 +439,12 @@ pub(crate) fn colon_spaces(config: &Config) -> &'static str { #[inline] pub(crate) fn left_most_sub_expr(e: &ast::Expr) -> &ast::Expr { - match e.node { + 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, _) @@ -423,19 +467,20 @@ pub(crate) fn first_line_ends_with(s: &str, c: char) -> bool { // 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.node { - ast::ExprKind::Mac(..) + 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) @@ -448,7 +493,27 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr 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, } } @@ -484,7 +549,7 @@ pub(crate) 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, @@ -498,7 +563,7 @@ pub(crate) fn remove_trailing_white_spaces(text: &str) -> String { /// /// will become /// -/// ```rust,ignore +/// ```rust,compile_fail /// foo!{ /// x, /// y, @@ -580,9 +645,8 @@ pub(crate) fn trim_left_preserve_layout( /// 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 { +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 { @@ -607,7 +671,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()) } } @@ -615,26 +679,6 @@ pub(crate) fn unicode_str_width(s: &str) -> usize { s.width() } -pub(crate) fn get_skip_macro_names(attrs: &[ast::Attribute]) -> Vec { - let mut skip_macro_names = vec![]; - for attr in attrs { - // syntax::ast::Path is implemented partialEq - // but it is designed for segments.len() == 1 - if format!("{}", attr.path) != "rustfmt::skip::macros" { - continue; - } - - if let Some(list) = attr.meta_item_list() { - for spanned in list { - if let Some(name) = spanned.name() { - skip_macro_names.push(name.to_string()); - } - } - } - } - skip_macro_names -} - #[cfg(test)] mod test { use super::*;