Rename structures in ast

7 files changed, 67 insertions, 67 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index c2626c70a42..f589057218c 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -160,7 +160,7 @@ impl GenericArgs {
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum GenericArgAST {
+pub enum GenericArg {
     Lifetime(Lifetime),
     Type(P<Ty>),
 }
@@ -171,7 +171,7 @@ pub struct AngleBracketedArgs {
     /// Overall span
     pub span: Span,
     /// The arguments for this path segment.
-    pub args: Vec<GenericArgAST>,
+    pub args: Vec<GenericArg>,
     /// Bindings (equality constraints) on associated types, if present.
     ///
     /// E.g., `Foo<A=Bar>`.
@@ -299,7 +299,7 @@ pub enum TraitBoundModifier {
 pub type TyParamBounds = Vec<TyParamBound>;
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum GenericParamKindAST {
+pub enum GenericParamKind {
     /// A lifetime definition, e.g. `'a: 'b+'c+'d`.
     Lifetime {
         bounds: Vec<Lifetime>,
@@ -312,19 +312,19 @@ pub enum GenericParamKindAST {
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub struct GenericParamAST {
+pub struct GenericParam {
     pub ident: Ident,
     pub id: NodeId,
     pub attrs: ThinVec<Attribute>,
 
-    pub kind: GenericParamKindAST,
+    pub kind: GenericParamKind,
 }
 
 /// Represents lifetime, type and const parameters attached to a declaration of
 /// a function, enum, trait, etc.
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct Generics {
-    pub params: Vec<GenericParamAST>,
+    pub params: Vec<GenericParam>,
     pub where_clause: WhereClause,
     pub span: Span,
 }
@@ -380,7 +380,7 @@ impl WherePredicate {
 pub struct WhereBoundPredicate {
     pub span: Span,
     /// Any generics from a `for` binding
-    pub bound_generic_params: Vec<GenericParamAST>,
+    pub bound_generic_params: Vec<GenericParam>,
     /// The type being bounded
     pub bounded_ty: P<Ty>,
     /// Trait and lifetime bounds (`Clone+Send+'static`)
@@ -1512,7 +1512,7 @@ impl fmt::Debug for Ty {
 pub struct BareFnTy {
     pub unsafety: Unsafety,
     pub abi: Abi,
-    pub generic_params: Vec<GenericParamAST>,
+    pub generic_params: Vec<GenericParam>,
     pub decl: P<FnDecl>
 }
 
@@ -1891,7 +1891,7 @@ pub struct TraitRef {
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct PolyTraitRef {
     /// The `'a` in `<'a> Foo<&'a T>`
-    pub bound_generic_params: Vec<GenericParamAST>,
+    pub bound_generic_params: Vec<GenericParam>,
 
     /// The `Foo<&'a T>` in `<'a> Foo<&'a T>`
     pub trait_ref: TraitRef,
@@ -1900,7 +1900,7 @@ pub struct PolyTraitRef {
 }
 
 impl PolyTraitRef {
-    pub fn new(generic_params: Vec<GenericParamAST>, path: Path, span: Span) -> Self {
+    pub fn new(generic_params: Vec<GenericParam>, path: Path, span: Span) -> Self {
         PolyTraitRef {
             bound_generic_params: generic_params,
             trait_ref: TraitRef { path: path, ref_id: DUMMY_NODE_ID },
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 42745c14965..695ad9c233f 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -31,7 +31,7 @@ pub trait AstBuilder {
     fn path_all(&self, sp: Span,
                 global: bool,
                 idents: Vec<ast::Ident>,
-                args: Vec<ast::GenericArgAST>,
+                args: Vec<ast::GenericArg>,
                 bindings: Vec<ast::TypeBinding>)
         -> ast::Path;
 
@@ -42,7 +42,7 @@ pub trait AstBuilder {
     fn qpath_all(&self, self_type: P<ast::Ty>,
                 trait_path: ast::Path,
                 ident: ast::Ident,
-                args: Vec<ast::GenericArgAST>,
+                args: Vec<ast::GenericArg>,
                 bindings: Vec<ast::TypeBinding>)
                 -> (ast::QSelf, ast::Path);
 
@@ -69,7 +69,7 @@ pub trait AstBuilder {
                id: ast::Ident,
                attrs: Vec<ast::Attribute>,
                bounds: ast::TyParamBounds,
-               default: Option<P<ast::Ty>>) -> ast::GenericParamAST;
+               default: Option<P<ast::Ty>>) -> ast::GenericParam;
 
     fn trait_ref(&self, path: ast::Path) -> ast::TraitRef;
     fn poly_trait_ref(&self, span: Span, path: ast::Path) -> ast::PolyTraitRef;
@@ -80,7 +80,7 @@ pub trait AstBuilder {
                     ident: ast::Ident,
                     attrs: Vec<ast::Attribute>,
                     bounds: Vec<ast::Lifetime>)
-                    -> ast::GenericParamAST;
+                    -> ast::GenericParam;
 
     // statements
     fn stmt_expr(&self, expr: P<ast::Expr>) -> ast::Stmt;
@@ -314,7 +314,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                 span: Span,
                 global: bool,
                 mut idents: Vec<ast::Ident> ,
-                args: Vec<ast::GenericArgAST>,
+                args: Vec<ast::GenericArg>,
                 bindings: Vec<ast::TypeBinding> )
                 -> ast::Path {
         let last_ident = idents.pop().unwrap();
@@ -356,7 +356,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                  self_type: P<ast::Ty>,
                  trait_path: ast::Path,
                  ident: ast::Ident,
-                 args: Vec<ast::GenericArgAST>,
+                 args: Vec<ast::GenericArg>,
                  bindings: Vec<ast::TypeBinding>)
                  -> (ast::QSelf, ast::Path) {
         let mut path = trait_path;
@@ -424,7 +424,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             self.path_all(DUMMY_SP,
                           true,
                           self.std_path(&["option", "Option"]),
-                          vec![ast::GenericArgAST::Type(ty)],
+                          vec![ast::GenericArg::Type(ty)],
                           Vec::new()))
     }
 
@@ -437,12 +437,12 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                ident: ast::Ident,
                attrs: Vec<ast::Attribute>,
                bounds: ast::TyParamBounds,
-               default: Option<P<ast::Ty>>) -> ast::GenericParamAST {
-        ast::GenericParamAST {
+               default: Option<P<ast::Ty>>) -> ast::GenericParam {
+        ast::GenericParam {
             ident: ident.with_span_pos(span),
             id: ast::DUMMY_NODE_ID,
             attrs: attrs.into(),
-            kind: ast::GenericParamKindAST::Type {
+            kind: ast::GenericParamKind::Type {
                 bounds,
                 default,
             }
@@ -477,13 +477,13 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
                     ident: ast::Ident,
                     attrs: Vec<ast::Attribute>,
                     bounds: Vec<ast::Lifetime>)
-                    -> ast::GenericParamAST {
+                    -> ast::GenericParam {
         let lifetime = self.lifetime(span, ident);
-        ast::GenericParamAST {
+        ast::GenericParam {
             ident: lifetime.ident,
             id: lifetime.id,
             attrs: attrs.into(),
-            kind: ast::GenericParamKindAST::Lifetime {
+            kind: ast::GenericParamKind::Lifetime {
                 lifetime,
                 bounds,
             }
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 2f43487e036..ea147186b18 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -132,10 +132,10 @@ pub trait Folder : Sized {
         noop_fold_exprs(es, self)
     }
 
-    fn fold_generic_arg(&mut self, arg: GenericArgAST) -> GenericArgAST {
+    fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg {
         match arg {
-            GenericArgAST::Lifetime(lt) => GenericArgAST::Lifetime(self.fold_lifetime(lt)),
-            GenericArgAST::Type(ty) => GenericArgAST::Type(self.fold_ty(ty)),
+            GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.fold_lifetime(lt)),
+            GenericArg::Type(ty) => GenericArg::Type(self.fold_ty(ty)),
         }
     }
 
@@ -244,11 +244,11 @@ pub trait Folder : Sized {
         noop_fold_ty_param(tp, self)
     }
 
-    fn fold_generic_param(&mut self, param: GenericParamAST) -> GenericParamAST {
+    fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam {
         noop_fold_generic_param(param, self)
     }
 
-    fn fold_generic_params(&mut self, params: Vec<GenericParamAST>) -> Vec<GenericParamAST> {
+    fn fold_generic_params(&mut self, params: Vec<GenericParam>) -> Vec<GenericParam> {
         noop_fold_generic_params(params, self)
     }
 
@@ -687,11 +687,11 @@ pub fn noop_fold_ty_param_bound<T>(tpb: TyParamBound, fld: &mut T)
     }
 }
 
-pub fn noop_fold_generic_param<T: Folder>(param: GenericParamAST, fld: &mut T) -> GenericParamAST {
-    match param {
-        GenericParamAST::Lifetime { bounds, lifetime } => {
+pub fn noop_fold_generic_param<T: Folder>(param: GenericParam, fld: &mut T) -> GenericParam {
+    match param.kind {
+        GenericParamKind::Lifetime { bounds, lifetime } => {
             let attrs: Vec<_> = param.attrs.into();
-            GenericParamAST::Lifetime(LifetimeDef {
+            GenericParamKind::Lifetime(LifetimeDef {
                 attrs: attrs.into_iter()
                     .flat_map(|x| fld.fold_attribute(x).into_iter())
                     .collect::<Vec<_>>()
@@ -703,14 +703,14 @@ pub fn noop_fold_generic_param<T: Folder>(param: GenericParamAST, fld: &mut T) -
                 bounds: bounds.move_map(|l| noop_fold_lifetime(l, fld)),
             })
         }
-        GenericParamAST::Type { .. } => GenericParamAST::Type(fld.fold_ty_param(param)),
+        GenericParamKind::Type { .. } => GenericParamKind::Type(fld.fold_ty_param(param)),
     }
 }
 
 pub fn noop_fold_generic_params<T: Folder>(
-    params: Vec<GenericParamAST>,
+    params: Vec<GenericParam>,
     fld: &mut T
-) -> Vec<GenericParamAST> {
+) -> Vec<GenericParam> {
     params.move_map(|p| fld.fold_generic_param(p))
 }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 2a1fc6b291c..203b529222d 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -21,8 +21,8 @@ use ast::EnumDef;
 use ast::{Expr, ExprKind, RangeLimits};
 use ast::{Field, FnDecl};
 use ast::{ForeignItem, ForeignItemKind, FunctionRetTy};
-use ast::{GenericParamAST, GenericParamKindAST};
-use ast::GenericArgAST;
+use ast::{GenericParam, GenericParamKind};
+use ast::GenericArg;
 use ast::{Ident, ImplItem, IsAuto, Item, ItemKind};
 use ast::{Label, Lifetime, Lit, LitKind};
 use ast::Local;
@@ -1246,7 +1246,7 @@ impl<'a> Parser<'a> {
     }
 
     /// parse a TyKind::BareFn type:
-    fn parse_ty_bare_fn(&mut self, generic_params: Vec<GenericParamAST>) -> PResult<'a, TyKind> {
+    fn parse_ty_bare_fn(&mut self, generic_params: Vec<GenericParam>) -> PResult<'a, TyKind> {
         /*
 
         [unsafe] [extern "ABI"] fn (S) -> T
@@ -1563,7 +1563,7 @@ impl<'a> Parser<'a> {
         Ok(P(ty))
     }
 
-    fn parse_remaining_bounds(&mut self, generic_params: Vec<GenericParamAST>, path: ast::Path,
+    fn parse_remaining_bounds(&mut self, generic_params: Vec<GenericParam>, path: ast::Path,
                               lo: Span, parse_plus: bool) -> PResult<'a, TyKind> {
         let poly_trait_ref = PolyTraitRef::new(generic_params, path, lo.to(self.prev_span));
         let mut bounds = vec![TraitTyParamBound(poly_trait_ref, TraitBoundModifier::None)];
@@ -4805,7 +4805,7 @@ impl<'a> Parser<'a> {
     /// Matches typaram = IDENT (`?` unbound)? optbounds ( EQ ty )?
     fn parse_ty_param(&mut self,
                       preceding_attrs: Vec<Attribute>)
-                      -> PResult<'a, GenericParamAST> {
+                      -> PResult<'a, GenericParam> {
         let ident = self.parse_ident()?;
 
         // Parse optional colon and param bounds.
@@ -4821,11 +4821,11 @@ impl<'a> Parser<'a> {
             None
         };
 
-        Ok(GenericParamAST {
+        Ok(GenericParam {
             ident,
             attrs: preceding_attrs.into(),
             id: ast::DUMMY_NODE_ID,
-            kind: GenericParamKindAST::Type {
+            kind: GenericParamKind::Type {
                 bounds,
                 default,
             }
@@ -4859,7 +4859,7 @@ impl<'a> Parser<'a> {
 
     /// Parses (possibly empty) list of lifetime and type parameters, possibly including
     /// trailing comma and erroneous trailing attributes.
-    crate fn parse_generic_params(&mut self) -> PResult<'a, Vec<ast::GenericParamAST>> {
+    crate fn parse_generic_params(&mut self) -> PResult<'a, Vec<ast::GenericParam>> {
         let mut params = Vec::new();
         let mut seen_ty_param = false;
         loop {
@@ -4872,11 +4872,11 @@ impl<'a> Parser<'a> {
                 } else {
                     Vec::new()
                 };
-                params.push(ast::GenericParamAST {
+                params.push(ast::GenericParam {
                     ident: lifetime.ident,
                     id: lifetime.id,
                     attrs: attrs.into(),
-                    kind: ast::GenericParamKindAST::Lifetime {
+                    kind: ast::GenericParamKind::Lifetime {
                         lifetime,
                         bounds,
                     }
@@ -4937,7 +4937,7 @@ impl<'a> Parser<'a> {
     /// Parses (possibly empty) list of lifetime and type arguments and associated type bindings,
     /// possibly including trailing comma.
     fn parse_generic_args(&mut self)
-                          -> PResult<'a, (Vec<GenericArgAST>, Vec<TypeBinding>)> {
+                          -> PResult<'a, (Vec<GenericArg>, Vec<TypeBinding>)> {
         let mut args = Vec::new();
         let mut bindings = Vec::new();
         let mut seen_type = false;
@@ -4945,7 +4945,7 @@ impl<'a> Parser<'a> {
         loop {
             if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
                 // Parse lifetime argument.
-                args.push(GenericArgAST::Lifetime(self.expect_lifetime()));
+                args.push(GenericArg::Lifetime(self.expect_lifetime()));
                 if seen_type || seen_binding {
                     self.span_err(self.prev_span,
                         "lifetime parameters must be declared prior to type parameters");
@@ -4970,7 +4970,7 @@ impl<'a> Parser<'a> {
                     self.span_err(ty_param.span,
                         "type parameters must be declared prior to associated type bindings");
                 }
-                args.push(GenericArgAST::Type(ty_param));
+                args.push(GenericArg::Type(ty_param));
                 seen_type = true;
             } else {
                 break
@@ -5692,7 +5692,7 @@ impl<'a> Parser<'a> {
         Ok((keywords::Invalid.ident(), item_kind, Some(attrs)))
     }
 
-    fn parse_late_bound_lifetime_defs(&mut self) -> PResult<'a, Vec<GenericParamAST>> {
+    fn parse_late_bound_lifetime_defs(&mut self) -> PResult<'a, Vec<GenericParam>> {
         if self.eat_keyword(keywords::For) {
             self.expect_lt()?;
             let params = self.parse_generic_params()?;
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 458947299c8..84a4a51b716 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -13,7 +13,7 @@ pub use self::AnnNode::*;
 use rustc_target::spec::abi::{self, Abi};
 use ast::{self, BlockCheckMode, PatKind, RangeEnd, RangeSyntax};
 use ast::{SelfKind, RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
-use ast::{Attribute, MacDelimiter, GenericArgAST};
+use ast::{Attribute, MacDelimiter, GenericArg};
 use util::parser::{self, AssocOp, Fixity};
 use attr;
 use codemap::{self, CodeMap};
@@ -344,7 +344,7 @@ pub fn trait_item_to_string(i: &ast::TraitItem) -> String {
     to_string(|s| s.print_trait_item(i))
 }
 
-pub fn generic_params_to_string(generic_params: &[ast::GenericParamAST]) -> String {
+pub fn generic_params_to_string(generic_params: &[ast::GenericParam]) -> String {
     to_string(|s| s.print_generic_params(generic_params))
 }
 
@@ -1017,10 +1017,10 @@ impl<'a> State<'a> {
         Ok(())
     }
 
-    pub fn print_generic_arg(&mut self, generic_arg: &GenericArgAST) -> io::Result<()> {
+    pub fn print_generic_arg(&mut self, generic_arg: &GenericArg) -> io::Result<()> {
         match generic_arg {
-            GenericArgAST::Lifetime(lt) => self.print_lifetime(lt),
-            GenericArgAST::Type(ty) => self.print_type(ty),
+            GenericArg::Lifetime(lt) => self.print_lifetime(lt),
+            GenericArg::Type(ty) => self.print_type(ty),
         }
     }
 
@@ -1443,7 +1443,7 @@ impl<'a> State<'a> {
 
     fn print_formal_generic_params(
         &mut self,
-        generic_params: &[ast::GenericParamAST]
+        generic_params: &[ast::GenericParam]
     ) -> io::Result<()> {
         if !generic_params.is_empty() {
             self.s.word("for")?;
@@ -2869,7 +2869,7 @@ impl<'a> State<'a> {
 
     pub fn print_generic_params(
         &mut self,
-        generic_params: &[ast::GenericParamAST]
+        generic_params: &[ast::GenericParam]
     ) -> io::Result<()> {
         if generic_params.is_empty() {
             return Ok(());
@@ -2879,11 +2879,11 @@ impl<'a> State<'a> {
 
         self.commasep(Inconsistent, &generic_params, |s, param| {
             match param.kind {
-                ast::GenericParamKindAST::Lifetime { ref bounds, ref lifetime } => {
+                ast::GenericParamKind::Lifetime { ref bounds, ref lifetime } => {
                     s.print_outer_attributes_inline(&param.attrs)?;
                     s.print_lifetime_bounds(lifetime, bounds)
                 },
-                ast::GenericParamKindAST::Type { ref bounds, ref default } => {
+                ast::GenericParamKind::Type { ref bounds, ref default } => {
                     s.print_outer_attributes_inline(&param.attrs)?;
                     s.print_ident(param.ident)?;
                     s.print_bounds(":", bounds)?;
@@ -3045,7 +3045,7 @@ impl<'a> State<'a> {
                        unsafety: ast::Unsafety,
                        decl: &ast::FnDecl,
                        name: Option<ast::Ident>,
-                       generic_params: &Vec<ast::GenericParamAST>)
+                       generic_params: &Vec<ast::GenericParam>)
                        -> io::Result<()> {
         self.ibox(INDENT_UNIT)?;
         if !generic_params.is_empty() {
diff --git a/src/libsyntax/util/node_count.rs b/src/libsyntax/util/node_count.rs
index caddd0513d1..95ae9f9bcf8 100644
--- a/src/libsyntax/util/node_count.rs
+++ b/src/libsyntax/util/node_count.rs
@@ -71,7 +71,7 @@ impl<'ast> Visitor<'ast> for NodeCounter {
         self.count += 1;
         walk_ty(self, t)
     }
-    fn visit_generic_param(&mut self, param: &GenericParamAST) {
+    fn visit_generic_param(&mut self, param: &GenericParam) {
         self.count += 1;
         walk_generic_param(self, param)
     }
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index c919f6c355c..3a81796bae4 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -73,7 +73,7 @@ pub trait Visitor<'ast>: Sized {
     fn visit_expr(&mut self, ex: &'ast Expr) { walk_expr(self, ex) }
     fn visit_expr_post(&mut self, _ex: &'ast Expr) { }
     fn visit_ty(&mut self, t: &'ast Ty) { walk_ty(self, t) }
-    fn visit_generic_param(&mut self, param: &'ast GenericParamAST) {
+    fn visit_generic_param(&mut self, param: &'ast GenericParam) {
         walk_generic_param(self, param)
     }
     fn visit_generics(&mut self, g: &'ast Generics) { walk_generics(self, g) }
@@ -133,10 +133,10 @@ pub trait Visitor<'ast>: Sized {
     fn visit_generic_args(&mut self, path_span: Span, generic_args: &'ast GenericArgs) {
         walk_generic_args(self, path_span, generic_args)
     }
-    fn visit_generic_arg(&mut self, generic_arg: &'ast GenericArgAST) {
+    fn visit_generic_arg(&mut self, generic_arg: &'ast GenericArg) {
         match generic_arg {
-            GenericArgAST::Lifetime(lt) => self.visit_lifetime(lt),
-            GenericArgAST::Type(ty)     => self.visit_ty(ty),
+            GenericArg::Lifetime(lt) => self.visit_lifetime(lt),
+            GenericArg::Type(ty)     => self.visit_ty(ty),
         }
     }
     fn visit_assoc_type_binding(&mut self, type_binding: &'ast TypeBinding) {
@@ -490,14 +490,14 @@ pub fn walk_ty_param_bound<'a, V: Visitor<'a>>(visitor: &mut V, bound: &'a TyPar
     }
 }
 
-pub fn walk_generic_param<'a, V: Visitor<'a>>(visitor: &mut V, param: &'a GenericParamAST) {
+pub fn walk_generic_param<'a, V: Visitor<'a>>(visitor: &mut V, param: &'a GenericParam) {
     match param.kind {
-        GenericParamKindAST::Lifetime { ref bounds, ref lifetime, .. } => {
+        GenericParamKind::Lifetime { ref bounds, ref lifetime, .. } => {
             visitor.visit_ident(param.ident);
             walk_list!(visitor, visit_lifetime, bounds);
             walk_list!(visitor, visit_attribute, param.attrs.iter());
         }
-        GenericParamKindAST::Type { ref bounds, ref default, .. } => {
+        GenericParamKind::Type { ref bounds, ref default, .. } => {
             visitor.visit_ident(t.ident);
             walk_list!(visitor, visit_ty_param_bound, bounds);
             walk_list!(visitor, visit_ty, default);