X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Futils.rs;h=5f92255e79cad80fcd253f1ba70c4501f7fd9998;hb=caefd218c9f6c43493c28c5cc4ea8828c494830e;hp=055f75b460913d346dd9543c30252f15f790ce5b;hpb=edcc7b69ebe7f13223bd0e44f766a050df859eaa;p=rust.git diff --git a/src/utils.rs b/src/utils.rs index 055f75b4609..5f92255e79c 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -10,31 +10,55 @@ use std::borrow::Cow; -use syntax::ast::{self, Attribute, CrateSugar, MetaItem, MetaItemKind, NestedMetaItem, - NestedMetaItemKind, Path, Visibility, VisibilityKind}; +use rustc_target::spec::abi; +use syntax::ast::{ + self, Attribute, CrateSugar, MetaItem, MetaItemKind, NestedMetaItem, NestedMetaItemKind, Path, + Visibility, VisibilityKind, +}; use syntax::codemap::{BytePos, Span, NO_EXPANSION}; -use syntax::{abi, ptr}; +use syntax::ptr; -use config::Color; use rewrite::RewriteContext; use shape::Shape; -// When we get scoped annotations, we should have rustfmt::skip. -const SKIP_ANNOTATION: &str = "rustfmt_skip"; +pub const DEPR_SKIP_ANNOTATION: &str = "rustfmt_skip"; +pub const SKIP_ANNOTATION: &str = "rustfmt::skip"; + +pub 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 { match text.rfind('\n') { // 1 for newline character - Some(idx) => text.len() - .checked_sub(idx + 1 + shape.used_width()) - .unwrap_or(0), + Some(idx) => text.len().saturating_sub(idx + 1 + shape.used_width()), None => text.len(), } } +pub fn is_same_visibility(a: &Visibility, b: &Visibility) -> bool { + match (&a.node, &b.node) { + ( + VisibilityKind::Restricted { path: p, .. }, + VisibilityKind::Restricted { path: q, .. }, + ) => format!("{}", p) == format!("{}", q), + (VisibilityKind::Public, VisibilityKind::Public) + | (VisibilityKind::Inherited, VisibilityKind::Inherited) + | ( + VisibilityKind::Crate(CrateSugar::PubCrate), + VisibilityKind::Crate(CrateSugar::PubCrate), + ) + | ( + VisibilityKind::Crate(CrateSugar::JustCrate), + VisibilityKind::Crate(CrateSugar::JustCrate), + ) => true, + _ => false, + } +} + // Uses Cow to avoid allocating in the common cases. -pub fn format_visibility(vis: &Visibility) -> Cow<'static, str> { +pub fn format_visibility(context: &RewriteContext, vis: &Visibility) -> Cow<'static, str> { match vis.node { VisibilityKind::Public => Cow::from("pub "), VisibilityKind::Inherited => Cow::from(""), @@ -42,7 +66,7 @@ pub fn format_visibility(vis: &Visibility) -> Cow<'static, str> { VisibilityKind::Crate(CrateSugar::JustCrate) => Cow::from("crate "), VisibilityKind::Restricted { ref path, .. } => { let Path { ref segments, .. } = **path; - let mut segments_iter = segments.iter().map(|seg| seg.identifier.name.to_string()); + let mut segments_iter = segments.iter().map(|seg| rewrite_ident(context, seg.ident)); if path.is_global() { segments_iter .next() @@ -57,6 +81,14 @@ pub fn format_visibility(vis: &Visibility) -> Cow<'static, str> { } } +#[inline] +pub fn format_async(is_async: ast::IsAsync) -> &'static str { + match is_async { + ast::IsAsync::Async { .. } => "async ", + ast::IsAsync::NotAsync => "", + } +} + #[inline] pub fn format_constness(constness: ast::Constness) -> &'static str { match constness { @@ -81,6 +113,14 @@ pub fn format_unsafety(unsafety: ast::Unsafety) -> &'static str { } } +#[inline] +pub fn format_auto(is_auto: ast::IsAuto) -> &'static str { + match is_auto { + ast::IsAuto::Yes => "auto ", + ast::IsAuto::No => "", + } +} + #[inline] pub fn format_mutability(mutability: ast::Mutability) -> &'static str { match mutability { @@ -125,6 +165,16 @@ pub fn outer_attributes(attrs: &[ast::Attribute]) -> Vec { filter_attributes(attrs, ast::AttrStyle::Outer) } +#[inline] +pub 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 { + s.lines().next().map_or(false, |l| l.contains("//")) +} + #[inline] pub fn last_line_contains_single_line_comment(s: &str) -> bool { s.lines().last().map_or(false, |l| l.contains("//")) @@ -190,9 +240,12 @@ pub fn last_line_extendable(s: &str) -> bool { #[inline] fn is_skip(meta_item: &MetaItem) -> bool { match meta_item.node { - MetaItemKind::Word => meta_item.name == SKIP_ANNOTATION, + MetaItemKind::Word => { + let path_str = meta_item.ident.to_string(); + path_str == SKIP_ANNOTATION || path_str == DEPR_SKIP_ANNOTATION + } MetaItemKind::List(ref l) => { - meta_item.name == "cfg_attr" && l.len() == 2 && is_skip_nested(&l[1]) + meta_item.name() == "cfg_attr" && l.len() == 2 && is_skip_nested(&l[1]) } _ => false, } @@ -255,15 +308,6 @@ pub fn count_newlines(input: &str) -> usize { input.as_bytes().iter().filter(|&&c| c == b'\n').count() } -macro_rules! msg { - ($($arg:tt)*) => ( - match writeln!(&mut ::std::io::stderr(), $($arg)* ) { - Ok(_) => {}, - Err(x) => panic!("Unable to write to stderr: {}", x), - } - ) -} - // For format_missing and last_pos, need to use the source callsite (if applicable). // Required as generated code spans aren't guaranteed to follow on from the last span. macro_rules! source { @@ -279,11 +323,10 @@ pub fn mk_sp(lo: BytePos, hi: BytePos) -> Span { // Return 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.codemap.lookup_line_range($span)) + !$self.config.file_lines().is_all() && !$self + .config + .file_lines() + .intersects(&$self.codemap.lookup_line_range($span)) }; } @@ -305,7 +348,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 else otherwise. +// Rewrite constraints defined for the Rewrite trait and None otherwise. pub fn wrap_str(s: String, max_width: usize, shape: Shape) -> Option { if is_valid_str(&s, max_width, shape) { Some(s) @@ -348,14 +391,6 @@ pub fn colon_spaces(before: bool, after: bool) -> &'static str { } #[inline] -pub fn paren_overhead(context: &RewriteContext) -> usize { - if context.config.spaces_within_parens_and_brackets() { - 4 - } else { - 2 - } -} - pub fn left_most_sub_expr(e: &ast::Expr) -> &ast::Expr { match e.node { ast::ExprKind::Call(ref e, _) @@ -365,7 +400,6 @@ pub fn left_most_sub_expr(e: &ast::Expr) -> &ast::Expr { | ast::ExprKind::Assign(ref e, _) | ast::ExprKind::AssignOp(_, ref e, _) | ast::ExprKind::Field(ref e, _) - | ast::ExprKind::TupField(ref e, _) | ast::ExprKind::Index(ref e, _) | ast::ExprKind::Range(Some(ref e), _, _) | ast::ExprKind::Try(ref e) => left_most_sub_expr(e), @@ -373,32 +407,12 @@ pub fn left_most_sub_expr(e: &ast::Expr) -> &ast::Expr { } } -// isatty shamelessly adapted from cargo. -#[cfg(unix)] -pub fn isatty() -> bool { - extern crate libc; - - unsafe { libc::isatty(libc::STDOUT_FILENO) != 0 } -} -#[cfg(windows)] -pub fn isatty() -> bool { - extern crate winapi; - - unsafe { - let handle = winapi::um::processenv::GetStdHandle(winapi::um::winbase::STD_OUTPUT_HANDLE); - let mut out = 0; - winapi::um::consoleapi::GetConsoleMode(handle, &mut out) != 0 - } -} - -pub fn use_colored_tty(color: Color) -> bool { - match color { - Color::Always => true, - Color::Never => false, - Color::Auto => isatty(), - } -} - +#[inline] pub 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 { + s.lines().next().map_or(false, |l| l.ends_with(c)) +}