Refactor ast::GenericParam as a struct

3 files changed, 29 insertions, 31 deletions

diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
index 4bc8d208bab..cbf7b1e0876 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, GenericParamAST, Generics, Ident, PatKind};
-use syntax::ast::{VariantData, GenericArgAST};
+use syntax::ast::{self, BinOpKind, EnumDef, Expr, Generics, Ident, PatKind};
+use syntax::ast::{VariantData, GenericParamKindAST, GenericArgAST};
 use syntax::attr;
 use syntax::ext::base::{Annotatable, ExtCtxt};
 use syntax::ext::build::AstBuilder;
@@ -547,9 +547,9 @@ impl<'a> TraitDef<'a> {
 
         // Create the generic parameters
         params.extend(generics.params.iter().map(|param| {
-            match *param {
-                ref l @ GenericParamAST::Lifetime(_) => l.clone(),
-                GenericParamAST::Type(ref ty_param) => {
+            match param.kind {
+                GenericParamKindAST::Lifetime { .. } => param.clone(),
+                GenericParamKindAST::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<_> =
@@ -564,12 +564,11 @@ impl<'a> TraitDef<'a> {
                     bounds.push(cx.typarambound(trait_path.clone()));
 
                     // also add in any bounds from the declaration
-                    for declared_bound in ty_param.bounds.iter() {
+                    for declared_bound in ty_bounds {
                         bounds.push((*declared_bound).clone());
                     }
 
-                    let ty_param = cx.typaram(self.span, ty_param.ident, vec![], bounds, None);
-                    GenericParamAST::Type(ty_param)
+                    cx.typaram(self.span, param.ident, vec![], bounds, None)
                 }
             }
         }));
@@ -607,8 +606,8 @@ impl<'a> TraitDef<'a> {
             // Extra scope required here so ty_params goes out of scope before params is moved
 
             let mut ty_params = params.iter()
-                .filter_map(|param| match *param {
-                    ast::GenericParamAST::Type(ref t) => Some(t),
+                .filter_map(|param| match param.kind {
+                    ast::GenericParamKindAST::Type { .. } => Some(param),
                     _ => None,
                 })
                 .peekable();
@@ -668,17 +667,16 @@ impl<'a> TraitDef<'a> {
         // Create the type parameters on the `self` path.
         let self_ty_params: Vec<P<ast::Ty>> = generics.params
             .iter()
-            .filter_map(|param| match *param {
-                GenericParamAST::Type(ref ty_param)
-                    => Some(cx.ty_ident(self.span, ty_param.ident)),
+            .filter_map(|param| match param.kind {
+                GenericParamKindAST::Type { .. } => Some(cx.ty_ident(self.span, param.ident)),
                 _ => None,
             })
             .collect();
 
         let self_lifetimes: Vec<ast::Lifetime> = generics.params
             .iter()
-            .filter_map(|param| match *param {
-                GenericParamAST::Lifetime(ref ld) => Some(ld.lifetime),
+            .filter_map(|param| match param.kind {
+                GenericParamKindAST::Lifetime { ref lifetime, .. } => Some(*lifetime),
                 _ => None,
             })
             .collect();
diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs
index 22487e7bfe3..c9f274ed210 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, GenericParamAST, Generics, Ident, SelfKind, GenericArgAST};
+use syntax::ast::{Expr, GenericParamKindAST, Generics, Ident, SelfKind, GenericArgAST};
 use syntax::ext::base::ExtCtxt;
 use syntax::ext::build::AstBuilder;
 use syntax::codemap::{respan, DUMMY_SP};
@@ -191,9 +191,9 @@ impl<'a> Ty<'a> {
             Self_ => {
                 let ty_params: Vec<P<ast::Ty>> = self_generics.params
                     .iter()
-                    .filter_map(|param| match *param {
-                        GenericParamAST::Type(ref ty_param) => {
-                            Some(cx.ty_ident(span, ty_param.ident))
+                    .filter_map(|param| match param.kind {
+                        GenericParamKindAST::Type { .. } => {
+                            Some(cx.ty_ident(span, param.ident))
                         }
                         _ => None,
                     })
@@ -201,8 +201,8 @@ impl<'a> Ty<'a> {
 
                 let lifetimes: Vec<ast::Lifetime> = self_generics.params
                     .iter()
-                    .filter_map(|param| match *param {
-                        GenericParamAST::Lifetime(ref ld) => Some(ld.lifetime),
+                    .filter_map(|param| match param.kind {
+                        GenericParamKindAST::Lifetime { ref lifetime, .. } => Some(*lifetime),
                         _ => None,
                     })
                     .collect();
@@ -234,7 +234,7 @@ fn mk_ty_param(cx: &ExtCtxt,
                bounds: &[Path],
                self_ident: Ident,
                self_generics: &Generics)
-               -> ast::TyParam {
+               -> ast::GenericParamAST {
     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<GenericParamAST>, span: Span) -> Generics {
+fn mk_generics(params: Vec<ast::GenericParamAST>, span: Span) -> Generics {
     Generics {
         params,
         where_clause: ast::WhereClause {
@@ -282,16 +282,13 @@ impl<'a> LifetimeBounds<'a> {
                 let bounds = bounds.iter()
                     .map(|b| cx.lifetime(span, Ident::from_str(b)))
                     .collect();
-                let lifetime_def = cx.lifetime_def(span, Ident::from_str(lt), vec![], bounds);
-                GenericParamAST::Lifetime(lifetime_def)
+                cx.lifetime_def(span, Ident::from_str(lt), vec![], bounds)
             })
             .chain(self.bounds
                 .iter()
                 .map(|t| {
                     let (name, ref bounds) = *t;
-                    GenericParamAST::Type(mk_ty_param(
-                        cx, span, name, &[], &bounds, self_ty, self_generics
-                    ))
+                    mk_ty_param(cx, span, name, &[], &bounds, self_ty, self_generics)
                 })
             )
             .collect();
diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs
index 9bc19bb5ede..6813ce4c265 100644
--- a/src/libsyntax_ext/deriving/mod.rs
+++ b/src/libsyntax_ext/deriving/mod.rs
@@ -134,9 +134,12 @@ fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String {
         match item.node {
             ast::ItemKind::Struct(_, ast::Generics { ref params, .. }) |
             ast::ItemKind::Enum(_, ast::Generics { ref params, .. }) => {
-                for param in params.iter() {
-                    if let ast::GenericParamAST::Type(ref ty) = *param {
-                        typaram.push_str(&ty.ident.as_str());
+                for param in params {
+                    match param.kind {
+                        ast::GenericParamKindAST::Type { .. } => {
+                            typaram.push_str(&param.ident.as_str());
+                        }
+                        _ => {}
                     }
                 }
             }