Remove PredicateKind::Atom

jackh726 · jackh726 · commit 8278314a8bf7 · 2021-01-16T18:40:47.000-05:00
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -541,8 +541,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
                     span_bug!(cause.span, "unexpected const outlives {:?}", constraint);
                 }
             };
-            let predicate =
-                predicate.rebind(atom).potentially_quantified(self.tcx, ty::PredicateKind::ForAll);
+            let predicate = predicate.rebind(atom).potentially_quantified(self.tcx);
 
             Obligation::new(cause.clone(), param_env, predicate)
         })
diff --git a/compiler/rustc_infer/src/traits/util.rs b/compiler/rustc_infer/src/traits/util.rs
@@ -14,7 +14,6 @@ pub fn anonymize_predicate<'tcx>(
             let new = ty::PredicateKind::ForAll(tcx.anonymize_late_bound_regions(binder));
             tcx.reuse_or_mk_predicate(pred, new)
         }
-        ty::PredicateKind::Atom(_) => pred,
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
@@ -211,7 +211,6 @@ impl FlagComputation {
                     computation.add_predicate_atom(atom)
                 });
             }
-            ty::PredicateKind::Atom(atom) => self.add_predicate_atom(atom),
         }
     }
 
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -1037,7 +1037,7 @@ crate struct PredicateInner<'tcx> {
 }
 
 #[cfg(target_arch = "x86_64")]
-static_assert_size!(PredicateInner<'_>, 48);
+static_assert_size!(PredicateInner<'_>, 40);
 
 #[derive(Clone, Copy, Lift)]
 pub struct Predicate<'tcx> {
@@ -1074,10 +1074,6 @@ impl<'tcx> Predicate<'tcx> {
     pub fn skip_binders(self) -> PredicateAtom<'tcx> {
         match self.kind() {
             &PredicateKind::ForAll(binder) => binder.skip_binder(),
-            &PredicateKind::Atom(atom) => {
-                debug_assert!(!atom.has_escaping_bound_vars());
-                atom
-            }
         }
     }
 
@@ -1090,7 +1086,6 @@ impl<'tcx> Predicate<'tcx> {
     pub fn skip_binders_unchecked(self) -> PredicateAtom<'tcx> {
         match self.kind() {
             &PredicateKind::ForAll(binder) => binder.skip_binder(),
-            &PredicateKind::Atom(atom) => atom,
         }
     }
 
@@ -1099,19 +1094,14 @@ impl<'tcx> Predicate<'tcx> {
     pub fn bound_atom(self) -> Binder<PredicateAtom<'tcx>> {
         match self.kind() {
             &PredicateKind::ForAll(binder) => binder,
-            &PredicateKind::Atom(atom) => {
-                debug_assert!(!atom.has_escaping_bound_vars());
-                Binder::dummy(atom)
-            }
         }
     }
 
     /// Allows using a `Binder<PredicateAtom<'tcx>>` even if the given predicate previously
     /// contained unbound variables by shifting these variables outwards.
-    pub fn bound_atom_with_opt_escaping(self, tcx: TyCtxt<'tcx>) -> Binder<PredicateAtom<'tcx>> {
+    pub fn bound_atom_with_opt_escaping(self, _tcx: TyCtxt<'tcx>) -> Binder<PredicateAtom<'tcx>> {
         match self.kind() {
             &PredicateKind::ForAll(binder) => binder,
-            &PredicateKind::Atom(atom) => Binder::wrap_nonbinding(tcx, atom),
         }
     }
 }
@@ -1136,7 +1126,6 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Predicate<'tcx> {
 pub enum PredicateKind<'tcx> {
     /// `for<'a>: ...`
     ForAll(Binder<PredicateAtom<'tcx>>),
-    Atom(PredicateAtom<'tcx>),
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
@@ -1189,16 +1178,8 @@ pub enum PredicateAtom<'tcx> {
 
 impl<'tcx> Binder<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> {
-        match self.no_bound_vars() {
-            Some(atom) => PredicateKind::Atom(atom),
-            None => qualifier(self),
-        }
-        .to_predicate(tcx)
+    pub fn potentially_quantified(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+        PredicateKind::ForAll(self).to_predicate(tcx)
     }
 }
 
@@ -1289,11 +1270,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 {
-            ty::Binder::bind(new).potentially_quantified(tcx, PredicateKind::ForAll)
-        } else {
-            self
-        }
+        if new != pred { ty::Binder::bind(new).potentially_quantified(tcx) } else { self }
     }
 }
 
@@ -1425,7 +1402,7 @@ impl ToPredicate<'tcx> for PredicateAtom<'tcx> {
     #[inline(always)]
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
         debug_assert!(!self.has_escaping_bound_vars(), "escaping bound vars for {:?}", self);
-        tcx.mk_predicate(PredicateKind::Atom(self))
+        tcx.mk_predicate(PredicateKind::ForAll(Binder::dummy(self)))
     }
 }
 
@@ -1450,27 +1427,25 @@ impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitPredicate<'tcx>> {
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
         self.value
             .map_bound(|value| PredicateAtom::Trait(value, self.constness))
-            .potentially_quantified(tcx, PredicateKind::ForAll)
+            .potentially_quantified(tcx)
     }
 }
 
 impl<'tcx> ToPredicate<'tcx> for PolyRegionOutlivesPredicate<'tcx> {
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
-        self.map_bound(PredicateAtom::RegionOutlives)
-            .potentially_quantified(tcx, PredicateKind::ForAll)
+        self.map_bound(PredicateAtom::RegionOutlives).potentially_quantified(tcx)
     }
 }
 
 impl<'tcx> ToPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> {
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
-        self.map_bound(PredicateAtom::TypeOutlives)
-            .potentially_quantified(tcx, PredicateKind::ForAll)
+        self.map_bound(PredicateAtom::TypeOutlives).potentially_quantified(tcx)
     }
 }
 
 impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> {
     fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
-        self.map_bound(PredicateAtom::Projection).potentially_quantified(tcx, PredicateKind::ForAll)
+        self.map_bound(PredicateAtom::Projection).potentially_quantified(tcx)
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -2069,7 +2069,6 @@ define_print_and_forward_display! {
 
     ty::Predicate<'tcx> {
         match self.kind() {
-            &ty::PredicateKind::Atom(atom) => p!(print(atom)),
             ty::PredicateKind::ForAll(binder) => p!(print(binder)),
         }
     }
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -232,7 +232,6 @@ impl fmt::Debug for ty::PredicateKind<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             ty::PredicateKind::ForAll(binder) => write!(f, "ForAll({:?})", binder),
-            ty::PredicateKind::Atom(atom) => write!(f, "{:?}", atom),
         }
     }
 }
@@ -486,7 +485,6 @@ impl<'a, 'tcx> Lift<'tcx> for ty::PredicateKind<'a> {
     fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
         match self {
             ty::PredicateKind::ForAll(binder) => tcx.lift(binder).map(ty::PredicateKind::ForAll),
-            ty::PredicateKind::Atom(atom) => tcx.lift(atom).map(ty::PredicateKind::Atom),
         }
     }
 }
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -346,45 +346,47 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
         let infcx = self.selcx.infcx();
 
         match *obligation.predicate.kind() {
-            ty::PredicateKind::ForAll(binder) => match binder.skip_binder() {
-                // Evaluation will discard candidates using the leak check.
-                // This means we need to pass it the bound version of our
-                // predicate.
-                ty::PredicateAtom::Trait(trait_ref, _constness) => {
-                    let trait_obligation = obligation.with(binder.rebind(trait_ref));
-
-                    self.process_trait_obligation(
-                        obligation,
-                        trait_obligation,
-                        &mut pending_obligation.stalled_on,
-                    )
-                }
-                ty::PredicateAtom::Projection(data) => {
-                    let project_obligation = obligation.with(binder.rebind(data));
+            ty::PredicateKind::ForAll(binder) if binder.skip_binder().has_escaping_bound_vars() => {
+                match binder.skip_binder() {
+                    // Evaluation will discard candidates using the leak check.
+                    // This means we need to pass it the bound version of our
+                    // predicate.
+                    ty::PredicateAtom::Trait(trait_ref, _constness) => {
+                        let trait_obligation = obligation.with(binder.rebind(trait_ref));
+
+                        self.process_trait_obligation(
+                            obligation,
+                            trait_obligation,
+                            &mut pending_obligation.stalled_on,
+                        )
+                    }
+                    ty::PredicateAtom::Projection(data) => {
+                        let project_obligation = obligation.with(binder.rebind(data));
 
-                    self.process_projection_obligation(
-                        project_obligation,
-                        &mut pending_obligation.stalled_on,
-                    )
-                }
-                ty::PredicateAtom::RegionOutlives(_)
-                | ty::PredicateAtom::TypeOutlives(_)
-                | ty::PredicateAtom::WellFormed(_)
-                | ty::PredicateAtom::ObjectSafe(_)
-                | ty::PredicateAtom::ClosureKind(..)
-                | ty::PredicateAtom::Subtype(_)
-                | ty::PredicateAtom::ConstEvaluatable(..)
-                | ty::PredicateAtom::ConstEquate(..) => {
-                    let pred = infcx.replace_bound_vars_with_placeholders(binder);
-                    ProcessResult::Changed(mk_pending(vec![
-                        obligation.with(pred.to_predicate(self.selcx.tcx())),
-                    ]))
-                }
-                ty::PredicateAtom::TypeWellFormedFromEnv(..) => {
-                    bug!("TypeWellFormedFromEnv is only used for Chalk")
+                        self.process_projection_obligation(
+                            project_obligation,
+                            &mut pending_obligation.stalled_on,
+                        )
+                    }
+                    ty::PredicateAtom::RegionOutlives(_)
+                    | ty::PredicateAtom::TypeOutlives(_)
+                    | ty::PredicateAtom::WellFormed(_)
+                    | ty::PredicateAtom::ObjectSafe(_)
+                    | ty::PredicateAtom::ClosureKind(..)
+                    | ty::PredicateAtom::Subtype(_)
+                    | ty::PredicateAtom::ConstEvaluatable(..)
+                    | ty::PredicateAtom::ConstEquate(..) => {
+                        let pred = infcx.replace_bound_vars_with_placeholders(binder);
+                        ProcessResult::Changed(mk_pending(vec![
+                            obligation.with(pred.to_predicate(self.selcx.tcx())),
+                        ]))
+                    }
+                    ty::PredicateAtom::TypeWellFormedFromEnv(..) => {
+                        bug!("TypeWellFormedFromEnv is only used for Chalk")
+                    }
                 }
-            },
-            ty::PredicateKind::Atom(atom) => match atom {
+            }
+            ty::PredicateKind::ForAll(binder) => match binder.skip_binder() {
                 ty::PredicateAtom::Trait(data, _) => {
                     let trait_obligation = obligation.with(Binder::dummy(data));
 
diff --git a/compiler/rustc_traits/src/implied_outlives_bounds.rs b/compiler/rustc_traits/src/implied_outlives_bounds.rs
@@ -95,8 +95,12 @@ fn compute_implied_outlives_bounds<'tcx>(
         implied_bounds.extend(obligations.into_iter().flat_map(|obligation| {
             assert!(!obligation.has_escaping_bound_vars());
             match obligation.predicate.kind() {
-                &ty::PredicateKind::ForAll(..) => vec![],
-                &ty::PredicateKind::Atom(atom) => match atom {
+                &ty::PredicateKind::ForAll(binder)
+                    if binder.skip_binder().has_escaping_bound_vars() =>
+                {
+                    vec![]
+                }
+                &ty::PredicateKind::ForAll(binder) => match binder.skip_binder() {
                     ty::PredicateAtom::Trait(..)
                     | ty::PredicateAtom::Subtype(..)
                     | ty::PredicateAtom::Projection(..)
diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs
@@ -1949,10 +1949,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
                         let predicate = ty::Binder::bind(ty::PredicateAtom::TypeOutlives(
                             ty::OutlivesPredicate(ty, re_root_empty),
                         ));
-                        predicates.insert((
-                            predicate.potentially_quantified(tcx, ty::PredicateKind::ForAll),
-                            span,
-                        ));
+                        predicates.insert((predicate.potentially_quantified(tcx), span));
                     }
                 }
 
@@ -1996,7 +1993,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
                                 ty::Binder::bind(ty::PredicateAtom::TypeOutlives(
                                     ty::OutlivesPredicate(ty, region),
                                 ))
-                                .potentially_quantified(tcx, ty::PredicateKind::ForAll),
+                                .potentially_quantified(tcx),
                                 lifetime.span,
                             ));
                         }
diff --git a/compiler/rustc_typeck/src/outlives/mod.rs b/compiler/rustc_typeck/src/outlives/mod.rs
@@ -31,13 +31,11 @@ fn inferred_outlives_of(tcx: TyCtxt<'_>, item_def_id: DefId) -> &[(ty::Predicate
                     let mut pred: Vec<String> = predicates
                         .iter()
                         .map(|(out_pred, _)| match out_pred.kind() {
-                            ty::PredicateKind::Atom(ty::PredicateAtom::RegionOutlives(p)) => {
-                                p.to_string()
-                            }
-                            ty::PredicateKind::Atom(ty::PredicateAtom::TypeOutlives(p)) => {
-                                p.to_string()
-                            }
-                            err => bug!("unexpected predicate {:?}", err),
+                            ty::PredicateKind::ForAll(binder) => match binder.skip_binder() {
+                                ty::PredicateAtom::RegionOutlives(p) => p.to_string(),
+                                ty::PredicateAtom::TypeOutlives(p) => p.to_string(),
+                                err => bug!("unexpected predicate {:?}", err),
+                            },
                         })
                         .collect();
                     pred.sort();
diff --git a/src/test/ui/specialization/min_specialization/repeated_projection_type.stderr b/src/test/ui/specialization/min_specialization/repeated_projection_type.stderr
@@ -1,4 +1,4 @@
-error: cannot specialize on `ProjectionPredicate(ProjectionTy { substs: [V], item_def_id: DefId(0:6 ~ repeated_projection_type[317d]::Id::This) }, (I,))`
+error: cannot specialize on `ForAll(Binder(ProjectionPredicate(ProjectionTy { substs: [V], item_def_id: DefId(0:6 ~ repeated_projection_type[317d]::Id::This) }, (I,))))`
   --> $DIR/repeated_projection_type.rs:19:1
    |
 LL | / impl<I, V: Id<This = (I,)>> X for V {
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
@@ -115,13 +115,15 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             .filter(|p| !p.is_global())
             .filter_map(|obligation| {
                 // Note that we do not want to deal with qualified predicates here.
-                if let ty::PredicateKind::Atom(ty::PredicateAtom::Trait(pred, _)) = obligation.predicate.kind() {
-                    if pred.def_id() == sized_trait {
-                        return None;
+                let ty::PredicateKind::ForAll(binder) = obligation.predicate.kind();
+                match binder.skip_binder() {
+                    ty::PredicateAtom::Trait(pred, _) if !binder.has_escaping_bound_vars() => {
+                        if pred.def_id() == sized_trait {
+                            return None;
+                        }
+                        Some(pred)
                     }
-                    Some(pred)
-                } else {
-                    None
+                    _ => None,
                 }
             })
             .collect::<Vec<_>>();

Original file line number	Diff line number	Diff line change
`@@ -541,8 +541,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {`
`541`	`541`	`span_bug!(cause.span, "unexpected const outlives {:?}", constraint);`
`542`	`542`	`}`
`543`	`543`	`};`
`544`		`- let predicate =`
`545`		`- predicate.rebind(atom).potentially_quantified(self.tcx, ty::PredicateKind::ForAll);`
	`544`	`+ let predicate = predicate.rebind(atom).potentially_quantified(self.tcx);`
`546`	`545`
`547`	`546`	`Obligation::new(cause.clone(), param_env, predicate)`
`548`	`547`	`})`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,6 @@ pub fn anonymize_predicate<'tcx>(`
`14`	`14`	`let new = ty::PredicateKind::ForAll(tcx.anonymize_late_bound_regions(binder));`
`15`	`15`	`tcx.reuse_or_mk_predicate(pred, new)`
`16`	`16`	`}`
`17`		`- ty::PredicateKind::Atom(_) => pred,`
`18`	`17`	`}`
`19`	`18`	`}`
`20`	`19`
Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,6 @@ impl FlagComputation {`
`211`	`211`	`computation.add_predicate_atom(atom)`
`212`	`212`	`});`
`213`	`213`	`}`
`214`		`- ty::PredicateKind::Atom(atom) => self.add_predicate_atom(atom),`
`215`	`214`	`}`
`216`	`215`	`}`
`217`	`216`
Original file line number	Diff line number	Diff line change
`@@ -1037,7 +1037,7 @@ crate struct PredicateInner<'tcx> {`
`1037`	`1037`	`}`
`1038`	`1038`
`1039`	`1039`	`#[cfg(target_arch = "x86_64")]`
`1040`		`-static_assert_size!(PredicateInner<'_>, 48);`
	`1040`	`+static_assert_size!(PredicateInner<'_>, 40);`
`1041`	`1041`
`1042`	`1042`	`#[derive(Clone, Copy, Lift)]`
`1043`	`1043`	`pub struct Predicate<'tcx> {`
`@@ -1074,10 +1074,6 @@ impl<'tcx> Predicate<'tcx> {`
`1074`	`1074`	`pub fn skip_binders(self) -> PredicateAtom<'tcx> {`
`1075`	`1075`	`match self.kind() {`
`1076`	`1076`	`&PredicateKind::ForAll(binder) => binder.skip_binder(),`
`1077`		`- &PredicateKind::Atom(atom) => {`
`1078`		`- debug_assert!(!atom.has_escaping_bound_vars());`
`1079`		`- atom`
`1080`		`- }`
`1081`	`1077`	`}`
`1082`	`1078`	`}`
`1083`	`1079`
`@@ -1090,7 +1086,6 @@ impl<'tcx> Predicate<'tcx> {`
`1090`	`1086`	`pub fn skip_binders_unchecked(self) -> PredicateAtom<'tcx> {`
`1091`	`1087`	`match self.kind() {`
`1092`	`1088`	`&PredicateKind::ForAll(binder) => binder.skip_binder(),`
`1093`		`- &PredicateKind::Atom(atom) => atom,`
`1094`	`1089`	`}`
`1095`	`1090`	`}`
`1096`	`1091`
`@@ -1099,19 +1094,14 @@ impl<'tcx> Predicate<'tcx> {`
`1099`	`1094`	`pub fn bound_atom(self) -> Binder<PredicateAtom<'tcx>> {`
`1100`	`1095`	`match self.kind() {`
`1101`	`1096`	`&PredicateKind::ForAll(binder) => binder,`
`1102`		`- &PredicateKind::Atom(atom) => {`
`1103`		`- debug_assert!(!atom.has_escaping_bound_vars());`
`1104`		`- Binder::dummy(atom)`
`1105`		`- }`
`1106`	`1097`	`}`
`1107`	`1098`	`}`
`1108`	`1099`
`1109`	`1100`	/// Allows using a `Binder<PredicateAtom<'tcx>>` even if the given predicate previously
`1110`	`1101`	`/// contained unbound variables by shifting these variables outwards.`
`1111`		`- pub fn bound_atom_with_opt_escaping(self, tcx: TyCtxt<'tcx>) -> Binder<PredicateAtom<'tcx>> {`
	`1102`	`+ pub fn bound_atom_with_opt_escaping(self, _tcx: TyCtxt<'tcx>) -> Binder<PredicateAtom<'tcx>> {`
`1112`	`1103`	`match self.kind() {`
`1113`	`1104`	`&PredicateKind::ForAll(binder) => binder,`
`1114`		`- &PredicateKind::Atom(atom) => Binder::wrap_nonbinding(tcx, atom),`
`1115`	`1105`	`}`
`1116`	`1106`	`}`
`1117`	`1107`	`}`
`@@ -1136,7 +1126,6 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Predicate<'tcx> {`
`1136`	`1126`	`pub enum PredicateKind<'tcx> {`
`1137`	`1127`	/// `for<'a>: ...`
`1138`	`1128`	`ForAll(Binder<PredicateAtom<'tcx>>),`
`1139`		`- Atom(PredicateAtom<'tcx>),`
`1140`	`1129`	`}`
`1141`	`1130`
`1142`	`1131`	`#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]`
`@@ -1189,16 +1178,8 @@ pub enum PredicateAtom<'tcx> {`
`1189`	`1178`
`1190`	`1179`	`impl<'tcx> Binder<PredicateAtom<'tcx>> {`
`1191`	`1180`	/// Wraps `self` with the given qualifier if this predicate has any unbound variables.
`1192`		`- pub fn potentially_quantified(`
`1193`		`- self,`
`1194`		`- tcx: TyCtxt<'tcx>,`
`1195`		`- qualifier: impl FnOnce(Binder<PredicateAtom<'tcx>>) -> PredicateKind<'tcx>,`
`1196`		`- ) -> Predicate<'tcx> {`
`1197`		`- match self.no_bound_vars() {`
`1198`		`- Some(atom) => PredicateKind::Atom(atom),`
`1199`		`- None => qualifier(self),`
`1200`		`- }`
`1201`		`- .to_predicate(tcx)`
	`1181`	`+ pub fn potentially_quantified(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
	`1182`	`+ PredicateKind::ForAll(self).to_predicate(tcx)`
`1202`	`1183`	`}`
`1203`	`1184`	`}`
`1204`	`1185`
`@@ -1289,11 +1270,7 @@ impl<'tcx> Predicate<'tcx> {`
`1289`	`1270`	`let substs = trait_ref.skip_binder().substs;`
`1290`	`1271`	`let pred = self.skip_binders();`
`1291`	`1272`	`let new = pred.subst(tcx, substs);`
`1292`		`- if new != pred {`
`1293`		`- ty::Binder::bind(new).potentially_quantified(tcx, PredicateKind::ForAll)`
`1294`		`- } else {`
`1295`		`- self`
`1296`		`- }`
	`1273`	`+ if new != pred { ty::Binder::bind(new).potentially_quantified(tcx) } else { self }`
`1297`	`1274`	`}`
`1298`	`1275`	`}`
`1299`	`1276`
`@@ -1425,7 +1402,7 @@ impl ToPredicate<'tcx> for PredicateAtom<'tcx> {`
`1425`	`1402`	`#[inline(always)]`
`1426`	`1403`	`fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1427`	`1404`	`debug_assert!(!self.has_escaping_bound_vars(), "escaping bound vars for {:?}", self);`
`1428`		`- tcx.mk_predicate(PredicateKind::Atom(self))`
	`1405`	`+ tcx.mk_predicate(PredicateKind::ForAll(Binder::dummy(self)))`
`1429`	`1406`	`}`
`1430`	`1407`	`}`
`1431`	`1408`
`@@ -1450,27 +1427,25 @@ impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitPredicate<'tcx>> {`
`1450`	`1427`	`fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1451`	`1428`	`self.value`
`1452`	`1429`	`.map_bound(\|value\| PredicateAtom::Trait(value, self.constness))`
`1453`		`- .potentially_quantified(tcx, PredicateKind::ForAll)`
	`1430`	`+ .potentially_quantified(tcx)`
`1454`	`1431`	`}`
`1455`	`1432`	`}`
`1456`	`1433`
`1457`	`1434`	`impl<'tcx> ToPredicate<'tcx> for PolyRegionOutlivesPredicate<'tcx> {`
`1458`	`1435`	`fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1459`		`- self.map_bound(PredicateAtom::RegionOutlives)`
`1460`		`- .potentially_quantified(tcx, PredicateKind::ForAll)`
	`1436`	`+ self.map_bound(PredicateAtom::RegionOutlives).potentially_quantified(tcx)`
`1461`	`1437`	`}`
`1462`	`1438`	`}`
`1463`	`1439`
`1464`	`1440`	`impl<'tcx> ToPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> {`
`1465`	`1441`	`fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1466`		`- self.map_bound(PredicateAtom::TypeOutlives)`
`1467`		`- .potentially_quantified(tcx, PredicateKind::ForAll)`
	`1442`	`+ self.map_bound(PredicateAtom::TypeOutlives).potentially_quantified(tcx)`
`1468`	`1443`	`}`
`1469`	`1444`	`}`
`1470`	`1445`
`1471`	`1446`	`impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> {`
`1472`	`1447`	`fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {`
`1473`		`- self.map_bound(PredicateAtom::Projection).potentially_quantified(tcx, PredicateKind::ForAll)`
	`1448`	`+ self.map_bound(PredicateAtom::Projection).potentially_quantified(tcx)`
`1474`	`1449`	`}`
`1475`	`1450`	`}`
`1476`	`1451`
Original file line number	Diff line number	Diff line change
`@@ -2069,7 +2069,6 @@ define_print_and_forward_display! {`
`2069`	`2069`
`2070`	`2070`	`ty::Predicate<'tcx> {`
`2071`	`2071`	`match self.kind() {`
`2072`		`- &ty::PredicateKind::Atom(atom) => p!(print(atom)),`
`2073`	`2072`	`ty::PredicateKind::ForAll(binder) => p!(print(binder)),`
`2074`	`2073`	`}`
`2075`	`2074`	`}`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,6 @@ impl fmt::Debug for ty::PredicateKind<'tcx> {`
`232`	`232`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`233`	`233`	`match *self {`
`234`	`234`	`ty::PredicateKind::ForAll(binder) => write!(f, "ForAll({:?})", binder),`
`235`		`- ty::PredicateKind::Atom(atom) => write!(f, "{:?}", atom),`
`236`	`235`	`}`
`237`	`236`	`}`
`238`	`237`	`}`
`@@ -486,7 +485,6 @@ impl<'a, 'tcx> Lift<'tcx> for ty::PredicateKind<'a> {`
`486`	`485`	`fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {`
`487`	`486`	`match self {`
`488`	`487`	`ty::PredicateKind::ForAll(binder) => tcx.lift(binder).map(ty::PredicateKind::ForAll),`
`489`		`- ty::PredicateKind::Atom(atom) => tcx.lift(atom).map(ty::PredicateKind::Atom),`
`490`	`488`	`}`
`491`	`489`	`}`
`492`	`490`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1949,10 +1949,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP`
`1949`	`1949`	`let predicate = ty::Binder::bind(ty::PredicateAtom::TypeOutlives(`
`1950`	`1950`	`ty::OutlivesPredicate(ty, re_root_empty),`
`1951`	`1951`	`));`
`1952`		`- predicates.insert((`
`1953`		`- predicate.potentially_quantified(tcx, ty::PredicateKind::ForAll),`
`1954`		`- span,`
`1955`		`- ));`
	`1952`	`+ predicates.insert((predicate.potentially_quantified(tcx), span));`
`1956`	`1953`	`}`
`1957`	`1954`	`}`
`1958`	`1955`
`@@ -1996,7 +1993,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP`
`1996`	`1993`	`ty::Binder::bind(ty::PredicateAtom::TypeOutlives(`
`1997`	`1994`	`ty::OutlivesPredicate(ty, region),`
`1998`	`1995`	`))`
`1999`		`- .potentially_quantified(tcx, ty::PredicateKind::ForAll),`
	`1996`	`+ .potentially_quantified(tcx),`
`2000`	`1997`	`lifetime.span,`
`2001`	`1998`	`));`
`2002`	`1999`	`}`