lots of lifetimes

Author: jyn514

compiler/rustc_infer/src/infer/at.rs

@@ -30,25 +30,25 @@ use super::*;
 use rustc_middle::ty::relate::{Relate, TypeRelation};
 use rustc_middle::ty::Const;
 
-pub struct At<'a, 'tcx> {
-    pub infcx: &'a InferCtxt<'a, 'tcx>,
-    pub cause: &'a ObligationCause<'tcx>,
+pub struct At<'a, 'b, 'tcx> {
+    pub infcx: &'b mut InferCtxt<'a, 'tcx>,
+    pub cause: &'b ObligationCause<'tcx>,
     pub param_env: ty::ParamEnv<'tcx>,
 }
 
-pub struct Trace<'a, 'tcx> {
-    at: At<'a, 'tcx>,
+pub struct Trace<'a, 'b, 'tcx> {
+    at: At<'a, 'b, 'tcx>,
     a_is_expected: bool,
     trace: TypeTrace<'tcx>,
 }
 
 impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     #[inline]
-    pub fn at(
-        &'a self,
-        cause: &'a ObligationCause<'tcx>,
+    pub fn at<'b>(
+        &'b mut self,
+        cause: &'b ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
-    ) -> At<'a, 'tcx> {
+    ) -> At<'a, 'b, 'tcx> {
         At { infcx: self, cause, param_env }
     }
 }
@@ -62,7 +62,7 @@ pub trait ToTrace<'tcx>: Relate<'tcx> + Copy {
     ) -> TypeTrace<'tcx>;
 }
 
-impl<'a, 'tcx> At<'a, 'tcx> {
+impl<'a, 'b, 'tcx> At<'a, 'b, 'tcx> {
     /// Hacky routine for equating two impl headers in coherence.
     pub fn eq_impl_headers(
         self,
@@ -164,7 +164,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
     /// error-reporting, but doesn't actually perform any operation
     /// yet (this is useful when you want to set the trace using
     /// distinct values from those you wish to operate upon).
-    pub fn trace<T>(self, expected: T, actual: T) -> Trace<'a, 'tcx>
+    pub fn trace<T>(self, expected: T, actual: T) -> Trace<'a, 'b, 'tcx>
     where
         T: ToTrace<'tcx>,
     {
@@ -174,7 +174,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
     /// Like `trace`, but the expected value is determined by the
     /// boolean argument (if true, then the first argument `a` is the
     /// "expected" value).
-    pub fn trace_exp<T>(self, a_is_expected: bool, a: T, b: T) -> Trace<'a, 'tcx>
+    pub fn trace_exp<T>(self, a_is_expected: bool, a: T, b: T) -> Trace<'a, 'b, 'tcx>
     where
         T: ToTrace<'tcx>,
     {
@@ -183,7 +183,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> Trace<'a, 'tcx> {
+impl<'a, 'b, 'tcx> Trace<'a, 'b, 'tcx> {
     /// Makes `a <: b` where `a` may or may not be expected (if
     /// `a_is_expected` is true, then `a` is expected).
     pub fn sub<T>(self, a: T, b: T) -> InferResult<'tcx, ()>

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -157,7 +157,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html#processing-the-canonicalized-query-result
     pub fn instantiate_query_response_and_region_obligations<R>(
         &mut self,
-        cause: &ObligationCause<'tcx>,
+        cause: &'cx ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
         query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>,
@@ -335,7 +335,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// projection.
     fn query_response_substitution<R>(
         &mut self,
-        cause: &ObligationCause<'tcx>,
+        cause: &'cx ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
         query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>,
@@ -488,7 +488,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// See also: `query_response_substitution_guess`
     fn unify_query_response_substitution_guess<R>(
         &mut self,
-        cause: &ObligationCause<'tcx>,
+        cause: &'cx ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
         result_subst: &CanonicalVarValues<'tcx>,
@@ -552,7 +552,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// The second set is produced lazily by supplying indices from the first set.
     fn unify_canonical_vars(
         &mut self,
-        cause: &ObligationCause<'tcx>,
+        cause: &'cx ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         variables1: &OriginalQueryValues<'tcx>,
         variables2: impl Fn(BoundVar) -> GenericArg<'tcx>,

compiler/rustc_infer/src/infer/combine.rs

@@ -45,9 +45,8 @@ use rustc_middle::ty::{self, InferConst, ToPredicate, Ty, TyCtxt, TypeFoldable};
 use rustc_middle::ty::{IntType, UintType};
 use rustc_span::{Span, DUMMY_SP};
 
-#[derive(Clone)]
-pub struct CombineFields<'infcx, 'tcx> {
-    pub infcx: &'infcx InferCtxt<'infcx, 'tcx>,
+pub struct CombineFields<'a, 'infcx, 'tcx> {
+    pub infcx: &'a mut InferCtxt<'infcx, 'tcx>,
     pub trace: TypeTrace<'tcx>,
     pub cause: Option<ty::relate::Cause>,
     pub param_env: ty::ParamEnv<'tcx>,
@@ -285,24 +284,24 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
     }
 }
 
-impl<'infcx, 'tcx> CombineFields<'infcx, 'tcx> {
+impl<'infcx_borrow, 'infcx, 'tcx> CombineFields<'infcx_borrow, 'infcx, 'tcx> {
     pub fn tcx(&self) -> TyCtxt<'tcx> {
         self.infcx.tcx
     }
 
-    pub fn equate<'a>(&'a mut self, a_is_expected: bool) -> Equate<'a, 'infcx, 'tcx> {
+    pub fn equate<'a>(&'a mut self, a_is_expected: bool) -> Equate<'a, 'infcx_borrow, 'infcx, 'tcx> {
         Equate::new(self, a_is_expected)
     }
 
-    pub fn sub<'a>(&'a mut self, a_is_expected: bool) -> Sub<'a, 'infcx, 'tcx> {
+    pub fn sub<'a>(&'a mut self, a_is_expected: bool) -> Sub<'a, 'infcx_borrow, 'infcx, 'tcx> {
         Sub::new(self, a_is_expected)
     }
 
-    pub fn lub<'a>(&'a mut self, a_is_expected: bool) -> Lub<'a, 'infcx, 'tcx> {
+    pub fn lub<'a>(&'a mut self, a_is_expected: bool) -> Lub<'a, 'infcx_borrow, 'infcx, 'tcx> {
         Lub::new(self, a_is_expected)
     }
 
-    pub fn glb<'a>(&'a mut self, a_is_expected: bool) -> Glb<'a, 'infcx, 'tcx> {
+    pub fn glb<'a>(&'a mut self, a_is_expected: bool) -> Glb<'a, 'infcx_borrow, 'infcx, 'tcx> {
         Glb::new(self, a_is_expected)
     }
 
@@ -456,11 +455,11 @@ impl<'infcx, 'tcx> CombineFields<'infcx, 'tcx> {
     }
 }
 
-struct Generalizer<'cx, 'tcx> {
-    infcx: &'cx InferCtxt<'cx, 'tcx>,
+struct Generalizer<'a, 'cx, 'tcx> {
+    infcx: &'a mut InferCtxt<'cx, 'tcx>,
 
     /// The span, used when creating new type variables and things.
-    cause: &'cx ObligationCause<'tcx>,
+    cause: &'a ObligationCause<'tcx>,
 
     /// The vid of the type variable that is in the process of being
     /// instantiated; if we find this within the type we are folding,
@@ -520,7 +519,7 @@ struct Generalization<'tcx> {
     needs_wf: bool,
 }
 
-impl TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
+impl TypeRelation<'tcx> for Generalizer<'_, '_, 'tcx> {
     fn tcx(&self) -> TyCtxt<'tcx> {
         self.infcx.tcx
     }

compiler/rustc_infer/src/infer/equate.rs

@@ -9,21 +9,22 @@ use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_hir::def_id::DefId;
 
 /// Ensures `a` is made equal to `b`. Returns `a` on success.
-pub struct Equate<'combine, 'infcx, 'tcx> {
-    fields: &'combine mut CombineFields<'infcx, 'tcx>,
+pub struct Equate<'s, 'combine, 'infcx, 'tcx> {
+    // TODO: 'combine looks wrong
+    fields: &'s mut CombineFields<'combine, 'infcx, 'tcx>,
     a_is_expected: bool,
 }
 
-impl<'combine, 'infcx, 'tcx> Equate<'combine, 'infcx, 'tcx> {
+impl<'s, 'combine, 'infcx, 'tcx> Equate<'s, 'combine, 'infcx, 'tcx> {
     pub fn new(
-        fields: &'combine mut CombineFields<'infcx, 'tcx>,
+        fields: &'s mut CombineFields<'combine, 'infcx, 'tcx>,
         a_is_expected: bool,
-    ) -> Equate<'combine, 'infcx, 'tcx> {
+    ) -> Self {
         Equate { fields, a_is_expected }
     }
 }
 
-impl TypeRelation<'tcx> for Equate<'combine, 'infcx, 'tcx> {
+impl TypeRelation<'tcx> for Equate<'_, 'combine, 'infcx, 'tcx> {
     fn tag(&self) -> &'static str {
         "Equate"
     }
@@ -140,7 +141,7 @@ impl TypeRelation<'tcx> for Equate<'combine, 'infcx, 'tcx> {
     }
 }
 
-impl<'tcx> ConstEquateRelation<'tcx> for Equate<'_, '_, 'tcx> {
+impl<'tcx> ConstEquateRelation<'tcx> for Equate<'_, '_, '_, 'tcx> {
     fn const_equate_obligation(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>) {
         self.fields.add_const_equate_obligation(self.a_is_expected, a, b);
     }

compiler/rustc_infer/src/infer/glb.rs

@@ -9,21 +9,21 @@ use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 
 /// "Greatest lower bound" (common subtype)
-pub struct Glb<'combine, 'infcx, 'tcx> {
-    fields: &'combine mut CombineFields<'infcx, 'tcx>,
+pub struct Glb<'combine_borrow, 'combine, 'infcx, 'tcx> {
+    fields: &'combine_borrow mut CombineFields<'combine, 'infcx, 'tcx>,
     a_is_expected: bool,
 }
 
-impl<'combine, 'infcx, 'tcx> Glb<'combine, 'infcx, 'tcx> {
+impl<'combine_borrow, 'combine, 'infcx, 'tcx> Glb<'combine_borrow, 'combine, 'infcx, 'tcx> {
     pub fn new(
-        fields: &'combine mut CombineFields<'infcx, 'tcx>,
+        fields: &'combine_borrow mut CombineFields<'combine, 'infcx, 'tcx>,
         a_is_expected: bool,
-    ) -> Glb<'combine, 'infcx, 'tcx> {
+    ) -> Glb<'combine_borrow, 'combine, 'infcx, 'tcx> {
         Glb { fields, a_is_expected }
     }
 }
 
-impl TypeRelation<'tcx> for Glb<'combine, 'infcx, 'tcx> {
+impl TypeRelation<'tcx> for Glb<'_, 'combine, 'infcx, 'tcx> {
     fn tag(&self) -> &'static str {
         "Glb"
     }
@@ -101,8 +101,8 @@ impl TypeRelation<'tcx> for Glb<'combine, 'infcx, 'tcx> {
     }
 }
 
-impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Glb<'combine, 'infcx, 'tcx> {
-    fn infcx(&self) -> &'infcx InferCtxt<'infcx, 'tcx> {
+impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Glb<'_, 'combine, 'infcx, 'tcx> {
+    fn infcx(&self) -> &InferCtxt<'infcx, 'tcx> {
         self.fields.infcx
     }
 
@@ -118,7 +118,7 @@ impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Glb<'combine, 'infcx,
     }
 }
 
-impl<'tcx> ConstEquateRelation<'tcx> for Glb<'_, '_, 'tcx> {
+impl<'tcx> ConstEquateRelation<'tcx> for Glb<'_, '_, '_, 'tcx> {
     fn const_equate_obligation(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>) {
         self.fields.add_const_equate_obligation(self.a_is_expected, a, b);
     }

compiler/rustc_infer/src/infer/higher_ranked/mod.rs

@@ -8,7 +8,7 @@ use crate::infer::CombinedSnapshot;
 use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
 use rustc_middle::ty::{self, Binder, TypeFoldable};
 
-impl<'a, 'tcx> CombineFields<'a, 'tcx> {
+impl<'a, 'tcx> CombineFields<'_, 'a, 'tcx> {
     pub fn higher_ranked_sub<T>(
         &mut self,
         a: Binder<T>,

compiler/rustc_infer/src/infer/lattice.rs

@@ -28,7 +28,7 @@ use rustc_middle::ty::TyVar;
 use rustc_middle::ty::{self, Ty};
 
 pub trait LatticeDir<'f, 'tcx>: TypeRelation<'tcx> {
-    fn infcx(&self) -> &'f InferCtxt<'f, 'tcx>;
+    fn infcx(&self) -> &InferCtxt<'f, 'tcx>;
 
     fn cause(&self) -> &ObligationCause<'tcx>;
 

compiler/rustc_infer/src/infer/lub.rs

@@ -9,21 +9,21 @@ use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 
 /// "Least upper bound" (common supertype)
-pub struct Lub<'combine, 'infcx, 'tcx> {
-    fields: &'combine mut CombineFields<'infcx, 'tcx>,
+pub struct Lub<'combine_borrow, 'combine, 'infcx, 'tcx> {
+    fields: &'combine_borrow mut CombineFields<'combine, 'infcx, 'tcx>,
     a_is_expected: bool,
 }
 
-impl<'combine, 'infcx, 'tcx> Lub<'combine, 'infcx, 'tcx> {
+impl<'combine_borrow, 'combine, 'infcx, 'tcx> Lub<'combine_borrow, 'combine, 'infcx, 'tcx> {
     pub fn new(
-        fields: &'combine mut CombineFields<'infcx, 'tcx>,
+        fields: &'combine_borrow mut CombineFields<'combine, 'infcx, 'tcx>,
         a_is_expected: bool,
-    ) -> Lub<'combine, 'infcx, 'tcx> {
+    ) -> Lub<'combine_borrow, 'combine, 'infcx, 'tcx> {
         Lub { fields, a_is_expected }
     }
 }
 
-impl TypeRelation<'tcx> for Lub<'combine, 'infcx, 'tcx> {
+impl TypeRelation<'tcx> for Lub<'_, 'combine, 'infcx, 'tcx> {
     fn tag(&self) -> &'static str {
         "Lub"
     }
@@ -101,14 +101,14 @@ impl TypeRelation<'tcx> for Lub<'combine, 'infcx, 'tcx> {
     }
 }
 
-impl<'tcx> ConstEquateRelation<'tcx> for Lub<'_, '_, 'tcx> {
+impl<'tcx> ConstEquateRelation<'tcx> for Lub<'_, '_, '_, 'tcx> {
     fn const_equate_obligation(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>) {
         self.fields.add_const_equate_obligation(self.a_is_expected, a, b);
     }
 }
 
-impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Lub<'combine, 'infcx, 'tcx> {
-    fn infcx(&self) -> &'infcx InferCtxt<'infcx, 'tcx> {
+impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Lub<'_, 'combine, 'infcx, 'tcx> {
+    fn infcx(&self) -> &InferCtxt<'infcx, 'tcx> {
         self.fields.infcx
     }
 

compiler/rustc_infer/src/infer/mod.rs

@@ -697,11 +697,11 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         vars
     }
 
-    fn combine_fields(
-        &'a self,
+    fn combine_fields<'s>(
+        &'s mut self,
         trace: TypeTrace<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
-    ) -> CombineFields<'a, 'tcx> {
+    ) -> CombineFields<'s, 'a, 'tcx> {
         CombineFields {
             infcx: self,
             trace,
@@ -802,7 +802,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     /// Execute `f` and commit the bindings if closure `f` returns `Ok(_)`.
     pub fn commit_if_ok<T, E, F>(&mut self, f: F) -> Result<T, E>
     where
-        F: FnOnce(&mut Self, &CombinedSnapshot<'a, 'tcx>) -> Result<T, E>,
+        F: for<'s> FnOnce(&'s mut Self, &CombinedSnapshot<'a, 'tcx>) -> Result<T, E>,
     {
         debug!("commit_if_ok()");
         let snapshot = self.start_snapshot();
@@ -924,7 +924,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
 
     pub fn subtype_predicate(
         &mut self,
-        cause: &ObligationCause<'tcx>,
+        cause: &'a ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         predicate: ty::PolySubtypePredicate<'tcx>,
     ) -> Option<InferResult<'tcx, ()>> {

compiler/rustc_infer/src/infer/sub.rs

@@ -10,16 +10,16 @@ use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt};
 use std::mem;
 
 /// Ensures `a` is made a subtype of `b`. Returns `a` on success.
-pub struct Sub<'combine, 'infcx, 'tcx> {
-    fields: &'combine mut CombineFields<'infcx, 'tcx>,
+pub struct Sub<'combine_borrow, 'combine, 'infcx, 'tcx> {
+    fields: &'combine_borrow mut CombineFields<'combine, 'infcx, 'tcx>,
     a_is_expected: bool,
 }
 
-impl<'combine, 'infcx, 'tcx> Sub<'combine, 'infcx, 'tcx> {
+impl<'combine_borrow, 'combine, 'infcx, 'tcx> Sub<'combine_borrow, 'combine, 'infcx, 'tcx> {
     pub fn new(
-        f: &'combine mut CombineFields<'infcx, 'tcx>,
+        f: &'combine_borrow mut CombineFields<'combine, 'infcx, 'tcx>,
         a_is_expected: bool,
-    ) -> Sub<'combine, 'infcx, 'tcx> {
+    ) -> Sub<'combine_borrow, 'combine, 'infcx, 'tcx> {
         Sub { fields: f, a_is_expected }
     }
 
@@ -31,7 +31,7 @@ impl<'combine, 'infcx, 'tcx> Sub<'combine, 'infcx, 'tcx> {
     }
 }
 
-impl TypeRelation<'tcx> for Sub<'combine, 'infcx, 'tcx> {
+impl TypeRelation<'tcx> for Sub<'_, 'combine, 'infcx, 'tcx> {
     fn tag(&self) -> &'static str {
         "Sub"
     }
@@ -171,7 +171,7 @@ impl TypeRelation<'tcx> for Sub<'combine, 'infcx, 'tcx> {
     }
 }
 
-impl<'tcx> ConstEquateRelation<'tcx> for Sub<'_, '_, 'tcx> {
+impl<'tcx> ConstEquateRelation<'tcx> for Sub<'_, '_, '_, 'tcx> {
     fn const_equate_obligation(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>) {
         self.fields.add_const_equate_obligation(self.a_is_expected, a, b);
     }