Rename ast::GenericParam and ast::GenericArg

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

6 files changed, 27 insertions, 27 deletions

diff --git a/src/libsyntax_ext/deriving/clone.rs b/src/libsyntax_ext/deriving/clone.rs
index 504c3f8e913..40d49b49960 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::GenericArg;
+use syntax::ast::GenericArgAST;
 use syntax::attr;
 use syntax::ext::base::{Annotatable, ExtCtxt};
 use syntax::ext::build::AstBuilder;
@@ -124,7 +124,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![GenericArg::Type(ty)], vec![]);
+                                        vec![GenericArgAST::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 00ab39032ac..e9bcf70e90c 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, GenericArg};
+use syntax::ast::{self, Expr, MetaItem, GenericArgAST};
 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![GenericArg::Type(ty)], vec![]);
+                                        vec![GenericArgAST::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 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
                     ))
                 })
diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs
index a5b348a661a..9bc19bb5ede 100644
--- a/src/libsyntax_ext/deriving/mod.rs
+++ b/src/libsyntax_ext/deriving/mod.rs
@@ -135,7 +135,7 @@ fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String {
             ast::ItemKind::Struct(_, ast::Generics { ref params, .. }) |
             ast::ItemKind::Enum(_, ast::Generics { ref params, .. }) => {
                 for param in params.iter() {
-                    if let ast::GenericParam::Type(ref ty) = *param{
+                    if let ast::GenericParamAST::Type(ref ty) = *param {
                         typaram.push_str(&ty.ident.as_str());
                     }
                 }
diff --git a/src/libsyntax_ext/env.rs b/src/libsyntax_ext/env.rs
index 5c3080260cc..a3254788d45 100644
--- a/src/libsyntax_ext/env.rs
+++ b/src/libsyntax_ext/env.rs
@@ -13,7 +13,7 @@
 // interface.
 //
 
-use syntax::ast::{self, Ident, GenericArg};
+use syntax::ast::{self, Ident, GenericArgAST};
 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![GenericArg::Type(cx.ty_rptr(sp,
+                                     vec![GenericArgAST::Type(cx.ty_rptr(sp,
                                                      cx.ty_ident(sp, Ident::from_str("str")),
                                                      Some(lt),
                                                      ast::Mutability::Immutable))],