Use trim_tries to extract post comment over simple trim_matches

[rust.git] / src / imports.rs

diff --git a/src/imports.rs b/src/imports.rs
index 93f2ac8867a0c9a64162f9a386df9d9205c2af25..db00c45b9d9326ef51ea3273589e69060e62335e 100644 (file)
--- a/src/imports.rs
+++ b/src/imports.rs
@@ -12,14 +12,14 @@
 
 use config::lists::*;
 use syntax::ast::{self, UseTreeKind};
-use syntax::codemap::{self, BytePos, Span, DUMMY_SP};
+use syntax::source_map::{self, BytePos, Span, DUMMY_SP};
 
-use codemap::SpanUtils;
 use comment::combine_strs_with_missing_comments;
-use config::IndentStyle;
+use config::{Edition, IndentStyle};
 use lists::{definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator};
 use rewrite::{Rewrite, RewriteContext};
 use shape::Shape;
+use source_map::SpanUtils;
 use spanned::Spanned;
 use utils::{is_same_visibility, mk_sp, rewrite_ident};
 use visitor::FmtVisitor;
@@ -144,17 +144,19 @@ fn remove_alias(&self) -> UseSegment {
     fn from_path_segment(
         context: &RewriteContext,
         path_seg: &ast::PathSegment,
+        modsep: bool,
     ) -> Option<UseSegment> {
         let name = rewrite_ident(context, path_seg.ident);
         if name.is_empty() || name == "{{root}}" {
             return None;
         }
-        Some(if name == "self" {
-            UseSegment::Slf(None)
-        } else if name == "super" {
-            UseSegment::Super(None)
-        } else {
-            UseSegment::Ident((*name).to_owned(), None)
+        Some(match name {
+            "self" => UseSegment::Slf(None),
+            "super" => UseSegment::Super(None),
+            _ => {
+                let mod_sep = if modsep { "::" } else { "" };
+                UseSegment::Ident(format!("{}{}", mod_sep, name), None)
+            }
         })
     }
 }
@@ -315,8 +317,13 @@ fn from_ast(
             visibility,
             attrs,
         };
+
+        let leading_modsep = context.config.edition() == Edition::Edition2018
+            && a.prefix.to_string().len() > 2
+            && a.prefix.to_string().starts_with("::");
+
         for p in &a.prefix.segments {
-            if let Some(use_segment) = UseSegment::from_path_segment(context, p) {
+            if let Some(use_segment) = UseSegment::from_path_segment(context, p, leading_modsep) {
                 result.path.push(use_segment);
             }
         }
@@ -350,19 +357,19 @@ fn from_ast(
             UseTreeKind::Simple(ref rename, ..) => {
                 let name = rewrite_ident(context, path_to_imported_ident(&a.prefix)).to_owned();
                 let alias = rename.and_then(|ident| {
-                    if ident == path_to_imported_ident(&a.prefix) {
+                    if ident.name == "_" {
+                        // for impl-only-use
+                        Some("_".to_owned())
+                    } else if ident == path_to_imported_ident(&a.prefix) {
                         None
                     } else {
                         Some(rewrite_ident(context, ident).to_owned())
                     }
                 });
-
-                let segment = if &name == "self" {
-                    UseSegment::Slf(alias)
-                } else if &name == "super" {
-                    UseSegment::Super(alias)
-                } else {
-                    UseSegment::Ident(name, alias)
+                let segment = match name.as_ref() {
+                    "self" => UseSegment::Slf(alias),
+                    "super" => UseSegment::Super(alias),
+                    _ => UseSegment::Ident(name, alias),
                 };
 
                 // `name` is already in result.
@@ -470,7 +477,7 @@ fn has_comment(&self) -> bool {
     fn same_visibility(&self, other: &UseTree) -> bool {
         match (&self.visibility, &other.visibility) {
             (
-                Some(codemap::Spanned {
+                Some(source_map::Spanned {
                     node: ast::VisibilityKind::Inherited,
                     ..
                 }),
@@ -478,7 +485,7 @@ fn same_visibility(&self, other: &UseTree) -> bool {
             )
             | (
                 None,
-                Some(codemap::Spanned {
+                Some(source_map::Spanned {
                     node: ast::VisibilityKind::Inherited,
                     ..
                 }),
@@ -597,7 +604,8 @@ fn cmp(&self, other: &UseSegment) -> Ordering {
         use self::UseSegment::*;
 
         fn is_upper_snake_case(s: &str) -> bool {
-            s.chars().all(|c| c.is_uppercase() || c == '_')
+            s.chars()
+                .all(|c| c.is_uppercase() || c == '_' || c.is_numeric())
         }
 
         match (self, other) {
@@ -713,21 +721,17 @@ fn rewrite_nested_use_tree(
 
     let ends_with_newline = context.config.imports_indent() == IndentStyle::Block
         && tactic != DefinitiveListTactic::Horizontal;
-    let fmt = ListFormatting {
-        tactic,
-        separator: ",",
-        trailing_separator: if ends_with_newline {
-            context.config.trailing_comma()
-        } else {
-            SeparatorTactic::Never
-        },
-        separator_place: SeparatorPlace::Back,
-        shape: nested_shape,
-        ends_with_newline,
-        preserve_newline: true,
-        nested: has_nested_list,
-        config: context.config,
+    let trailing_separator = if ends_with_newline {
+        context.config.trailing_comma()
+    } else {
+        SeparatorTactic::Never
     };
+    let fmt = ListFormatting::new(nested_shape, context.config)
+        .tactic(tactic)
+        .trailing_separator(trailing_separator)
+        .ends_with_newline(ends_with_newline)
+        .preserve_newline(true)
+        .nested(has_nested_list);
 
     let list_str = write_list(&list_items, &fmt)?;
 
@@ -749,7 +753,7 @@ fn rewrite_nested_use_tree(
 
 impl Rewrite for UseSegment {
     fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
-        Some(match *self {
+        Some(match self {
             UseSegment::Ident(ref ident, Some(ref rename)) => format!("{} as {}", ident, rename),
             UseSegment::Ident(ref ident, None) => ident.clone(),
             UseSegment::Slf(Some(ref rename)) => format!("self as {}", rename),
@@ -788,7 +792,7 @@ fn rewrite(&self, context: &RewriteContext, mut shape: Shape) -> Option<String>
 #[cfg(test)]
 mod test {
     use super::*;
-    use syntax::codemap::DUMMY_SP;
+    use syntax::source_map::DUMMY_SP;
 
     // Parse the path part of an import. This parser is not robust and is only
     // suitable for use in a test harness.