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

oli-obk · oli-obk · commit dfe35da6b83f · 2016-02-11T12:34:48.000+01:00
diff --git 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<ast::TraitItem>) -> SmallVector<P<ast::TraitItem>> {
         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
@@ -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
@@ -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
@@ -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<Attribute>,
-    pub node: TraitItem_,
+    pub node: TraitItemKind,
     pub span: Span,
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum TraitItem_ {
-    ConstTraitItem(P<Ty>, Option<P<Expr>>),
-    MethodTraitItem(MethodSig, Option<P<Block>>),
-    TypeTraitItem(TyParamBounds, Option<P<Ty>>),
+pub enum TraitItemKind {
+    Const(P<Ty>, Option<P<Expr>>),
+    Method(MethodSig, Option<P<Block>>),
+    Type(TyParamBounds, Option<P<Ty>>),
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
diff --git 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
@@ -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
@@ -969,16 +969,16 @@ pub fn noop_fold_trait_item<T: Folder>(i: P<TraitItem>, 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
@@ -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
@@ -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
@@ -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);
         }

Original file line number	Diff line number	Diff line change
`@@ -728,15 +728,15 @@ pub fn lower_trait_item(lctx: &LoweringContext, i: &TraitItem) -> hir::TraitItem`
`728`	`728`	`name: i.ident.name,`
`729`	`729`	`attrs: lower_attrs(lctx, &i.attrs),`
`730`	`730`	`node: match i.node {`
`731`		`- ConstTraitItem(ref ty, ref default) => {`
	`731`	`+ TraitItemKind::Const(ref ty, ref default) => {`
`732`	`732`	`hir::ConstTraitItem(lower_ty(lctx, ty),`
`733`	`733`	`default.as_ref().map(\|x\| lower_expr(lctx, x)))`
`734`	`734`	`}`
`735`		`- MethodTraitItem(ref sig, ref body) => {`
	`735`	`+ TraitItemKind::Method(ref sig, ref body) => {`
`736`	`736`	`hir::MethodTraitItem(lower_method_sig(lctx, sig),`
`737`	`737`	`body.as_ref().map(\|x\| lower_block(lctx, x)))`
`738`	`738`	`}`
`739`		`- TypeTraitItem(ref bounds, ref default) => {`
	`739`	`+ TraitItemKind::Type(ref bounds, ref default) => {`
`740`	`740`	`hir::TypeTraitItem(lower_bounds(lctx, bounds),`
`741`	`741`	`default.as_ref().map(\|x\| lower_ty(lctx, x)))`
`742`	`742`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1071,17 +1071,17 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {`
`1071`	`1071`
`1072`	`1072`	`fn visit_trait_item(&mut self, ti: &'v ast::TraitItem) {`
`1073`	`1073`	`match ti.node {`
`1074`		`- ast::ConstTraitItem(..) => {`
	`1074`	`+ ast::TraitItemKind::Const(..) => {`
`1075`	`1075`	`self.gate_feature("associated_consts",`
`1076`	`1076`	`ti.span,`
`1077`	`1077`	`"associated constants are experimental")`
`1078`	`1078`	`}`
`1079`		`- ast::MethodTraitItem(ref sig, _) => {`
	`1079`	`+ ast::TraitItemKind::Method(ref sig, _) => {`
`1080`	`1080`	`if sig.constness == ast::Constness::Const {`
`1081`	`1081`	`self.gate_feature("const_fn", ti.span, "const fn is unstable");`
`1082`	`1082`	`}`
`1083`	`1083`	`}`
`1084`		`- ast::TypeTraitItem(_, Some(_)) => {`
	`1084`	`+ ast::TraitItemKind::Type(_, Some(_)) => {`
`1085`	`1085`	`self.gate_feature("associated_type_defaults", ti.span,`
`1086`	`1086`	`"associated type defaults are unstable");`
`1087`	`1087`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1552,12 +1552,12 @@ impl<'a> State<'a> {`
`1552`	`1552`	`try!(self.maybe_print_comment(ti.span.lo));`
`1553`	`1553`	`try!(self.print_outer_attributes(&ti.attrs));`
`1554`	`1554`	`match ti.node {`
`1555`		`- ast::ConstTraitItem(ref ty, ref default) => {`
	`1555`	`+ ast::TraitItemKind::Const(ref ty, ref default) => {`
`1556`	`1556`	`try!(self.print_associated_const(ti.ident, &ty,`
`1557`	`1557`	`default.as_ref().map(\|expr\| &**expr),`
`1558`	`1558`	`ast::Inherited));`
`1559`	`1559`	`}`
`1560`		`- ast::MethodTraitItem(ref sig, ref body) => {`
	`1560`	`+ ast::TraitItemKind::Method(ref sig, ref body) => {`
`1561`	`1561`	`if body.is_some() {`
`1562`	`1562`	`try!(self.head(""));`
`1563`	`1563`	`}`
`@@ -1569,7 +1569,7 @@ impl<'a> State<'a> {`
`1569`	`1569`	`try!(word(&mut self.s, ";"));`
`1570`	`1570`	`}`
`1571`	`1571`	`}`
`1572`		`- ast::TypeTraitItem(ref bounds, ref default) => {`
	`1572`	`+ ast::TraitItemKind::Type(ref bounds, ref default) => {`
`1573`	`1573`	`try!(self.print_associated_type(ti.ident, Some(bounds),`
`1574`	`1574`	`default.as_ref().map(\|ty\| &**ty)));`
`1575`	`1575`	`}`