diff --git a/README.md b/README.md index 921f5e38..aae20a85 100644 --- a/README.md +++ b/README.md @@ -27,13 +27,13 @@ repository and compiled from source or installed from of the nightly toolchain is supported at any given time. -It's recommended to use `nightly-2021-10-15` toolchain. -You can install it by using `rustup install nightly-2021-10-15` if you already have rustup. +It's recommended to use `nightly-2021-09-30` toolchain. +You can install it by using `rustup install nightly-2021-09-30` if you already have rustup. Then you can do: ```sh -$ rustup component add rustc-dev llvm-tools-preview --toolchain nightly-2021-10-15 -$ cargo +nightly-2021-10-15 install --git https://github.com/rust-lang/rust-semverver +$ rustup component add rustc-dev llvm-tools-preview --toolchain nightly-2021-09-30 +$ cargo +nightly-2021-09-30 install --git https://github.com/rust-lang/rust-semverver ``` You'd also need `cmake` for some dependencies, and a few common libraries (if you hit diff --git a/rust-toolchain b/rust-toolchain index 085c7531..be691470 100644 --- a/rust-toolchain +++ b/rust-toolchain @@ -1,4 +1,4 @@ # NOTE: Keep in sync with nightly date on README [toolchain] -channel = "nightly-2021-10-15" +channel = "nightly-2021-09-30" components = ["llvm-tools-preview", "rustc-dev"] diff --git a/src/translate.rs b/src/translate.rs index 08d349f2..49835fef 100644 --- a/src/translate.rs +++ b/src/translate.rs @@ -376,97 +376,102 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> { predicate: Predicate<'tcx>, ) -> Option> { use rustc_middle::ty::{ - self, CoercePredicate, OutlivesPredicate, PredicateKind, ProjectionPredicate, - ProjectionTy, SubtypePredicate, ToPredicate, TraitPredicate, WithOptConstParam, + CoercePredicate, OutlivesPredicate, PredicateKind, ProjectionPredicate, ProjectionTy, + self, SubtypePredicate, ToPredicate, TraitPredicate, WithOptConstParam, }; let pred = match predicate.kind().skip_binder() { - PredicateKind::Trait(pred) => PredicateKind::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, - }, - constness: pred.constness, + PredicateKind::Trait(pred) => PredicateKind::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, + }, + constness: pred.constness, + } + } else { + return None; + }, + ), + PredicateKind::RegionOutlives(pred) => PredicateKind::RegionOutlives({ + let l = self.translate_region(pred.0); + let r = self.translate_region(pred.1); + OutlivesPredicate(l, r) + }), + PredicateKind::TypeOutlives(pred) => PredicateKind::TypeOutlives({ + let l = self.translate(index_map, pred.0); + let r = self.translate_region(pred.1); + OutlivesPredicate(l, r) + }), + PredicateKind::Projection(pred) => PredicateKind::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; + }, + ), + PredicateKind::WellFormed(ty) => { + PredicateKind::WellFormed(self.translate(index_map, ty)) + } + PredicateKind::ObjectSafe(did) => { + PredicateKind::ObjectSafe(self.translate_orig(did)) + } + PredicateKind::ClosureKind(did, substs, kind) => PredicateKind::ClosureKind( + self.translate_orig(did), + self.translate(index_map, substs), + kind, + ), + PredicateKind::Subtype(pred) => PredicateKind::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, } - } else { - return None; - }, - ), - PredicateKind::RegionOutlives(pred) => PredicateKind::RegionOutlives({ - let l = self.translate_region(pred.0); - let r = self.translate_region(pred.1); - OutlivesPredicate(l, r) - }), - PredicateKind::TypeOutlives(pred) => PredicateKind::TypeOutlives({ - let l = self.translate(index_map, pred.0); - let r = self.translate_region(pred.1); - OutlivesPredicate(l, r) - }), - PredicateKind::Projection(pred) => PredicateKind::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), + }), + PredicateKind::Coerce(pred) => PredicateKind::Coerce({ + let a = self.translate(index_map, pred.a); + let b = self.translate(index_map, pred.b); + CoercePredicate { a, b } + }), + PredicateKind::ConstEvaluatable(uv) => { + if let Some((target_def_id, target_substs)) = + self.translate_orig_substs(index_map, uv.def.did, uv.substs(self.tcx)) + { + // TODO: We could probably use translated version for + // `WithOptConstParam::const_param_did` + let const_param = WithOptConstParam::unknown(target_def_id); + PredicateKind::ConstEvaluatable(Unevaluated::new( + const_param, + target_substs, + )) + } else { + return None; } - } else { - return None; - }, - ), - PredicateKind::WellFormed(ty) => { - PredicateKind::WellFormed(self.translate(index_map, ty)) - } - PredicateKind::ObjectSafe(did) => PredicateKind::ObjectSafe(self.translate_orig(did)), - PredicateKind::ClosureKind(did, substs, kind) => PredicateKind::ClosureKind( - self.translate_orig(did), - self.translate(index_map, substs), - kind, - ), - PredicateKind::Subtype(pred) => PredicateKind::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, } - }), - PredicateKind::Coerce(pred) => PredicateKind::Coerce({ - let a = self.translate(index_map, pred.a); - let b = self.translate(index_map, pred.b); - CoercePredicate { a, b } - }), - PredicateKind::ConstEvaluatable(uv) => { - if let Some((target_def_id, target_substs)) = - self.translate_orig_substs(index_map, uv.def.did, uv.substs(self.tcx)) - { - // TODO: We could probably use translated version for - // `WithOptConstParam::const_param_did` - let const_param = WithOptConstParam::unknown(target_def_id); - PredicateKind::ConstEvaluatable(Unevaluated::new(const_param, target_substs)) - } else { - return None; - } - } - PredicateKind::ConstEquate(c1, c2) => PredicateKind::ConstEquate( - self.translate(index_map, c1), - self.translate(index_map, c2), - ), - // NOTE: Only used for Chalk trait solver - PredicateKind::TypeWellFormedFromEnv(_) => unimplemented!(), - }; + PredicateKind::ConstEquate(c1, c2) => PredicateKind::ConstEquate( + self.translate(index_map, c1), + self.translate(index_map, c2), + ), + // NOTE: Only used for Chalk trait solver + PredicateKind::TypeWellFormedFromEnv(_) => unimplemented!(), + }; Some(ty::Binder::dummy(pred).to_predicate(self.tcx)) } diff --git a/src/traverse.rs b/src/traverse.rs index c4c58139..2cc67961 100644 --- a/src/traverse.rs +++ b/src/traverse.rs @@ -17,6 +17,7 @@ use crate::{ typeck::{BoundContext, TypeComparisonContext}, }; use log::{debug, info}; +use rustc_const_eval::const_eval::is_const_fn; use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res, Res::Def}; use rustc_hir::def_id::DefId; use rustc_hir::hir_id::HirId; @@ -362,8 +363,8 @@ fn diff_fn<'tcx>(changes: &mut ChangeSet, tcx: TyCtxt<'tcx>, old: Res, new: Res) let old_def_id = old.def_id(); let new_def_id = new.def_id(); - let old_const = tcx.is_const_fn(old_def_id); - let new_const = tcx.is_const_fn(new_def_id); + let old_const = is_const_fn(tcx, old_def_id); + let new_const = is_const_fn(tcx, new_def_id); if old_const != new_const { changes.add_change( diff --git a/src/typeck.rs b/src/typeck.rs index ae490e8e..2ab90066 100644 --- a/src/typeck.rs +++ b/src/typeck.rs @@ -72,7 +72,7 @@ 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_middle::ty::{self, BoundConstness, ToPredicate, TraitPredicate}; + use rustc_middle::ty::{BoundConstness, self, ToPredicate, TraitPredicate}; let predicate = ty::Binder::dummy(PredicateKind::Trait(TraitPredicate { trait_ref: checked_trait_ref,