Rename ty::GenericParameterDef to GenericParam

src/librustc/ich/impls_ty.rs

@@ -753,7 +753,7 @@ fn hash_stable<W: StableHasherResult>(&self,
     }
 }
 
-impl_stable_hash_for!(enum ty::GenericParameterDef {
+impl_stable_hash_for!(enum ty::GenericParam {
     Lifetime(lt),
     Type(ty)
 });

src/librustc/ty/mod.rs

@@ -758,16 +758,16 @@ pub fn to_bound_region(&self) -> ty::BoundRegion {
 }
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
-pub enum GenericParameterDef {
+pub enum GenericParam {
     Lifetime(RegionParameterDef),
     Type(TypeParameterDef),
 }
 
-impl GenericParameterDef {
+impl GenericParam {
     pub fn index(&self) -> u32 {
         match self {
-            GenericParameterDef::Lifetime(lt) => lt.index,
-            GenericParameterDef::Type(ty)     => ty.index,
+            GenericParam::Lifetime(lt) => lt.index,
+            GenericParam::Type(ty)     => ty.index,
         }
     }
 }
@@ -785,7 +785,7 @@ pub fn index(&self) -> u32 {
 pub struct Generics {
     pub parent: Option<DefId>,
     pub parent_count: usize,
-    pub params: Vec<GenericParameterDef>,
+    pub params: Vec<GenericParam>,
 
     /// Reverse map to each `TypeParameterDef`'s `index` field
     pub type_param_to_index: FxHashMap<DefId, u32>,
@@ -805,7 +805,7 @@ pub fn count(&self) -> usize {
 
     pub fn lifetimes(&self) -> Vec<&RegionParameterDef> {
         self.params.iter().filter_map(|p| {
-            if let GenericParameterDef::Lifetime(lt) = p {
+            if let GenericParam::Lifetime(lt) = p {
                 Some(lt)
             } else {
                 None
@@ -815,7 +815,7 @@ pub fn lifetimes(&self) -> Vec<&RegionParameterDef> {
 
     pub fn types(&self) -> Vec<&TypeParameterDef> {
         self.params.iter().filter_map(|p| {
-            if let GenericParameterDef::Type(ty) = p {
+            if let GenericParam::Type(ty) = p {
                 Some(ty)
             } else {
                 None
@@ -843,7 +843,7 @@ pub fn region_param(&'tcx self,
         if let Some(index) = param.index.checked_sub(self.parent_count as u32) {
             // We're currently assuming that lifetimes precede other generic parameters.
             match self.params[index as usize - self.has_self as usize] {
-                ty::GenericParameterDef::Lifetime(ref lt) => lt,
+                ty::GenericParam::Lifetime(ref lt) => lt,
                 _ => bug!("expected region parameter, but found another generic parameter")
             }
         } else {
@@ -893,13 +893,13 @@ pub fn type_param(&'tcx self,
             if let Some(_) = (idx as usize).checked_sub(type_param_offset) {
                 assert!(!is_separated_self, "found a Self after type_param_offset");
                 match self.params[idx as usize] {
-                    ty::GenericParameterDef::Type(ref ty) => ty,
+                    ty::GenericParam::Type(ref ty) => ty,
                     _ => bug!("expected type parameter, but found another generic parameter")
                 }
             } else {
                 assert!(is_separated_self, "non-Self param before type_param_offset");
                 match self.params[type_param_offset] {
-                    ty::GenericParameterDef::Type(ref ty) => ty,
+                    ty::GenericParam::Type(ref ty) => ty,
                     _ => bug!("expected type parameter, but found another generic parameter")
                 }
             }

src/librustc/ty/subst.rs

@@ -254,10 +254,10 @@ fn fill_single<FR, FT>(substs: &mut Vec<Kind<'tcx>>,
 
         for def in &defs.params {
             let param = match def {
-                ty::GenericParameterDef::Lifetime(ref lt) => {
+                ty::GenericParam::Lifetime(ref lt) => {
                     UnpackedKind::Lifetime(mk_region(lt, substs))
                 }
-                ty::GenericParameterDef::Type(ref ty) => {
+                ty::GenericParam::Type(ref ty) => {
                     if skip_self {
                         skip_self = false;
                         continue

src/librustc_typeck/collect.rs

@@ -970,10 +970,10 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                    .map(|param| (param.def_id, param.index))
                                    .collect();
 
-    let lifetimes: Vec<ty::GenericParameterDef> =
-        regions.into_iter().map(|lt| ty::GenericParameterDef::Lifetime(lt)).collect();
-    let types: Vec<ty::GenericParameterDef> =
-        types.into_iter().map(|ty| ty::GenericParameterDef::Type(ty)).collect();
+    let lifetimes: Vec<ty::GenericParam> =
+        regions.into_iter().map(|lt| ty::GenericParam::Lifetime(lt)).collect();
+    let types: Vec<ty::GenericParam> =
+        types.into_iter().map(|ty| ty::GenericParam::Type(ty)).collect();
     let params = lifetimes.into_iter().chain(types.into_iter()).collect();
 
     tcx.alloc_generics(ty::Generics {