[breaking-change] don't glob export ast::PathListItem_ variants

7 files changed, 43 insertions, 39 deletions

diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs
index fda538df5b3..977f271c301 100644
--- a/src/librustc_front/lowering.rs
+++ b/src/librustc_front/lowering.rs
@@ -211,24 +211,7 @@ pub fn lower_view_path(lctx: &LoweringContext, view_path: &ViewPath) -> P<hir::V
             ViewPathList(ref path, ref path_list_idents) => {
                 hir::ViewPathList(lower_path(lctx, path),
                                   path_list_idents.iter()
-                                                  .map(|path_list_ident| {
-                                                      Spanned {
-                                                          node: match path_list_ident.node {
-                                                              PathListIdent { id, name, rename } =>
-                                                                  hir::PathListIdent {
-                                                                  id: id,
-                                                                  name: name.name,
-                                                                  rename: rename.map(|x| x.name),
-                                                              },
-                                                              PathListMod { id, rename } =>
-                                                                  hir::PathListMod {
-                                                                  id: id,
-                                                                  rename: rename.map(|x| x.name),
-                                                              },
-                                                          },
-                                                          span: path_list_ident.span,
-                                                      }
-                                                  })
+                                                  .map(lower_path_list_item)
                                                   .collect())
             }
         },
@@ -236,6 +219,23 @@ pub fn lower_view_path(lctx: &LoweringContext, view_path: &ViewPath) -> P<hir::V
     })
 }
 
+fn lower_path_list_item(path_list_ident: &PathListItem) -> hir::PathListItem {
+    Spanned {
+        node: match path_list_ident.node {
+            PathListItemKind::Ident { id, name, rename } => hir::PathListIdent {
+                id: id,
+                name: name.name,
+                rename: rename.map(|x| x.name),
+            },
+            PathListItemKind::Mod { id, rename } => hir::PathListMod {
+                id: id,
+                rename: rename.map(|x| x.name),
+            },
+        },
+        span: path_list_ident.span,
+    }
+}
+
 pub fn lower_arm(lctx: &LoweringContext, arm: &Arm) -> hir::Arm {
     hir::Arm {
         attrs: lower_attrs(lctx, &arm.attrs),
diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs
index 1d12abbb9cb..34d806ab0a8 100644
--- a/src/librustc_trans/save/dump_csv.rs
+++ b/src/librustc_trans/save/dump_csv.rs
@@ -928,7 +928,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
                     ast::ViewPathList(ref path, ref list) => {
                         for plid in list {
                             match plid.node {
-                                ast::PathListIdent { id, .. } => {
+                                ast::PathListItemKind::Ident { id, .. } => {
                                     match self.lookup_type_ref(id) {
                                         Some(def_id) => match self.lookup_def_kind(id, plid.span) {
                                             Some(kind) => {
@@ -943,7 +943,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
                                         None => (),
                                     }
                                 }
-                                ast::PathListMod { .. } => (),
+                                ast::PathListItemKind::Mod { .. } => (),
                             }
                         }
 
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 713f5c9a7be..bae6d780b5e 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -11,7 +11,6 @@
 // The Rust abstract syntax tree.
 
 pub use self::Pat_::*;
-pub use self::PathListItem_::*;
 pub use self::StructFieldKind::*;
 pub use self::TyParamBound::*;
 pub use self::UnsafeSource::*;
@@ -1737,42 +1736,42 @@ pub struct Variant_ {
 pub type Variant = Spanned<Variant_>;
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
-pub enum PathListItem_ {
-    PathListIdent {
+pub enum PathListItemKind {
+    Ident {
         name: Ident,
         /// renamed in list, eg `use foo::{bar as baz};`
         rename: Option<Ident>,
         id: NodeId
     },
-    PathListMod {
+    Mod {
         /// renamed in list, eg `use foo::{self as baz};`
         rename: Option<Ident>,
         id: NodeId
     }
 }
 
-impl PathListItem_ {
+impl PathListItemKind {
     pub fn id(&self) -> NodeId {
         match *self {
-            PathListIdent { id, .. } | PathListMod { id, .. } => id
+            PathListItemKind::Ident { id, .. } | PathListItemKind::Mod { id, .. } => id
         }
     }
 
     pub fn name(&self) -> Option<Ident> {
         match *self {
-            PathListIdent { name, .. } => Some(name),
-            PathListMod { .. } => None,
+            PathListItemKind::Ident { name, .. } => Some(name),
+            PathListItemKind::Mod { .. } => None,
         }
     }
 
     pub fn rename(&self) -> Option<Ident> {
         match *self {
-            PathListIdent { rename, .. } | PathListMod { rename, .. } => rename
+            PathListItemKind::Ident { rename, .. } | PathListItemKind::Mod { rename, .. } => rename
         }
     }
 }
 
-pub type PathListItem = Spanned<PathListItem_>;
+pub type PathListItem = Spanned<PathListItemKind>;
 
 pub type ViewPath = Spanned<ViewPath_>;
 
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 161443c6eb0..31d5521799e 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -1150,7 +1150,12 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     fn item_use_list(&self, sp: Span, vis: ast::Visibility,
                      path: Vec<ast::Ident>, imports: &[ast::Ident]) -> P<ast::Item> {
         let imports = imports.iter().map(|id| {
-            respan(sp, ast::PathListIdent { name: *id, rename: None, id: ast::DUMMY_NODE_ID })
+            let item = ast::PathListItemKind::Ident {
+                name: *id,
+                rename: None,
+                id: ast::DUMMY_NODE_ID,
+            };
+            respan(sp, item)
         }).collect();
 
         self.item_use(sp, vis,
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 7cbb3439551..5ae24e6fb24 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -316,14 +316,14 @@ pub fn noop_fold_view_path<T: Folder>(view_path: P<ViewPath>, fld: &mut T) -> P<
                              path_list_idents.move_map(|path_list_ident| {
                                 Spanned {
                                     node: match path_list_ident.node {
-                                        PathListIdent { id, name, rename } =>
-                                            PathListIdent {
+                                        PathListItemKind::Ident { id, name, rename } =>
+                                            PathListItemKind::Ident {
                                                 id: fld.new_id(id),
                                                 rename: rename,
                                                 name: name
                                             },
-                                        PathListMod { id, rename } =>
-                                            PathListMod {
+                                        PathListItemKind::Mod { id, rename } =>
+                                            PathListItemKind::Mod {
                                                 id: fld.new_id(id),
                                                 rename: rename
                                             }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index afab3a0711b..e985bfd37b0 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -574,11 +574,11 @@ impl<'a> Parser<'a> {
         let lo = self.span.lo;
         let node = if self.eat_keyword(keywords::SelfValue) {
             let rename = try!(self.parse_rename());
-            ast::PathListMod { id: ast::DUMMY_NODE_ID, rename: rename }
+            ast::PathListItemKind::Mod { id: ast::DUMMY_NODE_ID, rename: rename }
         } else {
             let ident = try!(self.parse_ident());
             let rename = try!(self.parse_rename());
-            ast::PathListIdent { name: ident, rename: rename, id: ast::DUMMY_NODE_ID }
+            ast::PathListItemKind::Ident { name: ident, rename: rename, id: ast::DUMMY_NODE_ID }
         };
         let hi = self.last_span.hi;
         Ok(spanned(lo, hi, node))
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index bb3bc2d78e3..ab218971a51 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -2918,7 +2918,7 @@ impl<'a> State<'a> {
                 }
                 try!(self.commasep(Inconsistent, &idents[..], |s, w| {
                     match w.node {
-                        ast::PathListIdent { name, rename, .. } => {
+                        ast::PathListItemKind::Ident { name, rename, .. } => {
                             try!(s.print_ident(name));
                             if let Some(ident) = rename {
                                 try!(space(&mut s.s));
@@ -2927,7 +2927,7 @@ impl<'a> State<'a> {
                             }
                             Ok(())
                         },
-                        ast::PathListMod { rename, .. } => {
+                        ast::PathListItemKind::Mod { rename, .. } => {
                             try!(word(&mut s.s, "self"));
                             if let Some(ident) = rename {
                                 try!(space(&mut s.s));