From cd9743b4d49bbc9c8d84f419ecf37c93047d7ec3 Mon Sep 17 00:00:00 2001 From: Bastian Kauschke Date: Sat, 18 Jul 2020 11:46:38 +0200 Subject: [PATCH] directly contain `PredicateAtom` in `PredicateKind::ForAll` --- .../infer/canonical/query_response.rs | 2 - src/librustc_middle/ty/flags.rs | 81 +++++++++---------- src/librustc_middle/ty/mod.rs | 64 +++++++-------- src/librustc_middle/ty/print/pretty.rs | 74 ++++++++--------- .../traits/fulfill.rs | 1 + src/librustc_trait_selection/traits/wf.rs | 67 +++++++-------- src/librustc_typeck/check/method/probe.rs | 40 ++++----- src/librustc_typeck/check/mod.rs | 5 +- src/librustc_typeck/collect.rs | 5 +- src/librustc_typeck/outlives/mod.rs | 4 +- 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 @@ fn query_outlives_constraints_into_obligations<'a>( 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 @@ fn add_kind(&mut self, kind: &ty::TyKind<'_>) { } } - 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 @@ pub fn kind(self) -> &'tcx PredicateKind<'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 @@ pub fn skip_binders(self) -> PredicateAtom<'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> { 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>) -> PredicateKind<'tcx>, - ) -> Predicate<'tcx> { - if self.has_escaping_bound_vars() { - qualifier(Binder::bind(self)).to_predicate(tcx) - } else { - self - } - } } impl<'a, 'tcx> HashStable> for Predicate<'tcx> { @@ -1114,7 +1099,7 @@ fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHas #[derive(HashStable, TypeFoldable)] pub enum PredicateKind<'tcx> { /// `for<'a>: ...` - ForAll(Binder>), + ForAll(Binder>), 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>) -> 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 @@ pub fn subst_supertrait( 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 @@ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'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 @@ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'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 @@ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'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 @@ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'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 @@ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'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 @@ pub fn print_only_trait_path(self) -> ty::Binder { 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_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> { 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 @@ fn assemble_inherent_candidates_from_param(&mut self, param_ty: ty::ParamTy) { // 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 @@ fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredic 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 @@ fn suggest_missing_await( 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 extend, Span)>>(&mut self, iter: 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 extend, Span)>>(&mut self, iter: } _ => 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::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, )), -- 2.44.0