Rename structures in ast

2 files changed, 18 insertions, 18 deletions

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 {