Rename infcx lifetimes in inference relations

soltanmm-google · soltanmm-google · commit 5e390322c3ca · 2016-07-25T15:08:19.000-07:00
diff --git a/src/librustc/infer/bivariate.rs b/src/librustc/infer/bivariate.rs
@@ -32,20 +32,20 @@ use ty::{self, Ty, TyCtxt};
 use ty::TyVar;
 use ty::relate::{Relate, RelateResult, TypeRelation};
 
-pub struct Bivariate<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
-    fields: CombineFields<'a, 'gcx, 'tcx>
+pub struct Bivariate<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
+    fields: CombineFields<'infcx, 'gcx, 'tcx>
 }
 
-impl<'a, 'gcx, 'tcx> Bivariate<'a, 'gcx, 'tcx> {
-    pub fn new(fields: CombineFields<'a, 'gcx, 'tcx>) -> Bivariate<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> Bivariate<'infcx, 'gcx, 'tcx> {
+    pub fn new(fields: CombineFields<'infcx, 'gcx, 'tcx>) -> Bivariate<'infcx, 'gcx, 'tcx> {
         Bivariate { fields: fields }
     }
 }
 
-impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Bivariate<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx> for Bivariate<'infcx, 'gcx, 'tcx> {
     fn tag(&self) -> &'static str { "Bivariate" }
 
-    fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.fields.tcx() }
+    fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.tcx() }
 
     fn a_is_expected(&self) -> bool { self.fields.a_is_expected }
 
diff --git a/src/librustc/infer/combine.rs b/src/librustc/infer/combine.rs
@@ -52,21 +52,21 @@ use syntax::ast;
 use syntax_pos::Span;
 
 #[derive(Clone)]
-pub struct CombineFields<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
-    pub infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
+pub struct CombineFields<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
+    pub infcx: &'infcx InferCtxt<'infcx, 'gcx, 'tcx>,
     pub a_is_expected: bool,
     pub trace: TypeTrace<'tcx>,
     pub cause: Option<ty::relate::Cause>,
     pub obligations: PredicateObligations<'tcx>,
 }
 
-impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {
     pub fn super_combine_tys<R>(&self,
                                 relation: &mut R,
                                 a: Ty<'tcx>,
                                 b: Ty<'tcx>)
                                 -> RelateResult<'tcx, Ty<'tcx>>
-        where R: TypeRelation<'a, 'gcx, 'tcx>
+        where R: TypeRelation<'infcx, 'gcx, 'tcx>
     {
         let a_is_expected = relation.a_is_expected();
 
@@ -150,35 +150,35 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'gcx, 'tcx> CombineFields<'a, 'gcx, 'tcx> {
-    pub fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> CombineFields<'infcx, 'gcx, 'tcx> {
+    pub fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> {
         self.infcx.tcx
     }
 
-    pub fn switch_expected(&self) -> CombineFields<'a, 'gcx, 'tcx> {
+    pub fn switch_expected(&self) -> CombineFields<'infcx, 'gcx, 'tcx> {
         CombineFields {
             a_is_expected: !self.a_is_expected,
             ..(*self).clone()
         }
     }
 
-    pub fn equate(&self) -> Equate<'a, 'gcx, 'tcx> {
+    pub fn equate(&self) -> Equate<'infcx, 'gcx, 'tcx> {
         Equate::new(self.clone())
     }
 
-    pub fn bivariate(&self) -> Bivariate<'a, 'gcx, 'tcx> {
+    pub fn bivariate(&self) -> Bivariate<'infcx, 'gcx, 'tcx> {
         Bivariate::new(self.clone())
     }
 
-    pub fn sub(&self) -> Sub<'a, 'gcx, 'tcx> {
+    pub fn sub(&self) -> Sub<'infcx, 'gcx, 'tcx> {
         Sub::new(self.clone())
     }
 
-    pub fn lub(&self) -> Lub<'a, 'gcx, 'tcx> {
+    pub fn lub(&self) -> Lub<'infcx, 'gcx, 'tcx> {
         Lub::new(self.clone())
     }
 
-    pub fn glb(&self) -> Glb<'a, 'gcx, 'tcx> {
+    pub fn glb(&self) -> Glb<'infcx, 'gcx, 'tcx> {
         Glb::new(self.clone())
     }
 
diff --git a/src/librustc/infer/equate.rs b/src/librustc/infer/equate.rs
@@ -18,12 +18,12 @@ use ty::relate::{Relate, RelateResult, TypeRelation};
 use traits::PredicateObligations;
 
 /// Ensures `a` is made equal to `b`. Returns `a` on success.
-pub struct Equate<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
-    fields: CombineFields<'a, 'gcx, 'tcx>
+pub struct Equate<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
+    fields: CombineFields<'infcx, 'gcx, 'tcx>
 }
 
-impl<'a, 'gcx, 'tcx> Equate<'a, 'gcx, 'tcx> {
-    pub fn new(fields: CombineFields<'a, 'gcx, 'tcx>) -> Equate<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> Equate<'infcx, 'gcx, 'tcx> {
+    pub fn new(fields: CombineFields<'infcx, 'gcx, 'tcx>) -> Equate<'infcx, 'gcx, 'tcx> {
         Equate { fields: fields }
     }
 
@@ -32,10 +32,10 @@ impl<'a, 'gcx, 'tcx> Equate<'a, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Equate<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx> for Equate<'infcx, 'gcx, 'tcx> {
     fn tag(&self) -> &'static str { "Equate" }
 
-    fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.fields.tcx() }
+    fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.tcx() }
 
     fn a_is_expected(&self) -> bool { self.fields.a_is_expected }
 
diff --git a/src/librustc/infer/glb.rs b/src/librustc/infer/glb.rs
@@ -18,12 +18,12 @@ use ty::relate::{Relate, RelateResult, TypeRelation};
 use traits::PredicateObligations;
 
 /// "Greatest lower bound" (common subtype)
-pub struct Glb<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
-    fields: CombineFields<'a, 'gcx, 'tcx>
+pub struct Glb<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
+    fields: CombineFields<'infcx, 'gcx, 'tcx>
 }
 
-impl<'a, 'gcx, 'tcx> Glb<'a, 'gcx, 'tcx> {
-    pub fn new(fields: CombineFields<'a, 'gcx, 'tcx>) -> Glb<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> Glb<'infcx, 'gcx, 'tcx> {
+    pub fn new(fields: CombineFields<'infcx, 'gcx, 'tcx>) -> Glb<'infcx, 'gcx, 'tcx> {
         Glb { fields: fields }
     }
 
@@ -32,10 +32,10 @@ impl<'a, 'gcx, 'tcx> Glb<'a, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Glb<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx> for Glb<'infcx, 'gcx, 'tcx> {
     fn tag(&self) -> &'static str { "Glb" }
 
-    fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.fields.tcx() }
+    fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.tcx() }
 
     fn a_is_expected(&self) -> bool { self.fields.a_is_expected }
 
@@ -75,8 +75,8 @@ impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Glb<'a, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'gcx, 'tcx> LatticeDir<'a, 'gcx, 'tcx> for Glb<'a, 'gcx, 'tcx> {
-    fn infcx(&self) -> &'a InferCtxt<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> LatticeDir<'infcx, 'gcx, 'tcx> for Glb<'infcx, 'gcx, 'tcx> {
+    fn infcx(&self) -> &'infcx InferCtxt<'infcx, 'gcx, 'tcx> {
         self.fields.infcx
     }
 
diff --git a/src/librustc/infer/lub.rs b/src/librustc/infer/lub.rs
@@ -18,12 +18,12 @@ use ty::relate::{Relate, RelateResult, TypeRelation};
 use traits::PredicateObligations;
 
 /// "Least upper bound" (common supertype)
-pub struct Lub<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
-    fields: CombineFields<'a, 'gcx, 'tcx>
+pub struct Lub<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
+    fields: CombineFields<'infcx, 'gcx, 'tcx>
 }
 
-impl<'a, 'gcx, 'tcx> Lub<'a, 'gcx, 'tcx> {
-    pub fn new(fields: CombineFields<'a, 'gcx, 'tcx>) -> Lub<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> Lub<'infcx, 'gcx, 'tcx> {
+    pub fn new(fields: CombineFields<'infcx, 'gcx, 'tcx>) -> Lub<'infcx, 'gcx, 'tcx> {
         Lub { fields: fields }
     }
 
@@ -32,10 +32,10 @@ impl<'a, 'gcx, 'tcx> Lub<'a, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Lub<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx> for Lub<'infcx, 'gcx, 'tcx> {
     fn tag(&self) -> &'static str { "Lub" }
 
-    fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.fields.tcx() }
+    fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.tcx() }
 
     fn a_is_expected(&self) -> bool { self.fields.a_is_expected }
 
@@ -75,8 +75,8 @@ impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Lub<'a, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'gcx, 'tcx> LatticeDir<'a, 'gcx, 'tcx> for Lub<'a, 'gcx, 'tcx> {
-    fn infcx(&self) -> &'a InferCtxt<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> LatticeDir<'infcx, 'gcx, 'tcx> for Lub<'infcx, 'gcx, 'tcx> {
+    fn infcx(&self) -> &'infcx InferCtxt<'infcx, 'gcx, 'tcx> {
         self.fields.infcx
     }
 
diff --git a/src/librustc/infer/sub.rs b/src/librustc/infer/sub.rs
@@ -19,12 +19,12 @@ use traits::PredicateObligations;
 use std::mem;
 
 /// Ensures `a` is made a subtype of `b`. Returns `a` on success.
-pub struct Sub<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
-    fields: CombineFields<'a, 'gcx, 'tcx>,
+pub struct Sub<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
+    fields: CombineFields<'infcx, 'gcx, 'tcx>,
 }
 
-impl<'a, 'gcx, 'tcx> Sub<'a, 'gcx, 'tcx> {
-    pub fn new(f: CombineFields<'a, 'gcx, 'tcx>) -> Sub<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> Sub<'infcx, 'gcx, 'tcx> {
+    pub fn new(f: CombineFields<'infcx, 'gcx, 'tcx>) -> Sub<'infcx, 'gcx, 'tcx> {
         Sub { fields: f }
     }
 
@@ -33,9 +33,9 @@ impl<'a, 'gcx, 'tcx> Sub<'a, 'gcx, 'tcx> {
     }
 }
 
-impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Sub<'a, 'gcx, 'tcx> {
+impl<'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx> for Sub<'infcx, 'gcx, 'tcx> {
     fn tag(&self) -> &'static str { "Sub" }
-    fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.fields.infcx.tcx }
+    fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.infcx.tcx }
     fn a_is_expected(&self) -> bool { self.fields.a_is_expected }
 
     fn with_cause<F,R>(&mut self, cause: Cause, f: F) -> R

Original file line number	Diff line number	Diff line change
`@@ -52,21 +52,21 @@ use syntax::ast;`
`52`	`52`	`use syntax_pos::Span;`
`53`	`53`
`54`	`54`	`#[derive(Clone)]`
`55`		`-pub struct CombineFields<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {`
`56`		`- pub infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,`
	`55`	`+pub struct CombineFields<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {`
	`56`	`+ pub infcx: &'infcx InferCtxt<'infcx, 'gcx, 'tcx>,`
`57`	`57`	`pub a_is_expected: bool,`
`58`	`58`	`pub trace: TypeTrace<'tcx>,`
`59`	`59`	`pub cause: Option<ty::relate::Cause>,`
`60`	`60`	`pub obligations: PredicateObligations<'tcx>,`
`61`	`61`	`}`
`62`	`62`
`63`		`-impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {`
	`63`	`+impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {`
`64`	`64`	`pub fn super_combine_tys<R>(&self,`
`65`	`65`	`relation: &mut R,`
`66`	`66`	`a: Ty<'tcx>,`
`67`	`67`	`b: Ty<'tcx>)`
`68`	`68`	`-> RelateResult<'tcx, Ty<'tcx>>`
`69`		`- where R: TypeRelation<'a, 'gcx, 'tcx>`
	`69`	`+ where R: TypeRelation<'infcx, 'gcx, 'tcx>`
`70`	`70`	`{`
`71`	`71`	`let a_is_expected = relation.a_is_expected();`
`72`	`72`
`@@ -150,35 +150,35 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`
`153`		`-impl<'a, 'gcx, 'tcx> CombineFields<'a, 'gcx, 'tcx> {`
`154`		`- pub fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> {`
	`153`	`+impl<'infcx, 'gcx, 'tcx> CombineFields<'infcx, 'gcx, 'tcx> {`
	`154`	`+ pub fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> {`
`155`	`155`	`self.infcx.tcx`
`156`	`156`	`}`
`157`	`157`
`158`		`- pub fn switch_expected(&self) -> CombineFields<'a, 'gcx, 'tcx> {`
	`158`	`+ pub fn switch_expected(&self) -> CombineFields<'infcx, 'gcx, 'tcx> {`
`159`	`159`	`CombineFields {`
`160`	`160`	`a_is_expected: !self.a_is_expected,`
`161`	`161`	`..(*self).clone()`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`
`165`		`- pub fn equate(&self) -> Equate<'a, 'gcx, 'tcx> {`
	`165`	`+ pub fn equate(&self) -> Equate<'infcx, 'gcx, 'tcx> {`
`166`	`166`	`Equate::new(self.clone())`
`167`	`167`	`}`
`168`	`168`
`169`		`- pub fn bivariate(&self) -> Bivariate<'a, 'gcx, 'tcx> {`
	`169`	`+ pub fn bivariate(&self) -> Bivariate<'infcx, 'gcx, 'tcx> {`
`170`	`170`	`Bivariate::new(self.clone())`
`171`	`171`	`}`
`172`	`172`
`173`		`- pub fn sub(&self) -> Sub<'a, 'gcx, 'tcx> {`
	`173`	`+ pub fn sub(&self) -> Sub<'infcx, 'gcx, 'tcx> {`
`174`	`174`	`Sub::new(self.clone())`
`175`	`175`	`}`
`176`	`176`
`177`		`- pub fn lub(&self) -> Lub<'a, 'gcx, 'tcx> {`
	`177`	`+ pub fn lub(&self) -> Lub<'infcx, 'gcx, 'tcx> {`
`178`	`178`	`Lub::new(self.clone())`
`179`	`179`	`}`
`180`	`180`
`181`		`- pub fn glb(&self) -> Glb<'a, 'gcx, 'tcx> {`
	`181`	`+ pub fn glb(&self) -> Glb<'infcx, 'gcx, 'tcx> {`
`182`	`182`	`Glb::new(self.clone())`
`183`	`183`	`}`
`184`	`184`
Original file line number	Diff line number	Diff line change
`@@ -18,12 +18,12 @@ use ty::relate::{Relate, RelateResult, TypeRelation};`
`18`	`18`	`use traits::PredicateObligations;`
`19`	`19`
`20`	`20`	/// Ensures `a` is made equal to `b`. Returns `a` on success.
`21`		`-pub struct Equate<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {`
`22`		`- fields: CombineFields<'a, 'gcx, 'tcx>`
	`21`	`+pub struct Equate<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {`
	`22`	`+ fields: CombineFields<'infcx, 'gcx, 'tcx>`
`23`	`23`	`}`
`24`	`24`
`25`		`-impl<'a, 'gcx, 'tcx> Equate<'a, 'gcx, 'tcx> {`
`26`		`- pub fn new(fields: CombineFields<'a, 'gcx, 'tcx>) -> Equate<'a, 'gcx, 'tcx> {`
	`25`	`+impl<'infcx, 'gcx, 'tcx> Equate<'infcx, 'gcx, 'tcx> {`
	`26`	`+ pub fn new(fields: CombineFields<'infcx, 'gcx, 'tcx>) -> Equate<'infcx, 'gcx, 'tcx> {`
`27`	`27`	`Equate { fields: fields }`
`28`	`28`	`}`
`29`	`29`
`@@ -32,10 +32,10 @@ impl<'a, 'gcx, 'tcx> Equate<'a, 'gcx, 'tcx> {`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
`35`		`-impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Equate<'a, 'gcx, 'tcx> {`
	`35`	`+impl<'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx> for Equate<'infcx, 'gcx, 'tcx> {`
`36`	`36`	`fn tag(&self) -> &'static str { "Equate" }`
`37`	`37`
`38`		`- fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.fields.tcx() }`
	`38`	`+ fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.tcx() }`
`39`	`39`
`40`	`40`	`fn a_is_expected(&self) -> bool { self.fields.a_is_expected }`
`41`	`41`
Original file line number	Diff line number	Diff line change
`@@ -19,12 +19,12 @@ use traits::PredicateObligations;`
`19`	`19`	`use std::mem;`
`20`	`20`
`21`	`21`	/// Ensures `a` is made a subtype of `b`. Returns `a` on success.
`22`		`-pub struct Sub<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {`
`23`		`- fields: CombineFields<'a, 'gcx, 'tcx>,`
	`22`	`+pub struct Sub<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {`
	`23`	`+ fields: CombineFields<'infcx, 'gcx, 'tcx>,`
`24`	`24`	`}`
`25`	`25`
`26`		`-impl<'a, 'gcx, 'tcx> Sub<'a, 'gcx, 'tcx> {`
`27`		`- pub fn new(f: CombineFields<'a, 'gcx, 'tcx>) -> Sub<'a, 'gcx, 'tcx> {`
	`26`	`+impl<'infcx, 'gcx, 'tcx> Sub<'infcx, 'gcx, 'tcx> {`
	`27`	`+ pub fn new(f: CombineFields<'infcx, 'gcx, 'tcx>) -> Sub<'infcx, 'gcx, 'tcx> {`
`28`	`28`	`Sub { fields: f }`
`29`	`29`	`}`
`30`	`30`
`@@ -33,9 +33,9 @@ impl<'a, 'gcx, 'tcx> Sub<'a, 'gcx, 'tcx> {`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`		`-impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for Sub<'a, 'gcx, 'tcx> {`
	`36`	`+impl<'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx> for Sub<'infcx, 'gcx, 'tcx> {`
`37`	`37`	`fn tag(&self) -> &'static str { "Sub" }`
`38`		`- fn tcx(&self) -> TyCtxt<'a, 'gcx, 'tcx> { self.fields.infcx.tcx }`
	`38`	`+ fn tcx(&self) -> TyCtxt<'infcx, 'gcx, 'tcx> { self.fields.infcx.tcx }`
`39`	`39`	`fn a_is_expected(&self) -> bool { self.fields.a_is_expected }`
`40`	`40`
`41`	`41`	`fn with_cause<F,R>(&mut self, cause: Cause, f: F) -> R`