impl_stable_hash_for!(struct ty::ParamEnv<'tcx> {
caller_bounds,
- reveal
+ reveal,
+ def_id
});
impl_stable_hash_for!(enum traits::Reveal {
computed_preds.extend(user_computed_preds.iter().cloned());
let normalized_preds =
elaborate_predicates(tcx, computed_preds.clone().into_iter().collect());
- new_env = ty::ParamEnv::new(tcx.mk_predicates(normalized_preds), param_env.reveal);
+ new_env = ty::ParamEnv::new(
+ tcx.mk_predicates(normalized_preds),
+ param_env.reveal,
+ None
+ );
}
let final_user_env = ty::ParamEnv::new(
tcx.mk_predicates(user_computed_preds.into_iter()),
user_env.reveal,
+ None
);
debug!(
"evaluate_nested_obligations(ty_did={:?}, trait_did={:?}): succeeded with '{:?}' \
debug!("normalize_param_env_or_error: elaborated-predicates={:?}",
predicates);
- let elaborated_env = ty::ParamEnv::new(tcx.intern_predicates(&predicates),
- unnormalized_env.reveal);
+ let elaborated_env = ty::ParamEnv::new(
+ tcx.intern_predicates(&predicates),
+ unnormalized_env.reveal,
+ unnormalized_env.def_id
+ );
// HACK: we are trying to normalize the param-env inside *itself*. The problem is that
// normalization expects its param-env to be already normalized, which means we have
// predicates here anyway. Keeping them here anyway because it seems safer.
let outlives_env: Vec<_> =
non_outlives_predicates.iter().chain(&outlives_predicates).cloned().collect();
- let outlives_env = ty::ParamEnv::new(tcx.intern_predicates(&outlives_env),
- unnormalized_env.reveal);
+ let outlives_env = ty::ParamEnv::new(
+ tcx.intern_predicates(&outlives_env),
+ unnormalized_env.reveal,
+ None
+ );
let outlives_predicates =
match do_normalize_predicates(tcx, region_context, cause,
outlives_env, outlives_predicates) {
let mut predicates = non_outlives_predicates;
predicates.extend(outlives_predicates);
debug!("normalize_param_env_or_error: final predicates={:?}", predicates);
- ty::ParamEnv::new(tcx.intern_predicates(&predicates), unnormalized_env.reveal)
+ ty::ParamEnv::new(
+ tcx.intern_predicates(&predicates),
+ unnormalized_env.reveal,
+ unnormalized_env.def_id
+ )
}
pub fn fully_normalize<'a, 'gcx, 'tcx, T>(
/// want `Reveal::All` -- note that this is always paired with an
/// empty environment. To get that, use `ParamEnv::reveal()`.
pub reveal: traits::Reveal,
+
+ /// If this `ParamEnv` comes from a call to `tcx.param_env(def_id)`,
+ /// register that `def_id` (useful for transitioning to the chalk trait
+ /// solver).
+ pub def_id: Option<DefId>,
}
impl<'tcx> ParamEnv<'tcx> {
/// type-checking.
#[inline]
pub fn empty() -> Self {
- Self::new(List::empty(), Reveal::UserFacing)
+ Self::new(List::empty(), Reveal::UserFacing, None)
}
/// Construct a trait environment with no where clauses in scope
/// or invoke `param_env.with_reveal_all()`.
#[inline]
pub fn reveal_all() -> Self {
- Self::new(List::empty(), Reveal::All)
+ Self::new(List::empty(), Reveal::All, None)
}
/// Construct a trait environment with the given set of predicates.
#[inline]
- pub fn new(caller_bounds: &'tcx List<ty::Predicate<'tcx>>,
- reveal: Reveal)
- -> Self {
- ty::ParamEnv { caller_bounds, reveal }
+ pub fn new(
+ caller_bounds: &'tcx List<ty::Predicate<'tcx>>,
+ reveal: Reveal,
+ def_id: Option<DefId>
+ ) -> Self {
+ ty::ParamEnv { caller_bounds, reveal, def_id }
}
/// Returns a new parameter environment with the same clauses, but
// are any errors at that point, so after type checking you can be
// sure that this will succeed without errors anyway.
- let unnormalized_env = ty::ParamEnv::new(tcx.intern_predicates(&predicates),
- traits::Reveal::UserFacing);
+ let unnormalized_env = ty::ParamEnv::new(
+ tcx.intern_predicates(&predicates),
+ traits::Reveal::UserFacing,
+ Some(def_id)
+ );
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)
ty::ParamEnv {
reveal: self.reveal,
caller_bounds,
+ def_id: self.def_id,
}
})
}
}
BraceStructTypeFoldableImpl! {
- impl<'tcx> TypeFoldable<'tcx> for ty::ParamEnv<'tcx> { reveal, caller_bounds }
+ impl<'tcx> TypeFoldable<'tcx> for ty::ParamEnv<'tcx> { reveal, caller_bounds, def_id }
}
impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::List<ty::ExistentialPredicate<'tcx>> {
// The key step here is to update the caller_bounds's predicates to be
// 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);
+ let param_env = ty::ParamEnv::new(
+ tcx.intern_predicates(&hybrid_preds.predicates),
+ Reveal::UserFacing,
+ None
+ );
let param_env = traits::normalize_param_env_or_error(tcx,
impl_m.def_id,
param_env,