remove impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for PolyProjectionPredicate<'tcx>

Author: zirconium-n

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -2188,16 +2188,18 @@ pub(super) fn check_type_bounds<'tcx>(
                 //
                 // impl<T> X for T where T: X { type Y = <T as X>::Y; }
             }
-            _ => predicates.push(
-                ty::Binder::bind_with_vars(
+            _ => {
+                let pred: ty::Predicate<'_> = ty::Binder::bind_with_vars(
                     ty::ProjectionPredicate {
                         projection_ty: tcx.mk_alias_ty(trait_ty.def_id, rebased_args),
                         term: normalize_impl_ty.into(),
                     },
                     bound_vars,
                 )
-                .to_predicate(tcx),
-            ),
+                .to_predicate(tcx);
+
+                predicates.push(pred.expect_clause())
+            }
         };
         ty::ParamEnv::new(tcx.mk_clauses(&predicates), Reveal::UserFacing)
     };

compiler/rustc_middle/src/ty/mod.rs

@@ -1316,13 +1316,6 @@ impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for ProjectionPredicate<'tcx> {
     }
 }
 
-impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for PolyProjectionPredicate<'tcx> {
-    fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx> {
-        let p: Predicate<'tcx> = self.to_predicate(tcx);
-        p.expect_clause()
-    }
-}
-
 impl<'tcx> ToPredicate<'tcx> for TraitPredicate<'tcx> {
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
         PredicateKind::Clause(ClauseKind::Trait(self)).to_predicate(tcx)

compiler/rustc_middle/src/ty/sty.rs

@@ -725,7 +725,9 @@ impl<'tcx> PolyExistentialPredicate<'tcx> {
                 self.rebind(tr).with_self_ty(tcx, self_ty).to_predicate(tcx)
             }
             ExistentialPredicate::Projection(p) => {
-                self.rebind(p.with_self_ty(tcx, self_ty)).to_predicate(tcx)
+                let pred: ty::Predicate<'tcx> =
+                    self.rebind(p.with_self_ty(tcx, self_ty)).to_predicate(tcx);
+                pred.expect_clause()
             }
             ExistentialPredicate::AutoTrait(did) => {
                 let generics = tcx.generics_of(did);

compiler/rustc_trait_selection/src/solve/project_goals.rs

@@ -331,16 +331,22 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> {
             ty::TraitRef::from_lang_item(tcx, LangItem::Sized, DUMMY_SP, [output])
         });
 
-        let pred = tupled_inputs_and_output
+        let pred: ty::Predicate<'_> = tupled_inputs_and_output
             .map_bound(|(inputs, output)| ty::ProjectionPredicate {
                 projection_ty: tcx
                     .mk_alias_ty(goal.predicate.def_id(), [goal.predicate.self_ty(), inputs]),
                 term: output.into(),
             })
             .to_predicate(tcx);
+
         // A built-in `Fn` impl only holds if the output is sized.
         // (FIXME: technically we only need to check this if the type is a fn ptr...)
-        Self::consider_implied_clause(ecx, goal, pred, [goal.with(tcx, output_is_sized_pred)])
+        Self::consider_implied_clause(
+            ecx,
+            goal,
+            pred.expect_clause(),
+            [goal.with(tcx, output_is_sized_pred)],
+        )
     }
 
     fn consider_builtin_tuple_candidate(

compiler/rustc_trait_selection/src/traits/project.rs

@@ -1644,7 +1644,10 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
     let env_predicates = data
         .projection_bounds()
         .filter(|bound| bound.item_def_id() == obligation.predicate.def_id)
-        .map(|p| p.with_self_ty(tcx, object_ty).to_predicate(tcx));
+        .map(|p| {
+            let pred: ty::Predicate<'_> = p.with_self_ty(tcx, object_ty).to_predicate(tcx);
+            pred.expect_clause()
+        });
 
     assemble_candidates_from_predicates(
         selcx,

compiler/rustc_ty_utils/src/ty.rs

@@ -220,13 +220,12 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ImplTraitInTraitFinder<'_, 'tcx> {
             // strategy, then just reinterpret the associated type like an opaque :^)
             let default_ty = self.tcx.type_of(shifted_alias_ty.def_id).instantiate(self.tcx, shifted_alias_ty.args);
 
-            self.predicates.push(
-                ty::Binder::bind_with_vars(
-                    ty::ProjectionPredicate { projection_ty: shifted_alias_ty, term: default_ty.into() },
-                    self.bound_vars,
-                )
-                .to_predicate(self.tcx),
-            );
+            let pred: ty::Predicate<'_> = ty::Binder::bind_with_vars(
+                ty::ProjectionPredicate { projection_ty: shifted_alias_ty, term: default_ty.into() },
+                self.bound_vars,
+            )
+            .to_predicate(self.tcx);
+            self.predicates.push(pred.expect_clause());
 
             // We walk the *un-shifted* alias ty, because we're tracking the de bruijn
             // binder depth, and if we were to walk `shifted_alias_ty` instead, we'd