diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index e0a948f7661..71f9d3c7e74 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -616,7 +616,7 @@ impl fold::Folder for ReplaceBodyWithLoop { fn fold_trait_item(&mut self, i: P) -> SmallVector> { match i.node { - ast::ConstTraitItem(..) => { + ast::TraitItemKind::Const(..) => { self.within_static_or_const = true; let ret = fold::noop_fold_trait_item(i, self); self.within_static_or_const = false; diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index e9dfa1bd164..412e6a68a58 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -728,15 +728,15 @@ pub fn lower_trait_item(lctx: &LoweringContext, i: &TraitItem) -> hir::TraitItem name: i.ident.name, attrs: lower_attrs(lctx, &i.attrs), node: match i.node { - ConstTraitItem(ref ty, ref default) => { + TraitItemKind::Const(ref ty, ref default) => { hir::ConstTraitItem(lower_ty(lctx, ty), default.as_ref().map(|x| lower_expr(lctx, x))) } - MethodTraitItem(ref sig, ref body) => { + TraitItemKind::Method(ref sig, ref body) => { hir::MethodTraitItem(lower_method_sig(lctx, sig), body.as_ref().map(|x| lower_block(lctx, x))) } - TypeTraitItem(ref bounds, ref default) => { + TraitItemKind::Type(ref bounds, ref default) => { hir::TypeTraitItem(lower_bounds(lctx, bounds), default.as_ref().map(|x| lower_ty(lctx, x))) } diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index 68c04427c65..1d12abbb9cb 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -1020,22 +1020,22 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> { fn visit_trait_item(&mut self, trait_item: &ast::TraitItem) { self.process_macro_use(trait_item.span, trait_item.id); match trait_item.node { - ast::ConstTraitItem(ref ty, Some(ref expr)) => { + ast::TraitItemKind::Const(ref ty, Some(ref expr)) => { self.process_const(trait_item.id, trait_item.ident.name, trait_item.span, &*ty, &*expr); } - ast::MethodTraitItem(ref sig, ref body) => { + ast::TraitItemKind::Method(ref sig, ref body) => { self.process_method(sig, body.as_ref().map(|x| &**x), trait_item.id, trait_item.ident.name, trait_item.span); } - ast::ConstTraitItem(_, None) | - ast::TypeTraitItem(..) => {} + ast::TraitItemKind::Const(_, None) | + ast::TraitItemKind::Type(..) => {} } } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index cfaa5fc4a96..796e5923578 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -14,7 +14,6 @@ pub use self::Pat_::*; pub use self::PathListItem_::*; pub use self::StrStyle::*; pub use self::StructFieldKind::*; -pub use self::TraitItem_::*; pub use self::TyParamBound::*; pub use self::UnsafeSource::*; pub use self::ViewPath_::*; @@ -1324,15 +1323,15 @@ pub struct TraitItem { pub id: NodeId, pub ident: Ident, pub attrs: Vec, - pub node: TraitItem_, + pub node: TraitItemKind, pub span: Span, } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub enum TraitItem_ { - ConstTraitItem(P, Option>), - MethodTraitItem(MethodSig, Option>), - TypeTraitItem(TyParamBounds, Option>), +pub enum TraitItemKind { + Const(P, Option>), + Method(MethodSig, Option>), + Type(TyParamBounds, Option>), } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index c53001e665e..c4bbe709f34 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -919,14 +919,14 @@ fn expand_annotatable(a: Annotatable, }, Annotatable::TraitItem(it) => match it.node { - ast::MethodTraitItem(_, Some(_)) => SmallVector::one(it.map(|ti| ast::TraitItem { + ast::TraitItemKind::Method(_, Some(_)) => SmallVector::one(it.map(|ti| ast::TraitItem { id: ti.id, ident: ti.ident, attrs: ti.attrs, node: match ti.node { - ast::MethodTraitItem(sig, Some(body)) => { + ast::TraitItemKind::Method(sig, Some(body)) => { let (sig, body) = expand_and_rename_method(sig, body, fld); - ast::MethodTraitItem(sig, Some(body)) + ast::TraitItemKind::Method(sig, Some(body)) } _ => unreachable!() }, diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index b04f6b06639..9bf1dd49db5 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -1071,17 +1071,17 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> { fn visit_trait_item(&mut self, ti: &'v ast::TraitItem) { match ti.node { - ast::ConstTraitItem(..) => { + ast::TraitItemKind::Const(..) => { self.gate_feature("associated_consts", ti.span, "associated constants are experimental") } - ast::MethodTraitItem(ref sig, _) => { + ast::TraitItemKind::Method(ref sig, _) => { if sig.constness == ast::Constness::Const { self.gate_feature("const_fn", ti.span, "const fn is unstable"); } } - ast::TypeTraitItem(_, Some(_)) => { + ast::TraitItemKind::Type(_, Some(_)) => { self.gate_feature("associated_type_defaults", ti.span, "associated type defaults are unstable"); } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 722a65fa526..08b0c0c539f 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -969,16 +969,16 @@ pub fn noop_fold_trait_item(i: P, folder: &mut T) ident: folder.fold_ident(ident), attrs: fold_attrs(attrs, folder), node: match node { - ConstTraitItem(ty, default) => { - ConstTraitItem(folder.fold_ty(ty), + TraitItemKind::Const(ty, default) => { + TraitItemKind::Const(folder.fold_ty(ty), default.map(|x| folder.fold_expr(x))) } - MethodTraitItem(sig, body) => { - MethodTraitItem(noop_fold_method_sig(sig, folder), + TraitItemKind::Method(sig, body) => { + TraitItemKind::Method(noop_fold_method_sig(sig, folder), body.map(|x| folder.fold_block(x))) } - TypeTraitItem(bounds, default) => { - TypeTraitItem(folder.fold_bounds(bounds), + TraitItemKind::Type(bounds, default) => { + TraitItemKind::Type(folder.fold_bounds(bounds), default.map(|x| folder.fold_ty(x))) } }, diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 11638a3d424..d8fab03d21a 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -13,11 +13,11 @@ pub use self::PathParsingMode::*; use abi::{self, Abi}; use ast::BareFnTy; use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier}; -use ast::{Public, Unsafety}; -use ast::{Mod, Arg, Arm, Attribute, BindingMode}; +use ast::Unsafety; +use ast::{Mod, Arg, Arm, Attribute, BindingMode, TraitItemKind}; use ast::Block; use ast::{BlockCheckMode, CaptureBy}; -use ast::{Constness, ConstTraitItem, Crate, CrateConfig}; +use ast::{Constness, Crate, CrateConfig}; use ast::{Decl, DeclKind}; use ast::{EMPTY_CTXT, EnumDef, ExplicitSelf}; use ast::{Expr, ExprKind}; @@ -39,7 +39,6 @@ use ast::StrStyle; use ast::SelfKind; use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef}; use ast::{Ty, TyKind, TypeBinding, TyParam, TyParamBounds}; -use ast::TypeTraitItem; use ast::UnnamedField; use ast::{ViewPath, ViewPathGlob, ViewPathList, ViewPathSimple}; use ast::{Visibility, WhereClause}; @@ -1188,7 +1187,7 @@ impl<'a> Parser<'a> { let (name, node) = if p.eat_keyword(keywords::Type) { let TyParam {ident, bounds, default, ..} = try!(p.parse_ty_param()); try!(p.expect(&token::Semi)); - (ident, TypeTraitItem(bounds, default)) + (ident, TraitItemKind::Type(bounds, default)) } else if p.is_const_item() { try!(p.expect_keyword(keywords::Const)); let ident = try!(p.parse_ident()); @@ -1203,7 +1202,7 @@ impl<'a> Parser<'a> { try!(p.expect(&token::Semi)); None }; - (ident, ConstTraitItem(ty, default)) + (ident, TraitItemKind::Const(ty, default)) } else { let (constness, unsafety, abi) = try!(p.parse_fn_front_matter()); @@ -1247,7 +1246,7 @@ impl<'a> Parser<'a> { token_str)[..])) } }; - (ident, ast::MethodTraitItem(sig, body)) + (ident, ast::TraitItemKind::Method(sig, body)) }; Ok(P(TraitItem { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index b14117c9704..6e8f0781b4e 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1552,12 +1552,12 @@ impl<'a> State<'a> { try!(self.maybe_print_comment(ti.span.lo)); try!(self.print_outer_attributes(&ti.attrs)); match ti.node { - ast::ConstTraitItem(ref ty, ref default) => { + ast::TraitItemKind::Const(ref ty, ref default) => { try!(self.print_associated_const(ti.ident, &ty, default.as_ref().map(|expr| &**expr), ast::Inherited)); } - ast::MethodTraitItem(ref sig, ref body) => { + ast::TraitItemKind::Method(ref sig, ref body) => { if body.is_some() { try!(self.head("")); } @@ -1569,7 +1569,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, ";")); } } - ast::TypeTraitItem(ref bounds, ref default) => { + ast::TraitItemKind::Type(ref bounds, ref default) => { try!(self.print_associated_type(ti.ident, Some(bounds), default.as_ref().map(|ty| &**ty))); } diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 4082bcbe38e..66ac370c149 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -565,20 +565,20 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai visitor.visit_ident(trait_item.span, trait_item.ident); walk_list!(visitor, visit_attribute, &trait_item.attrs); match trait_item.node { - ConstTraitItem(ref ty, ref default) => { + TraitItemKind::Const(ref ty, ref default) => { visitor.visit_ty(ty); walk_list!(visitor, visit_expr, default); } - MethodTraitItem(ref sig, None) => { + TraitItemKind::Method(ref sig, None) => { visitor.visit_explicit_self(&sig.explicit_self); visitor.visit_generics(&sig.generics); walk_fn_decl(visitor, &sig.decl); } - MethodTraitItem(ref sig, Some(ref body)) => { + TraitItemKind::Method(ref sig, Some(ref body)) => { visitor.visit_fn(FnKind::Method(trait_item.ident, sig, None), &sig.decl, body, trait_item.span, trait_item.id); } - TypeTraitItem(ref bounds, ref default) => { + TraitItemKind::Type(ref bounds, ref default) => { walk_list!(visitor, visit_ty_param_bound, bounds); walk_list!(visitor, visit_ty, default); }