rustc: Avoid free functions taking &TyCtxt and &InferCtxt.

Author: eddyb

src/librustc/infer/bivariate.rs

@@ -25,7 +25,7 @@
 //! In particular, it might be enough to say (A,B) are bivariant for
 //! all (A,B).
 
-use super::combine::{self, CombineFields};
+use super::combine::CombineFields;
 use super::type_variable::{BiTo};
 
 use ty::{self, Ty, TyCtxt};
@@ -96,7 +96,7 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Bivariate<'a, 'tcx> {
             }
 
             _ => {
-                combine::super_combine_tys(self.fields.infcx, self, a, b)
+                self.fields.infcx.super_combine_tys(self, a, b)
             }
         }
     }

src/librustc/infer/combine.rs

@@ -60,50 +60,51 @@ pub struct CombineFields<'a, 'tcx: 'a> {
     pub obligations: PredicateObligations<'tcx>,
 }
 
-pub fn super_combine_tys<'a,'tcx:'a,R>(infcx: &InferCtxt<'a, 'tcx>,
-                                       relation: &mut R,
-                                       a: Ty<'tcx>,
-                                       b: Ty<'tcx>)
-                                       -> RelateResult<'tcx, Ty<'tcx>>
+impl<'a, 'tcx> InferCtxt<'a, '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,'tcx>
 {
     let a_is_expected = relation.a_is_expected();
 
     match (&a.sty, &b.sty) {
         // Relate integral variables to other types
         (&ty::TyInfer(ty::IntVar(a_id)), &ty::TyInfer(ty::IntVar(b_id))) => {
-            infcx.int_unification_table
-                 .borrow_mut()
-                 .unify_var_var(a_id, b_id)
-                 .map_err(|e| int_unification_error(a_is_expected, e))?;
+            self.int_unification_table
+                .borrow_mut()
+                .unify_var_var(a_id, b_id)
+                .map_err(|e| int_unification_error(a_is_expected, e))?;
             Ok(a)
         }
         (&ty::TyInfer(ty::IntVar(v_id)), &ty::TyInt(v)) => {
-            unify_integral_variable(infcx, a_is_expected, v_id, IntType(v))
+            self.unify_integral_variable(a_is_expected, v_id, IntType(v))
         }
         (&ty::TyInt(v), &ty::TyInfer(ty::IntVar(v_id))) => {
-            unify_integral_variable(infcx, !a_is_expected, v_id, IntType(v))
+            self.unify_integral_variable(!a_is_expected, v_id, IntType(v))
         }
         (&ty::TyInfer(ty::IntVar(v_id)), &ty::TyUint(v)) => {
-            unify_integral_variable(infcx, a_is_expected, v_id, UintType(v))
+            self.unify_integral_variable(a_is_expected, v_id, UintType(v))
         }
         (&ty::TyUint(v), &ty::TyInfer(ty::IntVar(v_id))) => {
-            unify_integral_variable(infcx, !a_is_expected, v_id, UintType(v))
+            self.unify_integral_variable(!a_is_expected, v_id, UintType(v))
         }
 
         // Relate floating-point variables to other types
         (&ty::TyInfer(ty::FloatVar(a_id)), &ty::TyInfer(ty::FloatVar(b_id))) => {
-            infcx.float_unification_table
-                 .borrow_mut()
-                 .unify_var_var(a_id, b_id)
-                 .map_err(|e| float_unification_error(relation.a_is_expected(), e))?;
+            self.float_unification_table
+                .borrow_mut()
+                .unify_var_var(a_id, b_id)
+                .map_err(|e| float_unification_error(relation.a_is_expected(), e))?;
             Ok(a)
         }
         (&ty::TyInfer(ty::FloatVar(v_id)), &ty::TyFloat(v)) => {
-            unify_float_variable(infcx, a_is_expected, v_id, v)
+            self.unify_float_variable(a_is_expected, v_id, v)
         }
         (&ty::TyFloat(v), &ty::TyInfer(ty::FloatVar(v_id))) => {
-            unify_float_variable(infcx, !a_is_expected, v_id, v)
+            self.unify_float_variable(!a_is_expected, v_id, v)
         }
 
         // All other cases of inference are errors
@@ -119,33 +120,34 @@ pub fn super_combine_tys<'a,'tcx:'a,R>(infcx: &InferCtxt<'a, 'tcx>,
     }
 }
 
-fn unify_integral_variable<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
-                                    vid_is_expected: bool,
-                                    vid: ty::IntVid,
-                                    val: ty::IntVarValue)
-                                    -> RelateResult<'tcx, Ty<'tcx>>
+fn unify_integral_variable(&self,
+                           vid_is_expected: bool,
+                           vid: ty::IntVid,
+                           val: ty::IntVarValue)
+                           -> RelateResult<'tcx, Ty<'tcx>>
 {
-    infcx.int_unification_table
-         .borrow_mut()
-         .unify_var_value(vid, val)
-         .map_err(|e| int_unification_error(vid_is_expected, e))?;
+    self.int_unification_table
+        .borrow_mut()
+        .unify_var_value(vid, val)
+        .map_err(|e| int_unification_error(vid_is_expected, e))?;
     match val {
-        IntType(v) => Ok(infcx.tcx.mk_mach_int(v)),
-        UintType(v) => Ok(infcx.tcx.mk_mach_uint(v)),
+        IntType(v) => Ok(self.tcx.mk_mach_int(v)),
+        UintType(v) => Ok(self.tcx.mk_mach_uint(v)),
     }
 }
 
-fn unify_float_variable<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
-                                 vid_is_expected: bool,
-                                 vid: ty::FloatVid,
-                                 val: ast::FloatTy)
-                                 -> RelateResult<'tcx, Ty<'tcx>>
+fn unify_float_variable(&self,
+                        vid_is_expected: bool,
+                        vid: ty::FloatVid,
+                        val: ast::FloatTy)
+                        -> RelateResult<'tcx, Ty<'tcx>>
 {
-    infcx.float_unification_table
-         .borrow_mut()
-         .unify_var_value(vid, val)
-         .map_err(|e| float_unification_error(vid_is_expected, e))?;
-    Ok(infcx.tcx.mk_mach_float(val))
+    self.float_unification_table
+        .borrow_mut()
+        .unify_var_value(vid, val)
+        .map_err(|e| float_unification_error(vid_is_expected, e))?;
+    Ok(self.tcx.mk_mach_float(val))
+}
 }
 
 impl<'a, 'tcx> CombineFields<'a, 'tcx> {

src/librustc/infer/equate.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use super::combine::{self, CombineFields};
+use super::combine::CombineFields;
 use super::higher_ranked::HigherRankedRelations;
 use super::{Subtype};
 use super::type_variable::{EqTo};
@@ -74,7 +74,7 @@ impl<'a, 'tcx> TypeRelation<'a,'tcx> for Equate<'a, 'tcx> {
             }
 
             _ => {
-                combine::super_combine_tys(self.fields.infcx, self, a, b)?;
+                self.fields.infcx.super_combine_tys(self, a, b)?;
                 Ok(a)
             }
         }

src/librustc/infer/higher_ranked/mod.rs

@@ -31,14 +31,6 @@ pub trait HigherRankedRelations<'a,'tcx> {
         where T: Relate<'a,'tcx>;
 }
 
-trait InferCtxtExt {
-    fn tainted_regions(&self, snapshot: &CombinedSnapshot, r: ty::Region) -> Vec<ty::Region>;
-
-    fn region_vars_confined_to_snapshot(&self,
-                                        snapshot: &CombinedSnapshot)
-                                        -> Vec<ty::RegionVid>;
-}
-
 impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
     fn higher_ranked_sub<T>(&self, a: &Binder<T>, b: &Binder<T>)
                             -> RelateResult<'tcx, Binder<T>>
@@ -79,23 +71,9 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
 
             // Presuming type comparison succeeds, we need to check
             // that the skolemized regions do not "leak".
-            match leak_check(self.infcx, &skol_map, snapshot) {
-                Ok(()) => { }
-                Err((skol_br, tainted_region)) => {
-                    if self.a_is_expected {
-                        debug!("Not as polymorphic!");
-                        return Err(TypeError::RegionsInsufficientlyPolymorphic(skol_br,
-                                                                               tainted_region));
-                    } else {
-                        debug!("Overly polymorphic!");
-                        return Err(TypeError::RegionsOverlyPolymorphic(skol_br,
-                                                                       tainted_region));
-                    }
-                }
-            }
+            self.infcx.leak_check(!self.a_is_expected, &skol_map, snapshot)?;
 
-            debug!("higher_ranked_sub: OK result={:?}",
-                   result);
+            debug!("higher_ranked_sub: OK result={:?}", result);
 
             Ok(ty::Binder(result))
         });
@@ -371,7 +349,7 @@ fn fold_regions_in<'tcx, T, F>(tcx: &TyCtxt<'tcx>,
     })
 }
 
-impl<'a,'tcx> InferCtxtExt for InferCtxt<'a,'tcx> {
+impl<'a,'tcx> InferCtxt<'a,'tcx> {
     fn tainted_regions(&self, snapshot: &CombinedSnapshot, r: ty::Region) -> Vec<ty::Region> {
         self.region_vars.tainted(&snapshot.region_vars_snapshot, r)
     }
@@ -452,12 +430,11 @@ impl<'a,'tcx> InferCtxtExt for InferCtxt<'a,'tcx> {
 
         region_vars
     }
-}
 
-pub fn skolemize_late_bound_regions<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
-                                               binder: &ty::Binder<T>,
-                                               snapshot: &CombinedSnapshot)
-                                               -> (T, SkolemizationMap)
+pub fn skolemize_late_bound_regions<T>(&self,
+                                       binder: &ty::Binder<T>,
+                                       snapshot: &CombinedSnapshot)
+                                       -> (T, SkolemizationMap)
     where T : TypeFoldable<'tcx>
 {
     /*!
@@ -468,8 +445,8 @@ pub fn skolemize_late_bound_regions<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
      * details.
      */
 
-    let (result, map) = infcx.tcx.replace_late_bound_regions(binder, |br| {
-        infcx.region_vars.new_skolemized(br, &snapshot.region_vars_snapshot)
+    let (result, map) = self.tcx.replace_late_bound_regions(binder, |br| {
+        self.region_vars.new_skolemized(br, &snapshot.region_vars_snapshot)
     });
 
     debug!("skolemize_bound_regions(binder={:?}, result={:?}, map={:?})",
@@ -480,10 +457,11 @@ pub fn skolemize_late_bound_regions<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
     (result, map)
 }
 
-pub fn leak_check<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
-                           skol_map: &SkolemizationMap,
-                           snapshot: &CombinedSnapshot)
-                           -> Result<(),(ty::BoundRegion,ty::Region)>
+pub fn leak_check(&self,
+                  overly_polymorphic: bool,
+                  skol_map: &SkolemizationMap,
+                  snapshot: &CombinedSnapshot)
+                  -> RelateResult<'tcx, ()>
 {
     /*!
      * Searches the region constriants created since `snapshot` was started
@@ -496,9 +474,9 @@ pub fn leak_check<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
     debug!("leak_check: skol_map={:?}",
            skol_map);
 
-    let new_vars = infcx.region_vars_confined_to_snapshot(snapshot);
+    let new_vars = self.region_vars_confined_to_snapshot(snapshot);
     for (&skol_br, &skol) in skol_map {
-        let tainted = infcx.tainted_regions(snapshot, skol);
+        let tainted = self.tainted_regions(snapshot, skol);
         for &tainted_region in &tainted {
             // Each skolemized should only be relatable to itself
             // or new variables:
@@ -516,8 +494,15 @@ pub fn leak_check<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
                    skol_br,
                    tainted_region);
 
-            // A is not as polymorphic as B:
-            return Err((skol_br, tainted_region));
+            if overly_polymorphic {
+                debug!("Overly polymorphic!");
+                return Err(TypeError::RegionsOverlyPolymorphic(skol_br,
+                                                               tainted_region));
+            } else {
+                debug!("Not as polymorphic!");
+                return Err(TypeError::RegionsInsufficientlyPolymorphic(skol_br,
+                                                                       tainted_region));
+            }
         }
     }
     Ok(())
@@ -551,14 +536,13 @@ pub fn leak_check<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
 /// replace `'0` with a late-bound region `'a`.  The depth is matched
 /// to the depth of the predicate, in this case 1, so that the final
 /// predicate is `for<'a> &'a int : Clone`.
-pub fn plug_leaks<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
-                             skol_map: SkolemizationMap,
-                             snapshot: &CombinedSnapshot,
-                             value: &T)
-                             -> T
+pub fn plug_leaks<T>(&self,
+                     skol_map: SkolemizationMap,
+                     snapshot: &CombinedSnapshot,
+                     value: &T) -> T
     where T : TypeFoldable<'tcx>
 {
-    debug_assert!(leak_check(infcx, &skol_map, snapshot).is_ok());
+    debug_assert!(self.leak_check(false, &skol_map, snapshot).is_ok());
 
     debug!("plug_leaks(skol_map={:?}, value={:?})",
            skol_map,
@@ -572,7 +556,7 @@ pub fn plug_leaks<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
         skol_map
         .into_iter()
         .flat_map(|(skol_br, skol)| {
-            infcx.tainted_regions(snapshot, skol)
+            self.tainted_regions(snapshot, skol)
                 .into_iter()
                 .map(move |tainted_region| (tainted_region, skol_br))
         })
@@ -583,14 +567,14 @@ pub fn plug_leaks<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
 
     // Remove any instantiated type variables from `value`; those can hide
     // references to regions from the `fold_regions` code below.
-    let value = infcx.resolve_type_vars_if_possible(value);
+    let value = self.resolve_type_vars_if_possible(value);
 
     // Map any skolemization byproducts back to a late-bound
     // region. Put that late-bound region at whatever the outermost
     // binder is that we encountered in `value`. The caller is
     // responsible for ensuring that (a) `value` contains at least one
     // binder and (b) that binder is the one we want to use.
-    let result = infcx.tcx.fold_regions(&value, &mut false, |r, current_depth| {
+    let result = self.tcx.fold_regions(&value, &mut false, |r, current_depth| {
         match inv_skol_map.get(&r) {
             None => r,
             Some(br) => {
@@ -612,3 +596,4 @@ pub fn plug_leaks<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
 
     result
 }
+}

src/librustc/infer/lattice.rs

@@ -29,7 +29,6 @@
 //! over a `LatticeValue`, which is a value defined with respect to
 //! a lattice.
 
-use super::combine;
 use super::InferCtxt;
 
 use ty::TyVar;
@@ -78,7 +77,7 @@ pub fn super_lattice_tys<'a,'tcx,L:LatticeDir<'a,'tcx>>(this: &mut L,
         }
 
         _ => {
-            combine::super_combine_tys(this.infcx(), this, a, b)
+            infcx.super_combine_tys(this, a, b)
         }
     }
 }