directly contain `PredicateAtom` in `PredicateKind::ForAll`

10 files changed, 163 insertions, 180 deletions

diff --git a/src/librustc_infer/infer/canonical/query_response.rs b/src/librustc_infer/infer/canonical/query_response.rs
index 8406eb9bc17..0dbebac7e36 100644
--- a/src/librustc_infer/infer/canonical/query_response.rs
+++ b/src/librustc_infer/infer/canonical/query_response.rs
@@ -531,11 +531,9 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
             let predicate = match k1.unpack() {
                 GenericArgKind::Lifetime(r1) => {
                     ty::PredicateAtom::RegionOutlives(ty::OutlivesPredicate(r1, r2))
-                        .to_predicate(self.tcx)
                 }
                 GenericArgKind::Type(t1) => {
                     ty::PredicateAtom::TypeOutlives(ty::OutlivesPredicate(t1, r2))
-                        .to_predicate(self.tcx)
                 }
                 GenericArgKind::Const(..) => {
                     // Consts cannot outlive one another, so we don't expect to
diff --git a/src/librustc_middle/ty/flags.rs b/src/librustc_middle/ty/flags.rs
index 7452089658f..27f50c240db 100644
--- a/src/librustc_middle/ty/flags.rs
+++ b/src/librustc_middle/ty/flags.rs
@@ -201,55 +201,54 @@ impl FlagComputation {
         }
     }
 
-    fn add_predicate(&mut self, pred: ty::Predicate<'_>) {
-        self.add_flags(pred.inner.flags);
-        self.add_exclusive_binder(pred.inner.outer_exclusive_binder);
-    }
-
     fn add_predicate_kind(&mut self, kind: &ty::PredicateKind<'_>) {
         match kind {
             ty::PredicateKind::ForAll(binder) => {
                 let mut computation = FlagComputation::new();
 
-                computation.add_predicate(binder.skip_binder());
+                computation.add_predicate_atom(binder.skip_binder());
 
                 self.add_bound_computation(computation);
             }
-            &ty::PredicateKind::Atom(atom) => match atom {
-                ty::PredicateAtom::Trait(trait_pred, _constness) => {
-                    self.add_substs(trait_pred.trait_ref.substs);
-                }
-                ty::PredicateAtom::RegionOutlives(ty::OutlivesPredicate(a, b)) => {
-                    self.add_region(a);
-                    self.add_region(b);
-                }
-                ty::PredicateAtom::TypeOutlives(ty::OutlivesPredicate(ty, region)) => {
-                    self.add_ty(ty);
-                    self.add_region(region);
-                }
-                ty::PredicateAtom::Subtype(ty::SubtypePredicate { a_is_expected: _, a, b }) => {
-                    self.add_ty(a);
-                    self.add_ty(b);
-                }
-                ty::PredicateAtom::Projection(ty::ProjectionPredicate { projection_ty, ty }) => {
-                    self.add_projection_ty(projection_ty);
-                    self.add_ty(ty);
-                }
-                ty::PredicateAtom::WellFormed(arg) => {
-                    self.add_substs(slice::from_ref(&arg));
-                }
-                ty::PredicateAtom::ObjectSafe(_def_id) => {}
-                ty::PredicateAtom::ClosureKind(_def_id, substs, _kind) => {
-                    self.add_substs(substs);
-                }
-                ty::PredicateAtom::ConstEvaluatable(_def_id, substs) => {
-                    self.add_substs(substs);
-                }
-                ty::PredicateAtom::ConstEquate(expected, found) => {
-                    self.add_const(expected);
-                    self.add_const(found);
-                }
-            },
+            &ty::PredicateKind::Atom(atom) => self.add_predicate_atom(atom),
+        }
+    }
+
+    fn add_predicate_atom(&mut self, atom: ty::PredicateAtom<'_>) {
+        match atom {
+            ty::PredicateAtom::Trait(trait_pred, _constness) => {
+                self.add_substs(trait_pred.trait_ref.substs);
+            }
+            ty::PredicateAtom::RegionOutlives(ty::OutlivesPredicate(a, b)) => {
+                self.add_region(a);
+                self.add_region(b);
+            }
+            ty::PredicateAtom::TypeOutlives(ty::OutlivesPredicate(ty, region)) => {
+                self.add_ty(ty);
+                self.add_region(region);
+            }
+            ty::PredicateAtom::Subtype(ty::SubtypePredicate { a_is_expected: _, a, b }) => {
+                self.add_ty(a);
+                self.add_ty(b);
+            }
+            ty::PredicateAtom::Projection(ty::ProjectionPredicate { projection_ty, ty }) => {
+                self.add_projection_ty(projection_ty);
+                self.add_ty(ty);
+            }
+            ty::PredicateAtom::WellFormed(arg) => {
+                self.add_substs(slice::from_ref(&arg));
+            }
+            ty::PredicateAtom::ObjectSafe(_def_id) => {}
+            ty::PredicateAtom::ClosureKind(_def_id, substs, _kind) => {
+                self.add_substs(substs);
+            }
+            ty::PredicateAtom::ConstEvaluatable(_def_id, substs) => {
+                self.add_substs(substs);
+            }
+            ty::PredicateAtom::ConstEquate(expected, found) => {
+                self.add_const(expected);
+                self.add_const(found);
+            }
         }
     }
 
diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs
index 0ff475fb288..15210c5b21b 100644
--- a/src/librustc_middle/ty/mod.rs
+++ b/src/librustc_middle/ty/mod.rs
@@ -1053,8 +1053,9 @@ impl<'tcx> Predicate<'tcx> {
     ///
     /// Note that this method panics in case this predicate has unbound variables.
     pub fn skip_binders(self) -> PredicateAtom<'tcx> {
+        // TODO no_escaping_vars
         match self.kind() {
-            &PredicateKind::ForAll(binder) => binder.skip_binder().skip_binders(),
+            &PredicateKind::ForAll(binder) => binder.skip_binder(),
             &ty::PredicateKind::Atom(atom) => atom,
         }
     }
@@ -1066,33 +1067,17 @@ impl<'tcx> Predicate<'tcx> {
     /// to end up at the wrong binding level.
     pub fn skip_binders_unchecked(self) -> PredicateAtom<'tcx> {
         match self.kind() {
-            &PredicateKind::ForAll(binder) => binder.skip_binder().skip_binders(),
+            &PredicateKind::ForAll(binder) => binder.skip_binder(),
             &ty::PredicateKind::Atom(atom) => atom,
         }
     }
 
     pub fn bound_atom(self, tcx: TyCtxt<'tcx>) -> Binder<PredicateAtom<'tcx>> {
         match self.kind() {
-            &PredicateKind::ForAll(binder) => binder.map_bound(|inner| match inner.kind() {
-                ty::PredicateKind::ForAll(_) => bug!("unexpect forall"),
-                &ty::PredicateKind::Atom(atom) => atom,
-            }),
+            &PredicateKind::ForAll(binder) => binder,
             &ty::PredicateKind::Atom(atom) => Binder::wrap_nonbinding(tcx, atom),
         }
     }
-
-    /// Wraps `self` with the given qualifier if this predicate has any unbound variables.
-    pub fn potentially_quantified(
-        self,
-        tcx: TyCtxt<'tcx>,
-        qualifier: impl FnOnce(Binder<Predicate<'tcx>>) -> PredicateKind<'tcx>,
-    ) -> Predicate<'tcx> {
-        if self.has_escaping_bound_vars() {
-            qualifier(Binder::bind(self)).to_predicate(tcx)
-        } else {
-            self
-        }
-    }
 }
 
 impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Predicate<'tcx> {
@@ -1114,7 +1099,7 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Predicate<'tcx> {
 #[derive(HashStable, TypeFoldable)]
 pub enum PredicateKind<'tcx> {
     /// `for<'a>: ...`
-    ForAll(Binder<Predicate<'tcx>>),
+    ForAll(Binder<PredicateAtom<'tcx>>),
 
     Atom(PredicateAtom<'tcx>),
 }
@@ -1162,6 +1147,22 @@ pub enum PredicateAtom<'tcx> {
     ConstEquate(&'tcx Const<'tcx>, &'tcx Const<'tcx>),
 }
 
+impl<'tcx> PredicateAtom<'tcx> {
+    /// Wraps `self` with the given qualifier if this predicate has any unbound variables.
+    pub fn potentially_quantified(
+        self,
+        tcx: TyCtxt<'tcx>,
+        qualifier: impl FnOnce(Binder<PredicateAtom<'tcx>>) -> PredicateKind<'tcx>,
+    ) -> Predicate<'tcx> {
+        if self.has_escaping_bound_vars() {
+            qualifier(Binder::bind(self))
+        } else {
+            PredicateKind::Atom(self)
+        }
+        .to_predicate(tcx)
+    }
+}
+
 /// The crate outlives map is computed during typeck and contains the
 /// outlives of every item in the local crate. You should not use it
 /// directly, because to do so will make your pass dependent on the
@@ -1249,11 +1250,7 @@ impl<'tcx> Predicate<'tcx> {
         let substs = trait_ref.skip_binder().substs;
         let pred = self.skip_binders();
         let new = pred.subst(tcx, substs);
-        if new != pred {
-            new.to_predicate(tcx).potentially_quantified(tcx, PredicateKind::ForAll)
-        } else {
-            self
-        }
+        if new != pred { new.potentially_quantified(tcx, PredicateKind::ForAll) } else { self }
     }
 }
 
@@ -1381,6 +1378,7 @@ impl ToPredicate<'tcx> for PredicateKind<'tcx> {
 impl ToPredicate<'tcx> for PredicateAtom<'tcx> {
     #[inline(always)]
     fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+        debug_assert!(!self.has_escaping_bound_vars(), "excaping bound vars for {:?}", self);
         tcx.mk_predicate(ty::PredicateKind::Atom(*self))
     }
 }
@@ -1408,9 +1406,7 @@ impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitPredicate<'tcx>> {
             ty::PredicateAtom::Trait(pred, self.constness).to_predicate(tcx)
         } else {
             ty::PredicateKind::ForAll(
-                self.value.map_bound(|pred| {
-                    ty::PredicateAtom::Trait(pred, self.constness).to_predicate(tcx)
-                }),
+                self.value.map_bound(|pred| ty::PredicateAtom::Trait(pred, self.constness)),
             )
             .to_predicate(tcx)
         }
@@ -1423,9 +1419,7 @@ impl<'tcx> ToPredicate<'tcx> for PolyRegionOutlivesPredicate<'tcx> {
             PredicateAtom::RegionOutlives(outlives).to_predicate(tcx)
         } else {
             ty::PredicateKind::ForAll(
-                self.map_bound(|outlives| {
-                    PredicateAtom::RegionOutlives(outlives).to_predicate(tcx)
-                }),
+                self.map_bound(|outlives| PredicateAtom::RegionOutlives(outlives)),
             )
             .to_predicate(tcx)
         }
@@ -1438,7 +1432,7 @@ impl<'tcx> ToPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> {
             PredicateAtom::TypeOutlives(outlives).to_predicate(tcx)
         } else {
             ty::PredicateKind::ForAll(
-                self.map_bound(|outlives| PredicateAtom::TypeOutlives(outlives).to_predicate(tcx)),
+                self.map_bound(|outlives| PredicateAtom::TypeOutlives(outlives)),
             )
             .to_predicate(tcx)
         }
@@ -1450,10 +1444,8 @@ impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> {
         if let Some(proj) = self.no_bound_vars() {
             PredicateAtom::Projection(proj).to_predicate(tcx)
         } else {
-            ty::PredicateKind::ForAll(
-                self.map_bound(|proj| PredicateAtom::Projection(proj).to_predicate(tcx)),
-            )
-            .to_predicate(tcx)
+            ty::PredicateKind::ForAll(self.map_bound(|proj| PredicateAtom::Projection(proj)))
+                .to_predicate(tcx)
         }
     }
 }
diff --git a/src/librustc_middle/ty/print/pretty.rs b/src/librustc_middle/ty/print/pretty.rs
index b0de57e15cc..3bb9c20370e 100644
--- a/src/librustc_middle/ty/print/pretty.rs
+++ b/src/librustc_middle/ty/print/pretty.rs
@@ -2013,43 +2013,45 @@ define_print_and_forward_display! {
 
     ty::Predicate<'tcx> {
         match self.kind() {
-            &ty::PredicateKind::Atom(atom) => match atom {
-                ty::PredicateAtom::Trait(ref data, constness) => {
-                    if let hir::Constness::Const = constness {
-                        p!(write("const "));
-                    }
-                    p!(print(data))
-                }
-                ty::PredicateAtom::Subtype(predicate) => p!(print(predicate)),
-                ty::PredicateAtom::RegionOutlives(predicate) => p!(print(predicate)),
-                ty::PredicateAtom::TypeOutlives(predicate) => p!(print(predicate)),
-                ty::PredicateAtom::Projection(predicate) => p!(print(predicate)),
-                ty::PredicateAtom::WellFormed(arg) => p!(print(arg), write(" well-formed")),
-                ty::PredicateAtom::ObjectSafe(trait_def_id) => {
-                    p!(write("the trait `"),
-                    print_def_path(trait_def_id, &[]),
-                    write("` is object-safe"))
-                }
-                ty::PredicateAtom::ClosureKind(closure_def_id, _closure_substs, kind) => {
-                    p!(write("the closure `"),
-                    print_value_path(closure_def_id, &[]),
-                    write("` implements the trait `{}`", kind))
-                }
-                ty::PredicateAtom::ConstEvaluatable(def, substs) => {
-                    p!(write("the constant `"),
-                    print_value_path(def.did, substs),
-                    write("` can be evaluated"))
-                }
-                ty::PredicateAtom::ConstEquate(c1, c2) => {
-                    p!(write("the constant `"),
-                    print(c1),
-                    write("` equals `"),
-                    print(c2),
-                    write("`"))
+            &ty::PredicateKind::Atom(atom) => p!(print(atom)),
+            ty::PredicateKind::ForAll(binder) => p!(print(binder)),
+        }
+    }
+
+    ty::PredicateAtom<'tcx> {
+        match *self {
+            ty::PredicateAtom::Trait(ref data, constness) => {
+                if let hir::Constness::Const = constness {
+                    p!(write("const "));
                 }
-            }
-            ty::PredicateKind::ForAll(binder) => {
-                p!(print(binder))
+                p!(print(data))
+            }
+            ty::PredicateAtom::Subtype(predicate) => p!(print(predicate)),
+            ty::PredicateAtom::RegionOutlives(predicate) => p!(print(predicate)),
+            ty::PredicateAtom::TypeOutlives(predicate) => p!(print(predicate)),
+            ty::PredicateAtom::Projection(predicate) => p!(print(predicate)),
+            ty::PredicateAtom::WellFormed(arg) => p!(print(arg), write(" well-formed")),
+            ty::PredicateAtom::ObjectSafe(trait_def_id) => {
+                p!(write("the trait `"),
+                print_def_path(trait_def_id, &[]),
+                write("` is object-safe"))
+            }
+            ty::PredicateAtom::ClosureKind(closure_def_id, _closure_substs, kind) => {
+                p!(write("the closure `"),
+                print_value_path(closure_def_id, &[]),
+                write("` implements the trait `{}`", kind))
+            }
+            ty::PredicateAtom::ConstEvaluatable(def, substs) => {
+                p!(write("the constant `"),
+                print_value_path(def.did, substs),
+                write("` can be evaluated"))
+            }
+            ty::PredicateAtom::ConstEquate(c1, c2) => {
+                p!(write("the constant `"),
+                print(c1),
+                write("` equals `"),
+                print(c2),
+                write("`"))
             }
         }
     }
diff --git a/src/librustc_trait_selection/traits/fulfill.rs b/src/librustc_trait_selection/traits/fulfill.rs
index 0f6f3624906..c73ed986317 100644
--- a/src/librustc_trait_selection/traits/fulfill.rs
+++ b/src/librustc_trait_selection/traits/fulfill.rs
@@ -6,6 +6,7 @@ use rustc_errors::ErrorReported;
 use rustc_infer::traits::{PolyTraitObligation, TraitEngine, TraitEngineExt as _};
 use rustc_middle::mir::interpret::ErrorHandled;
 use rustc_middle::ty::error::ExpectedFound;
+use rustc_middle::ty::ToPredicate;
 use rustc_middle::ty::{self, Binder, Const, Ty, TypeFoldable};
 use std::marker::PhantomData;
 
diff --git a/src/librustc_trait_selection/traits/wf.rs b/src/librustc_trait_selection/traits/wf.rs
index 0ca69c0f76e..d225b10834a 100644
--- a/src/librustc_trait_selection/traits/wf.rs
+++ b/src/librustc_trait_selection/traits/wf.rs
@@ -93,45 +93,40 @@ pub fn predicate_obligations<'a, 'tcx>(
 ) -> Vec<traits::PredicateObligation<'tcx>> {
     let mut wf = WfPredicates { infcx, param_env, body_id, span, out: vec![], item: None };
 
-    match predicate.kind() {
-        ty::PredicateKind::ForAll(binder) => {
-            // It's ok to skip the binder here because wf code is prepared for it
-            return predicate_obligations(infcx, param_env, body_id, binder.skip_binder(), span);
+    // It's ok to skip the binder here because wf code is prepared for it
+    match predicate.skip_binders() {
+        ty::PredicateAtom::Trait(t, _) => {
+            wf.compute_trait_ref(&t.trait_ref, Elaborate::None);
         }
-        &ty::PredicateKind::Atom(atom) => match atom {
-            ty::PredicateAtom::Trait(t, _) => {
-                wf.compute_trait_ref(&t.trait_ref, Elaborate::None);
-            }
-            ty::PredicateAtom::RegionOutlives(..) => {}
-            ty::PredicateAtom::TypeOutlives(ty::OutlivesPredicate(ty, _reg)) => {
-                wf.compute(ty.into());
-            }
-            ty::PredicateAtom::Projection(t) => {
-                wf.compute_projection(t.projection_ty);
-                wf.compute(t.ty.into());
-            }
-            ty::PredicateAtom::WellFormed(arg) => {
-                wf.compute(arg);
-            }
-            ty::PredicateAtom::ObjectSafe(_) => {}
-            ty::PredicateAtom::ClosureKind(..) => {}
-            ty::PredicateAtom::Subtype(ty::SubtypePredicate { a, b, a_is_expected: _ }) => {
-                wf.compute(a.into());
-                wf.compute(b.into());
-            }
-            ty::PredicateAtom::ConstEvaluatable(def, substs) => {
-                let obligations = wf.nominal_obligations(def.did, substs);
-                wf.out.extend(obligations);
+        ty::PredicateAtom::RegionOutlives(..) => {}
+        ty::PredicateAtom::TypeOutlives(ty::OutlivesPredicate(ty, _reg)) => {
+            wf.compute(ty.into());
+        }
+        ty::PredicateAtom::Projection(t) => {
+            wf.compute_projection(t.projection_ty);
+            wf.compute(t.ty.into());
+        }
+        ty::PredicateAtom::WellFormed(arg) => {
+            wf.compute(arg);
+        }
+        ty::PredicateAtom::ObjectSafe(_) => {}
+        ty::PredicateAtom::ClosureKind(..) => {}
+        ty::PredicateAtom::Subtype(ty::SubtypePredicate { a, b, a_is_expected: _ }) => {
+            wf.compute(a.into());
+            wf.compute(b.into());
+        }
+        ty::PredicateAtom::ConstEvaluatable(def, substs) => {
+            let obligations = wf.nominal_obligations(def.did, substs);
+            wf.out.extend(obligations);
 
-                for arg in substs.iter() {
-                    wf.compute(arg);
-                }
-            }
-            ty::PredicateAtom::ConstEquate(c1, c2) => {
-                wf.compute(c1.into());
-                wf.compute(c2.into());
+            for arg in substs.iter() {
+                wf.compute(arg);
             }
-        },
+        }
+        ty::PredicateAtom::ConstEquate(c1, c2) => {
+            wf.compute(c1.into());
+            wf.compute(c2.into());
+        }
     }
 
     wf.normalize()
diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs
index e569d1c443a..106df847a05 100644
--- a/src/librustc_typeck/check/method/probe.rs
+++ b/src/librustc_typeck/check/method/probe.rs
@@ -798,24 +798,28 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         // FIXME: do we want to commit to this behavior for param bounds?
         debug!("assemble_inherent_candidates_from_param(param_ty={:?})", param_ty);
 
-        let bounds = self.param_env.caller_bounds().iter().map(ty::Predicate::skip_binders).filter_map(|predicate| match predicate
-        {
-            ty::PredicateAtom::Trait(trait_predicate, _) => {
-                match trait_predicate.trait_ref.self_ty().kind {
-                    ty::Param(ref p) if *p == param_ty => Some(ty::Binder::bind(trait_predicate.trait_ref)),
-                    _ => None,
-                }
-            }
-            ty::PredicateAtom::Subtype(..)
-            | ty::PredicateAtom::Projection(..)
-            | ty::PredicateAtom::RegionOutlives(..)
-            | ty::PredicateAtom::WellFormed(..)
-            | ty::PredicateAtom::ObjectSafe(..)
-            | ty::PredicateAtom::ClosureKind(..)
-            | ty::PredicateAtom::TypeOutlives(..)
-            | ty::PredicateAtom::ConstEvaluatable(..)
-            | ty::PredicateAtom::ConstEquate(..) => None,
-        });
+        let bounds =
+            self.param_env.caller_bounds().iter().map(ty::Predicate::skip_binders).filter_map(
+                |predicate| match predicate {
+                    ty::PredicateAtom::Trait(trait_predicate, _) => {
+                        match trait_predicate.trait_ref.self_ty().kind {
+                            ty::Param(ref p) if *p == param_ty => {
+                                Some(ty::Binder::bind(trait_predicate.trait_ref))
+                            }
+                            _ => None,
+                        }
+                    }
+                    ty::PredicateAtom::Subtype(..)
+                    | ty::PredicateAtom::Projection(..)
+                    | ty::PredicateAtom::RegionOutlives(..)
+                    | ty::PredicateAtom::WellFormed(..)
+                    | ty::PredicateAtom::ObjectSafe(..)
+                    | ty::PredicateAtom::ClosureKind(..)
+                    | ty::PredicateAtom::TypeOutlives(..)
+                    | ty::PredicateAtom::ConstEvaluatable(..)
+                    | ty::PredicateAtom::ConstEquate(..) => None,
+                },
+            );
 
         self.elaborate_bounds(bounds, |this, poly_trait_ref, item| {
             let trait_ref = this.erase_late_bound_regions(&poly_trait_ref);
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 61520e29236..6cefc99f7b1 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -2939,9 +2939,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
             predicates: tcx.arena.alloc_from_iter(
                 self.param_env.caller_bounds().iter().filter_map(|predicate| {
                     match predicate.skip_binders() {
-                        ty::PredicateAtom::Trait(data, _)
-                            if data.self_ty().is_param(index) =>
-                        {
+                        ty::PredicateAtom::Trait(data, _) if data.self_ty().is_param(index) => {
                             // HACK(eddyb) should get the original `Span`.
                             let span = tcx.def_span(def_id);
                             Some((predicate, span))
@@ -5373,7 +5371,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     projection_ty,
                     ty: expected,
                 })
-                .to_predicate(self.tcx)
                 .potentially_quantified(self.tcx, ty::PredicateKind::ForAll);
                 let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate);
 
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index d906c5c05c0..a733ad4fccd 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -1961,7 +1961,6 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat
                             let region = AstConv::ast_region_to_region(&icx, lifetime, None);
                             predicates.push((
                                 ty::PredicateAtom::TypeOutlives(ty::OutlivesPredicate(ty, region))
-                                    .to_predicate(tcx)
                                     .potentially_quantified(tcx, ty::PredicateKind::ForAll),
                                 lifetime.span,
                             ))
@@ -1979,8 +1978,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat
                         }
                         _ => bug!(),
                     };
-                    let pred = ty::PredicateAtom::RegionOutlives(ty::OutlivesPredicate(r1, r2))
-                        .to_predicate(icx.tcx);
+                    let pred = ty::PredicateAtom::RegionOutlives(ty::OutlivesPredicate(r1, r2));
 
                     (pred.potentially_quantified(icx.tcx, ty::PredicateKind::ForAll), span)
                 }))
@@ -2111,7 +2109,6 @@ fn predicates_from_bound<'tcx>(
         hir::GenericBound::Outlives(ref lifetime) => {
             let region = astconv.ast_region_to_region(lifetime, None);
             let pred = ty::PredicateAtom::TypeOutlives(ty::OutlivesPredicate(param_ty, region))
-                .to_predicate(astconv.tcx())
                 .potentially_quantified(astconv.tcx(), ty::PredicateKind::ForAll);
             vec![(pred, lifetime.span)]
         }
diff --git a/src/librustc_typeck/outlives/mod.rs b/src/librustc_typeck/outlives/mod.rs
index 823a0235b17..5dc7ac9fa0d 100644
--- a/src/librustc_typeck/outlives/mod.rs
+++ b/src/librustc_typeck/outlives/mod.rs
@@ -3,7 +3,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{self, CratePredicatesMap, ToPredicate, TyCtxt};
+use rustc_middle::ty::{self, CratePredicatesMap, TyCtxt};
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
@@ -90,7 +90,6 @@ fn inferred_outlives_crate(tcx: TyCtxt<'_>, crate_num: CrateNum) -> CratePredica
                     match kind1.unpack() {
                         GenericArgKind::Type(ty1) => Some((
                             ty::PredicateAtom::TypeOutlives(ty::OutlivesPredicate(ty1, region2))
-                                .to_predicate(tcx)
                                 .potentially_quantified(tcx, ty::PredicateKind::ForAll),
                             span,
                         )),
@@ -98,7 +97,6 @@ fn inferred_outlives_crate(tcx: TyCtxt<'_>, crate_num: CrateNum) -> CratePredica
                             ty::PredicateAtom::RegionOutlives(ty::OutlivesPredicate(
                                 region1, region2,
                             ))
-                            .to_predicate(tcx)
                             .potentially_quantified(tcx, ty::PredicateKind::ForAll),
                             span,
                         )),