Rename ast::GenericParam and ast::GenericArg

It's so confusing to have everything having the same name, at least while refactoring.

2 files changed, 20 insertions, 20 deletions

diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
index 299c53f3101..f85091b0e71 100644
--- a/src/libsyntax_ext/deriving/generic/mod.rs
+++ b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -192,8 +192,8 @@ use std::collections::HashSet;
 use std::vec;
 
 use rustc_target::spec::abi::Abi;
-use syntax::ast::{self, BinOpKind, EnumDef, Expr, GenericParam, Generics, Ident, PatKind};
-use syntax::ast::{VariantData, GenericArg};
+use syntax::ast::{self, BinOpKind, EnumDef, Expr, GenericParamAST, Generics, Ident, PatKind};
+use syntax::ast::{VariantData, GenericArgAST};
 use syntax::attr;
 use syntax::ext::base::{Annotatable, ExtCtxt};
 use syntax::ext::build::AstBuilder;
@@ -548,8 +548,8 @@ impl<'a> TraitDef<'a> {
         // Create the generic parameters
         params.extend(generics.params.iter().map(|param| {
             match *param {
-                ref l @ GenericParam::Lifetime(_) => l.clone(),
-                GenericParam::Type(ref ty_param) => {
+                ref l @ GenericParamAST::Lifetime(_) => l.clone(),
+                GenericParamAST::Type(ref ty_param) => {
                     // I don't think this can be moved out of the loop, since
                     // a TyParamBound requires an ast id
                     let mut bounds: Vec<_> =
@@ -568,7 +568,7 @@ impl<'a> TraitDef<'a> {
                         bounds.push((*declared_bound).clone());
                     }
 
-                    GenericParam::Type(cx.typaram(self.span, ty_param.ident, vec![], bounds, None))
+                    GenericParamAST::Type(cx.typaram(self.span, ty_param.ident, vec![], bounds, None))
                 }
             }
         }));
@@ -607,7 +607,7 @@ impl<'a> TraitDef<'a> {
 
             let mut ty_params = params.iter()
                 .filter_map(|param| match *param {
-                    ast::GenericParam::Type(ref t) => Some(t),
+                    ast::GenericParamAST::Type(ref t) => Some(t),
                     _ => None,
                 })
                 .peekable();
@@ -668,7 +668,7 @@ impl<'a> TraitDef<'a> {
         let self_ty_params: Vec<P<ast::Ty>> = generics.params
             .iter()
             .filter_map(|param| match *param {
-                GenericParam::Type(ref ty_param)
+                GenericParamAST::Type(ref ty_param)
                     => Some(cx.ty_ident(self.span, ty_param.ident)),
                 _ => None,
             })
@@ -677,15 +677,15 @@ impl<'a> TraitDef<'a> {
         let self_lifetimes: Vec<ast::Lifetime> = generics.params
             .iter()
             .filter_map(|param| match *param {
-                GenericParam::Lifetime(ref ld) => Some(ld.lifetime),
+                GenericParamAST::Lifetime(ref ld) => Some(ld.lifetime),
                 _ => None,
             })
             .collect();
 
         let self_params = self_lifetimes.into_iter()
-                                        .map(|lt| GenericArg::Lifetime(lt))
+                                        .map(|lt| GenericArgAST::Lifetime(lt))
                                         .chain(self_ty_params.into_iter().map(|ty|
-                                            GenericArg::Type(ty)))
+                                            GenericArgAST::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 7e6dd5fad25..92046262ed2 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, GenericParam, Generics, Ident, SelfKind, GenericArg};
+use syntax::ast::{Expr, GenericParamAST, Generics, Ident, SelfKind, GenericArgAST};
 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| GenericArg::Lifetime(lt))
-                       .chain(tys.into_iter().map(|ty| GenericArg::Type(ty)))
+                       .map(|lt| GenericArgAST::Lifetime(lt))
+                       .chain(tys.into_iter().map(|ty| GenericArgAST::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 {
-                        GenericParam::Type(ref ty_param) => Some(cx.ty_ident(span, ty_param.ident)),
+                        GenericParamAST::Type(ref ty_param) => Some(cx.ty_ident(span, ty_param.ident)),
                         _ => None,
                     })
                     .collect();
@@ -200,15 +200,15 @@ impl<'a> Ty<'a> {
                 let lifetimes: Vec<ast::Lifetime> = self_generics.params
                     .iter()
                     .filter_map(|param| match *param {
-                        GenericParam::Lifetime(ref ld) => Some(ld.lifetime),
+                        GenericParamAST::Lifetime(ref ld) => Some(ld.lifetime),
                         _ => None,
                     })
                     .collect();
 
                 let params = lifetimes.into_iter()
-                                      .map(|lt| GenericArg::Lifetime(lt))
+                                      .map(|lt| GenericArgAST::Lifetime(lt))
                                       .chain(ty_params.into_iter().map(|ty|
-                                            GenericArg::Type(ty)))
+                                            GenericArgAST::Type(ty)))
                                       .collect();
 
                 cx.path_all(span,
@@ -242,7 +242,7 @@ fn mk_ty_param(cx: &ExtCtxt,
     cx.typaram(span, cx.ident_of(name), attrs.to_owned(), bounds, None)
 }
 
-fn mk_generics(params: Vec<GenericParam>, span: Span) -> Generics {
+fn mk_generics(params: Vec<GenericParamAST>, span: Span) -> Generics {
     Generics {
         params,
         where_clause: ast::WhereClause {
@@ -280,13 +280,13 @@ impl<'a> LifetimeBounds<'a> {
                 let bounds = bounds.iter()
                     .map(|b| cx.lifetime(span, Ident::from_str(b)))
                     .collect();
-                GenericParam::Lifetime(cx.lifetime_def(span, Ident::from_str(lt), vec![], bounds))
+                GenericParamAST::Lifetime(cx.lifetime_def(span, Ident::from_str(lt), vec![], bounds))
             })
             .chain(self.bounds
                 .iter()
                 .map(|t| {
                     let (name, ref bounds) = *t;
-                    GenericParam::Type(mk_ty_param(
+                    GenericParamAST::Type(mk_ty_param(
                         cx, span, name, &[], &bounds, self_ty, self_generics
                     ))
                 })