diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index 9a442e052993..594adfca6b3c 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -1111,7 +1111,6 @@ for ty::steal::Steal impl_stable_hash_for!(struct ty::ParamEnv<'tcx> { caller_bounds, - universe, reveal }); @@ -1282,15 +1281,6 @@ for traits::VtableGeneratorData<'gcx, N> where N: HashStable HashStable> -for ty::UniverseIndex { - fn hash_stable(&self, - hcx: &mut StableHashingContext<'a>, - hasher: &mut StableHasher) { - self.depth().hash_stable(hcx, hasher); - } -} - impl_stable_hash_for!( impl<'tcx, V> for struct infer::canonical::Canonical<'tcx, V> { variables, value diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs index a0ba88f7d559..6716d27aa1c3 100644 --- a/src/librustc/traits/mod.rs +++ b/src/librustc/traits/mod.rs @@ -610,8 +610,7 @@ pub fn normalize_param_env_or_error<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, predicates); let elaborated_env = ty::ParamEnv::new(tcx.intern_predicates(&predicates), - unnormalized_env.reveal, - unnormalized_env.universe); + unnormalized_env.reveal); tcx.infer_ctxt().enter(|infcx| { // FIXME. We should really... do something with these region @@ -685,9 +684,7 @@ pub fn normalize_param_env_or_error<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, debug!("normalize_param_env_or_error: resolved predicates={:?}", predicates); - ty::ParamEnv::new(tcx.intern_predicates(&predicates), - unnormalized_env.reveal, - unnormalized_env.universe) + ty::ParamEnv::new(tcx.intern_predicates(&predicates), unnormalized_env.reveal) }) } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 6f1132500034..0942fa2567b6 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -1338,7 +1338,9 @@ pub struct UniverseIndex(u32); impl UniverseIndex { /// The root universe, where things that the user defined are /// visible. - pub const ROOT: UniverseIndex = UniverseIndex(0); + pub fn root() -> UniverseIndex { + UniverseIndex(0) + } /// A "subuniverse" corresponds to being inside a `forall` quantifier. /// So, for example, suppose we have this type in universe `U`: @@ -1354,13 +1356,6 @@ impl UniverseIndex { pub fn subuniverse(self) -> UniverseIndex { UniverseIndex(self.0 + 1) } - - /// Gets the "depth" of this universe in the universe tree. This - /// is not really useful except for e.g. the `HashStable` - /// implementation - pub fn depth(&self) -> u32 { - self.0 - } } /// When type checking, we use the `ParamEnv` to track @@ -1377,17 +1372,6 @@ pub struct ParamEnv<'tcx> { /// want `Reveal::All` -- note that this is always paired with an /// empty environment. To get that, use `ParamEnv::reveal()`. pub reveal: traits::Reveal, - - /// What is the innermost universe we have created? Starts out as - /// `UniverseIndex::root()` but grows from there as we enter - /// universal quantifiers. - /// - /// NB: At present, we exclude the universal quantifiers on the - /// item we are type-checking, and just consider those names as - /// part of the root universe. So this would only get incremented - /// when we enter into a higher-ranked (`for<..>`) type or trait - /// bound. - pub universe: UniverseIndex, } impl<'tcx> ParamEnv<'tcx> { @@ -2707,8 +2691,7 @@ fn param_env<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // sure that this will succeed without errors anyway. let unnormalized_env = ty::ParamEnv::new(tcx.intern_predicates(&predicates), - traits::Reveal::UserFacing, - ty::UniverseIndex::ROOT); + traits::Reveal::UserFacing); let body_id = tcx.hir.as_local_node_id(def_id).map_or(DUMMY_NODE_ID, |id| { tcx.hir.maybe_body_owned_by(id).map_or(id, |body| body.node_id) diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index c9a69d5405c9..05818b578ecc 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -279,7 +279,6 @@ impl<'a, 'tcx> Lift<'tcx> for ty::ParamEnv<'a> { tcx.lift(&self.caller_bounds).map(|caller_bounds| { ty::ParamEnv { reveal: self.reveal, - universe: self.universe, caller_bounds, } }) @@ -737,29 +736,8 @@ impl<'tcx, T:TypeFoldable<'tcx>> TypeFoldable<'tcx> for ty::Binder { } } -impl<'tcx> TypeFoldable<'tcx> for ty::ParamEnv<'tcx> { - fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { - ty::ParamEnv { - reveal: self.reveal, - caller_bounds: self.caller_bounds.fold_with(folder), - universe: self.universe.fold_with(folder), - } - } - - fn super_visit_with>(&self, visitor: &mut V) -> bool { - let &ty::ParamEnv { reveal: _, ref universe, ref caller_bounds } = self; - universe.super_visit_with(visitor) || caller_bounds.super_visit_with(visitor) - } -} - -impl<'tcx> TypeFoldable<'tcx> for ty::UniverseIndex { - fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, _folder: &mut F) -> Self { - *self - } - - fn super_visit_with>(&self, _visitor: &mut V) -> bool { - false - } +BraceStructTypeFoldableImpl! { + impl<'tcx> TypeFoldable<'tcx> for ty::ParamEnv<'tcx> { reveal, caller_bounds } } impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::Slice> { diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index 60ac31ac8eba..e1e3dea9a2a1 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -218,8 +218,7 @@ fn compare_predicate_entailment<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // the new hybrid bounds we computed. let normalize_cause = traits::ObligationCause::misc(impl_m_span, impl_m_node_id); let param_env = ty::ParamEnv::new(tcx.intern_predicates(&hybrid_preds.predicates), - Reveal::UserFacing, - ty::UniverseIndex::ROOT); + Reveal::UserFacing); let param_env = traits::normalize_param_env_or_error(tcx, impl_m.def_id, param_env,