Fixed build with newest nightly.

Author: ibabushkin

Diff for: src/bin/cargo_semver.rs

@@ -439,10 +439,7 @@ impl<'a> WorkInfo<'a> {
         let package = source.download_now(package_id, config)?;
         let workspace = Workspace::ephemeral(package.clone(), config, None, false)?;
 
-        Ok(Self {
-            package: package,
-            workspace,
-        })
+        Ok(Self { package, workspace })
     }
 
     /// Obtain the paths to the produced rlib and the dependency output directory.

Diff for: 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: 'a + 'tcx, 'tcx: 'a> {
+pub struct MismatchRelation<'a, 'gcx: 'tcx, 'tcx> {
     /// The type context used.
-    tcx: TyCtxt<'a, 'gcx, 'tcx>,
+    tcx: TyCtxt<'gcx, '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: 'a + 'tcx, 'tcx: 'a> {
     current_new_types: HashSet<Ty<'tcx>>,
 }
 
-impl<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> MismatchRelation<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx: 'tcx, 'tcx> MismatchRelation<'a, 'gcx, 'tcx> {
     /// Construct a new mismtach type relation.
-    pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>, id_mapping: &'a mut IdMapping) -> Self {
+    pub fn new(tcx: TyCtxt<'gcx, 'tcx>, id_mapping: &'a mut IdMapping) -> Self {
         Self {
             tcx,
             item_queue: id_mapping.toplevel_queue(),
@@ -100,8 +100,8 @@ impl<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> MismatchRelation<'a, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for MismatchRelation<'a, 'gcx, 'tcx> {
-    fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> {
+impl<'a, 'gcx, 'tcx> TypeRelation<'gcx, 'tcx> for MismatchRelation<'a, 'gcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'gcx, 'tcx> {
         self.tcx
     }
 

Diff for: 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 + 'a, 'tcx: 'a> {
+pub struct TranslationContext<'a, 'gcx: 'tcx, 'tcx> {
     /// The type context to use.
-    tcx: TyCtxt<'a, 'gcx, 'tcx>,
+    tcx: TyCtxt<'gcx, 'tcx>,
     /// The id mapping to use.
     id_mapping: &'a IdMapping,
     /// Whether to translate type and region parameters.
@@ -31,7 +31,7 @@ pub struct TranslationContext<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> {
 impl<'a, 'gcx, 'tcx> TranslationContext<'a, 'gcx, 'tcx> {
     /// Construct a translation context translating to the new crate's `DefId`s.
     pub fn target_new(
-        tcx: TyCtxt<'a, 'gcx, 'tcx>,
+        tcx: TyCtxt<'gcx, 'tcx>,
         id_mapping: &'a IdMapping,
         translate_params: bool,
     ) -> TranslationContext<'a, 'gcx, 'tcx> {
@@ -46,7 +46,7 @@ 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<'a, 'gcx, 'tcx>,
+        tcx: TyCtxt<'gcx, 'tcx>,
         id_mapping: &'a IdMapping,
         translate_params: bool,
     ) -> TranslationContext<'a, 'gcx, 'tcx> {
@@ -533,7 +533,7 @@ impl<'a, 'gcx, 'tcx> InferenceCleanupFolder<'a, 'gcx, 'tcx> {
 }
 
 impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for InferenceCleanupFolder<'a, 'gcx, 'tcx> {
-    fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'gcx, 'tcx> {
         self.infcx.tcx
     }
 

Diff for: src/traverse.rs

@@ -35,11 +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<'a, 'tcx>(
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    old: DefId,
-    new: DefId,
-) -> ChangeSet<'tcx> {
+pub fn run_analysis<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, old: DefId, new: DefId) -> ChangeSet<'tcx> {
     let mut changes = ChangeSet::default();
     let mut id_mapping = IdMapping::new(old.krate, new.krate);
 
@@ -78,7 +74,7 @@ fn get_vis(outer_vis: Visibility, def: Export<HirId>) -> Visibility {
     }
 }
 
-pub fn run_traversal<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, new: DefId) {
+pub fn run_traversal<'tcx>(tcx: TyCtxt<'tcx, 'tcx>, new: DefId) {
     use rustc::hir::def::DefKind::*;
     let mut visited = HashSet::new();
     let mut mod_queue = VecDeque::new();
@@ -125,10 +121,10 @@ pub fn run_traversal<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, new: DefId) {
 /// from the two crate versions and compare for changes. Matching children get processed
 /// in the same fashion.
 #[cfg_attr(feature = "cargo-clippy", allow(clippy::cognitive_complexity))]
-fn diff_structure<'a, 'tcx>(
+fn diff_structure<'tcx>(
     changes: &mut ChangeSet,
     id_mapping: &mut IdMapping,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
     old: DefId,
     new: DefId,
 ) {
@@ -362,7 +358,7 @@ fn diff_structure<'a, 'tcx>(
 }
 
 /// Given two fn items, perform structural checks.
-fn diff_fn<'a, 'tcx>(changes: &mut ChangeSet, tcx: TyCtxt<'a, 'tcx, 'tcx>, old: Res, new: Res) {
+fn diff_fn<'tcx>(changes: &mut ChangeSet, tcx: TyCtxt<'tcx, 'tcx>, old: Res, new: Res) {
     let old_def_id = old.def_id();
     let new_def_id = new.def_id();
 
@@ -381,9 +377,9 @@ fn diff_fn<'a, 'tcx>(changes: &mut ChangeSet, tcx: TyCtxt<'a, 'tcx, 'tcx>, old:
 }
 
 /// Given two method items, perform structural checks.
-fn diff_method<'a, 'tcx>(
+fn diff_method<'tcx>(
     changes: &mut ChangeSet,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
     old: AssocItem,
     new: AssocItem,
 ) {
@@ -562,10 +558,10 @@ fn diff_adts(changes: &mut ChangeSet, id_mapping: &mut IdMapping, tcx: TyCtxt, o
 ///
 /// This establishes the needed correspondence between non-toplevel items found in the trait
 /// definition.
-fn diff_traits<'a, 'tcx>(
+fn diff_traits<'tcx>(
     changes: &mut ChangeSet,
     id_mapping: &mut IdMapping,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
     old: DefId,
     new: DefId,
     output: bool,
@@ -833,10 +829,10 @@ fn diff_generics(
 // of matching items are compared for changes.
 
 /// Given two items, compare their types.
-fn diff_types<'a, 'tcx>(
+fn diff_types<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
     old: Res,
     new: Res,
 ) {
@@ -902,10 +898,10 @@ fn diff_types<'a, 'tcx>(
 }
 
 /// Compare two types and their trait bounds, possibly registering the resulting change.
-fn cmp_types<'a, 'tcx>(
+fn cmp_types<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
     orig_def_id: DefId,
     target_def_id: DefId,
     orig: Ty<'tcx>,
@@ -955,10 +951,10 @@ fn cmp_types<'a, 'tcx>(
 }
 
 /// Compare the trait bounds of two items, possibly registering the resulting change.
-fn cmp_bounds<'a, 'tcx>(
+fn cmp_bounds<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
     orig_def_id: DefId,
     target_def_id: DefId,
 ) {
@@ -988,10 +984,10 @@ fn cmp_bounds<'a, 'tcx>(
 // their trait bounds and compared for changes, if applicable.
 
 /// Compare the inherent implementations of all matching items.
-fn diff_inherent_impls<'a, 'tcx>(
+fn diff_inherent_impls<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
 ) {
     debug!("diffing inherent impls");
 
@@ -1071,8 +1067,8 @@ fn diff_inherent_impls<'a, '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<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_def_id: DefId) -> bool {
-    fn type_visibility<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty) -> Visibility {
+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 {
         match ty.sty {
             TyKind::Adt(def, _) => tcx.visibility(def.did),
 
@@ -1112,10 +1108,10 @@ fn is_impl_trait_public<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_def_id: DefI
 }
 
 /// Compare the implementations of all matching traits.
-fn diff_trait_impls<'a, 'tcx>(
+fn diff_trait_impls<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
 ) {
     debug!("diffing trait impls");
 
@@ -1165,10 +1161,10 @@ fn diff_trait_impls<'a, 'tcx>(
 
 /// Compare an item pair in two inherent implementations and indicate whether the target one is
 /// compatible with the original one.
-fn match_inherent_impl<'a, 'tcx>(
+fn match_inherent_impl<'tcx>(
     changes: &mut ChangeSet<'tcx>,
     id_mapping: &IdMapping,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
     orig_impl_def_id: DefId,
     target_impl_def_id: DefId,
     orig_item: AssocItem,
@@ -1294,7 +1290,7 @@ fn match_inherent_impl<'a, 'tcx>(
 /// Compare two implementations and indicate whether the target one is compatible with the
 /// original one.
 fn match_trait_impl<'a, 'tcx>(
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    tcx: TyCtxt<'tcx, 'tcx>,
     trans: &TranslationContext<'a, 'tcx, 'tcx>,
     orig_def_id: DefId,
 ) -> bool {

Diff for: src/typeck.rs

@@ -201,9 +201,9 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
     }
 
     /// Check for type mismatches in a pair of items.
-    pub fn check_type_error<'b, 'tcx2>(
+    pub fn check_type_error<'tcx2>(
         &self,
-        lift_tcx: TyCtxt<'b, 'tcx2, 'tcx2>,
+        lift_tcx: TyCtxt<'tcx2, 'tcx2>,
         target_def_id: DefId,
         target_param_env: ParamEnv<'tcx>,
         orig: Ty<'tcx>,
@@ -258,9 +258,9 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
     }
 
     /// Check for trait bound mismatches in a pair of items.
-    pub fn check_bounds_error<'b, 'tcx2>(
+    pub fn check_bounds_error<'tcx2>(
         &self,
-        lift_tcx: TyCtxt<'b, 'tcx2, 'tcx2>,
+        lift_tcx: TyCtxt<'tcx2, 'tcx2>,
         orig_param_env: ParamEnv<'tcx>,
         target_def_id: DefId,
         target_substs: SubstsRef<'tcx>,
@@ -289,10 +289,10 @@ impl<'a, 'gcx, 'tcx> TypeComparisonContext<'a, 'gcx, 'tcx> {
     }
 
     /// Check the bounds on an item in both directions and register changes found.
-    pub fn check_bounds_bidirectional<'b, 'tcx2>(
+    pub fn check_bounds_bidirectional<'tcx2>(
         &self,
         changes: &mut ChangeSet<'tcx2>,
-        lift_tcx: TyCtxt<'b, 'tcx2, 'tcx2>,
+        lift_tcx: TyCtxt<'tcx2, 'tcx2>,
         orig_def_id: DefId,
         target_def_id: DefId,
         orig_substs: SubstsRef<'tcx>,