bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

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

Browse source
This commit is contained in:
Oliver 'ker' Schneider 2016-02-09 11:36:51 +01:00 • committed by Oliver Schneider
parent 0d6ddd1903
commit 019614f03d
27 changed files with 230 additions and 233 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/librustc/front/check_attr.rs
View file

@ -26,9 +26,9 @@ enum Target {
impl Target { impl Target {
fn from_item(item: &ast::Item) -> Target { fn from_item(item: &ast::Item) -> Target {
match item.node { match item.node {
ast::ItemFn(..) => Target::Fn, ast::ItemKind::Fn(..) => Target::Fn,
ast::ItemStruct(..) => Target::Struct, ast::ItemKind::Struct(..) => Target::Struct,
ast::ItemEnum(..) => Target::Enum, ast::ItemKind::Enum(..) => Target::Enum,
_ => Target::Other, _ => Target::Other,
} }
} }

8
src/librustc_driver/pretty.rs
View file

@ -600,16 +600,16 @@ impl ReplaceBodyWithLoop {
} }
impl fold::Folder for 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 { match i {
ast::ItemStatic(..) | ast::ItemConst(..) => { ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => {
self.within_static_or_const = true; 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; self.within_static_or_const = false;
return ret; return ret;
} }
_ => { _ => {
fold::noop_fold_item_underscore(i, self) fold::noop_fold_item_kind(i, self)
} }
} }
} }

32
src/librustc_front/lowering.rs
View file

@ -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 { match *i {
ItemExternCrate(string) => hir::ItemExternCrate(string), ItemKind::ExternCrate(string) => hir::ItemExternCrate(string),
ItemUse(ref view_path) => { ItemKind::Use(ref view_path) => {
hir::ItemUse(lower_view_path(lctx, 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), hir::ItemStatic(lower_ty(lctx, t),
lower_mutability(lctx, m), lower_mutability(lctx, m),
lower_expr(lctx, e)) 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)) 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), hir::ItemFn(lower_fn_decl(lctx, decl),
lower_unsafety(lctx, unsafety), lower_unsafety(lctx, unsafety),
lower_constness(lctx, constness), lower_constness(lctx, constness),
@ -676,12 +676,12 @@ pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
lower_generics(lctx, generics), lower_generics(lctx, generics),
lower_block(lctx, body)) lower_block(lctx, body))
} }
ItemMod(ref m) => hir::ItemMod(lower_mod(lctx, m)), ItemKind::Mod(ref m) => hir::ItemMod(lower_mod(lctx, m)),
ItemForeignMod(ref nm) => hir::ItemForeignMod(lower_foreign_mod(lctx, nm)), ItemKind::ForeignMod(ref nm) => hir::ItemForeignMod(lower_foreign_mod(lctx, nm)),
ItemTy(ref t, ref generics) => { ItemKind::Ty(ref t, ref generics) => {
hir::ItemTy(lower_ty(lctx, t), lower_generics(lctx, 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 { hir::ItemEnum(hir::EnumDef {
variants: enum_definition.variants variants: enum_definition.variants
.iter() .iter()
@ -690,15 +690,15 @@ pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
}, },
lower_generics(lctx, generics)) 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); let struct_def = lower_variant_data(lctx, struct_def);
hir::ItemStruct(struct_def, lower_generics(lctx, generics)) 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), hir::ItemDefaultImpl(lower_unsafety(lctx, unsafety),
lower_trait_ref(lctx, trait_ref)) 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() let new_impl_items = impl_items.iter()
.map(|item| lower_impl_item(lctx, item)) .map(|item| lower_impl_item(lctx, item))
.collect(); .collect();
@ -710,7 +710,7 @@ pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
lower_ty(lctx, ty), lower_ty(lctx, ty),
new_impl_items) 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 bounds = lower_bounds(lctx, bounds);
let items = items.iter().map(|item| lower_trait_item(lctx, item)).collect(); let items = items.iter().map(|item| lower_trait_item(lctx, item)).collect();
hir::ItemTrait(lower_unsafety(lctx, unsafety), hir::ItemTrait(lower_unsafety(lctx, unsafety),
@ -718,7 +718,7 @@ pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
bounds, bounds,
items) 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 { 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 { hir::Item {
id: i.id, id: i.id,

2
src/librustc_metadata/creader.rs
View file

@ -157,7 +157,7 @@ impl<'a> CrateReader<'a> {
fn extract_crate_info(&self, i: &ast::Item) -> Option<CrateInfo> { fn extract_crate_info(&self, i: &ast::Item) -> Option<CrateInfo> {
match i.node { match i.node {
ast::ItemExternCrate(ref path_opt) => { ast::ItemKind::ExternCrate(ref path_opt) => {
debug!("resolving extern crate stmt. ident: {} path_opt: {:?}", debug!("resolving extern crate stmt. ident: {} path_opt: {:?}",
i.ident, path_opt); i.ident, path_opt);
let name = match *path_opt { let name = match *path_opt {

4
src/librustc_metadata/macro_import.rs
View file

@ -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 // crate root, because `$crate` won't work properly. Identify these by
// spans, because the crate map isn't set up yet. // spans, because the crate map isn't set up yet.
for item in &krate.module.items { 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); 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) { fn visit_item(&mut self, item: &ast::Item) {
// We're only interested in `extern crate`. // We're only interested in `extern crate`.
match item.node { match item.node {
ast::ItemExternCrate(_) => {} ast::ItemKind::ExternCrate(_) => {}
_ => { _ => {
visit::walk_item(self, item); visit::walk_item(self, item);
return; return;

4
src/librustc_passes/const_fn.rs
View file

@ -78,10 +78,10 @@ impl<'a, 'v> Visitor<'v> for CheckConstFn<'a> {
fn visit_item(&mut self, i: &'v ast::Item) { fn visit_item(&mut self, i: &'v ast::Item) {
visit::walk_item(self, i); visit::walk_item(self, i);
match i.node { match i.node {
ast::ItemConst(_, ref e) => { ast::ItemKind::Const(_, ref e) => {
CheckBlock{ sess: self.sess, kind: "constant"}.visit_expr(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) CheckBlock{ sess: self.sess, kind: "static"}.visit_expr(e)
}, },
_ => {}, _ => {},

25
src/librustc_trans/save/dump_csv.rs
View file

@ -864,9 +864,10 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> { impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) { fn visit_item(&mut self, item: &ast::Item) {
use syntax::ast::ItemKind::*;
self.process_macro_use(item.span, item.id); self.process_macro_use(item.span, item.id);
match item.node { match item.node {
ast::ItemUse(ref use_item) => { Use(ref use_item) => {
match use_item.node { match use_item.node {
ast::ViewPathSimple(ident, ref path) => { ast::ViewPathSimple(ident, ref path) => {
let sub_span = self.span.span_for_last_ident(path.span); let sub_span = self.span.span_for_last_ident(path.span);
@ -950,7 +951,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
} }
} }
} }
ast::ItemExternCrate(ref s) => { ExternCrate(ref s) => {
let location = match *s { let location = match *s {
Some(s) => s.to_string(), Some(s) => s.to_string(),
None => item.ident.to_string(), None => item.ident.to_string(),
@ -968,28 +969,28 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
&location, &location,
self.cur_scope); 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), 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), 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), self.process_static_or_const_item(item, &typ, &expr),
ast::ItemStruct(ref def, ref ty_params) => self.process_struct(item, def, ty_params), Struct(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), Enum(ref def, ref ty_params) => self.process_enum(item, def, ty_params),
ast::ItemImpl(_, _, Impl(_, _,
ref ty_params, ref ty_params,
ref trait_ref, ref trait_ref,
ref typ, ref typ,
ref impl_items) => { ref impl_items) => {
self.process_impl(item, ty_params, trait_ref, &typ, 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), self.process_trait(item, generics, trait_refs, methods),
ast::ItemMod(ref m) => { Mod(ref m) => {
self.process_mod(item); self.process_mod(item);
self.nest(item.id, |v| visit::walk_mod(v, m)); 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 qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
let value = ty_to_string(&**ty); let value = ty_to_string(&**ty);
let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Type); let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Type);
@ -998,7 +999,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
self.visit_ty(&**ty); self.visit_ty(&**ty);
self.process_generic_params(ty_params, item.span, &qualname, item.id); self.process_generic_params(ty_params, item.span, &qualname, item.id);
} }
ast::ItemMac(_) => (), Mac(_) => (),
_ => visit::walk_item(self, item), _ => visit::walk_item(self, item),
} }
} }

12
src/librustc_trans/save/mod.rs
View file

@ -229,7 +229,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
pub fn get_item_data(&self, item: &ast::Item) -> Option<Data> { pub fn get_item_data(&self, item: &ast::Item) -> Option<Data> {
match item.node { match item.node {
ast::ItemFn(..) => { ast::ItemKind::Fn(..) => {
let name = self.tcx.map.path_to_string(item.id); let name = self.tcx.map.path_to_string(item.id);
let qualname = format!("::{}", name); let qualname = format!("::{}", name);
let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Fn); let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Fn);
@ -243,7 +243,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
scope: self.enclosing_scope(item.id), 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)); let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
// If the variable is immutable, save the initialising expression. // If the variable is immutable, save the initialising expression.
@ -264,7 +264,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
type_value: ty_to_string(&typ), 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 qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Const); let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Const);
filter!(self.span_utils, sub_span, item.span, None); filter!(self.span_utils, sub_span, item.span, None);
@ -278,7 +278,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
type_value: ty_to_string(&typ), 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 qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
let cm = self.tcx.sess.codemap(); let cm = self.tcx.sess.codemap();
@ -295,7 +295,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
filename: filename, filename: filename,
})) }))
} }
ast::ItemEnum(..) => { ast::ItemKind::Enum(..) => {
let enum_name = format!("::{}", self.tcx.map.path_to_string(item.id)); let enum_name = format!("::{}", self.tcx.map.path_to_string(item.id));
let val = self.span_utils.snippet(item.span); let val = self.span_utils.snippet(item.span);
let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Enum); let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Enum);
@ -308,7 +308,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
scope: self.enclosing_scope(item.id), 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 mut type_data = None;
let sub_span; let sub_span;

65
src/libsyntax/ast.rs
View file

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

2
src/libsyntax/ast_util.rs
View file

@ -173,7 +173,7 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
self.operation.visit_id(item.id); self.operation.visit_id(item.id);
match item.node { match item.node {
ItemUse(ref view_path) => { ItemKind::Use(ref view_path) => {
match view_path.node { match view_path.node {
ViewPathSimple(_, _) | ViewPathSimple(_, _) |
ViewPathGlob(_) => {} ViewPathGlob(_) => {}

24
src/libsyntax/config.rs
View file

@ -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 { fn fold_foreign_mod(&mut self, foreign_mod: ast::ForeignMod) -> ast::ForeignMod {
fold_foreign_mod(self, foreign_mod) fold_foreign_mod(self, foreign_mod)
} }
fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ { fn fold_item_kind(&mut self, item: ast::ItemKind) -> ast::ItemKind {
fold_item_underscore(self, item) fold_item_kind(self, item)
} }
fn fold_expr(&mut self, expr: P<ast::Expr>) -> P<ast::Expr> { 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 // 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 F: FnMut(&[ast::Attribute]) -> bool
{ {
let item = match item { 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() let impl_items = impl_items.into_iter()
.filter(|ii| (cx.in_cfg)(&ii.attrs)) .filter(|ii| (cx.in_cfg)(&ii.attrs))
.collect(); .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() let methods = methods.into_iter()
.filter(|ti| (cx.in_cfg)(&ti.attrs)) .filter(|ti| (cx.in_cfg)(&ti.attrs))
.collect(); .collect();
ast::ItemTrait(u, a, b, methods) ast::ItemKind::Trait(u, a, b, methods)
} }
ast::ItemStruct(def, generics) => { ast::ItemKind::Struct(def, generics) => {
ast::ItemStruct(fold_struct(cx, 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| { let variants = def.variants.into_iter().filter_map(|v| {
if !(cx.in_cfg)(&v.node.attrs) { if !(cx.in_cfg)(&v.node.attrs) {
None 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(), variants: variants.collect(),
}, generics) }, generics)
} }
item => item, 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 fn fold_struct<F>(cx: &mut Context<F>, vdata: ast::VariantData) -> ast::VariantData where

2
src/libsyntax/diagnostics/plugin.rs
View file

@ -226,7 +226,7 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt,
ident: name.clone(), ident: name.clone(),
attrs: Vec::new(), attrs: Vec::new(),
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ItemConst( node: ast::ItemKind::Const(
ty, ty,
expr, expr,
), ),

4
src/libsyntax/entry.rs
View file

@ -9,7 +9,7 @@
// except according to those terms. // except according to those terms.
use attr; use attr;
use ast::{Item, ItemFn}; use ast::{Item, ItemKind};
pub enum EntryPointType { pub enum EntryPointType {
None, None,
@ -23,7 +23,7 @@ pub enum EntryPointType {
// them in sync. // them in sync.
pub fn entry_point_type(item: &Item, depth: usize) -> EntryPointType { pub fn entry_point_type(item: &Item, depth: usize) -> EntryPointType {
match item.node { match item.node {
ItemFn(..) => { ItemKind::Fn(..) => {
if attr::contains_name(&item.attrs, "start") { if attr::contains_name(&item.attrs, "start") {
EntryPointType::Start EntryPointType::Start
} else if attr::contains_name(&item.attrs, "main") { } else if attr::contains_name(&item.attrs, "main") {

2
src/libsyntax/ext/base.rs
View file

@ -120,7 +120,7 @@ impl<F> MultiItemDecorator for F
} }
} }
// 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 // 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. // 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. // FIXME Decorators should follow the same pattern too.

20
src/libsyntax/ext/build.rs
View file

@ -213,7 +213,7 @@ pub trait AstBuilder {
// items // items
fn item(&self, span: Span, 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; fn arg(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::Arg;
// FIXME unused self // FIXME unused self
@ -951,7 +951,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
} }
fn item(&self, span: Span, name: Ident, 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 // FIXME: Would be nice if our generated code didn't violate
// Rust coding conventions // Rust coding conventions
P(ast::Item { P(ast::Item {
@ -974,7 +974,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
self.item(span, self.item(span,
name, name,
Vec::new(), Vec::new(),
ast::ItemFn(self.fn_decl(inputs, output), ast::ItemKind::Fn(self.fn_decl(inputs, output),
ast::Unsafety::Normal, ast::Unsafety::Normal,
ast::Constness::NotConst, ast::Constness::NotConst,
Abi::Rust, Abi::Rust,
@ -1026,7 +1026,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn item_enum_poly(&self, span: Span, name: Ident, fn item_enum_poly(&self, span: Span, name: Ident,
enum_definition: ast::EnumDef, enum_definition: ast::EnumDef,
generics: Generics) -> P<ast::Item> { 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, fn item_enum(&self, span: Span, name: Ident,
@ -1047,7 +1047,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
fn item_struct_poly(&self, span: Span, name: Ident, fn item_struct_poly(&self, span: Span, name: Ident,
struct_def: ast::VariantData, generics: Generics) -> P<ast::Item> { 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, fn item_mod(&self, span: Span, inner_span: Span, name: Ident,
@ -1057,7 +1057,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
span, span,
name, name,
attrs, attrs,
ast::ItemMod(ast::Mod { ast::ItemKind::Mod(ast::Mod {
inner: inner_span, inner: inner_span,
items: items, items: items,
}) })
@ -1071,7 +1071,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
mutbl: ast::Mutability, mutbl: ast::Mutability,
expr: P<ast::Expr>) expr: P<ast::Expr>)
-> P<ast::Item> { -> 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, fn item_const(&self,
@ -1080,12 +1080,12 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
ty: P<ast::Ty>, ty: P<ast::Ty>,
expr: P<ast::Expr>) expr: P<ast::Expr>)
-> P<ast::Item> { -> 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>, fn item_ty_poly(&self, span: Span, name: Ident, ty: P<ast::Ty>,
generics: Generics) -> P<ast::Item> { 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> { fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> P<ast::Item> {
@ -1125,7 +1125,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
ident: special_idents::invalid, ident: special_idents::invalid,
attrs: vec![], attrs: vec![],
node: ast::ItemUse(vp), node: ast::ItemKind::Use(vp),
vis: vis, vis: vis,
span: sp span: sp
}) })

24
src/libsyntax/ext/expand.rs
View file

@ -10,7 +10,7 @@
use ast::{Block, Crate, DeclKind, PatMac}; use ast::{Block, Crate, DeclKind, PatMac};
use ast::{Local, Ident, Mac_, Name}; 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::TokenTree;
use ast; use ast;
use ext::mtwt; 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() .into_iter().map(|i| i.expect_item()).collect()
} }
/// Expand item_underscore /// Expand item_kind
fn expand_item_underscore(item: ast::Item_, fld: &mut MacroExpander) -> ast::Item_ { fn expand_item_kind(item: ast::ItemKind, fld: &mut MacroExpander) -> ast::ItemKind {
match item { 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) let (rewritten_fn_decl, rewritten_body)
= expand_and_rename_fn_decl_and_block(decl, body, fld); = expand_and_rename_fn_decl_and_block(decl, body, fld);
let expanded_generics = fold::noop_fold_generics(generics,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) 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>, pub fn expand_item_mac(it: P<ast::Item>,
fld: &mut MacroExpander) -> SmallVector<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 { 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), (path.segments[0].identifier.name, path.span, tts, it.span, it.attrs, it.ident),
_ => fld.cx.span_bug(it.span, "invalid item macro invocation") _ => 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 { let mut new_items: SmallVector<Annotatable> = match a {
Annotatable::Item(it) => match it.node { Annotatable::Item(it) => match it.node {
ast::ItemMac(..) => { ast::ItemKind::Mac(..) => {
expand_item_mac(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect() 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 = let valid_ident =
it.ident.name != parse::token::special_idents::invalid.name; 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) expand_item_multi_modifier(it, fld)
} }
@ -1194,8 +1194,8 @@ impl<'a, 'b> Folder for MacroExpander<'a, 'b> {
expand_item(item, self) expand_item(item, self)
} }
fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ { fn fold_item_kind(&mut self, item: ast::ItemKind) -> ast::ItemKind {
expand_item_underscore(item, self) expand_item_kind(item, self)
} }
fn fold_stmt(&mut self, stmt: P<ast::Stmt>) -> SmallVector<P<ast::Stmt>> { fn fold_stmt(&mut self, stmt: P<ast::Stmt>) -> SmallVector<P<ast::Stmt>> {

12
src/libsyntax/feature_gate.rs
View file

@ -855,7 +855,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
fn visit_item(&mut self, i: &ast::Item) { fn visit_item(&mut self, i: &ast::Item) {
match i.node { match i.node {
ast::ItemExternCrate(_) => { ast::ItemKind::ExternCrate(_) => {
if attr::contains_name(&i.attrs[..], "macro_reexport") { if attr::contains_name(&i.attrs[..], "macro_reexport") {
self.gate_feature("macro_reexport", i.span, self.gate_feature("macro_reexport", i.span,
"macros reexports are experimental \ "macros reexports are experimental \
@ -863,7 +863,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
} }
} }
ast::ItemForeignMod(ref foreign_module) => { ast::ItemKind::ForeignMod(ref foreign_module) => {
if attr::contains_name(&i.attrs[..], "link_args") { if attr::contains_name(&i.attrs[..], "link_args") {
self.gate_feature("link_args", i.span, self.gate_feature("link_args", i.span,
"the `link_args` attribute is not portable \ "the `link_args` attribute is not portable \
@ -888,7 +888,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
} }
} }
ast::ItemFn(..) => { ast::ItemKind::Fn(..) => {
if attr::contains_name(&i.attrs[..], "plugin_registrar") { if attr::contains_name(&i.attrs[..], "plugin_registrar") {
self.gate_feature("plugin_registrar", i.span, self.gate_feature("plugin_registrar", i.span,
"compiler plugins are experimental and possibly buggy"); "compiler plugins are experimental and possibly buggy");
@ -907,7 +907,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
} }
} }
ast::ItemStruct(..) => { ast::ItemKind::Struct(..) => {
if attr::contains_name(&i.attrs[..], "simd") { if attr::contains_name(&i.attrs[..], "simd") {
self.gate_feature("simd", i.span, self.gate_feature("simd", i.span,
"SIMD types are experimental and possibly buggy"); "SIMD types are experimental and possibly buggy");
@ -928,14 +928,14 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
} }
} }
ast::ItemDefaultImpl(..) => { ast::ItemKind::DefaultImpl(..) => {
self.gate_feature("optin_builtin_traits", self.gate_feature("optin_builtin_traits",
i.span, i.span,
"default trait implementations are experimental \ "default trait implementations are experimental \
and possibly buggy"); and possibly buggy");
} }
ast::ItemImpl(_, polarity, _, _, _, _) => { ast::ItemKind::Impl(_, polarity, _, _, _, _) => {
match polarity { match polarity {
ast::ImplPolarity::Negative => { ast::ImplPolarity::Negative => {
self.gate_feature("optin_builtin_traits", self.gate_feature("optin_builtin_traits",

62
src/libsyntax/fold.rs
View file

@ -71,8 +71,8 @@ pub trait Folder : Sized {
noop_fold_struct_field(sf, self) noop_fold_struct_field(sf, self)
} }
fn fold_item_underscore(&mut self, i: Item_) -> Item_ { fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind {
noop_fold_item_underscore(i, self) noop_fold_item_kind(i, self)
} }
fn fold_trait_item(&mut self, i: P<TraitItem>) -> SmallVector<P<TraitItem>> { 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 { match i {
ItemExternCrate(string) => ItemExternCrate(string), ItemKind::ExternCrate(string) => ItemKind::ExternCrate(string),
ItemUse(view_path) => { ItemKind::Use(view_path) => {
ItemUse(folder.fold_view_path(view_path)) ItemKind::Use(folder.fold_view_path(view_path))
} }
ItemStatic(t, m, e) => { ItemKind::Static(t, m, e) => {
ItemStatic(folder.fold_ty(t), m, folder.fold_expr(e)) ItemKind::Static(folder.fold_ty(t), m, folder.fold_expr(e))
} }
ItemConst(t, e) => { ItemKind::Const(t, e) => {
ItemConst(folder.fold_ty(t), folder.fold_expr(e)) ItemKind::Const(folder.fold_ty(t), folder.fold_expr(e))
} }
ItemFn(decl, unsafety, constness, abi, generics, body) => { ItemKind::Fn(decl, unsafety, constness, abi, generics, body) => {
ItemFn( ItemKind::Fn(
folder.fold_fn_decl(decl), folder.fold_fn_decl(decl),
unsafety, unsafety,
constness, constness,
@ -912,26 +912,26 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
folder.fold_block(body) folder.fold_block(body)
) )
} }
ItemMod(m) => ItemMod(folder.fold_mod(m)), ItemKind::Mod(m) => ItemKind::Mod(folder.fold_mod(m)),
ItemForeignMod(nm) => ItemForeignMod(folder.fold_foreign_mod(nm)), ItemKind::ForeignMod(nm) => ItemKind::ForeignMod(folder.fold_foreign_mod(nm)),
ItemTy(t, generics) => { ItemKind::Ty(t, generics) => {
ItemTy(folder.fold_ty(t), folder.fold_generics(generics)) ItemKind::Ty(folder.fold_ty(t), folder.fold_generics(generics))
} }
ItemEnum(enum_definition, generics) => { ItemKind::Enum(enum_definition, generics) => {
ItemEnum( ItemKind::Enum(
ast::EnumDef { ast::EnumDef {
variants: enum_definition.variants.move_map(|x| folder.fold_variant(x)), variants: enum_definition.variants.move_map(|x| folder.fold_variant(x)),
}, },
folder.fold_generics(generics)) folder.fold_generics(generics))
} }
ItemStruct(struct_def, generics) => { ItemKind::Struct(struct_def, generics) => {
let struct_def = folder.fold_variant_data(struct_def); 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) => { ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
ItemDefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone())) 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| { let new_impl_items = impl_items.move_flat_map(|item| {
folder.fold_impl_item(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())) Some(folder.fold_trait_ref((*trait_ref).clone()))
} }
}; };
ItemImpl(unsafety, ItemKind::Impl(unsafety,
polarity, polarity,
folder.fold_generics(generics), folder.fold_generics(generics),
ifce, ifce,
folder.fold_ty(ty), folder.fold_ty(ty),
new_impl_items) new_impl_items)
} }
ItemTrait(unsafety, generics, bounds, items) => { ItemKind::Trait(unsafety, generics, bounds, items) => {
let bounds = folder.fold_bounds(bounds); let bounds = folder.fold_bounds(bounds);
let items = items.move_flat_map(|item| { let items = items.move_flat_map(|item| {
folder.fold_trait_item(item) folder.fold_trait_item(item)
}); });
ItemTrait(unsafety, ItemKind::Trait(unsafety,
folder.fold_generics(generics), folder.fold_generics(generics),
bounds, bounds,
items) 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, id: ast::DUMMY_NODE_ID,
vis: ast::Public, vis: ast::Public,
span: span, span: span,
node: ast::ItemMod(module), node: ast::ItemKind::Mod(module),
})).into_iter(); })).into_iter();
let (module, attrs, span) = match items.next() { 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"); "a crate cannot expand to more than one item");
item.and_then(|ast::Item { attrs, span, node, .. }| { item.and_then(|ast::Item { attrs, span, node, .. }| {
match 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"), _ => 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, pub fn noop_fold_item_simple<T: Folder>(Item {id, ident, attrs, node, vis, span}: Item,
folder: &mut T) -> Item { folder: &mut T) -> Item {
let id = folder.new_id(id); let id = folder.new_id(id);
let node = folder.fold_item_underscore(node); let node = folder.fold_item_kind(node);
let ident = match node { let ident = match node {
// The node may have changed, recompute the "pretty" impl name. // 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)) ast_util::impl_pretty_name(maybe_trait, Some(&**ty))
} }
_ => ident _ => ident

2
src/libsyntax/parse/mod.rs
View file

@ -913,7 +913,7 @@ mod tests {
P(ast::Item{ident:str_to_ident("a"), P(ast::Item{ident:str_to_ident("a"),
attrs:Vec::new(), attrs:Vec::new(),
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: ast::ItemFn(P(ast::FnDecl { node: ast::ItemKind::Fn(P(ast::FnDecl {
inputs: vec!(ast::Arg{ inputs: vec!(ast::Arg{
ty: P(ast::Ty{id: ast::DUMMY_NODE_ID, ty: P(ast::Ty{id: ast::DUMMY_NODE_ID,
node: ast::TyKind::Path(None, ast::Path{ node: ast::TyKind::Path(None, ast::Path{

45
src/libsyntax/parse/parser.rs
View file

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

30
src/libsyntax/print/pprust.rs
View file

@ -1117,7 +1117,7 @@ impl<'a> State<'a> {
try!(self.print_outer_attributes(&item.attrs)); try!(self.print_outer_attributes(&item.attrs));
try!(self.ann.pre(self, NodeItem(item))); try!(self.ann.pre(self, NodeItem(item)));
match item.node { match item.node {
ast::ItemExternCrate(ref optional_path) => { ast::ItemKind::ExternCrate(ref optional_path) => {
try!(self.head(&visibility_qualified(item.vis, try!(self.head(&visibility_qualified(item.vis,
"extern crate"))); "extern crate")));
if let Some(p) = *optional_path { if let Some(p) = *optional_path {
@ -1136,7 +1136,7 @@ impl<'a> State<'a> {
try!(self.end()); // end inner head-block try!(self.end()); // end inner head-block
try!(self.end()); // end outer 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, try!(self.head(&visibility_qualified(item.vis,
"use"))); "use")));
try!(self.print_view_path(&**vp)); try!(self.print_view_path(&**vp));
@ -1144,7 +1144,7 @@ impl<'a> State<'a> {
try!(self.end()); // end inner head-block try!(self.end()); // end inner head-block
try!(self.end()); // end outer 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, try!(self.head(&visibility_qualified(item.vis,
"static"))); "static")));
if m == ast::MutMutable { if m == ast::MutMutable {
@ -1161,7 +1161,7 @@ impl<'a> State<'a> {
try!(word(&mut self.s, ";")); try!(word(&mut self.s, ";"));
try!(self.end()); // end the outer cbox 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, try!(self.head(&visibility_qualified(item.vis,
"const"))); "const")));
try!(self.print_ident(item.ident)); try!(self.print_ident(item.ident));
@ -1175,7 +1175,7 @@ impl<'a> State<'a> {
try!(word(&mut self.s, ";")); try!(word(&mut self.s, ";"));
try!(self.end()); // end the outer cbox 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.head(""));
try!(self.print_fn( try!(self.print_fn(
decl, decl,
@ -1190,7 +1190,7 @@ impl<'a> State<'a> {
try!(word(&mut self.s, " ")); try!(word(&mut self.s, " "));
try!(self.print_block_with_attrs(&**body, &item.attrs)); 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, try!(self.head(&visibility_qualified(item.vis,
"mod"))); "mod")));
try!(self.print_ident(item.ident)); try!(self.print_ident(item.ident));
@ -1199,14 +1199,14 @@ impl<'a> State<'a> {
try!(self.print_mod(_mod, &item.attrs)); try!(self.print_mod(_mod, &item.attrs));
try!(self.bclose(item.span)); try!(self.bclose(item.span));
} }
ast::ItemForeignMod(ref nmod) => { ast::ItemKind::ForeignMod(ref nmod) => {
try!(self.head("extern")); try!(self.head("extern"));
try!(self.word_nbsp(&nmod.abi.to_string())); try!(self.word_nbsp(&nmod.abi.to_string()));
try!(self.bopen()); try!(self.bopen());
try!(self.print_foreign_mod(nmod, &item.attrs)); try!(self.print_foreign_mod(nmod, &item.attrs));
try!(self.bclose(item.span)); 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(INDENT_UNIT));
try!(self.ibox(0)); try!(self.ibox(0));
try!(self.word_nbsp(&visibility_qualified(item.vis, "type"))); try!(self.word_nbsp(&visibility_qualified(item.vis, "type")));
@ -1221,7 +1221,7 @@ impl<'a> State<'a> {
try!(word(&mut self.s, ";")); try!(word(&mut self.s, ";"));
try!(self.end()); // end the outer ibox 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( try!(self.print_enum_def(
enum_definition, enum_definition,
params, params,
@ -1230,12 +1230,12 @@ impl<'a> State<'a> {
item.vis 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.head(&visibility_qualified(item.vis,"struct")));
try!(self.print_struct(&struct_def, generics, item.ident, item.span, true)); 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.head(""));
try!(self.print_visibility(item.vis)); try!(self.print_visibility(item.vis));
try!(self.print_unsafety(unsafety)); try!(self.print_unsafety(unsafety));
@ -1247,7 +1247,7 @@ impl<'a> State<'a> {
try!(self.bopen()); try!(self.bopen());
try!(self.bclose(item.span)); try!(self.bclose(item.span));
} }
ast::ItemImpl(unsafety, ast::ItemKind::Impl(unsafety,
polarity, polarity,
ref generics, ref generics,
ref opt_trait, ref opt_trait,
@ -1290,7 +1290,7 @@ impl<'a> State<'a> {
} }
try!(self.bclose(item.span)); 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.head(""));
try!(self.print_visibility(item.vis)); try!(self.print_visibility(item.vis));
try!(self.print_unsafety(unsafety)); try!(self.print_unsafety(unsafety));
@ -1316,7 +1316,7 @@ impl<'a> State<'a> {
} }
try!(self.bclose(item.span)); 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_visibility(item.vis));
try!(self.print_path(&node.path, false, 0)); try!(self.print_path(&node.path, false, 0));
try!(word(&mut self.s, "! ")); try!(word(&mut self.s, "! "));
@ -1596,7 +1596,7 @@ impl<'a> State<'a> {
try!(self.print_associated_type(ii.ident, None, Some(ty))); try!(self.print_associated_type(ii.ident, None, Some(ty)));
} }
ast::ImplItemKind::Macro(codemap::Spanned { ref node, .. }) => { 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!(self.print_path(&node.path, false, 0));
try!(word(&mut self.s, "! ")); try!(word(&mut self.s, "! "));
try!(self.cbox(INDENT_UNIT)); try!(self.cbox(INDENT_UNIT));

4
src/libsyntax/std_inject.rs
View file

@ -89,7 +89,7 @@ impl fold::Folder for CrateInjector {
attrs: vec!( attrs: vec!(
attr::mk_attr_outer(attr::mk_attr_id(), attr::mk_word_item( attr::mk_attr_outer(attr::mk_attr_id(), attr::mk_word_item(
InternedString::new("macro_use")))), InternedString::new("macro_use")))),
node: ast::ItemExternCrate(Some(self.crate_name)), node: ast::ItemKind::ExternCrate(Some(self.crate_name)),
vis: ast::Inherited, vis: ast::Inherited,
span: DUMMY_SP span: DUMMY_SP
})); }));
@ -149,7 +149,7 @@ impl fold::Folder for PreludeInjector {
mod_.items.insert(0, P(ast::Item { mod_.items.insert(0, P(ast::Item {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
ident: special_idents::invalid, ident: special_idents::invalid,
node: ast::ItemUse(vp), node: ast::ItemKind::Use(vp),
attrs: vec![ast::Attribute { attrs: vec![ast::Attribute {
span: self.span, span: self.span,
node: ast::Attribute_ { node: ast::Attribute_ {

20
src/libsyntax/test.rs
View file

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

28
src/libsyntax/visit.rs
View file

@ -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) { pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
visitor.visit_ident(item.span, item.ident); visitor.visit_ident(item.span, item.ident);
match item.node { match item.node {
ItemExternCrate(opt_name) => { ItemKind::ExternCrate(opt_name) => {
walk_opt_name(visitor, item.span, opt_name) walk_opt_name(visitor, item.span, opt_name)
} }
ItemUse(ref vp) => { ItemKind::Use(ref vp) => {
match vp.node { match vp.node {
ViewPathSimple(ident, ref path) => { ViewPathSimple(ident, ref path) => {
visitor.visit_ident(vp.span, ident); 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) | ItemKind::Static(ref typ, _, ref expr) |
ItemConst(ref typ, ref expr) => { ItemKind::Const(ref typ, ref expr) => {
visitor.visit_ty(typ); visitor.visit_ty(typ);
visitor.visit_expr(expr); 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, visitor.visit_fn(FnKind::ItemFn(item.ident, generics, unsafety,
constness, abi, item.vis), constness, abi, item.vis),
declaration, declaration,
@ -266,24 +266,24 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
item.span, item.span,
item.id) item.id)
} }
ItemMod(ref module) => { ItemKind::Mod(ref module) => {
visitor.visit_mod(module, item.span, item.id) 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); 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_ty(typ);
visitor.visit_generics(type_parameters) 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_generics(type_parameters);
visitor.visit_enum_def(enum_definition, type_parameters, item.id, item.span) 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) visitor.visit_trait_ref(trait_ref)
} }
ItemImpl(_, _, ItemKind::Impl(_, _,
ref type_parameters, ref type_parameters,
ref opt_trait_reference, ref opt_trait_reference,
ref typ, ref typ,
@ -293,17 +293,17 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
visitor.visit_ty(typ); visitor.visit_ty(typ);
walk_list!(visitor, visit_impl_item, impl_items); 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_generics(generics);
visitor.visit_variant_data(struct_definition, item.ident, visitor.visit_variant_data(struct_definition, item.ident,
generics, item.id, item.span); generics, item.id, item.span);
} }
ItemTrait(_, ref generics, ref bounds, ref methods) => { ItemKind::Trait(_, ref generics, ref bounds, ref methods) => {
visitor.visit_generics(generics); visitor.visit_generics(generics);
walk_list!(visitor, visit_ty_param_bound, bounds); walk_list!(visitor, visit_ty_param_bound, bounds);
walk_list!(visitor, visit_trait_item, methods); 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); walk_list!(visitor, visit_attribute, &item.attrs);
} }

6
src/libsyntax_ext/deriving/generic/mod.rs
View file

@ -391,13 +391,13 @@ impl<'a> TraitDef<'a> {
match *item { match *item {
Annotatable::Item(ref item) => { Annotatable::Item(ref item) => {
let newitem = match item.node { 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, self.expand_struct_def(cx,
&struct_def, &struct_def,
item.ident, item.ident,
generics) generics)
} }
ast::ItemEnum(ref enum_def, ref generics) => { ast::ItemKind::Enum(ref enum_def, ref generics) => {
self.expand_enum_def(cx, self.expand_enum_def(cx,
enum_def, enum_def,
&item.attrs, &item.attrs,
@ -637,7 +637,7 @@ impl<'a> TraitDef<'a> {
self.span, self.span,
ident, ident,
a, a,
ast::ItemImpl(unsafety, ast::ItemKind::Impl(unsafety,
ast::ImplPolarity::Positive, ast::ImplPolarity::Positive,
trait_generics, trait_generics,
opt_trait_ref, opt_trait_ref,

2
src/libsyntax_ext/format.rs
View file

@ -453,7 +453,7 @@ impl<'a, 'b> Context<'a, 'b> {
ast::MutImmutable); ast::MutImmutable);
let slice = ecx.expr_vec_slice(sp, pieces); let slice = ecx.expr_vec_slice(sp, pieces);
// static instead of const to speed up codegen by not requiring this to be inlined // 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 name = ecx.ident_of(name);
let item = ecx.item(sp, name, vec![], st); let item = ecx.item(sp, name, vec![], st);

6
src/test/auxiliary/macro_crate_test.rs
View file

@ -16,7 +16,7 @@ extern crate syntax;
extern crate rustc; extern crate rustc;
extern crate rustc_plugin; 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::codemap::Span;
use syntax::ext::base::*; use syntax::ext::base::*;
use syntax::parse::{self, token}; use syntax::parse::{self, token};
@ -73,7 +73,7 @@ fn expand_into_foo_multi(cx: &mut ExtCtxt,
Annotatable::ImplItem(it) => { Annotatable::ImplItem(it) => {
quote_item!(cx, impl X { fn foo(&self) -> i32 { 42 } }).unwrap().and_then(|i| { quote_item!(cx, impl X { fn foo(&self) -> i32 { 42 } }).unwrap().and_then(|i| {
match i.node { match i.node {
ast::ItemImpl(_, _, _, _, _, mut items) => { ItemKind::Impl(_, _, _, _, _, mut items) => {
Annotatable::ImplItem(items.pop().expect("impl method not found")) Annotatable::ImplItem(items.pop().expect("impl method not found"))
} }
_ => unreachable!("impl parsed to something other than impl") _ => unreachable!("impl parsed to something other than impl")
@ -83,7 +83,7 @@ fn expand_into_foo_multi(cx: &mut ExtCtxt,
Annotatable::TraitItem(it) => { Annotatable::TraitItem(it) => {
quote_item!(cx, trait X { fn foo(&self) -> i32 { 0 } }).unwrap().and_then(|i| { quote_item!(cx, trait X { fn foo(&self) -> i32 { 0 } }).unwrap().and_then(|i| {
match i.node { match i.node {
ast::ItemTrait(_, _, _, mut items) => { ItemKind::Trait(_, _, _, mut items) => {
Annotatable::TraitItem(items.pop().expect("trait method not found")) Annotatable::TraitItem(items.pop().expect("trait method not found"))
} }
_ => unreachable!("trait parsed to something other than trait") _ => unreachable!("trait parsed to something other than trait")