From 178a8f1139ddad2aa59ce0e54cf10659dc4eed30 Mon Sep 17 00:00:00 2001 From: varkor Date: Thu, 12 Apr 2018 17:53:29 +0100 Subject: [PATCH] Rename GenericParam to GenericParamDef --- src/librustc/ich/impls_ty.rs | 2 +- src/librustc/ty/mod.rs | 22 +++++++++++----------- src/librustc/ty/subst.rs | 4 ++-- src/librustc_typeck/collect.rs | 4 ++-- src/librustdoc/clean/auto_trait.rs | 6 +++--- src/librustdoc/clean/mod.rs | 30 +++++++++++++++--------------- src/librustdoc/html/format.rs | 6 +++--- src/librustdoc/html/render.rs | 2 +- 8 files changed, 38 insertions(+), 38 deletions(-) diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index dd09af10bd93..35c92dd48aa4 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -753,7 +753,7 @@ impl<'a> HashStable> for ty::Generics { } } -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 218be48da24d..3fe12e342eba 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -758,16 +758,16 @@ impl ty::EarlyBoundRegion { } #[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 @@ impl GenericParam { pub struct Generics { pub parent: Option, pub parent_count: usize, - pub params: Vec, + pub params: Vec, /// Reverse map to each `TypeParameterDef`'s `index` field pub type_param_to_index: FxHashMap, @@ -801,7 +801,7 @@ impl<'a, 'gcx, 'tcx> Generics { pub fn lifetimes(&self) -> impl DoubleEndedIterator { 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 @@ impl<'a, 'gcx, 'tcx> Generics { pub fn types(&self) -> impl DoubleEndedIterator { 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 @@ impl<'a, 'gcx, 'tcx> Generics { 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 @@ impl<'a, 'gcx, 'tcx> Generics { 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 @@ impl<'a, 'gcx, 'tcx> Generics { 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 8acda182b976..ed342e1d37e5 100644 --- a/src/librustc/ty/subst.rs +++ b/src/librustc/ty/subst.rs @@ -253,10 +253,10 @@ impl<'a, 'gcx, 'tcx> Substs<'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 0a5830e5f86e..03b685c82e7c 100644 --- 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 ea7371f06472..f35a4c080e50 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -491,7 +491,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> { &self, tcx: TyCtxt<'b, 'c, 'd>, pred: ty::Predicate<'d>, - ) -> FxHashSet { + ) -> FxHashSet { pred.walk_tys() .flat_map(|t| { let mut regions = FxHashSet(); @@ -502,7 +502,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> { // 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 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> { 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' ty.default.take(); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 25ca42db67e4..4797b5a912a7 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1484,7 +1484,7 @@ impl<'a, 'tcx> Clean for (&'a ty::TraitRef<'tcx>, Vec 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 @@ impl<'tcx> Clean for ty::ProjectionTy<'tcx> { } #[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 @@ impl GenericParam { } } -impl Clean for hir::GenericParam { - fn clean(&self, cx: &DocContext) -> GenericParam { +impl Clean 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 @@ impl Clean for hir::GenericParam { // maybe use a Generic enum and use Vec? #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Default, Hash)] pub struct Generics { - pub params: Vec, + pub params: Vec, pub where_predicates: Vec, } @@ -1774,7 +1774,7 @@ impl Clean for hir::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 @@ impl<'a, 'tcx> Clean for (&'a ty::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 @@ impl<'tcx> Clean for ty::AssociatedItem { #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)] pub struct PolyTrait { pub trait_: Type, - pub generic_params: Vec, + pub generic_params: Vec, } /// A representation of a Type suitable for hyperlinking purposes. Ideally one can get the original @@ -3413,7 +3413,7 @@ impl Clean for doctree::Typedef { #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)] pub struct BareFunctionDecl { pub unsafety: hir::Unsafety, - pub generic_params: Vec, + pub generic_params: Vec, pub decl: FnDecl, pub abi: Abi, } @@ -4172,7 +4172,7 @@ struct RegionDeps<'tcx> { #[derive(Eq, PartialEq, Hash, Debug)] enum SimpleBound { RegionBound(Lifetime), - TraitBound(Vec, Vec, Vec, hir::TraitBoundModifier) + TraitBound(Vec, Vec, Vec, hir::TraitBoundModifier) } enum AutoTraitResult { diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index a9a4c5113747..0323e2b1f522 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -117,11 +117,11 @@ impl<'a> fmt::Display for TyParamBounds<'a> { } } -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 32cfb05bbe49..5be9000d2a5c 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1437,7 +1437,7 @@ impl DocFolder for Cache { 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()); } }