Rename GenericParam to GenericParamDef

diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
index dd09af10bd93452fb237d1d6253884ad026f9942..35c92dd48aa406bf9412d0312144a08cf5199fbb 100644 (file)
--- a/src/librustc/ich/impls_ty.rs
+++ b/src/librustc/ich/impls_ty.rs
@@ -753,7 +753,7 @@ fn hash_stable<W: StableHasherResult>(&self,
     }
 }
 
-impl_stable_hash_for!(enum ty::GenericParam {
+impl_stable_hash_for!(enum ty::GenericParamDef {
     Lifetime(lt),
     Type(ty)
 });

diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 218be48da24d50be130c675fcb3ba3d31b5847a8..3fe12e342ebab113073858723786a279bfc22e3a 100644 (file)
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -758,16 +758,16 @@ pub fn to_bound_region(&self) -> ty::BoundRegion {
 }
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
-pub enum GenericParam {
+pub enum GenericParamDef {
     Lifetime(RegionParameterDef),
     Type(TypeParameterDef),
 }
 
-impl GenericParam {
+impl GenericParamDef {
     pub fn index(&self) -> u32 {
         match self {
-            GenericParam::Lifetime(lt) => lt.index,
-            GenericParam::Type(ty)     => ty.index,
+            GenericParamDef::Lifetime(lt) => lt.index,
+            GenericParamDef::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<GenericParam>,
+    pub params: Vec<GenericParamDef>,
 
     /// Reverse map to each `TypeParameterDef`'s `index` field
     pub type_param_to_index: FxHashMap<DefId, u32>,
@@ -801,7 +801,7 @@ pub fn count(&self) -> usize {
 
     pub fn lifetimes(&self) -> impl DoubleEndedIterator<Item = &RegionParameterDef> {
         self.params.iter().filter_map(|p| {
-            if let GenericParam::Lifetime(lt) = p {
+            if let GenericParamDef::Lifetime(lt) = p {
                 Some(lt)
             } else {
                 None
@@ -811,7 +811,7 @@ pub fn lifetimes(&self) -> impl DoubleEndedIterator<Item = &RegionParameterDef>
 
     pub fn types(&self) -> impl DoubleEndedIterator<Item = &TypeParameterDef> {
         self.params.iter().filter_map(|p| {
-            if let GenericParam::Type(ty) = p {
+            if let GenericParamDef::Type(ty) = p {
                 Some(ty)
             } else {
                 None
@@ -821,7 +821,7 @@ pub fn types(&self) -> impl DoubleEndedIterator<Item = &TypeParameterDef> {
 
     pub fn requires_monomorphization(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> bool {
         if self.params.iter().any(|p| {
-            if let GenericParam::Type(_) = p { true } else { false }
+            if let GenericParamDef::Type(_) = p { true } else { false }
         }) {
             return true;
         }
@@ -841,7 +841,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::GenericParam::Lifetime(ref lt) => lt,
+                ty::GenericParamDef::Lifetime(ref lt) => lt,
                 _ => bug!("expected region parameter, but found another generic parameter")
             }
         } else {
@@ -891,13 +891,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::GenericParam::Type(ref ty) => ty,
+                    ty::GenericParamDef::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::GenericParam::Type(ref ty) => ty,
+                    ty::GenericParamDef::Type(ref ty) => ty,
                     _ => bug!("expected type parameter, but found another generic parameter")
                 }
             }

diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs
index 8acda182b976b4c165ba65f85de1ea59c0567508..ed342e1d37e5754b15e0289a61f1ecd7b8557a26 100644 (file)
--- a/src/librustc/ty/subst.rs
+++ b/src/librustc/ty/subst.rs
@@ -253,10 +253,10 @@ fn fill_single<FR, FT>(substs: &mut Vec<Kind<'tcx>>,
 
         for def in &defs.params {
             let param = match def {
-                ty::GenericParam::Lifetime(ref lt) => {
+                ty::GenericParamDef::Lifetime(ref lt) => {
                     mk_region(lt, substs).into()
                 }
-                ty::GenericParam::Type(ref ty) => {
+                ty::GenericParamDef::Type(ref ty) => {
                     if skip_self {
                         skip_self = false;
                         continue

diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index 0a5830e5f86e94e630a22a792c53e84ab4c8cd77..03b685c82e7c818ab4f50bd3496655f610ecb0dd 100644 (file)
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -970,8 +970,8 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                    .map(|param| (param.def_id, param.index))
                                    .collect();
 
-    let lifetimes = regions.into_iter().map(|lt| ty::GenericParam::Lifetime(lt));
-    let types = types.into_iter().map(|ty| ty::GenericParam::Type(ty));
+    let lifetimes = regions.into_iter().map(|lt| ty::GenericParamDef::Lifetime(lt));
+    let types = types.into_iter().map(|ty| ty::GenericParamDef::Type(ty));
     let params = lifetimes.chain(types).collect();
 
     tcx.alloc_generics(ty::Generics {

diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index ea7371f0647261ad1937721183967cfea690a283..f35a4c080e50e18d0c2de523938443831025fe24 100644 (file)
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -491,7 +491,7 @@ fn extract_for_generics<'b, 'c, 'd>(
         &self,
         tcx: TyCtxt<'b, 'c, 'd>,
         pred: ty::Predicate<'d>,
-    ) -> FxHashSet<GenericParam> {
+    ) -> FxHashSet<GenericParamDef> {
         pred.walk_tys()
             .flat_map(|t| {
                 let mut regions = FxHashSet();
@@ -502,7 +502,7 @@ fn extract_for_generics<'b, 'c, 'd>(
                         // We only care about late bound regions, as we need to add them
                         // to the 'for<>' section
                         &ty::ReLateBound(_, ty::BoundRegion::BrNamed(_, name)) => {
-                            Some(GenericParam::Lifetime(Lifetime(name.to_string())))
+                            Some(GenericParamDef::Lifetime(Lifetime(name.to_string())))
                         }
                         &ty::ReVar(_) | &ty::ReEarlyBound(_) => None,
                         _ => panic!("Unexpected region type {:?}", r),
@@ -850,7 +850,7 @@ fn param_env_to_generics<'b, 'c, 'cx>(
 
         for p in generic_params.iter_mut() {
             match p {
-                &mut GenericParam::Type(ref mut ty) => {
+                &mut GenericParamDef::Type(ref mut ty) => {
                     // We never want something like 'impl<T=Foo>'
                     ty.default.take();
 

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 25ca42db67e4566ff18df6b16bdcc00d82d54301..4797b5a912a705fcdf815e4f97c5da7ce8ac04c2 100644 (file)
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1484,7 +1484,7 @@ fn clean(&self, cx: &DocContext) -> TyParamBound {
                         if let &ty::RegionKind::ReLateBound(..) = *reg {
                             debug!("  hit an ReLateBound {:?}", reg);
                             if let Some(lt) = reg.clean(cx) {
-                                late_bounds.push(GenericParam::Lifetime(lt));
+                                late_bounds.push(GenericParamDef::Lifetime(lt));
                             }
                         }
                     }
@@ -1718,14 +1718,14 @@ fn clean(&self, cx: &DocContext) -> Type {
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)]
-pub enum GenericParam {
+pub enum GenericParamDef {
     Lifetime(Lifetime),
     Type(TyParam),
 }
 
-impl GenericParam {
+impl GenericParamDef {
     pub fn is_synthetic_type_param(&self) -> bool {
-        if let GenericParam::Type(ref t) = *self {
+        if let GenericParamDef::Type(ref t) = *self {
             t.synthetic.is_some()
         } else {
             false
@@ -1733,11 +1733,11 @@ pub fn is_synthetic_type_param(&self) -> bool {
     }
 }
 
-impl Clean<GenericParam> for hir::GenericParam {
-    fn clean(&self, cx: &DocContext) -> GenericParam {
+impl Clean<GenericParamDef> for hir::GenericParam {
+    fn clean(&self, cx: &DocContext) -> GenericParamDef {
         match *self {
-            hir::GenericParam::Lifetime(ref l) => GenericParam::Lifetime(l.clean(cx)),
-            hir::GenericParam::Type(ref t) => GenericParam::Type(t.clean(cx)),
+            hir::GenericParam::Lifetime(ref l) => GenericParamDef::Lifetime(l.clean(cx)),
+            hir::GenericParam::Type(ref t) => GenericParamDef::Type(t.clean(cx)),
         }
     }
 }
@@ -1745,7 +1745,7 @@ fn clean(&self, cx: &DocContext) -> GenericParam {
 // maybe use a Generic enum and use Vec<Generic>?
 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Default, Hash)]
 pub struct Generics {
-    pub params: Vec<GenericParam>,
+    pub params: Vec<GenericParamDef>,
     pub where_predicates: Vec<WherePredicate>,
 }
 
@@ -1774,7 +1774,7 @@ fn clean(&self, cx: &DocContext) -> Generics {
                 WherePredicate::BoundPredicate { ty: Generic(ref name), ref mut bounds } => {
                     if bounds.is_empty() {
                         for param in &mut g.params {
-                            if let GenericParam::Type(ref mut type_param) = *param {
+                            if let GenericParamDef::Type(ref mut type_param) = *param {
                                 if &type_param.name == name {
                                     mem::swap(bounds, &mut type_param.bounds);
                                     break
@@ -1851,11 +1851,11 @@ fn clean(&self, cx: &DocContext) -> Generics {
         Generics {
             params: gens.lifetimes()
                         .into_iter()
-                        .map(|lp| GenericParam::Lifetime(lp.clean(cx)))
+                        .map(|lp| GenericParamDef::Lifetime(lp.clean(cx)))
                         .chain(
                             simplify::ty_params(stripped_typarams)
                                 .into_iter()
-                                .map(|tp| GenericParam::Type(tp))
+                                .map(|tp| GenericParamDef::Type(tp))
                         )
                         .collect(),
             where_predicates: simplify::where_clauses(cx, where_predicates),
@@ -2348,7 +2348,7 @@ fn clean(&self, cx: &DocContext) -> Item {
 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)]
 pub struct PolyTrait {
     pub trait_: Type,
-    pub generic_params: Vec<GenericParam>,
+    pub generic_params: Vec<GenericParamDef>,
 }
 
 /// A representation of a Type suitable for hyperlinking purposes. Ideally one can get the original
@@ -3413,7 +3413,7 @@ fn clean(&self, cx: &DocContext) -> Item {
 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)]
 pub struct BareFunctionDecl {
     pub unsafety: hir::Unsafety,
-    pub generic_params: Vec<GenericParam>,
+    pub generic_params: Vec<GenericParamDef>,
     pub decl: FnDecl,
     pub abi: Abi,
 }
@@ -4172,7 +4172,7 @@ struct RegionDeps<'tcx> {
 #[derive(Eq, PartialEq, Hash, Debug)]
 enum SimpleBound {
     RegionBound(Lifetime),
-    TraitBound(Vec<PathSegment>, Vec<SimpleBound>, Vec<GenericParam>, hir::TraitBoundModifier)
+    TraitBound(Vec<PathSegment>, Vec<SimpleBound>, Vec<GenericParamDef>, hir::TraitBoundModifier)
 }
 
 enum AutoTraitResult {

diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index a9a4c5113747ec685f80ce7c6f74ef4097a3a669..0323e2b1f522ee5b38d19081fb833779a8517bee 100644 (file)
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -117,11 +117,11 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
     }
 }
 
-impl fmt::Display for clean::GenericParam {
+impl fmt::Display for clean::GenericParamDef {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            clean::GenericParam::Lifetime(ref lp) => write!(f, "{}", lp),
-            clean::GenericParam::Type(ref tp) => {
+            clean::GenericParamDef::Lifetime(ref lp) => write!(f, "{}", lp),
+            clean::GenericParamDef::Type(ref tp) => {
                 f.write_str(&tp.name)?;
 
                 if !tp.bounds.is_empty() {

diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 32cfb05bbe49bb752414fdca7ac8336e451597b9..5be9000d2a5ce93dc3445fe986e991a85d3515ff 100644 (file)
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -1437,7 +1437,7 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
 impl<'a> Cache {
     fn generics(&mut self, generics: &clean::Generics) {
         for param in &generics.params {
-            if let clean::GenericParam::Type(ref typ) = *param {
+            if let clean::GenericParamDef::Type(ref typ) = *param {
                 self.typarams.insert(typ.did, typ.name.clone());
             }
         }