directly contain PredicateAtom in PredicateKind::ForAll

rust-lang · bors · Jul 27, 2020 · Jun 11, 2020 · Jun 13, 2020 · Jun 14, 2020
commit cd9743b4d49bbc9c8d84f419ecf37c93047d7ec3
diff --git 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
@@ -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)) => {
+                sel
8000
f.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
@@ -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
@@ -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
@@ -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;