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

diff --git a/src/librustc/front/check_attr.rs b/src/librustc/front/check_attr.rs
index 27785a072a6544a2a07012388d456738bfad3111..cfd9d5bdaa75d11be74b88e9e209a9aab7b7a4b3 100644 (file)
--- a/src/librustc/front/check_attr.rs
+++ b/src/librustc/front/check_attr.rs
@@ -26,9 +26,9 @@ enum Target {
 impl Target {
     fn from_item(item: &ast::Item) -> Target {
         match item.node {
-            ast::ItemFn(..) => Target::Fn,
-            ast::ItemStruct(..) => Target::Struct,
-            ast::ItemEnum(..) => Target::Enum,
+            ast::ItemKind::Fn(..) => Target::Fn,
+            ast::ItemKind::Struct(..) => Target::Struct,
+            ast::ItemKind::Enum(..) => Target::Enum,
             _ => Target::Other,
         }
     }

diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs
index 0f6ba63d54b67a50e292594df9a88c2b1f43780b..e0a948f766141ac5c799bfae0f969e0c27e987c4 100644 (file)
--- a/src/librustc_driver/pretty.rs
+++ b/src/librustc_driver/pretty.rs
@@ -600,16 +600,16 @@ fn new() -> ReplaceBodyWithLoop {
 }
 
 impl fold::Folder for ReplaceBodyWithLoop {
-    fn fold_item_underscore(&mut self, i: ast::Item_) -> ast::Item_ {
+    fn fold_item_kind(&mut self, i: ast::ItemKind) -> ast::ItemKind {
         match i {
-            ast::ItemStatic(..) | ast::ItemConst(..) => {
+            ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => {
                 self.within_static_or_const = true;
-                let ret = fold::noop_fold_item_underscore(i, self);
+                let ret = fold::noop_fold_item_kind(i, self);
                 self.within_static_or_const = false;
                 return ret;
             }
             _ => {
-                fold::noop_fold_item_underscore(i, self)
+                fold::noop_fold_item_kind(i, self)
             }
         }
     }

diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs
index 781008db129d12d9e2722034ed1237983acf3e48..d04f4c96504ec928ece7163a275557044ef2e70e 100644 (file)
--- a/src/librustc_front/lowering.rs
+++ b/src/librustc_front/lowering.rs
@@ -654,21 +654,21 @@ pub fn lower_block(lctx: &LoweringContext, b: &Block) -> P<hir::Block> {
     })
 }
 
-pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
+pub fn lower_item_kind(lctx: &LoweringContext, i: &ItemKind) -> hir::Item_ {
     match *i {
-        ItemExternCrate(string) => hir::ItemExternCrate(string),
-        ItemUse(ref view_path) => {
+        ItemKind::ExternCrate(string) => hir::ItemExternCrate(string),
+        ItemKind::Use(ref view_path) => {
             hir::ItemUse(lower_view_path(lctx, view_path))
         }
-        ItemStatic(ref t, m, ref e) => {
+        ItemKind::Static(ref t, m, ref e) => {
             hir::ItemStatic(lower_ty(lctx, t),
                             lower_mutability(lctx, m),
                             lower_expr(lctx, e))
         }
-        ItemConst(ref t, ref e) => {
+        ItemKind::Const(ref t, ref e) => {
             hir::ItemConst(lower_ty(lctx, t), lower_expr(lctx, e))
         }
-        ItemFn(ref decl, unsafety, constness, abi, ref generics, ref body) => {
+        ItemKind::Fn(ref decl, unsafety, constness, abi, ref generics, ref body) => {
             hir::ItemFn(lower_fn_decl(lctx, decl),
                         lower_unsafety(lctx, unsafety),
                         lower_constness(lctx, constness),
@@ -676,12 +676,12 @@ pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
                         lower_generics(lctx, generics),
                         lower_block(lctx, body))
         }
-        ItemMod(ref m) => hir::ItemMod(lower_mod(lctx, m)),
-        ItemForeignMod(ref nm) => hir::ItemForeignMod(lower_foreign_mod(lctx, nm)),
-        ItemTy(ref t, ref generics) => {
+        ItemKind::Mod(ref m) => hir::ItemMod(lower_mod(lctx, m)),
+        ItemKind::ForeignMod(ref nm) => hir::ItemForeignMod(lower_foreign_mod(lctx, nm)),
+        ItemKind::Ty(ref t, ref generics) => {
             hir::ItemTy(lower_ty(lctx, t), lower_generics(lctx, generics))
         }
-        ItemEnum(ref enum_definition, ref generics) => {
+        ItemKind::Enum(ref enum_definition, ref generics) => {
             hir::ItemEnum(hir::EnumDef {
                               variants: enum_definition.variants
                                                        .iter()
@@ -690,15 +690,15 @@ pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
                           },
                           lower_generics(lctx, generics))
         }
-        ItemStruct(ref struct_def, ref generics) => {
+        ItemKind::Struct(ref struct_def, ref generics) => {
             let struct_def = lower_variant_data(lctx, struct_def);
             hir::ItemStruct(struct_def, lower_generics(lctx, generics))
         }
-        ItemDefaultImpl(unsafety, ref trait_ref) => {
+        ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
             hir::ItemDefaultImpl(lower_unsafety(lctx, unsafety),
                                  lower_trait_ref(lctx, trait_ref))
         }
-        ItemImpl(unsafety, polarity, ref generics, ref ifce, ref ty, ref impl_items) => {
+        ItemKind::Impl(unsafety, polarity, ref generics, ref ifce, ref ty, ref impl_items) => {
             let new_impl_items = impl_items.iter()
                                            .map(|item| lower_impl_item(lctx, item))
                                            .collect();
@@ -710,7 +710,7 @@ pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
                           lower_ty(lctx, ty),
                           new_impl_items)
         }
-        ItemTrait(unsafety, ref generics, ref bounds, ref items) => {
+        ItemKind::Trait(unsafety, ref generics, ref bounds, ref items) => {
             let bounds = lower_bounds(lctx, bounds);
             let items = items.iter().map(|item| lower_trait_item(lctx, item)).collect();
             hir::ItemTrait(lower_unsafety(lctx, unsafety),
@@ -718,7 +718,7 @@ pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
                            bounds,
                            items)
         }
-        ItemMac(_) => panic!("Shouldn't still be around"),
+        ItemKind::Mac(_) => panic!("Shouldn't still be around"),
     }
 }
 
@@ -820,7 +820,7 @@ pub fn lower_item_id(_lctx: &LoweringContext, i: &Item) -> hir::ItemId {
 }
 
 pub fn lower_item(lctx: &LoweringContext, i: &Item) -> hir::Item {
-    let node = lower_item_underscore(lctx, &i.node);
+    let node = lower_item_kind(lctx, &i.node);
 
     hir::Item {
         id: i.id,

diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs
index d5aa091886eb1632c3e20b93f5e5ee037c88e251..52456251f962b18404d441c596589d1d31ae0a04 100644 (file)
--- a/src/librustc_metadata/creader.rs
+++ b/src/librustc_metadata/creader.rs
@@ -157,7 +157,7 @@ pub fn new(sess: &'a Session, cstore: &'a CStore) -> CrateReader<'a> {
 
     fn extract_crate_info(&self, i: &ast::Item) -> Option<CrateInfo> {
         match i.node {
-            ast::ItemExternCrate(ref path_opt) => {
+            ast::ItemKind::ExternCrate(ref path_opt) => {
                 debug!("resolving extern crate stmt. ident: {} path_opt: {:?}",
                        i.ident, path_opt);
                 let name = match *path_opt {

diff --git a/src/librustc_metadata/macro_import.rs b/src/librustc_metadata/macro_import.rs
index d67fc3a0eaba525acd0c792d8ff8af01f802fd47..b2395ac355f62800188343bc536e83c14074defc 100644 (file)
--- a/src/librustc_metadata/macro_import.rs
+++ b/src/librustc_metadata/macro_import.rs
@@ -56,7 +56,7 @@ pub fn read_macro_defs(sess: &Session, cstore: &CStore, krate: &ast::Crate)
     // crate root, because `$crate` won't work properly. Identify these by
     // spans, because the crate map isn't set up yet.
     for item in &krate.module.items {
-        if let ast::ItemExternCrate(_) = item.node {
+        if let ast::ItemKind::ExternCrate(_) = item.node {
             loader.span_whitelist.insert(item.span);
         }
     }
@@ -73,7 +73,7 @@ impl<'a, 'v> Visitor<'v> for MacroLoader<'a> {
     fn visit_item(&mut self, item: &ast::Item) {
         // We're only interested in `extern crate`.
         match item.node {
-            ast::ItemExternCrate(_) => {}
+            ast::ItemKind::ExternCrate(_) => {}
             _ => {
                 visit::walk_item(self, item);
                 return;

diff --git a/src/librustc_passes/const_fn.rs b/src/librustc_passes/const_fn.rs
index ec9fa1afb55f229e35baecd984c42ad15e302d3f..98346f538b0bc257d9538844a6de0007a98587c8 100644 (file)
--- a/src/librustc_passes/const_fn.rs
+++ b/src/librustc_passes/const_fn.rs
@@ -78,10 +78,10 @@ impl<'a, 'v> Visitor<'v> for CheckConstFn<'a> {
     fn visit_item(&mut self, i: &'v ast::Item) {
         visit::walk_item(self, i);
         match i.node {
-            ast::ItemConst(_, ref e) => {
+            ast::ItemKind::Const(_, ref e) => {
                 CheckBlock{ sess: self.sess, kind: "constant"}.visit_expr(e)
             },
-            ast::ItemStatic(_, _, ref e) => {
+            ast::ItemKind::Static(_, _, ref e) => {
                 CheckBlock{ sess: self.sess, kind: "static"}.visit_expr(e)
             },
             _ => {},

diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs
index 10840933c0146906b0541dd627747298ee74cf50..d8f21fd4dd6bf20e9a0c17cf22cbcc7cd1be1169 100644 (file)
--- a/src/librustc_trans/save/dump_csv.rs
+++ b/src/librustc_trans/save/dump_csv.rs
@@ -864,9 +864,10 @@ fn process_macro_use(&mut self, span: Span, id: NodeId) {
 
 impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
     fn visit_item(&mut self, item: &ast::Item) {
+        use syntax::ast::ItemKind::*;
         self.process_macro_use(item.span, item.id);
         match item.node {
-            ast::ItemUse(ref use_item) => {
+            Use(ref use_item) => {
                 match use_item.node {
                     ast::ViewPathSimple(ident, ref path) => {
                         let sub_span = self.span.span_for_last_ident(path.span);
@@ -950,7 +951,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                     }
                 }
             }
-            ast::ItemExternCrate(ref s) => {
+            ExternCrate(ref s) => {
                 let location = match *s {
                     Some(s) => s.to_string(),
                     None => item.ident.to_string(),
@@ -968,28 +969,28 @@ fn visit_item(&mut self, item: &ast::Item) {
                                           &location,
                                           self.cur_scope);
             }
-            ast::ItemFn(ref decl, _, _, _, ref ty_params, ref body) =>
+            Fn(ref decl, _, _, _, ref ty_params, ref body) =>
                 self.process_fn(item, &**decl, ty_params, &**body),
-            ast::ItemStatic(ref typ, _, ref expr) =>
+            Static(ref typ, _, ref expr) =>
                 self.process_static_or_const_item(item, typ, expr),
-            ast::ItemConst(ref typ, ref expr) =>
+            Const(ref typ, ref expr) =>
                 self.process_static_or_const_item(item, &typ, &expr),
-            ast::ItemStruct(ref def, ref ty_params) => self.process_struct(item, def, ty_params),
-            ast::ItemEnum(ref def, ref ty_params) => self.process_enum(item, def, ty_params),
-            ast::ItemImpl(_, _,
+            Struct(ref def, ref ty_params) => self.process_struct(item, def, ty_params),
+            Enum(ref def, ref ty_params) => self.process_enum(item, def, ty_params),
+            Impl(_, _,
                           ref ty_params,
                           ref trait_ref,
                           ref typ,
                           ref impl_items) => {
                 self.process_impl(item, ty_params, trait_ref, &typ, impl_items)
             }
-            ast::ItemTrait(_, ref generics, ref trait_refs, ref methods) =>
+            Trait(_, ref generics, ref trait_refs, ref methods) =>
                 self.process_trait(item, generics, trait_refs, methods),
-            ast::ItemMod(ref m) => {
+            Mod(ref m) => {
                 self.process_mod(item);
                 self.nest(item.id, |v| visit::walk_mod(v, m));
             }
-            ast::ItemTy(ref ty, ref ty_params) => {
+            Ty(ref ty, ref ty_params) => {
                 let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
                 let value = ty_to_string(&**ty);
                 let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Type);
@@ -998,7 +999,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                 self.visit_ty(&**ty);
                 self.process_generic_params(ty_params, item.span, &qualname, item.id);
             }
-            ast::ItemMac(_) => (),
+            Mac(_) => (),
             _ => visit::walk_item(self, item),
         }
     }

diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs
index 53fa1bfff38e47b082ed867885442c293781325c..1790da39ad0869b1802a33bf204ec5232fd2ef2e 100644 (file)
--- a/src/librustc_trans/save/mod.rs
+++ b/src/librustc_trans/save/mod.rs
@@ -229,7 +229,7 @@ pub fn get_external_crates(&self) -> Vec<CrateData> {
 
     pub fn get_item_data(&self, item: &ast::Item) -> Option<Data> {
         match item.node {
-            ast::ItemFn(..) => {
+            ast::ItemKind::Fn(..) => {
                 let name = self.tcx.map.path_to_string(item.id);
                 let qualname = format!("::{}", name);
                 let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Fn);
@@ -243,7 +243,7 @@ pub fn get_item_data(&self, item: &ast::Item) -> Option<Data> {
                     scope: self.enclosing_scope(item.id),
                 }))
             }
-            ast::ItemStatic(ref typ, mt, ref expr) => {
+            ast::ItemKind::Static(ref typ, mt, ref expr) => {
                 let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
 
                 // If the variable is immutable, save the initialising expression.
@@ -264,7 +264,7 @@ pub fn get_item_data(&self, item: &ast::Item) -> Option<Data> {
                     type_value: ty_to_string(&typ),
                 }))
             }
-            ast::ItemConst(ref typ, ref expr) => {
+            ast::ItemKind::Const(ref typ, ref expr) => {
                 let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
                 let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Const);
                 filter!(self.span_utils, sub_span, item.span, None);
@@ -278,7 +278,7 @@ pub fn get_item_data(&self, item: &ast::Item) -> Option<Data> {
                     type_value: ty_to_string(&typ),
                 }))
             }
-            ast::ItemMod(ref m) => {
+            ast::ItemKind::Mod(ref m) => {
                 let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
 
                 let cm = self.tcx.sess.codemap();
@@ -295,7 +295,7 @@ pub fn get_item_data(&self, item: &ast::Item) -> Option<Data> {
                     filename: filename,
                 }))
             }
-            ast::ItemEnum(..) => {
+            ast::ItemKind::Enum(..) => {
                 let enum_name = format!("::{}", self.tcx.map.path_to_string(item.id));
                 let val = self.span_utils.snippet(item.span);
                 let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Enum);
@@ -308,7 +308,7 @@ pub fn get_item_data(&self, item: &ast::Item) -> Option<Data> {
                     scope: self.enclosing_scope(item.id),
                 }))
             }
-            ast::ItemImpl(_, _, _, ref trait_ref, ref typ, _) => {
+            ast::ItemKind::Impl(_, _, _, ref trait_ref, ref typ, _) => {
                 let mut type_data = None;
                 let sub_span;
 

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index f2225ff2c09872bf49ac0a4b339e608a625aa52d..7519def15032feddf6cc5d70c6fe349ff5d21a51 100644 (file)
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -10,7 +10,6 @@
 
 // The Rust abstract syntax tree.
 
-pub use self::Item_::*;
 pub use self::KleeneOp::*;
 pub use self::MacStmtStyle::*;
 pub use self::MetaItem_::*;
@@ -1828,7 +1827,7 @@ pub struct Attribute_ {
 ///
 /// resolve maps each TraitRef's ref_id to its defining trait; that's all
 /// that the ref_id is for. The impl_id maps to the "self type" of this impl.
-/// If this impl is an ItemImpl, the impl_id is redundant (it could be the
+/// If this impl is an ItemKind::Impl, the impl_id is redundant (it could be the
 /// same as the impl's node id).
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct TraitRef {
@@ -1956,7 +1955,7 @@ pub struct Item {
     pub ident: Ident,
     pub attrs: Vec<Attribute>,
     pub id: NodeId,
-    pub node: Item_,
+    pub node: ItemKind,
     pub vis: Visibility,
     pub span: Span,
 }
@@ -1968,32 +1967,32 @@ pub fn attrs(&self) -> &[Attribute] {
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum Item_ {
+pub enum ItemKind {
     /// An`extern crate` item, with optional original crate name,
     ///
     /// e.g. `extern crate foo` or `extern crate foo_bar as foo`
-    ItemExternCrate(Option<Name>),
+    ExternCrate(Option<Name>),
     /// A `use` or `pub use` item
-    ItemUse(P<ViewPath>),
+    Use(P<ViewPath>),
 
     /// A `static` item
-    ItemStatic(P<Ty>, Mutability, P<Expr>),
+    Static(P<Ty>, Mutability, P<Expr>),
     /// A `const` item
-    ItemConst(P<Ty>, P<Expr>),
+    Const(P<Ty>, P<Expr>),
     /// A function declaration
-    ItemFn(P<FnDecl>, Unsafety, Constness, Abi, Generics, P<Block>),
+    Fn(P<FnDecl>, Unsafety, Constness, Abi, Generics, P<Block>),
     /// A module
-    ItemMod(Mod),
+    Mod(Mod),
     /// An external module
-    ItemForeignMod(ForeignMod),
+    ForeignMod(ForeignMod),
     /// A type alias, e.g. `type Foo = Bar<u8>`
-    ItemTy(P<Ty>, Generics),
+    Ty(P<Ty>, Generics),
     /// An enum definition, e.g. `enum Foo<A, B> {C<A>, D<B>}`
-    ItemEnum(EnumDef, Generics),
+    Enum(EnumDef, Generics),
     /// A struct definition, e.g. `struct Foo<A> {x: A}`
-    ItemStruct(VariantData, Generics),
+    Struct(VariantData, Generics),
     /// Represents a Trait Declaration
-    ItemTrait(Unsafety,
+    Trait(Unsafety,
               Generics,
               TyParamBounds,
               Vec<P<TraitItem>>),
@@ -2001,35 +2000,35 @@ pub enum Item_ {
     // Default trait implementations
     ///
     // `impl Trait for .. {}`
-    ItemDefaultImpl(Unsafety, TraitRef),
+    DefaultImpl(Unsafety, TraitRef),
     /// An implementation, eg `impl<A> Trait for Foo { .. }`
-    ItemImpl(Unsafety,
+    Impl(Unsafety,
              ImplPolarity,
              Generics,
              Option<TraitRef>, // (optional) trait this impl implements
              P<Ty>, // self
              Vec<P<ImplItem>>),
     /// A macro invocation (which includes macro definition)
-    ItemMac(Mac),
+    Mac(Mac),
 }
 
-impl Item_ {
+impl ItemKind {
     pub fn descriptive_variant(&self) -> &str {
         match *self {
-            ItemExternCrate(..) => "extern crate",
-            ItemUse(..) => "use",
-            ItemStatic(..) => "static item",
-            ItemConst(..) => "constant item",
-            ItemFn(..) => "function",
-            ItemMod(..) => "module",
-            ItemForeignMod(..) => "foreign module",
-            ItemTy(..) => "type alias",
-            ItemEnum(..) => "enum",
-            ItemStruct(..) => "struct",
-            ItemTrait(..) => "trait",
-            ItemMac(..) |
-            ItemImpl(..) |
-            ItemDefaultImpl(..) => "item"
+            ItemKind::ExternCrate(..) => "extern crate",
+            ItemKind::Use(..) => "use",
+            ItemKind::Static(..) => "static item",
+            ItemKind::Const(..) => "constant item",
+            ItemKind::Fn(..) => "function",
+            ItemKind::Mod(..) => "module",
+            ItemKind::ForeignMod(..) => "foreign module",
+            ItemKind::Ty(..) => "type alias",
+            ItemKind::Enum(..) => "enum",
+            ItemKind::Struct(..) => "struct",
+            ItemKind::Trait(..) => "trait",
+            ItemKind::Mac(..) |
+            ItemKind::Impl(..) |
+            ItemKind::DefaultImpl(..) => "item"
         }
     }
 }

diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 8ccff527b8831a6abcbed2ce6216cfb7f4dfc320..270133ad59995fb196fe0c1b4859ecf0630203cd 100644 (file)
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -173,7 +173,7 @@ fn visit_item(&mut self, item: &Item) {
 
         self.operation.visit_id(item.id);
         match item.node {
-            ItemUse(ref view_path) => {
+            ItemKind::Use(ref view_path) => {
                 match view_path.node {
                     ViewPathSimple(_, _) |
                     ViewPathGlob(_) => {}

diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
index 840acff73ada49a5921b62b589a5111b5c7ba1d0..57416bce3cbe7585b60bab42b43b173a319573c6 100644 (file)
--- a/src/libsyntax/config.rs
+++ b/src/libsyntax/config.rs
@@ -52,8 +52,8 @@ impl<'a, F> fold::Folder for Context<'a, F> where F: FnMut(&[ast::Attribute]) ->
     fn fold_foreign_mod(&mut self, foreign_mod: ast::ForeignMod) -> ast::ForeignMod {
         fold_foreign_mod(self, foreign_mod)
     }
-    fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ {
-        fold_item_underscore(self, item)
+    fn fold_item_kind(&mut self, item: ast::ItemKind) -> ast::ItemKind {
+        fold_item_kind(self, item)
     }
     fn fold_expr(&mut self, expr: P<ast::Expr>) -> P<ast::Expr> {
         // If an expr is valid to cfg away it will have been removed by the
@@ -129,26 +129,26 @@ fn fold_item<F>(cx: &mut Context<F>, item: P<ast::Item>) -> SmallVector<P<ast::I
     }
 }
 
-fn fold_item_underscore<F>(cx: &mut Context<F>, item: ast::Item_) -> ast::Item_ where
+fn fold_item_kind<F>(cx: &mut Context<F>, item: ast::ItemKind) -> ast::ItemKind where
     F: FnMut(&[ast::Attribute]) -> bool
 {
     let item = match item {
-        ast::ItemImpl(u, o, a, b, c, impl_items) => {
+        ast::ItemKind::Impl(u, o, a, b, c, impl_items) => {
             let impl_items = impl_items.into_iter()
                                        .filter(|ii| (cx.in_cfg)(&ii.attrs))
                                        .collect();
-            ast::ItemImpl(u, o, a, b, c, impl_items)
+            ast::ItemKind::Impl(u, o, a, b, c, impl_items)
         }
-        ast::ItemTrait(u, a, b, methods) => {
+        ast::ItemKind::Trait(u, a, b, methods) => {
             let methods = methods.into_iter()
                                  .filter(|ti| (cx.in_cfg)(&ti.attrs))
                                  .collect();
-            ast::ItemTrait(u, a, b, methods)
+            ast::ItemKind::Trait(u, a, b, methods)
         }
-        ast::ItemStruct(def, generics) => {
-            ast::ItemStruct(fold_struct(cx, def), generics)
+        ast::ItemKind::Struct(def, generics) => {
+            ast::ItemKind::Struct(fold_struct(cx, def), generics)
         }
-        ast::ItemEnum(def, generics) => {
+        ast::ItemKind::Enum(def, generics) => {
             let variants = def.variants.into_iter().filter_map(|v| {
                 if !(cx.in_cfg)(&v.node.attrs) {
                     None
@@ -167,14 +167,14 @@ fn fold_item_underscore<F>(cx: &mut Context<F>, item: ast::Item_) -> ast::Item_
                     }))
                 }
             });
-            ast::ItemEnum(ast::EnumDef {
+            ast::ItemKind::Enum(ast::EnumDef {
                 variants: variants.collect(),
             }, generics)
         }
         item => item,
     };
 
-    fold::noop_fold_item_underscore(item, cx)
+    fold::noop_fold_item_kind(item, cx)
 }
 
 fn fold_struct<F>(cx: &mut Context<F>, vdata: ast::VariantData) -> ast::VariantData where

diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs
index 4e6fde10ade2abb6c71b96ba3fc482f1a8382007..e8a4bb59bdc3c503f69aed31bea52ed14f5c83d8 100644 (file)
--- a/src/libsyntax/diagnostics/plugin.rs
+++ b/src/libsyntax/diagnostics/plugin.rs
@@ -226,7 +226,7 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt,
             ident: name.clone(),
             attrs: Vec::new(),
             id: ast::DUMMY_NODE_ID,
-            node: ast::ItemConst(
+            node: ast::ItemKind::Const(
                 ty,
                 expr,
             ),

diff --git a/src/libsyntax/entry.rs b/src/libsyntax/entry.rs
index ddc4443a77c9d7aa290aeb0511613560de3d5179..7014e576e2b8a36e2390e3da39262d03bf8c30a1 100644 (file)
--- a/src/libsyntax/entry.rs
+++ b/src/libsyntax/entry.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use attr;
-use ast::{Item, ItemFn};
+use ast::{Item, ItemKind};
 
 pub enum EntryPointType {
     None,
@@ -23,7 +23,7 @@ pub enum EntryPointType {
 // them in sync.
 pub fn entry_point_type(item: &Item, depth: usize) -> EntryPointType {
     match item.node {
-        ItemFn(..) => {
+        ItemKind::Fn(..) => {
             if attr::contains_name(&item.attrs, "start") {
                 EntryPointType::Start
             } else if attr::contains_name(&item.attrs, "main") {

diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index ceb7cf69680bd9967875a1c931be8c030f9481ed..381d952ea887499824193c4938ed8426400abed1 100644 (file)
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -120,7 +120,7 @@ fn expand(&self,
     }
 }
 
-// A more flexible ItemModifier (ItemModifier should go away, eventually, FIXME).
+// A more flexible ItemKind::Modifier (ItemKind::Modifier should go away, eventually, FIXME).
 // meta_item is the annotation, item is the item being modified, parent_item
 // is the impl or trait item is declared in if item is part of such a thing.
 // FIXME Decorators should follow the same pattern too.

diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 76071cc71e6cd2be5d693c8d255c597b13637f95..256825eacf28969e391a0b32068b5d5a114c63aa 100644 (file)
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -213,7 +213,7 @@ fn lambda_stmts_1(&self, span: Span, stmts: Vec<P<ast::Stmt>>,
 
     // items
     fn item(&self, span: Span,
-            name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item_) -> P<ast::Item>;
+            name: Ident, attrs: Vec<ast::Attribute> , node: ast::ItemKind) -> P<ast::Item>;
 
     fn arg(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::Arg;
     // FIXME unused self
@@ -951,7 +951,7 @@ fn fn_decl(&self, inputs: Vec<ast::Arg>, output: P<ast::Ty>) -> P<ast::FnDecl> {
     }
 
     fn item(&self, span: Span, name: Ident,
-            attrs: Vec<ast::Attribute>, node: ast::Item_) -> P<ast::Item> {
+            attrs: Vec<ast::Attribute>, node: ast::ItemKind) -> P<ast::Item> {
         // FIXME: Would be nice if our generated code didn't violate
         // Rust coding conventions
         P(ast::Item {
@@ -974,7 +974,7 @@ fn item_fn_poly(&self,
         self.item(span,
                   name,
                   Vec::new(),
-                  ast::ItemFn(self.fn_decl(inputs, output),
+                  ast::ItemKind::Fn(self.fn_decl(inputs, output),
                               ast::Unsafety::Normal,
                               ast::Constness::NotConst,
                               Abi::Rust,
@@ -1026,7 +1026,7 @@ fn variant(&self, span: Span, name: Ident, tys: Vec<P<ast::Ty>> ) -> ast::Varian
     fn item_enum_poly(&self, span: Span, name: Ident,
                       enum_definition: ast::EnumDef,
                       generics: Generics) -> P<ast::Item> {
-        self.item(span, name, Vec::new(), ast::ItemEnum(enum_definition, generics))
+        self.item(span, name, Vec::new(), ast::ItemKind::Enum(enum_definition, generics))
     }
 
     fn item_enum(&self, span: Span, name: Ident,
@@ -1047,7 +1047,7 @@ fn item_struct(&self, span: Span, name: Ident,
 
     fn item_struct_poly(&self, span: Span, name: Ident,
         struct_def: ast::VariantData, generics: Generics) -> P<ast::Item> {
-        self.item(span, name, Vec::new(), ast::ItemStruct(struct_def, generics))
+        self.item(span, name, Vec::new(), ast::ItemKind::Struct(struct_def, generics))
     }
 
     fn item_mod(&self, span: Span, inner_span: Span, name: Ident,
@@ -1057,7 +1057,7 @@ fn item_mod(&self, span: Span, inner_span: Span, name: Ident,
             span,
             name,
             attrs,
-            ast::ItemMod(ast::Mod {
+            ast::ItemKind::Mod(ast::Mod {
                 inner: inner_span,
                 items: items,
             })
@@ -1071,7 +1071,7 @@ fn item_static(&self,
                    mutbl: ast::Mutability,
                    expr: P<ast::Expr>)
                    -> P<ast::Item> {
-        self.item(span, name, Vec::new(), ast::ItemStatic(ty, mutbl, expr))
+        self.item(span, name, Vec::new(), ast::ItemKind::Static(ty, mutbl, expr))
     }
 
     fn item_const(&self,
@@ -1080,12 +1080,12 @@ fn item_const(&self,
                   ty: P<ast::Ty>,
                   expr: P<ast::Expr>)
                   -> P<ast::Item> {
-        self.item(span, name, Vec::new(), ast::ItemConst(ty, expr))
+        self.item(span, name, Vec::new(), ast::ItemKind::Const(ty, expr))
     }
 
     fn item_ty_poly(&self, span: Span, name: Ident, ty: P<ast::Ty>,
                     generics: Generics) -> P<ast::Item> {
-        self.item(span, name, Vec::new(), ast::ItemTy(ty, generics))
+        self.item(span, name, Vec::new(), ast::ItemKind::Ty(ty, generics))
     }
 
     fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> P<ast::Item> {
@@ -1125,7 +1125,7 @@ fn item_use(&self, sp: Span,
             id: ast::DUMMY_NODE_ID,
             ident: special_idents::invalid,
             attrs: vec![],
-            node: ast::ItemUse(vp),
+            node: ast::ItemKind::Use(vp),
             vis: vis,
             span: sp
         })

diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 78bc4e2c73520dfd4a25e266413baecd83dd3b22..bcd02fb8cb3cd345dbcb4facdb438e72c0b47a04 100644 (file)
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -10,7 +10,7 @@
 
 use ast::{Block, Crate, DeclKind, PatMac};
 use ast::{Local, Ident, Mac_, Name};
-use ast::{ItemMac, MacStmtWithSemicolon, Mrk, Stmt, StmtKind};
+use ast::{MacStmtStyle, Mrk, Stmt, StmtKind, ItemKind};
 use ast::TokenTree;
 use ast;
 use ext::mtwt;
@@ -315,17 +315,17 @@ pub fn expand_item(it: P<ast::Item>, fld: &mut MacroExpander)
         .into_iter().map(|i| i.expect_item()).collect()
 }
 
-/// Expand item_underscore
-fn expand_item_underscore(item: ast::Item_, fld: &mut MacroExpander) -> ast::Item_ {
+/// Expand item_kind
+fn expand_item_kind(item: ast::ItemKind, fld: &mut MacroExpander) -> ast::ItemKind {
     match item {
-        ast::ItemFn(decl, unsafety, constness, abi, generics, body) => {
+        ast::ItemKind::Fn(decl, unsafety, constness, abi, generics, body) => {
             let (rewritten_fn_decl, rewritten_body)
                 = expand_and_rename_fn_decl_and_block(decl, body, fld);
             let expanded_generics = fold::noop_fold_generics(generics,fld);
-            ast::ItemFn(rewritten_fn_decl, unsafety, constness, abi,
+            ast::ItemKind::Fn(rewritten_fn_decl, unsafety, constness, abi,
                         expanded_generics, rewritten_body)
         }
-        _ => noop_fold_item_underscore(item, fld)
+        _ => noop_fold_item_kind(item, fld)
     }
 }
 
@@ -362,7 +362,7 @@ fn contains_macro_use(fld: &mut MacroExpander, attrs: &[ast::Attribute]) -> bool
 pub fn expand_item_mac(it: P<ast::Item>,
                        fld: &mut MacroExpander) -> SmallVector<P<ast::Item>> {
     let (extname, path_span, tts, span, attrs, ident) = it.and_then(|it| match it.node {
-        ItemMac(codemap::Spanned { node: Mac_ { path, tts, .. }, .. }) =>
+        ItemKind::Mac(codemap::Spanned { node: Mac_ { path, tts, .. }, .. }) =>
             (path.segments[0].identifier.name, path.span, tts, it.span, it.attrs, it.ident),
         _ => fld.cx.span_bug(it.span, "invalid item macro invocation")
     });
@@ -890,10 +890,10 @@ fn expand_annotatable(a: Annotatable,
 
     let mut new_items: SmallVector<Annotatable> = match a {
         Annotatable::Item(it) => match it.node {
-            ast::ItemMac(..) => {
+            ast::ItemKind::Mac(..) => {
                 expand_item_mac(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
             }
-            ast::ItemMod(_) | ast::ItemForeignMod(_) => {
+            ast::ItemKind::Mod(_) | ast::ItemKind::ForeignMod(_) => {
                 let valid_ident =
                     it.ident.name != parse::token::special_idents::invalid.name;
 
@@ -1048,7 +1048,7 @@ fn expand_item_multi_modifier(mut it: Annotatable,
         }
     }
 
-    // Expansion may have added new ItemModifiers.
+    // Expansion may have added new ItemKind::Modifiers.
     expand_item_multi_modifier(it, fld)
 }
 
@@ -1194,8 +1194,8 @@ fn fold_item(&mut self, item: P<ast::Item>) -> SmallVector<P<ast::Item>> {
         expand_item(item, self)
     }
 
-    fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ {
-        expand_item_underscore(item, self)
+    fn fold_item_kind(&mut self, item: ast::ItemKind) -> ast::ItemKind {
+        expand_item_kind(item, self)
     }
 
     fn fold_stmt(&mut self, stmt: P<ast::Stmt>) -> SmallVector<P<ast::Stmt>> {

diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index 17eb43e2068a702a65b4c1876b4cd1753953000c..6dc0da1eb09d78ce73a2f861e1970d0a7f2a0803 100644 (file)
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -855,7 +855,7 @@ fn visit_name(&mut self, sp: Span, name: ast::Name) {
 
     fn visit_item(&mut self, i: &ast::Item) {
         match i.node {
-            ast::ItemExternCrate(_) => {
+            ast::ItemKind::ExternCrate(_) => {
                 if attr::contains_name(&i.attrs[..], "macro_reexport") {
                     self.gate_feature("macro_reexport", i.span,
                                       "macros reexports are experimental \
@@ -863,7 +863,7 @@ fn visit_item(&mut self, i: &ast::Item) {
                 }
             }
 
-            ast::ItemForeignMod(ref foreign_module) => {
+            ast::ItemKind::ForeignMod(ref foreign_module) => {
                 if attr::contains_name(&i.attrs[..], "link_args") {
                     self.gate_feature("link_args", i.span,
                                       "the `link_args` attribute is not portable \
@@ -888,7 +888,7 @@ fn visit_item(&mut self, i: &ast::Item) {
                 }
             }
 
-            ast::ItemFn(..) => {
+            ast::ItemKind::Fn(..) => {
                 if attr::contains_name(&i.attrs[..], "plugin_registrar") {
                     self.gate_feature("plugin_registrar", i.span,
                                       "compiler plugins are experimental and possibly buggy");
@@ -907,7 +907,7 @@ fn visit_item(&mut self, i: &ast::Item) {
                 }
             }
 
-            ast::ItemStruct(..) => {
+            ast::ItemKind::Struct(..) => {
                 if attr::contains_name(&i.attrs[..], "simd") {
                     self.gate_feature("simd", i.span,
                                       "SIMD types are experimental and possibly buggy");
@@ -928,14 +928,14 @@ fn visit_item(&mut self, i: &ast::Item) {
                 }
             }
 
-            ast::ItemDefaultImpl(..) => {
+            ast::ItemKind::DefaultImpl(..) => {
                 self.gate_feature("optin_builtin_traits",
                                   i.span,
                                   "default trait implementations are experimental \
                                    and possibly buggy");
             }
 
-            ast::ItemImpl(_, polarity, _, _, _, _) => {
+            ast::ItemKind::Impl(_, polarity, _, _, _, _) => {
                 match polarity {
                     ast::ImplPolarity::Negative => {
                         self.gate_feature("optin_builtin_traits",

diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 8c39c48bbc792d23feaf01ab4745112b2d8eaf8b..8bb915362e80d3966d1fb0f2ebccac813663d13e 100644 (file)
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -71,8 +71,8 @@ fn fold_struct_field(&mut self, sf: StructField) -> StructField {
         noop_fold_struct_field(sf, self)
     }
 
-    fn fold_item_underscore(&mut self, i: Item_) -> Item_ {
-        noop_fold_item_underscore(i, self)
+    fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind {
+        noop_fold_item_kind(i, self)
     }
 
     fn fold_trait_item(&mut self, i: P<TraitItem>) -> SmallVector<P<TraitItem>> {
@@ -890,20 +890,20 @@ pub fn noop_fold_block<T: Folder>(b: P<Block>, folder: &mut T) -> P<Block> {
     })
 }
 
-pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
+pub fn noop_fold_item_kind<T: Folder>(i: ItemKind, folder: &mut T) -> ItemKind {
     match i {
-        ItemExternCrate(string) => ItemExternCrate(string),
-        ItemUse(view_path) => {
-            ItemUse(folder.fold_view_path(view_path))
+        ItemKind::ExternCrate(string) => ItemKind::ExternCrate(string),
+        ItemKind::Use(view_path) => {
+            ItemKind::Use(folder.fold_view_path(view_path))
         }
-        ItemStatic(t, m, e) => {
-            ItemStatic(folder.fold_ty(t), m, folder.fold_expr(e))
+        ItemKind::Static(t, m, e) => {
+            ItemKind::Static(folder.fold_ty(t), m, folder.fold_expr(e))
         }
-        ItemConst(t, e) => {
-            ItemConst(folder.fold_ty(t), folder.fold_expr(e))
+        ItemKind::Const(t, e) => {
+            ItemKind::Const(folder.fold_ty(t), folder.fold_expr(e))
         }
-        ItemFn(decl, unsafety, constness, abi, generics, body) => {
-            ItemFn(
+        ItemKind::Fn(decl, unsafety, constness, abi, generics, body) => {
+            ItemKind::Fn(
                 folder.fold_fn_decl(decl),
                 unsafety,
                 constness,
@@ -912,26 +912,26 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
                 folder.fold_block(body)
             )
         }
-        ItemMod(m) => ItemMod(folder.fold_mod(m)),
-        ItemForeignMod(nm) => ItemForeignMod(folder.fold_foreign_mod(nm)),
-        ItemTy(t, generics) => {
-            ItemTy(folder.fold_ty(t), folder.fold_generics(generics))
+        ItemKind::Mod(m) => ItemKind::Mod(folder.fold_mod(m)),
+        ItemKind::ForeignMod(nm) => ItemKind::ForeignMod(folder.fold_foreign_mod(nm)),
+        ItemKind::Ty(t, generics) => {
+            ItemKind::Ty(folder.fold_ty(t), folder.fold_generics(generics))
         }
-        ItemEnum(enum_definition, generics) => {
-            ItemEnum(
+        ItemKind::Enum(enum_definition, generics) => {
+            ItemKind::Enum(
                 ast::EnumDef {
                     variants: enum_definition.variants.move_map(|x| folder.fold_variant(x)),
                 },
                 folder.fold_generics(generics))
         }
-        ItemStruct(struct_def, generics) => {
+        ItemKind::Struct(struct_def, generics) => {
             let struct_def = folder.fold_variant_data(struct_def);
-            ItemStruct(struct_def, folder.fold_generics(generics))
+            ItemKind::Struct(struct_def, folder.fold_generics(generics))
         }
-        ItemDefaultImpl(unsafety, ref trait_ref) => {
-            ItemDefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
+        ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
+            ItemKind::DefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
         }
-        ItemImpl(unsafety, polarity, generics, ifce, ty, impl_items) => {
+        ItemKind::Impl(unsafety, polarity, generics, ifce, ty, impl_items) => {
             let new_impl_items = impl_items.move_flat_map(|item| {
                 folder.fold_impl_item(item)
             });
@@ -941,24 +941,24 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
                     Some(folder.fold_trait_ref((*trait_ref).clone()))
                 }
             };
-            ItemImpl(unsafety,
+            ItemKind::Impl(unsafety,
                      polarity,
                      folder.fold_generics(generics),
                      ifce,
                      folder.fold_ty(ty),
                      new_impl_items)
         }
-        ItemTrait(unsafety, generics, bounds, items) => {
+        ItemKind::Trait(unsafety, generics, bounds, items) => {
             let bounds = folder.fold_bounds(bounds);
             let items = items.move_flat_map(|item| {
                 folder.fold_trait_item(item)
             });
-            ItemTrait(unsafety,
+            ItemKind::Trait(unsafety,
                       folder.fold_generics(generics),
                       bounds,
                       items)
         }
-        ItemMac(m) => ItemMac(folder.fold_mac(m)),
+        ItemKind::Mac(m) => ItemKind::Mac(folder.fold_mac(m)),
     }
 }
 
@@ -1025,7 +1025,7 @@ pub fn noop_fold_crate<T: Folder>(Crate {module, attrs, config, mut exported_mac
         id: ast::DUMMY_NODE_ID,
         vis: ast::Public,
         span: span,
-        node: ast::ItemMod(module),
+        node: ast::ItemKind::Mod(module),
     })).into_iter();
 
     let (module, attrs, span) = match items.next() {
@@ -1034,7 +1034,7 @@ pub fn noop_fold_crate<T: Folder>(Crate {module, attrs, config, mut exported_mac
                     "a crate cannot expand to more than one item");
             item.and_then(|ast::Item { attrs, span, node, .. }| {
                 match node {
-                    ast::ItemMod(m) => (m, attrs, span),
+                    ast::ItemKind::Mod(m) => (m, attrs, span),
                     _ => panic!("fold converted a module to not a module"),
                 }
             })
@@ -1067,10 +1067,10 @@ pub fn noop_fold_item<T: Folder>(i: P<Item>, folder: &mut T) -> SmallVector<P<It
 pub fn noop_fold_item_simple<T: Folder>(Item {id, ident, attrs, node, vis, span}: Item,
                                         folder: &mut T) -> Item {
     let id = folder.new_id(id);
-    let node = folder.fold_item_underscore(node);
+    let node = folder.fold_item_kind(node);
     let ident = match node {
         // The node may have changed, recompute the "pretty" impl name.
-        ItemImpl(_, _, _, ref maybe_trait, ref ty, _) => {
+        ItemKind::Impl(_, _, _, ref maybe_trait, ref ty, _) => {
             ast_util::impl_pretty_name(maybe_trait, Some(&**ty))
         }
         _ => ident

diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 2bbf1699662f870a94480ad4abcb75640c2f1c0a..a505b27e9db09500b2a39bc1880b9f33dbf647ef 100644 (file)
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -913,7 +913,7 @@ fn parser_done(p: Parser){
                       P(ast::Item{ident:str_to_ident("a"),
                             attrs:Vec::new(),
                             id: ast::DUMMY_NODE_ID,
-                            node: ast::ItemFn(P(ast::FnDecl {
+                            node: ast::ItemKind::Fn(P(ast::FnDecl {
                                 inputs: vec!(ast::Arg{
                                     ty: P(ast::Ty{id: ast::DUMMY_NODE_ID,
                                                   node: ast::TyKind::Path(None, ast::Path{

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 4faad48f5b76e20b72b04ac1e91442993ab59c18..4133c024f85668411f2a1a093abf9582ed5c532d 100644 (file)
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -23,10 +23,7 @@
 use ast::{Expr, ExprKind};
 use ast::{Field, FnDecl};
 use ast::{ForeignItem, ForeignItemKind, FunctionRetTy};
-use ast::{Ident, Inherited, ImplItem, Item, Item_, ItemStatic};
-use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemConst};
-use ast::{ItemMac, ItemMod, ItemStruct, ItemTrait, ItemTy, ItemDefaultImpl};
-use ast::{ItemExternCrate, ItemUse};
+use ast::{Ident, Inherited, ImplItem, Item, ItemKind};
 use ast::{Lit, LitKind, UintTy};
 use ast::Local;
 use ast::{MacStmtWithBraces, MacStmtWithSemicolon, MacStmtWithoutBraces};
@@ -80,7 +77,7 @@
     }
 }
 
-type ItemInfo = (Ident, Item_, Option<Vec<Attribute> >);
+type ItemInfo = (Ident, ItemKind, Option<Vec<Attribute> >);
 
 /// How to parse a path. There are four different kinds of paths, all of which
 /// are parsed somewhat differently.
@@ -3750,7 +3747,7 @@ fn parse_stmt_(&mut self) -> PResult<'a, Option<Stmt>> {
                     P(spanned(lo, hi, DeclKind::Item(
                         self.mk_item(
                             lo, hi, id /*id is good here*/,
-                            ItemMac(spanned(lo, hi,
+                            ItemKind::Mac(spanned(lo, hi,
                                             Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT })),
                             Inherited, attrs)))),
                     ast::DUMMY_NODE_ID))
@@ -4590,7 +4587,7 @@ fn parse_fn_header(&mut self) -> PResult<'a, (Ident, ast::Generics)> {
     }
 
     fn mk_item(&mut self, lo: BytePos, hi: BytePos, ident: Ident,
-               node: Item_, vis: Visibility,
+               node: ItemKind, vis: Visibility,
                attrs: Vec<Attribute>) -> P<Item> {
         P(Item {
             ident: ident,
@@ -4612,7 +4609,7 @@ fn parse_item_fn(&mut self,
         let decl = try!(self.parse_fn_decl(false));
         generics.where_clause = try!(self.parse_where_clause());
         let (inner_attrs, body) = try!(self.parse_inner_attrs_and_block());
-        Ok((ident, ItemFn(decl, unsafety, constness, abi, generics, body), Some(inner_attrs)))
+        Ok((ident, ItemKind::Fn(decl, unsafety, constness, abi, generics, body), Some(inner_attrs)))
     }
 
     /// true if we are looking at `const ID`, false for things like `const fn` etc
@@ -4772,7 +4769,7 @@ fn parse_item_trait(&mut self, unsafety: Unsafety) -> PResult<'a, ItemInfo> {
         tps.where_clause = try!(self.parse_where_clause());
 
         let meths = try!(self.parse_trait_items());
-        Ok((ident, ItemTrait(unsafety, tps, bounds, meths), None))
+        Ok((ident, ItemKind::Trait(unsafety, tps, bounds, meths), None))
     }
 
     /// Parses items implementations variants
@@ -4835,7 +4832,7 @@ fn parse_item_impl(&mut self, unsafety: ast::Unsafety) -> PResult<'a, ItemInfo>
             try!(self.expect(&token::OpenDelim(token::Brace)));
             try!(self.expect(&token::CloseDelim(token::Brace)));
             Ok((ast_util::impl_pretty_name(&opt_trait, None),
-             ItemDefaultImpl(unsafety, opt_trait.unwrap()), None))
+             ItemKind::DefaultImpl(unsafety, opt_trait.unwrap()), None))
         } else {
             if opt_trait.is_some() {
                 ty = try!(self.parse_ty_sum());
@@ -4851,7 +4848,7 @@ fn parse_item_impl(&mut self, unsafety: ast::Unsafety) -> PResult<'a, ItemInfo>
             }
 
             Ok((ast_util::impl_pretty_name(&opt_trait, Some(&*ty)),
-             ItemImpl(unsafety, polarity, generics, opt_trait, ty, impl_items),
+             ItemKind::Impl(unsafety, polarity, generics, opt_trait, ty, impl_items),
              Some(attrs)))
         }
     }
@@ -4936,7 +4933,7 @@ fn parse_item_struct(&mut self) -> PResult<'a, ItemInfo> {
                                             name, found `{}`", token_str)))
         };
 
-        Ok((class_name, ItemStruct(vdata, generics), None))
+        Ok((class_name, ItemKind::Struct(vdata, generics), None))
     }
 
     pub fn parse_record_struct_body(&mut self,
@@ -5066,8 +5063,8 @@ fn parse_item_const(&mut self, m: Option<Mutability>) -> PResult<'a, ItemInfo> {
         let e = try!(self.parse_expr());
         try!(self.commit_expr_expecting(&*e, token::Semi));
         let item = match m {
-            Some(m) => ItemStatic(ty, m, e),
-            None => ItemConst(ty, e),
+            Some(m) => ItemKind::Static(ty, m, e),
+            None => ItemKind::Const(ty, e),
         };
         Ok((id, item, None))
     }
@@ -5091,7 +5088,7 @@ fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> PResult<'a, ItemInfo>
             let m = try!(self.parse_mod_items(&token::CloseDelim(token::Brace), mod_inner_lo));
             self.owns_directory = old_owns_directory;
             self.pop_mod_path();
-            Ok((id, ItemMod(m), Some(attrs)))
+            Ok((id, ItemKind::Mod(m), Some(attrs)))
         }
     }
 
@@ -5197,7 +5194,7 @@ fn eval_src_mod(&mut self,
                     id: ast::Ident,
                     outer_attrs: &[ast::Attribute],
                     id_sp: Span)
-                    -> PResult<'a, (ast::Item_, Vec<ast::Attribute> )> {
+                    -> PResult<'a, (ast::ItemKind, Vec<ast::Attribute> )> {
         let ModulePathSuccess { path, owns_directory } = try!(self.submod_path(id,
                                                                                outer_attrs,
                                                                                id_sp));
@@ -5212,7 +5209,7 @@ fn eval_src_mod_from_path(&mut self,
                               path: PathBuf,
                               owns_directory: bool,
                               name: String,
-                              id_sp: Span) -> PResult<'a, (ast::Item_, Vec<ast::Attribute> )> {
+                              id_sp: Span) -> PResult<'a, (ast::ItemKind, Vec<ast::Attribute> )> {
         let mut included_mod_stack = self.sess.included_mod_stack.borrow_mut();
         match included_mod_stack.iter().position(|p| *p == path) {
             Some(i) => {
@@ -5240,7 +5237,7 @@ fn eval_src_mod_from_path(&mut self,
         let mod_attrs = try!(p0.parse_inner_attributes());
         let m0 = try!(p0.parse_mod_items(&token::Eof, mod_inner_lo));
         self.sess.included_mod_stack.borrow_mut().pop();
-        Ok((ast::ItemMod(m0), mod_attrs))
+        Ok((ast::ItemKind::Mod(m0), mod_attrs))
     }
 
     /// Parse a function declaration from a foreign module
@@ -5315,7 +5312,7 @@ fn parse_item_extern_crate(&mut self,
         Ok(self.mk_item(lo,
                         last_span.hi,
                         ident,
-                        ItemExternCrate(maybe_path),
+                        ItemKind::ExternCrate(maybe_path),
                         visibility,
                         attrs))
     }
@@ -5356,7 +5353,7 @@ fn parse_item_foreign_mod(&mut self,
         Ok(self.mk_item(lo,
                      last_span.hi,
                      special_idents::invalid,
-                     ItemForeignMod(m),
+                     ItemKind::ForeignMod(m),
                      visibility,
                      attrs))
     }
@@ -5369,7 +5366,7 @@ fn parse_item_type(&mut self) -> PResult<'a, ItemInfo> {
         try!(self.expect(&token::Eq));
         let ty = try!(self.parse_ty_sum());
         try!(self.expect(&token::Semi));
-        Ok((ident, ItemTy(ty, tps), None))
+        Ok((ident, ItemKind::Ty(ty, tps), None))
     }
 
     /// Parse the part of an "enum" decl following the '{'
@@ -5430,7 +5427,7 @@ fn parse_item_enum(&mut self) -> PResult<'a, ItemInfo> {
         try!(self.expect(&token::OpenDelim(token::Brace)));
 
         let enum_definition = try!(self.parse_enum_def(&generics));
-        Ok((id, ItemEnum(enum_definition, generics), None))
+        Ok((id, ItemKind::Enum(enum_definition, generics), None))
     }
 
     /// Parses a string as an ABI spec on an extern type or module. Consumes
@@ -5488,7 +5485,7 @@ fn parse_item_(&mut self, attrs: Vec<Attribute>,
 
         if self.eat_keyword(keywords::Use) {
             // USE ITEM
-            let item_ = ItemUse(try!(self.parse_view_path()));
+            let item_ = ItemKind::Use(try!(self.parse_view_path()));
             try!(self.expect(&token::Semi));
 
             let last_span = self.last_span;
@@ -5804,7 +5801,7 @@ fn parse_macro_use_or_failure(
                 }
             }
 
-            let item_ = ItemMac(m);
+            let item_ = ItemKind::Mac(m);
             let last_span = self.last_span;
             let item = self.mk_item(lo,
                                     last_span.hi,

diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index becf2d2bc14415b453ae2b48a2531c3a38818e59..167df26f433fbb91b8e7f50349a4c2399aa659b2 100644 (file)
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1117,7 +1117,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
         try!(self.print_outer_attributes(&item.attrs));
         try!(self.ann.pre(self, NodeItem(item)));
         match item.node {
-            ast::ItemExternCrate(ref optional_path) => {
+            ast::ItemKind::ExternCrate(ref optional_path) => {
                 try!(self.head(&visibility_qualified(item.vis,
                                                      "extern crate")));
                 if let Some(p) = *optional_path {
@@ -1136,7 +1136,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 try!(self.end()); // end inner head-block
                 try!(self.end()); // end outer head-block
             }
-            ast::ItemUse(ref vp) => {
+            ast::ItemKind::Use(ref vp) => {
                 try!(self.head(&visibility_qualified(item.vis,
                                                      "use")));
                 try!(self.print_view_path(&**vp));
@@ -1144,7 +1144,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 try!(self.end()); // end inner head-block
                 try!(self.end()); // end outer head-block
             }
-            ast::ItemStatic(ref ty, m, ref expr) => {
+            ast::ItemKind::Static(ref ty, m, ref expr) => {
                 try!(self.head(&visibility_qualified(item.vis,
                                                     "static")));
                 if m == ast::MutMutable {
@@ -1161,7 +1161,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 try!(word(&mut self.s, ";"));
                 try!(self.end()); // end the outer cbox
             }
-            ast::ItemConst(ref ty, ref expr) => {
+            ast::ItemKind::Const(ref ty, ref expr) => {
                 try!(self.head(&visibility_qualified(item.vis,
                                                     "const")));
                 try!(self.print_ident(item.ident));
@@ -1175,7 +1175,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 try!(word(&mut self.s, ";"));
                 try!(self.end()); // end the outer cbox
             }
-            ast::ItemFn(ref decl, unsafety, constness, abi, ref typarams, ref body) => {
+            ast::ItemKind::Fn(ref decl, unsafety, constness, abi, ref typarams, ref body) => {
                 try!(self.head(""));
                 try!(self.print_fn(
                     decl,
@@ -1190,7 +1190,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 try!(word(&mut self.s, " "));
                 try!(self.print_block_with_attrs(&**body, &item.attrs));
             }
-            ast::ItemMod(ref _mod) => {
+            ast::ItemKind::Mod(ref _mod) => {
                 try!(self.head(&visibility_qualified(item.vis,
                                                     "mod")));
                 try!(self.print_ident(item.ident));
@@ -1199,14 +1199,14 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 try!(self.print_mod(_mod, &item.attrs));
                 try!(self.bclose(item.span));
             }
-            ast::ItemForeignMod(ref nmod) => {
+            ast::ItemKind::ForeignMod(ref nmod) => {
                 try!(self.head("extern"));
                 try!(self.word_nbsp(&nmod.abi.to_string()));
                 try!(self.bopen());
                 try!(self.print_foreign_mod(nmod, &item.attrs));
                 try!(self.bclose(item.span));
             }
-            ast::ItemTy(ref ty, ref params) => {
+            ast::ItemKind::Ty(ref ty, ref params) => {
                 try!(self.ibox(INDENT_UNIT));
                 try!(self.ibox(0));
                 try!(self.word_nbsp(&visibility_qualified(item.vis, "type")));
@@ -1221,7 +1221,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 try!(word(&mut self.s, ";"));
                 try!(self.end()); // end the outer ibox
             }
-            ast::ItemEnum(ref enum_definition, ref params) => {
+            ast::ItemKind::Enum(ref enum_definition, ref params) => {
                 try!(self.print_enum_def(
                     enum_definition,
                     params,
@@ -1230,12 +1230,12 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                     item.vis
                 ));
             }
-            ast::ItemStruct(ref struct_def, ref generics) => {
+            ast::ItemKind::Struct(ref struct_def, ref generics) => {
                 try!(self.head(&visibility_qualified(item.vis,"struct")));
                 try!(self.print_struct(&struct_def, generics, item.ident, item.span, true));
             }
 
-            ast::ItemDefaultImpl(unsafety, ref trait_ref) => {
+            ast::ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
                 try!(self.head(""));
                 try!(self.print_visibility(item.vis));
                 try!(self.print_unsafety(unsafety));
@@ -1247,7 +1247,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 try!(self.bopen());
                 try!(self.bclose(item.span));
             }
-            ast::ItemImpl(unsafety,
+            ast::ItemKind::Impl(unsafety,
                           polarity,
                           ref generics,
                           ref opt_trait,
@@ -1290,7 +1290,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 }
                 try!(self.bclose(item.span));
             }
-            ast::ItemTrait(unsafety, ref generics, ref bounds, ref trait_items) => {
+            ast::ItemKind::Trait(unsafety, ref generics, ref bounds, ref trait_items) => {
                 try!(self.head(""));
                 try!(self.print_visibility(item.vis));
                 try!(self.print_unsafety(unsafety));
@@ -1316,7 +1316,7 @@ pub fn print_item(&mut self, item: &ast::Item) -> io::Result<()> {
                 }
                 try!(self.bclose(item.span));
             }
-            ast::ItemMac(codemap::Spanned { ref node, .. }) => {
+            ast::ItemKind::Mac(codemap::Spanned { ref node, .. }) => {
                 try!(self.print_visibility(item.vis));
                 try!(self.print_path(&node.path, false, 0));
                 try!(word(&mut self.s, "! "));
@@ -1596,7 +1596,7 @@ pub fn print_impl_item(&mut self, ii: &ast::ImplItem) -> io::Result<()> {
                 try!(self.print_associated_type(ii.ident, None, Some(ty)));
             }
             ast::ImplItemKind::Macro(codemap::Spanned { ref node, .. }) => {
-                // code copied from ItemMac:
+                // code copied from ItemKind::Mac:
                 try!(self.print_path(&node.path, false, 0));
                 try!(word(&mut self.s, "! "));
                 try!(self.cbox(INDENT_UNIT));

diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs
index 345adff23443a943b86d5aacf11cd1f87f244470..828896d422cc1d683c80be45f61142d7bc84fe2f 100644 (file)
--- a/src/libsyntax/std_inject.rs
+++ b/src/libsyntax/std_inject.rs
@@ -89,7 +89,7 @@ fn fold_crate(&mut self, mut krate: ast::Crate) -> ast::Crate {
             attrs: vec!(
                 attr::mk_attr_outer(attr::mk_attr_id(), attr::mk_word_item(
                         InternedString::new("macro_use")))),
-            node: ast::ItemExternCrate(Some(self.crate_name)),
+            node: ast::ItemKind::ExternCrate(Some(self.crate_name)),
             vis: ast::Inherited,
             span: DUMMY_SP
         }));
@@ -149,7 +149,7 @@ fn fold_mod(&mut self, mut mod_: ast::Mod) -> ast::Mod {
         mod_.items.insert(0, P(ast::Item {
             id: ast::DUMMY_NODE_ID,
             ident: special_idents::invalid,
-            node: ast::ItemUse(vp),
+            node: ast::ItemKind::Use(vp),
             attrs: vec![ast::Attribute {
                 span: self.span,
                 node: ast::Attribute_ {

diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
index 24890d2cbed783fec6c6ac3bda03c7199eb962ee..a817eb62af8f7f7914f3cc16660958c43dd88098 100644 (file)
--- a/src/libsyntax/test.rs
+++ b/src/libsyntax/test.rs
@@ -125,7 +125,7 @@ fn fold_item(&mut self, i: P<ast::Item>) -> SmallVector<P<ast::Item>> {
 
         let i = if is_test_fn(&self.cx, &*i) || is_bench_fn(&self.cx, &*i) {
             match i.node {
-                ast::ItemFn(_, ast::Unsafety::Unsafe, _, _, _, _) => {
+                ast::ItemKind::Fn(_, ast::Unsafety::Unsafe, _, _, _, _) => {
                     let diag = self.cx.span_diagnostic;
                     panic!(diag.span_fatal(i.span, "unsafe functions cannot be used for tests"));
                 }
@@ -159,7 +159,7 @@ fn fold_item(&mut self, i: P<ast::Item>) -> SmallVector<P<ast::Item>> {
         // We don't want to recurse into anything other than mods, since
         // mods or tests inside of functions will break things
         let res = match i.node {
-            ast::ItemMod(..) => fold::noop_fold_item(i, self),
+            ast::ItemKind::Mod(..) => fold::noop_fold_item(i, self),
             _ => SmallVector::one(i),
         };
         if ident.name != token::special_idents::invalid.name {
@@ -262,7 +262,7 @@ fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>,
         ident: sym.clone(),
         attrs: Vec::new(),
         id: ast::DUMMY_NODE_ID,
-        node: ast::ItemMod(reexport_mod),
+        node: ast::ItemKind::Mod(reexport_mod),
         vis: ast::Public,
         span: DUMMY_SP,
     });
@@ -355,7 +355,7 @@ fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
 
     fn has_test_signature(i: &ast::Item) -> HasTestSignature {
         match i.node {
-          ast::ItemFn(ref decl, _, _, _, ref generics, _) => {
+          ast::ItemKind::Fn(ref decl, _, _, _, ref generics, _) => {
             let no_output = match decl.output {
                 ast::FunctionRetTy::Default(..) => true,
                 ast::FunctionRetTy::Ty(ref t) if t.node == ast::TyKind::Tup(vec![]) => true,
@@ -391,7 +391,7 @@ fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
 
     fn has_test_signature(i: &ast::Item) -> bool {
         match i.node {
-            ast::ItemFn(ref decl, _, _, _, ref generics, _) => {
+            ast::ItemKind::Fn(ref decl, _, _, _, ref generics, _) => {
                 let input_cnt = decl.inputs.len();
                 let no_output = match decl.output {
                     ast::FunctionRetTy::Default(..) => true,
@@ -453,12 +453,12 @@ fn main() {
 fn mk_std(cx: &TestCtxt) -> P<ast::Item> {
     let id_test = token::str_to_ident("test");
     let (vi, vis, ident) = if cx.is_test_crate {
-        (ast::ItemUse(
+        (ast::ItemKind::Use(
             P(nospan(ast::ViewPathSimple(id_test,
                                          path_node(vec!(id_test)))))),
          ast::Public, token::special_idents::invalid)
     } else {
-        (ast::ItemExternCrate(None), ast::Inherited, id_test)
+        (ast::ItemKind::ExternCrate(None), ast::Inherited, id_test)
     };
     P(ast::Item {
         id: ast::DUMMY_NODE_ID,
@@ -496,7 +496,7 @@ fn mk_main(cx: &mut TestCtxt) -> P<ast::Item> {
     // pub fn main() { ... }
     let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(vec![]));
     let main_body = ecx.block_all(sp, vec![call_test_main], None);
-    let main = ast::ItemFn(ecx.fn_decl(vec![], main_ret_ty),
+    let main = ast::ItemKind::Fn(ecx.fn_decl(vec![], main_ret_ty),
                            ast::Unsafety::Normal,
                            ast::Constness::NotConst,
                            ::abi::Abi::Rust, ast::Generics::default(), main_body);
@@ -527,7 +527,7 @@ fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<P<ast::Item>>) {
         inner: DUMMY_SP,
         items: vec![import, mainfn, tests],
     };
-    let item_ = ast::ItemMod(testmod);
+    let item_ = ast::ItemKind::Mod(testmod);
 
     let mod_ident = token::gensym_ident("__test");
     let item = P(ast::Item {
@@ -550,7 +550,7 @@ fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<P<ast::Item>>) {
             id: ast::DUMMY_NODE_ID,
             ident: token::special_idents::invalid,
             attrs: vec![],
-            node: ast::ItemUse(P(use_path)),
+            node: ast::ItemKind::Use(P(use_path)),
             vis: ast::Inherited,
             span: DUMMY_SP
         })

diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 54b3eccefc65fc099602b6adf47ab8a8c0aa1979..4082bcbe38e76a3f94d6f66741606b9611680a0e 100644 (file)
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -230,10 +230,10 @@ pub fn walk_trait_ref<'v,V>(visitor: &mut V,
 pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
     visitor.visit_ident(item.span, item.ident);
     match item.node {
-        ItemExternCrate(opt_name) => {
+        ItemKind::ExternCrate(opt_name) => {
             walk_opt_name(visitor, item.span, opt_name)
         }
-        ItemUse(ref vp) => {
+        ItemKind::Use(ref vp) => {
             match vp.node {
                 ViewPathSimple(ident, ref path) => {
                     visitor.visit_ident(vp.span, ident);
@@ -253,12 +253,12 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
                 }
             }
         }
-        ItemStatic(ref typ, _, ref expr) |
-        ItemConst(ref typ, ref expr) => {
+        ItemKind::Static(ref typ, _, ref expr) |
+        ItemKind::Const(ref typ, ref expr) => {
             visitor.visit_ty(typ);
             visitor.visit_expr(expr);
         }
-        ItemFn(ref declaration, unsafety, constness, abi, ref generics, ref body) => {
+        ItemKind::Fn(ref declaration, unsafety, constness, abi, ref generics, ref body) => {
             visitor.visit_fn(FnKind::ItemFn(item.ident, generics, unsafety,
                                             constness, abi, item.vis),
                              declaration,
@@ -266,24 +266,24 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
                              item.span,
                              item.id)
         }
-        ItemMod(ref module) => {
+        ItemKind::Mod(ref module) => {
             visitor.visit_mod(module, item.span, item.id)
         }
-        ItemForeignMod(ref foreign_module) => {
+        ItemKind::ForeignMod(ref foreign_module) => {
             walk_list!(visitor, visit_foreign_item, &foreign_module.items);
         }
-        ItemTy(ref typ, ref type_parameters) => {
+        ItemKind::Ty(ref typ, ref type_parameters) => {
             visitor.visit_ty(typ);
             visitor.visit_generics(type_parameters)
         }
-        ItemEnum(ref enum_definition, ref type_parameters) => {
+        ItemKind::Enum(ref enum_definition, ref type_parameters) => {
             visitor.visit_generics(type_parameters);
             visitor.visit_enum_def(enum_definition, type_parameters, item.id, item.span)
         }
-        ItemDefaultImpl(_, ref trait_ref) => {
+        ItemKind::DefaultImpl(_, ref trait_ref) => {
             visitor.visit_trait_ref(trait_ref)
         }
-        ItemImpl(_, _,
+        ItemKind::Impl(_, _,
                  ref type_parameters,
                  ref opt_trait_reference,
                  ref typ,
@@ -293,17 +293,17 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
             visitor.visit_ty(typ);
             walk_list!(visitor, visit_impl_item, impl_items);
         }
-        ItemStruct(ref struct_definition, ref generics) => {
+        ItemKind::Struct(ref struct_definition, ref generics) => {
             visitor.visit_generics(generics);
             visitor.visit_variant_data(struct_definition, item.ident,
                                      generics, item.id, item.span);
         }
-        ItemTrait(_, ref generics, ref bounds, ref methods) => {
+        ItemKind::Trait(_, ref generics, ref bounds, ref methods) => {
             visitor.visit_generics(generics);
             walk_list!(visitor, visit_ty_param_bound, bounds);
             walk_list!(visitor, visit_trait_item, methods);
         }
-        ItemMac(ref mac) => visitor.visit_mac(mac),
+        ItemKind::Mac(ref mac) => visitor.visit_mac(mac),
     }
     walk_list!(visitor, visit_attribute, &item.attrs);
 }

diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
index e54ff637f25a8f04a1afc94129e1ec6bc6725a18..51091b84672704b02ec6f9aca147ddfc1a2a7b89 100644 (file)
--- a/src/libsyntax_ext/deriving/generic/mod.rs
+++ b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -391,13 +391,13 @@ pub fn expand(&self,
         match *item {
             Annotatable::Item(ref item) => {
                 let newitem = match item.node {
-                    ast::ItemStruct(ref struct_def, ref generics) => {
+                    ast::ItemKind::Struct(ref struct_def, ref generics) => {
                         self.expand_struct_def(cx,
                                                &struct_def,
                                                item.ident,
                                                generics)
                     }
-                    ast::ItemEnum(ref enum_def, ref generics) => {
+                    ast::ItemKind::Enum(ref enum_def, ref generics) => {
                         self.expand_enum_def(cx,
                                              enum_def,
                                              &item.attrs,
@@ -637,12 +637,12 @@ fn create_derived_impl(&self,
             self.span,
             ident,
             a,
-            ast::ItemImpl(unsafety,
-                          ast::ImplPolarity::Positive,
-                          trait_generics,
-                          opt_trait_ref,
-                          self_type,
-                          methods.into_iter().chain(associated_types).collect()))
+            ast::ItemKind::Impl(unsafety,
+                                ast::ImplPolarity::Positive,
+                                trait_generics,
+                                opt_trait_ref,
+                                self_type,
+                                methods.into_iter().chain(associated_types).collect()))
     }
 
     fn expand_struct_def(&self,

diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs
index 831a6250c9fccff2b1457910d14f373a972294b3..a5ad143f15b56dd0e4bfc21d9533bdecefbf5366 100644 (file)
--- a/src/libsyntax_ext/format.rs
+++ b/src/libsyntax_ext/format.rs
@@ -453,7 +453,7 @@ fn static_array(ecx: &mut ExtCtxt,
             ast::MutImmutable);
         let slice = ecx.expr_vec_slice(sp, pieces);
         // static instead of const to speed up codegen by not requiring this to be inlined
-        let st = ast::ItemStatic(ty, ast::MutImmutable, slice);
+        let st = ast::ItemKind::Static(ty, ast::MutImmutable, slice);
 
         let name = ecx.ident_of(name);
         let item = ecx.item(sp, name, vec![], st);

diff --git a/src/test/auxiliary/macro_crate_test.rs b/src/test/auxiliary/macro_crate_test.rs
index fe61c80b4c3821680f2a66319bb9e58d782604a3..2c68296b634d2da94360c7bbe4b36610d1c1d09c 100644 (file)
--- a/src/test/auxiliary/macro_crate_test.rs
+++ b/src/test/auxiliary/macro_crate_test.rs
@@ -16,7 +16,7 @@
 extern crate rustc;
 extern crate rustc_plugin;
 
-use syntax::ast::{self, TokenTree, Item, MetaItem, ImplItem, TraitItem};
+use syntax::ast::{self, TokenTree, Item, MetaItem, ImplItem, TraitItem, ItemKind};
 use syntax::codemap::Span;
 use syntax::ext::base::*;
 use syntax::parse::{self, token};
@@ -73,7 +73,7 @@ fn expand_into_foo_multi(cx: &mut ExtCtxt,
         Annotatable::ImplItem(it) => {
             quote_item!(cx, impl X { fn foo(&self) -> i32 { 42 } }).unwrap().and_then(|i| {
                 match i.node {
-                    ast::ItemImpl(_, _, _, _, _, mut items) => {
+                    ItemKind::Impl(_, _, _, _, _, mut items) => {
                         Annotatable::ImplItem(items.pop().expect("impl method not found"))
                     }
                     _ => unreachable!("impl parsed to something other than impl")
@@ -83,7 +83,7 @@ fn expand_into_foo_multi(cx: &mut ExtCtxt,
         Annotatable::TraitItem(it) => {
             quote_item!(cx, trait X { fn foo(&self) -> i32 { 0 } }).unwrap().and_then(|i| {
                 match i.node {
-                    ast::ItemTrait(_, _, _, mut items) => {
+                    ItemKind::Trait(_, _, _, mut items) => {
                         Annotatable::TraitItem(items.pop().expect("trait method not found"))
                     }
                     _ => unreachable!("trait parsed to something other than trait")