diff --git a/rust-toolchain b/rust-toolchain index 3e0f3c66..ce197494 100644 --- a/rust-toolchain +++ b/rust-toolchain @@ -1 +1 @@ -nightly-2020-07-23 +nightly-2020-07-28 diff --git a/src/translate.rs b/src/translate.rs index 810d931c..9b676b64 100644 --- a/src/translate.rs +++ b/src/translate.rs @@ -365,105 +365,95 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> { predicate: Predicate<'tcx>, ) -> Option> { use rustc_middle::ty::{ - Binder, OutlivesPredicate, PredicateKind, ProjectionPredicate, ProjectionTy, + OutlivesPredicate, PredicateAtom, PredicateKind, ProjectionPredicate, ProjectionTy, SubtypePredicate, ToPredicate, TraitPredicate, WithOptConstParam, }; - Some(match predicate.kind() { - PredicateKind::Trait(trait_predicate, constness) => PredicateKind::Trait( - Binder::bind( - if let Some((target_def_id, target_substs)) = self.translate_orig_substs( - index_map, - trait_predicate.skip_binder().trait_ref.def_id, - trait_predicate.skip_binder().trait_ref.substs, - ) { - TraitPredicate { - trait_ref: TraitRef { - def_id: target_def_id, - substs: target_substs, - }, - } - } else { - return None; - }, - ), - *constness, + Some(match predicate.skip_binders() { + PredicateAtom::Trait(pred, constness) => PredicateAtom::Trait( + if let Some((target_def_id, target_substs)) = self.translate_orig_substs( + index_map, + pred.trait_ref.def_id, + pred.trait_ref.substs, + ) { + TraitPredicate { + trait_ref: TraitRef { + def_id: target_def_id, + substs: target_substs, + }, + } + } else { + return None; + }, + constness, ) - .to_predicate(self.tcx), - PredicateKind::RegionOutlives(region_outlives_predicate) => { - PredicateKind::RegionOutlives(region_outlives_predicate.map_bound(|r_pred| { - let l = self.translate_region(r_pred.0); - let r = self.translate_region(r_pred.1); - OutlivesPredicate(l, r) - })) - .to_predicate(self.tcx) - } - PredicateKind::TypeOutlives(type_outlives_predicate) => { - PredicateKind::TypeOutlives(type_outlives_predicate.map_bound(|r_pred| { - let l = self.translate(index_map, &r_pred.0); - let r = self.translate_region(r_pred.1); - OutlivesPredicate(l, r) - })) - .to_predicate(self.tcx) - } - PredicateKind::Projection(projection_predicate) => { - PredicateKind::Projection(Binder::bind( - if let Some((target_def_id, target_substs)) = self.translate_orig_substs( - index_map, - projection_predicate.skip_binder().projection_ty.item_def_id, - projection_predicate.skip_binder().projection_ty.substs, - ) { - ProjectionPredicate { - projection_ty: ProjectionTy { - substs: target_substs, - item_def_id: target_def_id, - }, - ty: self.translate(index_map, &projection_predicate.skip_binder().ty), - } - } else { - return None; - }, - )) - .to_predicate(self.tcx) - } - PredicateKind::WellFormed(ty) => { - PredicateKind::WellFormed(self.translate(index_map, &ty)).to_predicate(self.tcx) + .potentially_quantified(self.tcx, PredicateKind::ForAll), + PredicateAtom::RegionOutlives(pred) => PredicateAtom::RegionOutlives({ + let l = self.translate_region(pred.0); + let r = self.translate_region(pred.1); + OutlivesPredicate(l, r) + }) + .potentially_quantified(self.tcx, PredicateKind::ForAll), + PredicateAtom::TypeOutlives(pred) => PredicateAtom::TypeOutlives({ + let l = self.translate(index_map, &pred.0); + let r = self.translate_region(pred.1); + OutlivesPredicate(l, r) + }) + .potentially_quantified(self.tcx, PredicateKind::ForAll), + PredicateAtom::Projection(pred) => PredicateAtom::Projection( + if let Some((target_def_id, target_substs)) = self.translate_orig_substs( + index_map, + pred.projection_ty.item_def_id, + pred.projection_ty.substs, + ) { + ProjectionPredicate { + projection_ty: ProjectionTy { + substs: target_substs, + item_def_id: target_def_id, + }, + ty: self.translate(index_map, &pred.ty), + } + } else { + return None; + }, + ) + .potentially_quantified(self.tcx, PredicateKind::ForAll), + PredicateAtom::WellFormed(ty) => { + PredicateAtom::WellFormed(self.translate(index_map, &ty)).to_predicate(self.tcx) } - PredicateKind::ObjectSafe(did) => { - PredicateKind::ObjectSafe(self.translate_orig(*did)).to_predicate(self.tcx) + PredicateAtom::ObjectSafe(did) => { + PredicateAtom::ObjectSafe(self.translate_orig(did)).to_predicate(self.tcx) } - PredicateKind::ClosureKind(did, substs, kind) => PredicateKind::ClosureKind( - self.translate_orig(*did), + PredicateAtom::ClosureKind(did, substs, kind) => PredicateAtom::ClosureKind( + self.translate_orig(did), self.translate(index_map, &substs), - *kind, + kind, ) .to_predicate(self.tcx), - PredicateKind::Subtype(subtype_predicate) => { - PredicateKind::Subtype(subtype_predicate.map_bound(|s_pred| { - let l = self.translate(index_map, &s_pred.a); - let r = self.translate(index_map, &s_pred.b); - SubtypePredicate { - a_is_expected: s_pred.a_is_expected, - a: l, - b: r, - } - })) - .to_predicate(self.tcx) - } - PredicateKind::ConstEvaluatable(param, orig_substs) => { + PredicateAtom::Subtype(pred) => PredicateAtom::Subtype({ + let l = self.translate(index_map, &pred.a); + let r = self.translate(index_map, &pred.b); + SubtypePredicate { + a_is_expected: pred.a_is_expected, + a: l, + b: r, + } + }) + .to_predicate(self.tcx), + PredicateAtom::ConstEvaluatable(param, orig_substs) => { if let Some((target_def_id, target_substs)) = self.translate_orig_substs(index_map, param.did, orig_substs) { // TODO: We could probably use translated version for // `WithOptConstParam::const_param_did` let const_param = WithOptConstParam::unknown(target_def_id); - PredicateKind::ConstEvaluatable(const_param, target_substs) + PredicateAtom::ConstEvaluatable(const_param, target_substs) .to_predicate(self.tcx) } else { return None; } } - PredicateKind::ConstEquate(c1, c2) => PredicateKind::ConstEquate( + PredicateAtom::ConstEquate(c1, c2) => PredicateAtom::ConstEquate( self.translate(index_map, &c1), self.translate(index_map, &c2), ) @@ -503,7 +493,6 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> { self.tcx.intern_predicates(&target_preds), param_env.reveal(), param_env.def_id, - ) }) } diff --git a/src/traverse.rs b/src/traverse.rs index 2f4dc451..ac5989bd 100644 --- a/src/traverse.rs +++ b/src/traverse.rs @@ -570,7 +570,7 @@ fn diff_traits<'tcx>( ) { use rustc_hir::Unsafety::Unsafe; use rustc_middle::ty::subst::GenericArgKind::Type; - use rustc_middle::ty::{ParamTy, PredicateKind, TyS}; + use rustc_middle::ty::{ParamTy, PredicateAtom, TyS}; debug!( "diff_traits: old: {:?}, new: {:?}, output: {:?}", @@ -592,8 +592,8 @@ fn diff_traits<'tcx>( let old_param_env = tcx.param_env(old); for bound in old_param_env.caller_bounds() { - if let PredicateKind::Trait(pred, _) = *bound.kind() { - let trait_ref = pred.skip_binder().trait_ref; + if let PredicateAtom::Trait(pred, _) = bound.skip_binders() { + let trait_ref = pred.trait_ref; debug!("trait_ref substs (old): {:?}", trait_ref.substs); diff --git a/src/typeck.rs b/src/typeck.rs index f6108767..1709e004 100644 --- a/src/typeck.rs +++ b/src/typeck.rs @@ -18,7 +18,8 @@ use rustc_middle::{ error::TypeError, fold::TypeFoldable, subst::{GenericArg, InternalSubsts, SubstsRef}, - GenericParamDefKind, ParamEnv, Predicate, PredicateKind, ToPredicate, TraitRef, Ty, TyCtxt, + GenericParamDefKind, ParamEnv, Predicate, PredicateAtom, PredicateKind, TraitRef, Ty, + TyCtxt, }, }; use rustc_trait_selection::traits::FulfillmentContext; @@ -73,15 +74,15 @@ impl<'a, 'tcx> BoundContext<'a, 'tcx> { /// Register the trait bound represented by a `TraitRef`. pub fn register_trait_ref(&mut self, checked_trait_ref: TraitRef<'tcx>) { use rustc_hir::Constness; - use rustc_middle::ty::{Binder, TraitPredicate}; + use rustc_middle::ty::TraitPredicate; - let predicate = PredicateKind::Trait( - Binder::bind(TraitPredicate { + let predicate = PredicateAtom::Trait( + TraitPredicate { trait_ref: checked_trait_ref, - }), + }, Constness::NotConst, ) - .to_predicate(self.infcx.tcx); + .potentially_quantified(self.infcx.tcx, PredicateKind::ForAll); let obligation = Obligation::new(ObligationCause::dummy(), self.given_param_env, predicate); self.fulfill_cx .register_predicate_obligation(self.infcx, obligation);