Fixed build with newest nightly.

The `TyCtxt` and `InferCtxt` refactoring truly was a blessing.

Author: ibabushkin

src/bin/cargo_semver.rs

@@ -282,11 +282,7 @@ mod cli {
             "Space-separated list of features to activate",
             "FEATURES",
         );
-        opts.optflag(
-            "",
-            "all-features",
-            "Activate all available features",
-        );
+        opts.optflag("", "all-features", "Activate all available features");
         opts.optflag(
             "",
             "no-default-features",

src/mismatch.rs

@@ -24,9 +24,9 @@ use std::collections::{HashMap, HashSet, VecDeque};
 /// This allows to match up some items that aren't exported, and which possibly even differ in
 /// their names across versions.
 #[cfg_attr(feature = "cargo-clippy", allow(clippy::module_name_repetitions))]
-pub struct MismatchRelation<'a, 'gcx: 'tcx, 'tcx> {
+pub struct MismatchRelation<'a, 'tcx> {
     /// The type context used.
-    tcx: TyCtxt<'gcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
     /// The queue of found item pairings to be processed.
     item_queue: VecDeque<(Res, Res)>,
     /// The id mapping to use.
@@ -37,9 +37,9 @@ pub struct MismatchRelation<'a, 'gcx: 'tcx, 'tcx> {
     current_new_types: HashSet<Ty<'tcx>>,
 }
 
-impl<'a, 'gcx: 'tcx, 'tcx> MismatchRelation<'a, 'gcx, 'tcx> {
+impl<'a, 'tcx> MismatchRelation<'a, 'tcx> {
     /// Construct a new mismtach type relation.
-    pub fn new(tcx: TyCtxt<'gcx, 'tcx>, id_mapping: &'a mut IdMapping) -> Self {
+    pub fn new(tcx: TyCtxt<'tcx>, id_mapping: &'a mut IdMapping) -> Self {
         Self {
             tcx,
             item_queue: id_mapping.toplevel_queue(),
@@ -100,8 +100,8 @@ impl<'a, 'gcx: 'tcx, 'tcx> MismatchRelation<'a, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'gcx, 'tcx> TypeRelation<'gcx, 'tcx> for MismatchRelation<'a, 'gcx, 'tcx> {
-    fn tcx(&self) -> TyCtxt<'gcx, 'tcx> {
+impl<'a, 'tcx> TypeRelation<'tcx> for MismatchRelation<'a, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
         self.tcx
     }
 

src/translate.rs

@@ -15,9 +15,9 @@ use rustc::{
 use std::collections::HashMap;
 
 /// The context in which `DefId` translation happens.
-pub struct TranslationContext<'a, 'gcx: 'tcx, 'tcx> {
+pub struct TranslationContext<'a, 'tcx> {
     /// The type context to use.
-    tcx: TyCtxt<'gcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
     /// The id mapping to use.
     id_mapping: &'a IdMapping,
     /// Whether to translate type and region parameters.
@@ -28,13 +28,13 @@ pub struct TranslationContext<'a, 'gcx: 'tcx, 'tcx> {
     translate_orig: fn(&IdMapping, DefId) -> Option<DefId>,
 }
 
-impl<'a, 'gcx, 'tcx> TranslationContext<'a, 'gcx, 'tcx> {
+impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
     /// Construct a translation context translating to the new crate's `DefId`s.
     pub fn target_new(
-        tcx: TyCtxt<'gcx, 'tcx>,
+        tcx: TyCtxt<'tcx>,
         id_mapping: &'a IdMapping,
         translate_params: bool,
-    ) -> TranslationContext<'a, 'gcx, 'tcx> {
+    ) -> TranslationContext<'a, 'tcx> {
         TranslationContext {
             tcx,
             id_mapping,
@@ -46,10 +46,10 @@ impl<'a, 'gcx, 'tcx> TranslationContext<'a, 'gcx, 'tcx> {
 
     /// Construct a translation context translating to the old crate's `DefId`s.
     pub fn target_old(
-        tcx: TyCtxt<'gcx, 'tcx>,
+        tcx: TyCtxt<'tcx>,
         id_mapping: &'a IdMapping,
         translate_params: bool,
-    ) -> TranslationContext<'a, 'gcx, 'tcx> {
+    ) -> TranslationContext<'a, 'tcx> {
         TranslationContext {
             tcx,
             id_mapping,
@@ -520,20 +520,20 @@ impl<'a, 'gcx, 'tcx> TranslationContext<'a, 'gcx, 'tcx> {
 ///
 /// Used to lift type errors and predicates to wrap them in an error type.
 #[derive(Clone)]
-pub struct InferenceCleanupFolder<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
+pub struct InferenceCleanupFolder<'a, 'tcx: 'a> {
     /// The inference context used.
-    infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+    infcx: &'a InferCtxt<'a, 'tcx>,
 }
 
-impl<'a, 'gcx, 'tcx> InferenceCleanupFolder<'a, 'gcx, 'tcx> {
+impl<'a, 'tcx> InferenceCleanupFolder<'a, 'tcx> {
     /// Construct a new folder.
-    pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>) -> Self {
+    pub fn new(infcx: &'a InferCtxt<'a, 'tcx>) -> Self {
         InferenceCleanupFolder { infcx }
     }
 }
 
-impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for InferenceCleanupFolder<'a, 'gcx, 'tcx> {
-    fn tcx(&self) -> TyCtxt<'gcx, 'tcx> {
+impl<'a, 'tcx> TypeFolder<'tcx> for InferenceCleanupFolder<'a, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
         self.infcx.tcx
     }
 

src/traverse.rs

@@ -35,7 +35,7 @@ use std::collections::{BTreeMap, HashSet, VecDeque};
 /// The main entry point to our analysis passes.
 ///
 /// Set up the necessary data structures and run the analysis passes and call the actual passes.
-pub fn run_analysis<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, old: DefId, new: DefId) -> ChangeSet<'tcx> {
+pub fn run_analysis<'tcx>(tcx: TyCtxt<'tcx>, old: DefId, new: DefId) -> ChangeSet<'tcx> {
     let mut changes = ChangeSet::default();
     let mut id_mapping = IdMapping::new(old.krate, new.krate);
 
@@ -74,7 +74,7 @@ fn get_vis(outer_vis: Visibility, def: Export<HirId>) -> Visibility {
     }
 }
 
-pub fn run_traversal<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, new: DefId) {
+pub fn run_traversal<'tcx>(tcx: TyCtxt<'tcx>, new: DefId) {
     use rustc::hir::def::DefKind::*;
     let mut visited = HashSet::new();
     let mut mod_queue = VecDeque::new();
@@ -124,7 +124,7 @@ pub fn run_traversal<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, new: DefId) {
 fn diff_structure<'tcx>(
     changes: &mut ChangeSet,
     id_mapping: &mut IdMapping,
-    tcx: TyCtxt<'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
     old: DefId,
     new: DefId,
 ) {
@@ -358,7 +358,7 @@ fn diff_structure<'tcx>(
 }
 
 /// Given two fn items, perform structural checks.
-fn diff_fn<'tcx>(changes: &mut ChangeSet, tcx: TyCtxt<'tcx, 'tcx>, old: Res, new: Res) {
+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();
 
@@ -377,12 +377,7 @@ fn diff_fn<'tcx>(changes: &mut ChangeSet, tcx: TyCtxt<'tcx, 'tcx>, old: Res, new
 }
 
 /// Given two method items, perform structural checks.
-fn diff_method<'tcx>(
-    changes: &mut ChangeSet,
-    tcx: TyCtxt<'tcx, 'tcx>,
-    old: AssocItem,
-    new: AssocItem,
-) {
+fn diff_method<'tcx>(changes: &mut ChangeSet, tcx: TyCtxt<'tcx>, old: AssocItem, new: AssocItem) {
     if old.method_has_self_argument != new.method_has_self_argument {
         changes.add_change(
             ChangeType::MethodSelfChanged {
@@ -561,7 +556,7 @@ fn diff_adts(changes: &mut ChangeSet, id_mapping: &mut IdMapping, tcx: TyCtxt, o
 fn diff_traits<'tcx>(
     changes: &mut ChangeSet,
     id_mapping: &mut IdMapping,
-    tcx: TyCtxt<'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
     old: DefId,
     new: DefId,
     output: bool,
@@ -832,7 +827,7 @@ fn diff_generics(
 fn diff_types<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
     old: Res,
     new: Res,
 ) {
@@ -901,7 +896,7 @@ fn diff_types<'tcx>(
 fn cmp_types<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
     orig_def_id: DefId,
     target_def_id: DefId,
     orig: Ty<'tcx>,
@@ -954,7 +949,7 @@ fn cmp_types<'tcx>(
 fn cmp_bounds<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
     orig_def_id: DefId,
     target_def_id: DefId,
 ) {
@@ -987,7 +982,7 @@ fn cmp_bounds<'tcx>(
 fn diff_inherent_impls<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
 ) {
     debug!("diffing inherent impls");
 
@@ -1067,8 +1062,8 @@ fn diff_inherent_impls<'tcx>(
 // from perfect and will cause false positives in some cases (see comment in the inner function).
 #[allow(clippy::let_and_return)]
 #[allow(clippy::match_same_arms)]
-fn is_impl_trait_public<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, impl_def_id: DefId) -> bool {
-    fn type_visibility<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, ty: Ty) -> Visibility {
+fn is_impl_trait_public<'tcx>(tcx: TyCtxt<'tcx>, impl_def_id: DefId) -> bool {
+    fn type_visibility<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty) -> Visibility {
         match ty.sty {
             TyKind::Adt(def, _) => tcx.visibility(def.did),
 
@@ -1111,7 +1106,7 @@ fn is_impl_trait_public<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, impl_def_id: DefId) -> bo
 fn diff_trait_impls<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
 ) {
     debug!("diffing trait impls");
 
@@ -1164,7 +1159,7 @@ fn diff_trait_impls<'tcx>(
 fn match_inherent_impl<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
     orig_impl_def_id: DefId,
     target_impl_def_id: DefId,
     orig_item: AssocItem,
@@ -1290,8 +1285,8 @@ fn match_inherent_impl<'tcx>(
 /// Compare two implementations and indicate whether the target one is compatible with the
 /// original one.
 fn match_trait_impl<'a, 'tcx>(
-    tcx: TyCtxt<'tcx, 'tcx>,
-    trans: &TranslationContext<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx>,
+    trans: &TranslationContext<'a, 'tcx>,
     orig_def_id: DefId,
 ) -> bool {
     debug!("matching: {:?}", orig_def_id);

src/typeck.rs

@@ -22,18 +22,18 @@ use rustc::{
 };
 
 /// The context in which bounds analysis happens.
-pub struct BoundContext<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
+pub struct BoundContext<'a, 'tcx: 'a> {
     /// The inference context to use.
-    infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+    infcx: &'a InferCtxt<'a, 'tcx>,
     /// The fulfillment context to use.
     fulfill_cx: FulfillmentContext<'tcx>,
     /// The param env to be assumed.
     given_param_env: ParamEnv<'tcx>,
 }
 
-impl<'a, 'gcx, 'tcx> BoundContext<'a, 'gcx, 'tcx> {
+impl<'a, 'tcx> BoundContext<'a, 'tcx> {
     /// Construct a new bound context.
-    pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>, given_param_env: ParamEnv<'tcx>) -> Self {
+    pub fn new(infcx: &'a InferCtxt<'a, 'tcx>, given_param_env: ParamEnv<'tcx>) -> Self {
         BoundContext {
             infcx,
             fulfill_cx: FulfillmentContext::new(),
@@ -91,25 +91,25 @@ impl<'a, 'gcx, 'tcx> BoundContext<'a, 'gcx, 'tcx> {
 }
 
 /// The context in which types and their bounds can be compared.
-pub struct TypeComparisonContext<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
+pub struct TypeComparisonContext<'a, 'tcx: 'a> {
     /// The inference context to use.
-    infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+    infcx: &'a InferCtxt<'a, 'tcx>,
     /// The index mapping to use.
     id_mapping: &'a IdMapping,
     /// The folder to clean up found errors of inference artifacts.
-    folder: InferenceCleanupFolder<'a, 'gcx, 'tcx>,
+    folder: InferenceCleanupFolder<'a, 'tcx>,
     /// The translation context translating from original to target items.
-    pub forward_trans: TranslationContext<'a, 'gcx, 'tcx>,
+    pub forward_trans: TranslationContext<'a, 'tcx>,
     /// The translation context translating from target to original items.
-    pub backward_trans: TranslationContext<'a, 'gcx, 'tcx>,
+    pub backward_trans: TranslationContext<'a, 'tcx>,
     /// Whether we are checking a trait definition.
     checking_trait_def: bool,
 }
 
-impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
+impl<'a, 'tcx> TypeComparisonContext<'a, 'tcx> {
     /// Construct a new context where the original item is old.
     pub fn target_new(
-        infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+        infcx: &'a InferCtxt<'a, 'tcx>,
         id_mapping: &'a IdMapping,
         checking_trait_def: bool,
     ) -> Self {
@@ -126,7 +126,7 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
 
     /// Construct a new context where the original item is new.
     pub fn target_old(
-        infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+        infcx: &'a InferCtxt<'a, 'tcx>,
         id_mapping: &'a IdMapping,
         checking_trait_def: bool,
     ) -> Self {
@@ -143,10 +143,10 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
 
     /// Construct a new context given a pair of translation contexts.
     fn from_trans(
-        infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+        infcx: &'a InferCtxt<'a, 'tcx>,
         id_mapping: &'a IdMapping,
-        forward_trans: TranslationContext<'a, 'gcx, 'tcx>,
-        backward_trans: TranslationContext<'a, 'gcx, 'tcx>,
+        forward_trans: TranslationContext<'a, 'tcx>,
+        backward_trans: TranslationContext<'a, 'tcx>,
         checking_trait_def: bool,
     ) -> Self {
         TypeComparisonContext {
@@ -203,7 +203,7 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
     /// Check for type mismatches in a pair of items.
     pub fn check_type_error<'tcx2>(
         &self,
-        lift_tcx: TyCtxt<'tcx2, 'tcx2>,
+        lift_tcx: TyCtxt<'tcx2>,
         target_def_id: DefId,
         target_param_env: ParamEnv<'tcx>,
         orig: Ty<'tcx>,
@@ -260,7 +260,7 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
     /// Check for trait bound mismatches in a pair of items.
     pub fn check_bounds_error<'tcx2>(
         &self,
-        lift_tcx: TyCtxt<'tcx2, 'tcx2>,
+        lift_tcx: TyCtxt<'tcx2>,
         orig_param_env: ParamEnv<'tcx>,
         target_def_id: DefId,
         target_substs: SubstsRef<'tcx>,
@@ -292,7 +292,7 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
     pub fn check_bounds_bidirectional<'tcx2>(
         &self,
         changes: &mut ChangeSet<'tcx2>,
-        lift_tcx: TyCtxt<'tcx2, 'tcx2>,
+        lift_tcx: TyCtxt<'tcx2>,
         orig_def_id: DefId,
         target_def_id: DefId,
         orig_substs: SubstsRef<'tcx>,