let mut find = FindMin { tcx, effective_visibilities, min: Self::MAX };
find.visit(tcx.type_of(def_id));
if let Some(trait_ref) = tcx.impl_trait_ref(def_id) {
- find.visit_trait(trait_ref);
+ find.visit_trait(trait_ref.subst_identity());
}
find.min
}
GenericParamDefKind::Const { has_default } => {
self.visit(self.ev.tcx.type_of(param.def_id));
if has_default {
- self.visit(self.ev.tcx.const_param_default(param.def_id));
+ self.visit(self.ev.tcx.const_param_default(param.def_id).subst_identity());
}
}
}
fn trait_ref(&mut self) -> &mut Self {
if let Some(trait_ref) = self.ev.tcx.impl_trait_ref(self.item_def_id) {
- self.visit_trait(trait_ref);
+ self.visit_trait(trait_ref.subst_identity());
}
self
}
self.tcx.types.never,
);
- for (trait_predicate, _, _) in bounds.trait_bounds {
- if self.visit_trait(trait_predicate.skip_binder()).is_break() {
- return;
- }
- }
-
- for (poly_predicate, _) in bounds.projection_bounds {
- let pred = poly_predicate.skip_binder();
- let poly_pred_term = self.visit(pred.term);
- if poly_pred_term.is_break()
- || self.visit_projection_ty(pred.projection_ty).is_break()
- {
- return;
+ for (pred, _) in bounds.predicates() {
+ match pred.kind().skip_binder() {
+ ty::PredicateKind::Clause(ty::Clause::Trait(trait_predicate)) => {
+ if self.visit_trait(trait_predicate.trait_ref).is_break() {
+ return;
+ }
+ }
+ ty::PredicateKind::Clause(ty::Clause::Projection(proj_predicate)) => {
+ let term = self.visit(proj_predicate.term);
+ if term.is_break()
+ || self.visit_projection_ty(proj_predicate.projection_ty).is_break()
+ {
+ return;
+ }
+ }
+ _ => {}
}
}
}
// clauses that the compiler inferred. We only want to
// consider the ones that the user wrote. This is important
// for the inferred outlives rules; see
- // `src/test/ui/rfc-2093-infer-outlives/privacy.rs`.
+ // `tests/ui/rfc-2093-infer-outlives/privacy.rs`.
self.visit_predicates(self.tcx.explicit_predicates_of(self.item_def_id));
self
}