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

diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs
index fda538df5b3515d9401e198f29696bacb279f492..977f271c3014aa77148bf4aeb99f2f845c4b72ac 100644 (file)
--- 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 1d12abbb9cb79d63a64ab104cf1e07498d4e5e18..34d806ab0a8a30f9c621ac92246aef75e9f1cc10 100644 (file)
--- a/src/librustc_trans/save/dump_csv.rs
+++ b/src/librustc_trans/save/dump_csv.rs
@@ -928,7 +928,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                     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 @@ fn visit_item(&mut self, item: &ast::Item) {
                                         None => (),
                                     }
                                 }
-                                ast::PathListMod { .. } => (),
+                                ast::PathListItemKind::Mod { .. } => (),
                             }
                         }
 

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 713f5c9a7be381428cbfc5ed8038b276d8e0f077..bae6d780b5e5b5535e3bbd0cda5bff222b837e9c 100644 (file)
--- 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 161443c6eb0074c543b8e74d8d9aeb3324d5a828..31d5521799e1b852b69d468256883a263d96fa8f 100644 (file)
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -1150,7 +1150,12 @@ fn item_use_simple_(&self, sp: Span, vis: ast::Visibility,
     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 7cbb3439551e76a5b5ff64de71079b18c93e18d1..5ae24e6fb248242b4cd6f12081bc803d634cbb77 100644 (file)
--- 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 afab3a0711be1a695a38d1d923cead74b399f4c8..e985bfd37b0751b6797959cb47275f63276df76a 100644 (file)
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -574,11 +574,11 @@ pub fn parse_path_list_item(&mut self) -> PResult<'a, ast::PathListItem> {
         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 bb3bc2d78e33c5d551bcd7d171c05b69fe1ad1f9..ab218971a51ee406302f6741fa210c22d55775bd 100644 (file)
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -2918,7 +2918,7 @@ pub fn print_view_path(&mut self, vp: &ast::ViewPath) -> io::Result<()> {
                 }
                 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 @@ pub fn print_view_path(&mut self, vp: &ast::ViewPath) -> io::Result<()> {
                             }
                             Ok(())
                         },
-                        ast::PathListMod { rename, .. } => {
+                        ast::PathListItemKind::Mod { rename, .. } => {
                             try!(word(&mut s.s, "self"));
                             if let Some(ident) = rename {
                                 try!(space(&mut s.s));