rebasing

diff --git a/src/imports.rs b/src/imports.rs
index 62273a8659648c9e475a2e3c0478ae347bd2acd6..48b6af7fd4624959168ee809ae0cc72c0a441287 100644 (file)
--- a/src/imports.rs
+++ b/src/imports.rs
@@ -185,7 +185,7 @@ pub fn from_ast_with_normalization(
                     } else {
                         Some(item.attrs.clone())
                     },
-                ).normalize(context.config.reorder_imported_names()),
+                ).normalize(),
             ),
             _ => None,
         }
@@ -271,7 +271,7 @@ fn from_ast(
     }
 
     // Do the adjustments that rustfmt does elsewhere to use paths.
-    pub fn normalize(mut self, do_sort: bool) -> UseTree {
+    pub fn normalize(mut self) -> UseTree {
         let mut last = self.path.pop().expect("Empty use tree?");
         // Hack around borrow checker.
         let mut normalize_sole_list = false;
@@ -340,7 +340,7 @@ pub fn normalize(mut self, do_sort: bool) -> UseTree {
                     for seg in &list[0].path {
                         self.path.push(seg.clone());
                     }
-                    return self.normalize(do_sort);
+                    return self.normalize();
                 }
                 _ => unreachable!(),
             }
@@ -349,11 +349,9 @@ pub fn normalize(mut self, do_sort: bool) -> UseTree {
         // Recursively normalize elements of a list use (including sorting the list).
         if let UseSegment::List(list) = last {
             let mut list = list.into_iter()
-                .map(|ut| ut.normalize(do_sort))
+                .map(|ut| ut.normalize())
                 .collect::<Vec<_>>();
-            if do_sort {
-                list.sort();
-            }
+            list.sort();
             last = UseSegment::List(list);
         }
 
@@ -686,75 +684,64 @@ fn parse_list(&mut self) -> Vec<UseTree> {
 
     #[test]
     fn test_use_tree_normalize() {
+        assert_eq!(parse_use_tree("a::self").normalize(), parse_use_tree("a"));
         assert_eq!(
-            parse_use_tree("a::self").normalize(true),
-            parse_use_tree("a")
-        );
-        assert_eq!(
-            parse_use_tree("a::self as foo").normalize(true),
+            parse_use_tree("a::self as foo").normalize(),
             parse_use_tree("a as foo")
         );
+        assert_eq!(parse_use_tree("a::{self}").normalize(), parse_use_tree("a"));
+        assert_eq!(parse_use_tree("a::{b}").normalize(), parse_use_tree("a::b"));
         assert_eq!(
-            parse_use_tree("a::{self}").normalize(true),
-            parse_use_tree("a")
-        );
-        assert_eq!(
-            parse_use_tree("a::{b}").normalize(true),
-            parse_use_tree("a::b")
-        );
-        assert_eq!(
-            parse_use_tree("a::{b, c::self}").normalize(true),
+            parse_use_tree("a::{b, c::self}").normalize(),
             parse_use_tree("a::{b, c}")
         );
         assert_eq!(
-            parse_use_tree("a::{b as bar, c::self}").normalize(true),
+            parse_use_tree("a::{b as bar, c::self}").normalize(),
             parse_use_tree("a::{b as bar, c}")
         );
     }
 
     #[test]
     fn test_use_tree_ord() {
-        assert!(parse_use_tree("a").normalize(true) < parse_use_tree("aa").normalize(true));
-        assert!(parse_use_tree("a").normalize(true) < parse_use_tree("a::a").normalize(true));
-        assert!(parse_use_tree("a").normalize(true) < parse_use_tree("*").normalize(true));
-        assert!(parse_use_tree("a").normalize(true) < parse_use_tree("{a, b}").normalize(true));
-        assert!(parse_use_tree("*").normalize(true) < parse_use_tree("{a, b}").normalize(true));
+        assert!(parse_use_tree("a").normalize() < parse_use_tree("aa").normalize());
+        assert!(parse_use_tree("a").normalize() < parse_use_tree("a::a").normalize());
+        assert!(parse_use_tree("a").normalize() < parse_use_tree("*").normalize());
+        assert!(parse_use_tree("a").normalize() < parse_use_tree("{a, b}").normalize());
+        assert!(parse_use_tree("*").normalize() < parse_use_tree("{a, b}").normalize());
 
         assert!(
-            parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, dddddddd}").normalize(true)
-                < parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, ddddddddd}").normalize(true)
-        );
-        assert!(
-            parse_use_tree("serde::de::{Deserialize}").normalize(true)
-                < parse_use_tree("serde_json").normalize(true)
+            parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, dddddddd}").normalize()
+                < parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, ddddddddd}").normalize()
         );
         assert!(
-            parse_use_tree("a::b::c").normalize(true) < parse_use_tree("a::b::*").normalize(true)
+            parse_use_tree("serde::de::{Deserialize}").normalize()
+                < parse_use_tree("serde_json").normalize()
         );
+        assert!(parse_use_tree("a::b::c").normalize() < parse_use_tree("a::b::*").normalize());
         assert!(
-            parse_use_tree("foo::{Bar, Baz}").normalize(true)
-                < parse_use_tree("{Bar, Baz}").normalize(true)
+            parse_use_tree("foo::{Bar, Baz}").normalize()
+                < parse_use_tree("{Bar, Baz}").normalize()
         );
 
         assert!(
-            parse_use_tree("foo::{self as bar}").normalize(true)
-                < parse_use_tree("foo::{qux as bar}").normalize(true)
+            parse_use_tree("foo::{self as bar}").normalize()
+                < parse_use_tree("foo::{qux as bar}").normalize()
         );
         assert!(
-            parse_use_tree("foo::{qux as bar}").normalize(true)
-                < parse_use_tree("foo::{baz, qux as bar}").normalize(true)
+            parse_use_tree("foo::{qux as bar}").normalize()
+                < parse_use_tree("foo::{baz, qux as bar}").normalize()
         );
         assert!(
-            parse_use_tree("foo::{self as bar, baz}").normalize(true)
-                < parse_use_tree("foo::{baz, qux as bar}").normalize(true)
+            parse_use_tree("foo::{self as bar, baz}").normalize()
+                < parse_use_tree("foo::{baz, qux as bar}").normalize()
         );
 
-        assert!(parse_use_tree("foo").normalize(true) < parse_use_tree("Foo").normalize(true));
-        assert!(parse_use_tree("foo").normalize(true) < parse_use_tree("foo::Bar").normalize(true));
+        assert!(parse_use_tree("foo").normalize() < parse_use_tree("Foo").normalize());
+        assert!(parse_use_tree("foo").normalize() < parse_use_tree("foo::Bar").normalize());
 
         assert!(
-            parse_use_tree("std::cmp::{d, c, b, a}").normalize(true)
-                < parse_use_tree("std::cmp::{b, e, g, f}").normalize(true)
+            parse_use_tree("std::cmp::{d, c, b, a}").normalize()
+                < parse_use_tree("std::cmp::{b, e, g, f}").normalize()
         );
     }
 }

diff --git a/src/lib.rs b/src/lib.rs
index 61eeb9332a6af6aa7c83e74a7cb26af99f7e96cb..9a7d0d2f8817bf174d9cd6ef92be540d8bd6c81e 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -42,8 +42,8 @@
 use syntax::ast;
 pub use syntax::codemap::FileName;
 use syntax::codemap::{CodeMap, FilePathMapping};
-use syntax::errors::{DiagnosticBuilder, Handler};
 use syntax::errors::emitter::{ColorConfig, EmitterWriter};
+use syntax::errors::{DiagnosticBuilder, Handler};
 use syntax::parse::{self, ParseSess};
 
 use checkstyle::{output_footer, output_header};

diff --git a/src/reorder.rs b/src/reorder.rs
index 273f20c92543ee5394918016a0e851548444dfda..e4065146cc6881bfb5e0c08722168ea9f12608fc 100644 (file)
--- a/src/reorder.rs
+++ b/src/reorder.rs
@@ -207,7 +207,7 @@ pub fn is_reorderable(&self, config: &Config) -> bool {
 
     pub fn in_group(&self) -> bool {
         match *self {
-            ReorderableItemKind::ExternCrate => false,
+            ReorderableItemKind::ExternCrate => true,
             ReorderableItemKind::Mod => true,
             ReorderableItemKind::Use => true,
             ReorderableItemKind::Other => false,

diff --git a/tests/target/extern.rs b/tests/target/extern.rs
index 61989cace75de253dee4f0650d76c83023f0c2d0..b0aa51127d54ef737d93a60ef8a397653dfd604b 100644 (file)
--- a/tests/target/extern.rs
+++ b/tests/target/extern.rs
@@ -1,14 +1,17 @@
 // rustfmt-normalize_comments: true
 
-extern crate bar;
-extern crate chrono;
-extern crate dotenv;
-extern crate foo;
 extern crate foo;
 extern crate foo as bar;
+
+extern crate chrono;
+extern crate dotenv;
 extern crate futures;
-extern crate proc_macro;
+
+extern crate bar;
+extern crate foo;
+
 // #2315
+extern crate proc_macro;
 extern crate proc_macro2;
 
 extern "C" {

diff --git a/tests/target/import-fencepost-length.rs b/tests/target/import-fencepost-length.rs
index 9d247aaf6dffb6cbe1c01705c9ef127f88892f7a..e4f885c09b1f049d505b5887abb5913d73fcc282 100644 (file)
--- a/tests/target/import-fencepost-length.rs
+++ b/tests/target/import-fencepost-length.rs
@@ -1,4 +1,4 @@
+use aaaaaaaaaaaaaaa::bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
 use aaaaaaaaaaaaaaa::{bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, ccccccccccccccccccccccccccccccc, dddddddd};
 use aaaaaaaaaaaaaaa::{bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, ccccccccccccccccccccccccccccccc,
                       ddddddddd};
-use aaaaaaaaaaaaaaa::bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;

diff --git a/tests/target/imports.rs b/tests/target/imports.rs
index b6d939fc125f313a68e937aa0f389a5c43f1b9b7..236fee95e82befce8a8cd55cf50f18c86ccb96d9 100644 (file)
--- a/tests/target/imports.rs
+++ b/tests/target/imports.rs
@@ -54,9 +54,9 @@ fn test() {
 
 // With absolute paths
 use foo;
-use Foo;
 use foo::Bar;
 use foo::{Bar, Baz};
+use Foo;
 use {Bar, Baz};
 
 // Root globs