happy accidents

Author: lcnr

src/librustc_middle/ty/mod.rs

@@ -1054,7 +1054,12 @@ impl<'tcx> Predicate<'tcx> {
             | ty::PredicateKind::TypeOutlives(..)
             | ty::PredicateKind::ConstEvaluatable(..)
             | ty::PredicateKind::ConstEquate(..)
-            | ty::PredicateKind::RegionOutlives(..) => Binder::dummy(self),
+            | ty::PredicateKind::RegionOutlives(..) => {
+                // We can't use `Binder::dummy` here, as predicates can
+                // contain unbound variables in rare cases, for example when
+                // dealing with opaque types.
+                Binder::bind(self)
+            }
         }
     }
 
@@ -1065,9 +1070,7 @@ impl<'tcx> Predicate<'tcx> {
         qualifier: impl FnOnce(Binder<Predicate<'tcx>>) -> PredicateKind<'tcx>,
     ) -> Predicate<'tcx> {
         if self.has_escaping_bound_vars() {
-            let qualified = qualifier(Binder::bind(self)).to_predicate(tcx);
-            debug_assert!(!qualified.has_escaping_bound_vars(), "qualified: {:?}", qualified);
-            qualified
+            qualifier(Binder::bind(self)).to_predicate(tcx)
         } else {
             self
         }

src/librustc_trait_selection/traits/mod.rs

@@ -328,7 +328,7 @@ pub fn normalize_param_env_or_error<'tcx>(
     // This works fairly well because trait matching  does not actually care about param-env
     // TypeOutlives predicates - these are normally used by regionck.
     let outlives_predicates: Vec<_> = predicates
-        .drain_filter(|predicate| match predicate.kind() {
+        .drain_filter(|predicate| match predicate.ignore_qualifiers().skip_binder().kind() {
             ty::PredicateKind::TypeOutlives(..) => true,
             _ => false,
         })

src/librustc_trait_selection/traits/project.rs

@@ -663,7 +663,7 @@ fn prune_cache_value_obligations<'a, 'tcx>(
     let mut obligations: Vec<_> = result
         .obligations
         .iter()
-        .filter(|obligation| match obligation.predicate.kind() {
+        .filter(|obligation| match obligation.predicate.ignore_qualifiers().skip_binder().kind() {
             // We found a `T: Foo<X = U>` predicate, let's check
             // if `U` references any unresolved type
             // variables. In principle, we only care if this
@@ -673,8 +673,8 @@ fn prune_cache_value_obligations<'a, 'tcx>(
             // indirect obligations (e.g., we project to `?0`,
             // but we have `T: Foo<X = ?1>` and `?1: Bar<X =
             // ?0>`).
-            ty::PredicateKind::Projection(ref data) => {
-                infcx.unresolved_type_vars(&data.ty).is_some()
+            &ty::PredicateKind::Projection(data) => {
+                infcx.unresolved_type_vars(&ty::Binder::bind(data.ty)).is_some()
             }
 
             // We are only interested in `T: Foo<X = U>` predicates, whre

src/librustc_trait_selection/traits/select/mod.rs

@@ -793,7 +793,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     }
 
     fn coinductive_predicate(&self, predicate: ty::Predicate<'tcx>) -> bool {
-        let result = match predicate.kind() {
+        let result = match predicate.ignore_qualifiers().skip_binder().kind() {
             ty::PredicateKind::Trait(ref data, _) => self.tcx().trait_is_auto(data.def_id()),
             _ => false,
         };

src/librustc_typeck/check/dropck.rs

@@ -226,12 +226,15 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
         // could be extended easily also to the other `Predicate`.
         let predicate_matches_closure = |p: Predicate<'tcx>| {
             let mut relator: SimpleEqRelation<'tcx> = SimpleEqRelation::new(tcx, self_param_env);
-            match (predicate.kind(), p.kind()) {
-                (ty::PredicateKind::Trait(a, _), ty::PredicateKind::Trait(b, _)) => {
-                    relator.relate(a, b).is_ok()
+            match (
+                predicate.ignore_qualifiers().skip_binder().kind(),
+                p.ignore_qualifiers().skip_binder().kind(),
+            ) {
+                (&ty::PredicateKind::Trait(a, _), &ty::PredicateKind::Trait(b, _)) => {
+                    relator.relate(&ty::Binder::bind(a), &ty::Binder::bind(b)).is_ok()
                 }
-                (ty::PredicateKind::Projection(a), ty::PredicateKind::Projection(b)) => {
-                    relator.relate(a, b).is_ok()
+                (&ty::PredicateKind::Projection(a), &ty::PredicateKind::Projection(b)) => {
+                    relator.relate(&ty::Binder::bind(a), &ty::Binder::bind(b)).is_ok()
                 }
                 _ => predicate == p,
             }

src/librustc_typeck/collect.rs

@@ -993,7 +993,7 @@ fn super_predicates_of(tcx: TyCtxt<'_>, trait_def_id: DefId) -> ty::GenericPredi
     // which will, in turn, reach indirect supertraits.
     for &(pred, span) in superbounds {
         debug!("superbound: {:?}", pred);
-        if let ty::PredicateKind::Trait(bound, _) = pred.kind() {
+        if let ty::PredicateKind::Trait(bound, _) = pred.ignore_qualifiers().skip_binder().kind() {
             tcx.at(span).super_predicates_of(bound.def_id());
         }
     }

src/librustc_typeck/impl_wf_check/min_specialization.rs

@@ -361,7 +361,7 @@ fn check_predicates<'tcx>(
 
 fn check_specialization_on<'tcx>(tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tcx>, span: Span) {
     debug!("can_specialize_on(predicate = {:?})", predicate);
-    match predicate.kind() {
+    match predicate.ignore_qualifiers().skip_binder().kind() {
         // Global predicates are either always true or always false, so we
         // are fine to specialize on.
         _ if predicate.is_global() => (),
@@ -394,7 +394,7 @@ fn trait_predicate_kind<'tcx>(
     tcx: TyCtxt<'tcx>,
     predicate: ty::Predicate<'tcx>,
 ) -> Option<TraitSpecializationKind> {
-    match predicate.kind() {
+    match predicate.ignore_qualifiers().skip_binder().kind() {
         ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", predicate),
         ty::PredicateKind::Trait(pred, hir::Constness::NotConst) => {
             Some(tcx.trait_def(pred.def_id()).specialization_kind)

src/librustdoc/clean/auto_trait.rs

@@ -465,7 +465,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
             .iter()
             .filter(|p| {
                 !orig_bounds.contains(p)
-                    || match p.kind() {
+                    || match p.ignore_qualifiers().skip_binder().kind() {
                         ty::PredicateKind::Trait(pred, _) => pred.def_id() == sized_trait,
                         _ => false,
                     }

src/test/ui/specialization/min_specialization/repeated_projection_type.stderr

@@ -1,4 +1,4 @@
-error: cannot specialize on `Binder(ProjectionPredicate(ProjectionTy { substs: [V], item_def_id: DefId(0:6 ~ repeated_projection_type[317d]::Id[0]::This[0]) }, (I,)))`
+error: cannot specialize on `ProjectionPredicate(ProjectionTy { substs: [V], item_def_id: DefId(0:6 ~ repeated_projection_type[317d]::Id[0]::This[0]) }, (I,))`
   --> $DIR/repeated_projection_type.rs:19:1
    |
 LL | / impl<I, V: Id<This = (I,)>> X for V {