X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Futils.rs;h=5f92255e79cad80fcd253f1ba70c4501f7fd9998;hb=caefd218c9f6c43493c28c5cc4ea8828c494830e;hp=6c8862b9bf5550bc54bc5d2ac944b0704aa83440;hpb=db8cb0b8d6942d42a322b1d36b2504977404f362;p=rust.git

diff --git a/src/utils.rs b/src/utils.rs
index 6c8862b9bf5..5f92255e79c 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -18,13 +18,16 @@
 use syntax::codemap::{BytePos, Span, NO_EXPANSION};
 use syntax::ptr;
 
-use config::Color;
 use rewrite::RewriteContext;
 use shape::Shape;
 
 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') {
@@ -34,8 +37,28 @@ pub fn extra_offset(text: &str, shape: Shape) -> usize {
     }
 }
 
+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(""),
@@ -43,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.ident.name.to_string());
+            let mut segments_iter = segments.iter().map(|seg| rewrite_ident(context, seg.ident));
             if path.is_global() {
                 segments_iter
                     .next()
@@ -58,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 {
@@ -292,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))
     };
 }
 
@@ -318,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<String> {
     if is_valid_str(&s, max_width, shape) {
         Some(s)
@@ -361,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, _)
@@ -385,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))
+}