impl fmt::Debug for ty::PredicateKind<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
- ty::PredicateKind::Trait(ref a, constness) => {
+ ty::PredicateKind::ForAll(binder) => write!(f, "ForAll({:?})", binder),
+ ty::PredicateKind::Atom(atom) => write!(f, "{:?}", atom),
+ }
+ }
+}
+
+impl fmt::Debug for ty::PredicateAtom<'tcx> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match *self {
+ ty::PredicateAtom::Trait(ref a, constness) => {
if let hir::Constness::Const = constness {
write!(f, "const ")?;
}
a.fmt(f)
}
- ty::PredicateKind::Subtype(ref pair) => pair.fmt(f),
- ty::PredicateKind::RegionOutlives(ref pair) => pair.fmt(f),
- ty::PredicateKind::TypeOutlives(ref pair) => pair.fmt(f),
- ty::PredicateKind::Projection(ref pair) => pair.fmt(f),
- ty::PredicateKind::WellFormed(data) => write!(f, "WellFormed({:?})", data),
- ty::PredicateKind::ObjectSafe(trait_def_id) => {
+ ty::PredicateAtom::Subtype(ref pair) => pair.fmt(f),
+ ty::PredicateAtom::RegionOutlives(ref pair) => pair.fmt(f),
+ ty::PredicateAtom::TypeOutlives(ref pair) => pair.fmt(f),
+ ty::PredicateAtom::Projection(ref pair) => pair.fmt(f),
+ ty::PredicateAtom::WellFormed(data) => write!(f, "WellFormed({:?})", data),
+ ty::PredicateAtom::ObjectSafe(trait_def_id) => {
write!(f, "ObjectSafe({:?})", trait_def_id)
}
- ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
+ ty::PredicateAtom::ClosureKind(closure_def_id, closure_substs, kind) => {
write!(f, "ClosureKind({:?}, {:?}, {:?})", closure_def_id, closure_substs, kind)
}
- ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
+ ty::PredicateAtom::ConstEvaluatable(def_id, substs) => {
write!(f, "ConstEvaluatable({:?}, {:?})", def_id, substs)
}
- ty::PredicateKind::ConstEquate(c1, c2) => write!(f, "ConstEquate({:?}, {:?})", c1, c2),
+ ty::PredicateAtom::ConstEquate(c1, c2) => write!(f, "ConstEquate({:?}, {:?})", c1, c2),
}
}
}
type Lifted = ty::PredicateKind<'tcx>;
fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
match *self {
- ty::PredicateKind::Trait(ref binder, constness) => {
- tcx.lift(binder).map(|binder| ty::PredicateKind::Trait(binder, constness))
+ ty::PredicateKind::ForAll(ref binder) => {
+ tcx.lift(binder).map(ty::PredicateKind::ForAll)
}
- ty::PredicateKind::Subtype(ref binder) => {
- tcx.lift(binder).map(ty::PredicateKind::Subtype)
+ ty::PredicateKind::Atom(ref atom) => tcx.lift(atom).map(ty::PredicateKind::Atom),
+ }
+ }
+}
+
+impl<'a, 'tcx> Lift<'tcx> for ty::PredicateAtom<'a> {
+ type Lifted = ty::PredicateAtom<'tcx>;
+ fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
+ match *self {
+ ty::PredicateAtom::Trait(ref data, constness) => {
+ tcx.lift(data).map(|data| ty::PredicateAtom::Trait(data, constness))
}
- ty::PredicateKind::RegionOutlives(ref binder) => {
- tcx.lift(binder).map(ty::PredicateKind::RegionOutlives)
+ ty::PredicateAtom::Subtype(ref data) => tcx.lift(data).map(ty::PredicateAtom::Subtype),
+ ty::PredicateAtom::RegionOutlives(ref data) => {
+ tcx.lift(data).map(ty::PredicateAtom::RegionOutlives)
}
- ty::PredicateKind::TypeOutlives(ref binder) => {
- tcx.lift(binder).map(ty::PredicateKind::TypeOutlives)
+ ty::PredicateAtom::TypeOutlives(ref data) => {
+ tcx.lift(data).map(ty::PredicateAtom::TypeOutlives)
}
- ty::PredicateKind::Projection(ref binder) => {
- tcx.lift(binder).map(ty::PredicateKind::Projection)
+ ty::PredicateAtom::Projection(ref data) => {
+ tcx.lift(data).map(ty::PredicateAtom::Projection)
}
- ty::PredicateKind::WellFormed(ty) => tcx.lift(&ty).map(ty::PredicateKind::WellFormed),
- ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind) => {
+ ty::PredicateAtom::WellFormed(ty) => tcx.lift(&ty).map(ty::PredicateAtom::WellFormed),
+ ty::PredicateAtom::ClosureKind(closure_def_id, closure_substs, kind) => {
tcx.lift(&closure_substs).map(|closure_substs| {
- ty::PredicateKind::ClosureKind(closure_def_id, closure_substs, kind)
+ ty::PredicateAtom::ClosureKind(closure_def_id, closure_substs, kind)
})
}
- ty::PredicateKind::ObjectSafe(trait_def_id) => {
- Some(ty::PredicateKind::ObjectSafe(trait_def_id))
+ ty::PredicateAtom::ObjectSafe(trait_def_id) => {
+ Some(ty::PredicateAtom::ObjectSafe(trait_def_id))
}
- ty::PredicateKind::ConstEvaluatable(def_id, substs) => {
- tcx.lift(&substs).map(|substs| ty::PredicateKind::ConstEvaluatable(def_id, substs))
+ ty::PredicateAtom::ConstEvaluatable(def_id, substs) => {
+ tcx.lift(&substs).map(|substs| ty::PredicateAtom::ConstEvaluatable(def_id, substs))
}
- ty::PredicateKind::ConstEquate(c1, c2) => {
- tcx.lift(&(c1, c2)).map(|(c1, c2)| ty::PredicateKind::ConstEquate(c1, c2))
+ ty::PredicateAtom::ConstEquate(c1, c2) => {
+ tcx.lift(&(c1, c2)).map(|(c1, c2)| ty::PredicateAtom::ConstEquate(c1, c2))
}
}
}
impl<'tcx> TypeFoldable<'tcx> for ty::Predicate<'tcx> {
fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
let new = ty::PredicateKind::super_fold_with(&self.inner.kind, folder);
- if new != self.inner.kind { folder.tcx().mk_predicate(new) } else { *self }
+ folder.tcx().reuse_or_mk_predicate(*self, new)
}
fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {