rollup merge of #20179: eddyb/blind-items

Conflicts:
	src/librustc/diagnostics.rs
	src/librustdoc/clean/mod.rs
	src/librustdoc/html/format.rs
	src/libsyntax/parse/parser.rs

1 files changed, 36 insertions, 52 deletions

diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 3656c3a459c..cd2ed5f0a97 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -35,7 +35,7 @@
 pub use self::ExternalLocation::*;
 
 use std::cell::RefCell;
-use std::cmp::Ordering::{self, Less, Greater, Equal};
+use std::cmp::Ordering;
 use std::collections::{HashMap, HashSet};
 use std::default::Default;
 use std::fmt;
@@ -1497,18 +1497,19 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
     // the order of item types in the listing
     fn reorder(ty: ItemType) -> u8 {
         match ty {
-            ItemType::ViewItem        => 0,
-            ItemType::Primitive       => 1,
-            ItemType::Module          => 2,
-            ItemType::Macro           => 3,
-            ItemType::Struct          => 4,
-            ItemType::Enum            => 5,
-            ItemType::Constant        => 6,
-            ItemType::Static          => 7,
-            ItemType::Trait           => 8,
-            ItemType::Function        => 9,
-            ItemType::Typedef         => 10,
-            _                         => 11 + ty as u8,
+            ItemType::ExternCrate     => 0,
+            ItemType::Import          => 1,
+            ItemType::Primitive       => 2,
+            ItemType::Module          => 3,
+            ItemType::Macro           => 4,
+            ItemType::Struct          => 5,
+            ItemType::Enum            => 6,
+            ItemType::Constant        => 7,
+            ItemType::Static          => 8,
+            ItemType::Trait           => 9,
+            ItemType::Function        => 10,
+            ItemType::Typedef         => 12,
+            _                         => 13 + ty as u8,
         }
     }
 
@@ -1518,25 +1519,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
         if ty1 == ty2 {
             return i1.name.cmp(&i2.name);
         }
-
-        let tycmp = reorder(ty1).cmp(&reorder(ty2));
-        if let Equal = tycmp {
-            // for reexports, `extern crate` takes precedence.
-            match (&i1.inner, &i2.inner) {
-                (&clean::ViewItemItem(ref a), &clean::ViewItemItem(ref b)) => {
-                    match (&a.inner, &b.inner) {
-                        (&clean::ExternCrate(..), _) => return Less,
-                        (_, &clean::ExternCrate(..)) => return Greater,
-                        _ => {}
-                    }
-                }
-                (_, _) => {}
-            }
-
-            idx1.cmp(&idx2)
-        } else {
-            tycmp
-        }
+        (reorder(ty1), idx1).cmp(&(reorder(ty2), idx2))
     }
 
     indices.sort_by(|&i1, &i2| cmp(&items[i1], &items[i2], i1, i2));
@@ -1547,12 +1530,17 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
         let myitem = &items[idx];
 
         let myty = Some(shortty(myitem));
-        if myty != curty {
+        if curty == Some(ItemType::ExternCrate) && myty == Some(ItemType::Import) {
+            // Put `extern crate` and `use` re-exports in the same section.
+            curty = myty;
+        } else if myty != curty {
             if curty.is_some() {
                 try!(write!(w, "</table>"));
             }
             curty = myty;
             let (short, name) = match myty.unwrap() {
+                ItemType::ExternCrate |
+                ItemType::Import          => ("reexports", "Reexports"),
                 ItemType::Module          => ("modules", "Modules"),
                 ItemType::Struct          => ("structs", "Structs"),
                 ItemType::Enum            => ("enums", "Enums"),
@@ -1562,7 +1550,6 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
                 ItemType::Constant        => ("constants", "Constants"),
                 ItemType::Trait           => ("traits", "Traits"),
                 ItemType::Impl            => ("impls", "Implementations"),
-                ItemType::ViewItem        => ("reexports", "Reexports"),
                 ItemType::TyMethod        => ("tymethods", "Type Methods"),
                 ItemType::Method          => ("methods", "Methods"),
                 ItemType::StructField     => ("fields", "Struct Fields"),
@@ -1578,28 +1565,25 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
         }
 
         match myitem.inner {
-            clean::ViewItemItem(ref item) => {
-                match item.inner {
-                    clean::ExternCrate(ref name, ref src, _) => {
-                        match *src {
-                            Some(ref src) =>
-                                try!(write!(w, "<tr><td><code>extern crate \"{}\" as {}",
-                                            src.as_slice(),
-                                            name.as_slice())),
-                            None =>
-                                try!(write!(w, "<tr><td><code>extern crate {}",
-                                            name.as_slice())),
-                        }
-                        try!(write!(w, ";</code></td></tr>"));
+            clean::ExternCrateItem(ref name, ref src) => {
+                match *src {
+                    Some(ref src) => {
+                        try!(write!(w, "<tr><td><code>{}extern crate \"{}\" as {};",
+                                    VisSpace(myitem.visibility),
+                                    src.as_slice(),
+                                    name.as_slice()))
                     }
-
-                    clean::Import(ref import) => {
-                        try!(write!(w, "<tr><td><code>{}{}</code></td></tr>",
-                                      VisSpace(myitem.visibility),
-                                      *import));
+                    None => {
+                        try!(write!(w, "<tr><td><code>{}extern crate {};",
+                                    VisSpace(myitem.visibility), name.as_slice()))
                     }
                 }
+                try!(write!(w, "</code></td></tr>"));
+            }
 
+            clean::ImportItem(ref import) => {
+                try!(write!(w, "<tr><td><code>{}{}</code></td></tr>",
+                            VisSpace(myitem.visibility), *import));
             }
 
             _ => {