From 19b0f1d980663a30069161d5697b9753de74ffda Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Mon, 25 May 2020 14:50:20 +0900 Subject: [PATCH 1/3] Rustup to the latest nightly --- src/translate.rs | 94 +++++++++++++++++++++++++++--------------------- src/traverse.rs | 4 +-- src/typeck.rs | 10 +++--- 3 files changed, 60 insertions(+), 48 deletions(-) diff --git a/src/translate.rs b/src/translate.rs index 1e65c086..e5be434c 100644 --- a/src/translate.rs +++ b/src/translate.rs @@ -362,12 +362,12 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> { predicate: Predicate<'tcx>, ) -> Option> { use rustc_middle::ty::{ - Binder, OutlivesPredicate, ProjectionPredicate, ProjectionTy, SubtypePredicate, - TraitPredicate, + Binder, OutlivesPredicate, PredicateKind, ProjectionPredicate, ProjectionTy, + SubtypePredicate, ToPredicate, TraitPredicate, }; - Some(match predicate { - Predicate::Trait(trait_predicate, constness) => Predicate::Trait( + 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, @@ -384,48 +384,59 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> { return None; }, ), - constness, - ), - Predicate::RegionOutlives(region_outlives_predicate) => { - Predicate::RegionOutlives(region_outlives_predicate.map_bound(|r_pred| { + *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) } - Predicate::TypeOutlives(type_outlives_predicate) => { - Predicate::TypeOutlives(type_outlives_predicate.map_bound(|r_pred| { + 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) } - Predicate::Projection(projection_predicate) => Predicate::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; - }, - )), - Predicate::WellFormed(ty) => Predicate::WellFormed(self.translate(index_map, &ty)), - Predicate::ObjectSafe(did) => Predicate::ObjectSafe(self.translate_orig(did)), - Predicate::ClosureKind(did, substs, kind) => Predicate::ClosureKind( - self.translate_orig(did), + 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) + } + PredicateKind::ObjectSafe(did) => { + PredicateKind::ObjectSafe(self.translate_orig(*did)).to_predicate(self.tcx) + } + PredicateKind::ClosureKind(did, substs, kind) => PredicateKind::ClosureKind( + self.translate_orig(*did), self.translate(index_map, &substs), - kind, - ), - Predicate::Subtype(subtype_predicate) => { - Predicate::Subtype(subtype_predicate.map_bound(|s_pred| { + *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 { @@ -434,20 +445,23 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> { b: r, } })) + .to_predicate(self.tcx) } - Predicate::ConstEvaluatable(orig_did, orig_substs) => { + PredicateKind::ConstEvaluatable(orig_did, orig_substs) => { if let Some((target_def_id, target_substs)) = - self.translate_orig_substs(index_map, orig_did, orig_substs) + self.translate_orig_substs(index_map, *orig_did, orig_substs) { - Predicate::ConstEvaluatable(target_def_id, target_substs) + PredicateKind::ConstEvaluatable(target_def_id, target_substs) + .to_predicate(self.tcx) } else { return None; } } - Predicate::ConstEquate(c1, c2) => Predicate::ConstEquate( + PredicateKind::ConstEquate(c1, c2) => PredicateKind::ConstEquate( self.translate(index_map, &c1), self.translate(index_map, &c2), - ), + ) + .to_predicate(self.tcx), }) } diff --git a/src/traverse.rs b/src/traverse.rs index b72899e3..5191318a 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, Predicate, TyS}; + use rustc_middle::ty::{ParamTy, PredicateKind, TyS}; debug!( "diff_traits: old: {:?}, new: {:?}, output: {:?}", @@ -592,7 +592,7 @@ fn diff_traits<'tcx>( let old_param_env = tcx.param_env(old); for bound in old_param_env.caller_bounds { - if let Predicate::Trait(pred, _) = *bound { + if let PredicateKind::Trait(pred, _) = *bound.kind() { let trait_ref = pred.skip_binder().trait_ref; debug!("trait_ref substs (old): {:?}", trait_ref.substs); diff --git a/src/typeck.rs b/src/typeck.rs index 23241318..91a16b4f 100644 --- a/src/typeck.rs +++ b/src/typeck.rs @@ -18,7 +18,7 @@ use rustc_middle::{ error::TypeError, fold::TypeFoldable, subst::{GenericArg, InternalSubsts, SubstsRef}, - GenericParamDefKind, ParamEnv, Predicate, TraitRef, Ty, TyCtxt, + GenericParamDefKind, ParamEnv, Predicate, PredicateKind, ToPredicate, TraitRef, Ty, TyCtxt, }, }; use rustc_trait_selection::traits::FulfillmentContext; @@ -75,12 +75,13 @@ impl<'a, 'tcx> BoundContext<'a, 'tcx> { use rustc_hir::Constness; use rustc_middle::ty::{Binder, TraitPredicate}; - let predicate = Predicate::Trait( + let predicate = PredicateKind::Trait( Binder::bind(TraitPredicate { trait_ref: checked_trait_ref, }), Constness::NotConst, - ); + ) + .to_predicate(self.infcx.tcx); let obligation = Obligation::new(ObligationCause::dummy(), self.given_param_env, predicate); self.fulfill_cx .register_predicate_obligation(self.infcx, obligation); @@ -218,7 +219,6 @@ impl<'a, 'tcx> TypeComparisonContext<'a, 'tcx> { ) -> Option> { use rustc_infer::infer::outlives::env::OutlivesEnvironment; use rustc_infer::infer::{InferOk, RegionckMode}; - use rustc_middle::middle::region::ScopeTree; use rustc_middle::ty::Lift; let error = self @@ -230,7 +230,6 @@ impl<'a, 'tcx> TypeComparisonContext<'a, 'tcx> { }); if let Err(err) = error { - let scope_tree = ScopeTree::default(); let outlives_env = OutlivesEnvironment::new(target_param_env); // The old code here added the bounds from the target param env by hand. However, at @@ -246,7 +245,6 @@ impl<'a, 'tcx> TypeComparisonContext<'a, 'tcx> { self.infcx.resolve_regions_and_report_errors( target_def_id, - &scope_tree, &outlives_env, RegionckMode::default(), ); From cca51fd8cc7f804c0279f29f14987a8cac207b0d Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Mon, 25 May 2020 15:16:37 +0900 Subject: [PATCH 2/3] Install llvm-tools --- ci/run.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ci/run.sh b/ci/run.sh index 4443668f..2b5553fb 100755 --- a/ci/run.sh +++ b/ci/run.sh @@ -7,9 +7,9 @@ export RUST_BACKTRACE=full cargo +nightly install rustup-toolchain-install-master if [ "${TRAVIS_OS_NAME}" = "windows" ]; then - rustup-toolchain-install-master -f -n master -c rustc-dev -i x86_64-pc-windows-msvc + rustup-toolchain-install-master -f -n master -c rustc-dev -c llvm-tools -i x86_64-pc-windows-msvc else - rustup-toolchain-install-master -f -n master -c rustc-dev + rustup-toolchain-install-master -f -n master -c rustc-dev -c llvm-tools fi rustup override set master From b55a3e73dc7d6c5aa87d567a438edc369c80cbd8 Mon Sep 17 00:00:00 2001 From: Yuki Okushi Date: Mon, 25 May 2020 15:38:24 +0900 Subject: [PATCH 3/3] Bless tests --- tests/full_cases/log-0.3.4-0.3.8.osx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/full_cases/log-0.3.4-0.3.8.osx b/tests/full_cases/log-0.3.4-0.3.8.osx index 6f0122e2..e77b51cc 100644 --- a/tests/full_cases/log-0.3.4-0.3.8.osx +++ b/tests/full_cases/log-0.3.4-0.3.8.osx @@ -23,7 +23,7 @@ warning: technically breaking changes in ` as std::fmt::Debug | = note: trait impl generalized or newly added (technically breaking) -warning: technically breaking changes in ` as std::cmp::Eq>` +warning: technically breaking changes in ` as std::marker::StructuralEq>` --> log-0.3.8/src/lib.rs:552:10 | 552 | #[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug)] @@ -71,7 +71,7 @@ warning: technically breaking changes in ` as std::fmt::Deb | = note: trait impl generalized or newly added (technically breaking) -warning: technically breaking changes in `` +warning: technically breaking changes in `` --> log-0.3.8/src/lib.rs:604:30 | 604 | #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]