subst_supertrait

Author: lcnr

src/librustc_infer/traits/util.rs

@@ -156,10 +156,10 @@ impl Elaborator<'tcx> {
  // Get predicates declared on the trait.
  let predicates = tcx.super_predicates_of(data.def_id());
 
- let obligations = predicates.predicates.iter().map(|(pred, span)| {
+ let obligations = predicates.predicates.iter().map(|&(pred, span)| {
  predicate_obligation(
  pred.subst_supertrait(tcx, &data.to_poly_trait_ref()),
- Some(*span),
+ Some(span),
  )
  });
  debug!("super_predicates: data={:?}", data);

src/librustc_middle/ty/mod.rs

@@ -1303,37 +1303,20 @@ impl<'tcx> Predicate<'tcx> {
  // this trick achieves that).
 
  let substs = trait_ref.skip_binder().substs;
- let kind = self.kind();
- let new = match kind {
- &PredicateKind::Trait(ref binder, constness) => {
- PredicateKind::Trait(binder.map_bound(|data| data.subst(tcx, substs)), constness)
- }
- PredicateKind::Subtype(binder) => {
- PredicateKind::Subtype(binder.map_bound(|data| data.subst(tcx, substs)))
- }
- PredicateKind::RegionOutlives(binder) => {
- PredicateKind::RegionOutlives(binder.map_bound(|data| data.subst(tcx, substs)))
- }
- PredicateKind::TypeOutlives(binder) => {
- PredicateKind::TypeOutlives(binder.map_bound(|data| data.subst(tcx, substs)))
- }
- PredicateKind::Projection(binder) => {
- PredicateKind::Projection(binder.map_bound(|data| data.subst(tcx, substs)))
- }
- &PredicateKind::WellFormed(data) => PredicateKind::WellFormed(data.subst(tcx, substs)),
- &PredicateKind::ObjectSafe(trait_def_id) => PredicateKind::ObjectSafe(trait_def_id),
- &PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
- PredicateKind::ClosureKind(closure_def_id, closure_substs.subst(tcx, substs), kind)
- }
- &PredicateKind::ConstEvaluatable(def_id, const_substs) => {
- PredicateKind::ConstEvaluatable(def_id, const_substs.subst(tcx, substs))
- }
- PredicateKind::ConstEquate(c1, c2) => {
- PredicateKind::ConstEquate(c1.subst(tcx, substs), c2.subst(tcx, substs))
- }
+ let kind = match self.kint(tcx) {
+ PredicateKint::ForAll(binder) => *binder.skip_binder(),
+ kind => kind,
+ };
+
+ let new = kind.subst(tcx, substs);
+
+ let rebound = if new.has_escaping_bound_vars() {
+ PredicateKint::ForAll(Binder::bind(tcx.intern_predicate_kint(new)))
+ } else {
+ new
  };
 
- if new != *kind { new.to_predicate(tcx) } else { self }
+ if rebound != *kind { rebound.to_predicate(tcx) } else { self }
  }
 }