Rename structures in ast

6 files changed, 26 insertions, 26 deletions

diff --git a/src/libsyntax_ext/deriving/clone.rs b/src/libsyntax_ext/deriving/clone.rs
index 5f943a4cd00..9aeac5b1ddb 100644
--- a/src/libsyntax_ext/deriving/clone.rs
+++ b/src/libsyntax_ext/deriving/clone.rs
@@ -13,7 +13,7 @@ use deriving::generic::*;
 use deriving::generic::ty::*;
 
 use syntax::ast::{self, Expr, Generics, ItemKind, MetaItem, VariantData};
-use syntax::ast::GenericArgAST;
+use syntax::ast::GenericArg;
 use syntax::attr;
 use syntax::ext::base::{Annotatable, ExtCtxt};
 use syntax::ext::build::AstBuilder;
@@ -50,7 +50,7 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt,
                 ItemKind::Enum(_, Generics { ref params, .. }) => {
                     if attr::contains_name(&annitem.attrs, "rustc_copy_clone_marker") &&
                         !params.iter().any(|param| match param.kind {
-                            ast::GenericParamKindAST::Type { .. } => true,
+                            ast::GenericParamKind::Type { .. } => true,
                             _ => false,
                         })
                     {
@@ -127,7 +127,7 @@ fn cs_clone_shallow(name: &str,
         let span = span.with_ctxt(cx.backtrace());
         let assert_path = cx.path_all(span, true,
                                         cx.std_path(&["clone", helper_name]),
-                                        vec![GenericArgAST::Type(ty)], vec![]);
+                                        vec![GenericArg::Type(ty)], vec![]);
         stmts.push(cx.stmt_let_type_only(span, cx.ty_path(assert_path)));
     }
     fn process_variant(cx: &mut ExtCtxt, stmts: &mut Vec<ast::Stmt>, variant: &VariantData) {
diff --git a/src/libsyntax_ext/deriving/cmp/eq.rs b/src/libsyntax_ext/deriving/cmp/eq.rs
index e9bcf70e90c..00ab39032ac 100644
--- a/src/libsyntax_ext/deriving/cmp/eq.rs
+++ b/src/libsyntax_ext/deriving/cmp/eq.rs
@@ -12,7 +12,7 @@ use deriving::path_std;
 use deriving::generic::*;
 use deriving::generic::ty::*;
 
-use syntax::ast::{self, Expr, MetaItem, GenericArgAST};
+use syntax::ast::{self, Expr, MetaItem, GenericArg};
 use syntax::ext::base::{Annotatable, ExtCtxt};
 use syntax::ext::build::AstBuilder;
 use syntax::ptr::P;
@@ -62,7 +62,7 @@ fn cs_total_eq_assert(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
         let span = span.with_ctxt(cx.backtrace());
         let assert_path = cx.path_all(span, true,
                                         cx.std_path(&["cmp", helper_name]),
-                                        vec![GenericArgAST::Type(ty)], vec![]);
+                                        vec![GenericArg::Type(ty)], vec![]);
         stmts.push(cx.stmt_let_type_only(span, cx.ty_path(assert_path)));
     }
     fn process_variant(cx: &mut ExtCtxt, stmts: &mut Vec<ast::Stmt>, variant: &ast::VariantData) {
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
index fc244f67bb6..6c9aea51c7c 100644
--- a/src/libsyntax_ext/deriving/generic/mod.rs
+++ b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -193,7 +193,7 @@ use std::vec;
 
 use rustc_target::spec::abi::Abi;
 use syntax::ast::{self, BinOpKind, EnumDef, Expr, Generics, Ident, PatKind};
-use syntax::ast::{VariantData, GenericParamKindAST, GenericArgAST};
+use syntax::ast::{VariantData, GenericParamKind, GenericArg};
 use syntax::attr;
 use syntax::ext::base::{Annotatable, ExtCtxt};
 use syntax::ext::build::AstBuilder;
@@ -423,7 +423,7 @@ impl<'a> TraitDef<'a> {
                     ast::ItemKind::Enum(_, ref generics) |
                     ast::ItemKind::Union(_, ref generics) => {
                         !generics.params.iter().any(|param| match param.kind {
-                            ast::GenericParamKindAST::Type { .. } => true,
+                            ast::GenericParamKind::Type { .. } => true,
                             _ => false,
                         })
                     }
@@ -550,8 +550,8 @@ impl<'a> TraitDef<'a> {
 
         // Create the generic parameters
         params.extend(generics.params.iter().map(|param| match param.kind {
-            GenericParamKindAST::Lifetime { .. } => param.clone(),
-            GenericParamKindAST::Type { bounds: ref ty_bounds, .. } => {
+            GenericParamKind::Lifetime { .. } => param.clone(),
+            GenericParamKind::Type { bounds: ref ty_bounds, .. } => {
                 // I don't think this can be moved out of the loop, since
                 // a TyParamBound requires an ast id
                 let mut bounds: Vec<_> =
@@ -608,7 +608,7 @@ impl<'a> TraitDef<'a> {
 
             let mut ty_params = params.iter()
                 .filter_map(|param| match param.kind {
-                    ast::GenericParamKindAST::Type { .. } => Some(param),
+                    ast::GenericParamKind::Type { .. } => Some(param),
                     _ => None,
                 })
                 .peekable();
@@ -669,7 +669,7 @@ impl<'a> TraitDef<'a> {
         let self_ty_params: Vec<P<ast::Ty>> = generics.params
             .iter()
             .filter_map(|param| match param.kind {
-                GenericParamKindAST::Type { .. } => Some(cx.ty_ident(self.span, param.ident)),
+                GenericParamKind::Type { .. } => Some(cx.ty_ident(self.span, param.ident)),
                 _ => None,
             })
             .collect();
@@ -677,15 +677,15 @@ impl<'a> TraitDef<'a> {
         let self_lifetimes: Vec<ast::Lifetime> = generics.params
             .iter()
             .filter_map(|param| match param.kind {
-                GenericParamKindAST::Lifetime { ref lifetime, .. } => Some(*lifetime),
+                GenericParamKind::Lifetime { ref lifetime, .. } => Some(*lifetime),
                 _ => None,
             })
             .collect();
 
         let self_params = self_lifetimes.into_iter()
-                                        .map(|lt| GenericArgAST::Lifetime(lt))
+                                        .map(|lt| GenericArg::Lifetime(lt))
                                         .chain(self_ty_params.into_iter().map(|ty|
-                                            GenericArgAST::Type(ty)))
+                                            GenericArg::Type(ty)))
                                         .collect();
 
         // Create the type of `self`.
diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs
index c9f274ed210..78f6a9b9137 100644
--- a/src/libsyntax_ext/deriving/generic/ty.rs
+++ b/src/libsyntax_ext/deriving/generic/ty.rs
@@ -15,7 +15,7 @@ pub use self::PtrTy::*;
 pub use self::Ty::*;
 
 use syntax::ast;
-use syntax::ast::{Expr, GenericParamKindAST, Generics, Ident, SelfKind, GenericArgAST};
+use syntax::ast::{Expr, GenericParamKind, Generics, Ident, SelfKind, GenericArg};
 use syntax::ext::base::ExtCtxt;
 use syntax::ext::build::AstBuilder;
 use syntax::codemap::{respan, DUMMY_SP};
@@ -89,8 +89,8 @@ impl<'a> Path<'a> {
         let tys: Vec<P<ast::Ty>> =
             self.params.iter().map(|t| t.to_ty(cx, span, self_ty, self_generics)).collect();
         let params = lt.into_iter()
-                       .map(|lt| GenericArgAST::Lifetime(lt))
-                       .chain(tys.into_iter().map(|ty| GenericArgAST::Type(ty)))
+                       .map(|lt| GenericArg::Lifetime(lt))
+                       .chain(tys.into_iter().map(|ty| GenericArg::Type(ty)))
                        .collect();
 
         match self.kind {
@@ -192,7 +192,7 @@ impl<'a> Ty<'a> {
                 let ty_params: Vec<P<ast::Ty>> = self_generics.params
                     .iter()
                     .filter_map(|param| match param.kind {
-                        GenericParamKindAST::Type { .. } => {
+                        GenericParamKind::Type { .. } => {
                             Some(cx.ty_ident(span, param.ident))
                         }
                         _ => None,
@@ -202,15 +202,15 @@ impl<'a> Ty<'a> {
                 let lifetimes: Vec<ast::Lifetime> = self_generics.params
                     .iter()
                     .filter_map(|param| match param.kind {
-                        GenericParamKindAST::Lifetime { ref lifetime, .. } => Some(*lifetime),
+                        GenericParamKind::Lifetime { ref lifetime, .. } => Some(*lifetime),
                         _ => None,
                     })
                     .collect();
 
                 let params = lifetimes.into_iter()
-                                      .map(|lt| GenericArgAST::Lifetime(lt))
+                                      .map(|lt| GenericArg::Lifetime(lt))
                                       .chain(ty_params.into_iter().map(|ty|
-                                            GenericArgAST::Type(ty)))
+                                            GenericArg::Type(ty)))
                                       .collect();
 
                 cx.path_all(span,
@@ -234,7 +234,7 @@ fn mk_ty_param(cx: &ExtCtxt,
                bounds: &[Path],
                self_ident: Ident,
                self_generics: &Generics)
-               -> ast::GenericParamAST {
+               -> ast::GenericParam {
     let bounds = bounds.iter()
         .map(|b| {
             let path = b.to_path(cx, span, self_ident, self_generics);
@@ -244,7 +244,7 @@ fn mk_ty_param(cx: &ExtCtxt,
     cx.typaram(span, cx.ident_of(name), attrs.to_owned(), bounds, None)
 }
 
-fn mk_generics(params: Vec<ast::GenericParamAST>, span: Span) -> Generics {
+fn mk_generics(params: Vec<ast::GenericParam>, span: Span) -> Generics {
     Generics {
         params,
         where_clause: ast::WhereClause {
diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs
index 6813ce4c265..6ff385b18e8 100644
--- a/src/libsyntax_ext/deriving/mod.rs
+++ b/src/libsyntax_ext/deriving/mod.rs
@@ -136,7 +136,7 @@ fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String {
             ast::ItemKind::Enum(_, ast::Generics { ref params, .. }) => {
                 for param in params {
                     match param.kind {
-                        ast::GenericParamKindAST::Type { .. } => {
+                        ast::GenericParamKind::Type { .. } => {
                             typaram.push_str(&param.ident.as_str());
                         }
                         _ => {}
diff --git a/src/libsyntax_ext/env.rs b/src/libsyntax_ext/env.rs
index a3254788d45..5c3080260cc 100644
--- a/src/libsyntax_ext/env.rs
+++ b/src/libsyntax_ext/env.rs
@@ -13,7 +13,7 @@
 // interface.
 //
 
-use syntax::ast::{self, Ident, GenericArgAST};
+use syntax::ast::{self, Ident, GenericArg};
 use syntax::ext::base::*;
 use syntax::ext::base;
 use syntax::ext::build::AstBuilder;
@@ -39,7 +39,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt,
             cx.expr_path(cx.path_all(sp,
                                      true,
                                      cx.std_path(&["option", "Option", "None"]),
-                                     vec![GenericArgAST::Type(cx.ty_rptr(sp,
+                                     vec![GenericArg::Type(cx.ty_rptr(sp,
                                                      cx.ty_ident(sp, Ident::from_str("str")),
                                                      Some(lt),
                                                      ast::Mutability::Immutable))],