WIP WIP fix for rust-lang#18653

Author: nikomatsakis

src/librustc/infer/combine.rs

@@ -39,7 +39,7 @@ use super::lub::Lub;
 use super::sub::Sub;
 use super::InferCtxt;
 use super::{MiscVariable, TypeTrace};
-use super::type_variable::{RelationDir, BiTo, EqTo, SubtypeOf, SupertypeOf};
+use super::type_variable::{RelationDir, BiTo, EqTo, SubtypeOf, SupertypeOf, TypeVariableOrigin};
 
 use ty::{IntType, UintType};
 use ty::{self, Ty, TyCtxt};
@@ -322,7 +322,17 @@ impl<'cx, 'gcx, 'tcx> ty::fold::TypeFolder<'gcx, 'tcx> for Generalizer<'cx, 'gcx
                             drop(variables);
                             self.fold_ty(u)
                         }
-                        None => t,
+                        None => {
+                            if self.make_region_vars {
+                                let origin = variables.origin(vid);
+                                let new_var_id = variables.new_var(false, origin, None);
+                                let u = self.tcx().mk_var(new_var_id);
+                                debug!("XXX original-vid={:?} new={:?}", vid, u);
+                                u
+                            } else {
+                                t
+                            }
+                        }
                     }
                 }
             }

src/librustc/infer/equate.rs

@@ -56,6 +56,8 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
         let infcx = self.fields.infcx;
         let a = infcx.type_variables.borrow_mut().replace_if_possible(a);
         let b = infcx.type_variables.borrow_mut().replace_if_possible(b);
+        debug!("{}.tys: normalized a={:?}", self.tag(), a);
+        debug!("{}.tys: normalized b={:?}", self.tag(), b);
         match (&a.sty, &b.sty) {
             (&ty::TyInfer(TyVar(a_id)), &ty::TyInfer(TyVar(b_id))) => {
                 infcx.type_variables.borrow_mut().relate_vars(a_id, EqTo, b_id);

src/librustc/infer/fudge.rs

@@ -65,6 +65,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         F: FnOnce() -> Result<T, E>,
         T: TypeFoldable<'tcx>,
     {
+        debug!("fudge_regions_if_ok(origin={:?})", origin);
+
         let (region_vars, value) = self.probe(|snapshot| {
             let vars_at_start = self.type_variables.borrow().num_vars();
 

src/librustc/infer/type_variable.rs

@@ -30,7 +30,7 @@ pub struct TypeVariableTable<'tcx> {
 }
 
 /// Reasons to create a type inference variable
-#[derive(Debug)]
+#[derive(Copy, Clone, Debug)]
 pub enum TypeVariableOrigin {
     MiscVariable(Span),
     NormalizeProjectionType(Span),
@@ -44,6 +44,7 @@ pub enum TypeVariableOrigin {
     DivergingBlockExpr(Span),
     DivergingFn(Span),
     LatticeVariable(Span),
+    Generalized(ty::TyVid),
 }
 
 struct TypeVariableData<'tcx> {
@@ -134,9 +135,11 @@ impl<'tcx> TypeVariableTable<'tcx> {
     ///
     /// Precondition: neither `a` nor `b` are known.
     pub fn relate_vars(&mut self, a: ty::TyVid, dir: RelationDir, b: ty::TyVid) {
+        debug!("relate_vars({:?}, {:?}, {:?})", a, dir, b);
         let a = self.root_var(a);
         let b = self.root_var(b);
         if a != b {
+            debug!("relate_vars: root-a={:?} {:?} root-b={:?}", a, dir, b);
             if dir == EqTo {
                 // a and b must be equal which we mark in the unification table
                 let root = self.eq_relations.union(a, b);
@@ -223,6 +226,10 @@ impl<'tcx> TypeVariableTable<'tcx> {
         self.probe_root(vid)
     }
 
+    pub fn origin(&self, vid: ty::TyVid) -> TypeVariableOrigin {
+        self.values.get(vid.index as usize).origin.clone()
+    }
+
     /// Retrieves the type of `vid` given that it is currently a root in the unification table
     pub fn probe_root(&mut self, vid: ty::TyVid) -> Option<Ty<'tcx>> {
         debug_assert!(self.root_var(vid) == vid);

src/librustc_typeck/check/mod.rs

@@ -1795,6 +1795,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
     pub fn register_predicates(&self,
                                obligations: Vec<traits::PredicateObligation<'tcx>>)
     {
+        debug!("register_predicates({:?})", obligations);
         for obligation in obligations {
             self.register_predicate(obligation);
         }