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

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_>;
 

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,

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
                                             }

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))

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));