Unify replace_late_bound_regions_with_fresh_var and

`replace_late_bound_regions_with_fresh_reions` into one fn

Author: nikomatsakis

src/librustc/lib.rs

@@ -29,7 +29,7 @@ This API is completely unstable and subject to change.
       html_root_url = "http://doc.rust-lang.org/nightly/")]
 
 #![feature(default_type_params, globs, if_let, import_shadowing, macro_rules, phase, quote)]
-#![feature(slicing_syntax, struct_variant, unsafe_destructor)]
+#![feature(slicing_syntax, struct_variant, tuple_indexing, unsafe_destructor)]
 #![feature(rustc_diagnostic_macros)]
 
 extern crate arena;

src/librustc/middle/traits/select.rs

@@ -1709,7 +1709,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 closure_type.sig.binder_id,
                 &closure_type.sig,
                 |br| self.infcx.next_region_var(
-                         infer::LateBoundRegion(obligation.cause.span, br)));
+                         infer::LateBoundRegion(obligation.cause.span, br,
+                                                infer::FnCall)));
 
         let arguments_tuple = new_signature.inputs[0];
         let trait_ref = Rc::new(ty::TraitRef {

src/librustc/middle/typeck/check/method/confirm.rs

@@ -359,7 +359,8 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
         let fn_sig = bare_fn_ty.sig.subst(self.tcx(), all_substs);
         self.infcx().replace_late_bound_regions_with_fresh_var(fn_sig.binder_id,
                                                                self.span,
-                                                               &fn_sig)
+                                                               infer::FnCall,
+                                                               &fn_sig).0
     }
 
     fn add_obligations(&mut self,

src/librustc/middle/typeck/check/method/mod.rs

@@ -18,10 +18,11 @@ use middle::ty;
 use middle::typeck::astconv::AstConv;
 use middle::typeck::check::{FnCtxt};
 use middle::typeck::check::{impl_self_ty};
+use middle::typeck::check::vtable;
 use middle::typeck::check::vtable::select_new_fcx_obligations;
+use middle::typeck::infer;
 use middle::typeck::{MethodCallee};
 use middle::typeck::{MethodParam, MethodTypeParam};
-use middle::typeck::check::vtable;
 use util::ppaux::{Repr, UserString};
 
 use std::rc::Rc;
@@ -194,7 +195,8 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(
     let fn_sig = bare_fn_ty.sig.subst(tcx, &trait_ref.substs);
     let fn_sig = fcx.infcx().replace_late_bound_regions_with_fresh_var(fn_sig.binder_id,
                                                                        span,
-                                                                       &fn_sig);
+                                                                       infer::FnCall,
+                                                                       &fn_sig).0;
     let transformed_self_ty = fn_sig.inputs[0];
     let fty = ty::mk_bare_fn(tcx, ty::BareFnTy {
         sig: fn_sig,

src/librustc/middle/typeck/check/method/probe.rs

@@ -845,7 +845,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         let xform_self_ty = method.fty.sig.inputs[0].subst(self.tcx(), substs);
         self.infcx().replace_late_bound_regions_with_fresh_var(method.fty.sig.binder_id,
                                                                self.span,
-                                                               &xform_self_ty)
+                                                               infer::FnCall,
+                                                               &xform_self_ty).0
     }
 }
 

src/librustc/middle/typeck/check/mod.rs

@@ -3054,9 +3054,12 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
 
         // Replace any bound regions that appear in the function
         // signature with region variables
-        let (_, fn_sig) = replace_late_bound_regions(fcx.tcx(), fn_sig.binder_id, fn_sig, |br| {
-            fcx.infcx().next_region_var(infer::LateBoundRegion(call_expr.span, br))
-        });
+        let fn_sig =
+            fcx.infcx().replace_late_bound_regions_with_fresh_var(
+                fn_sig.binder_id,
+                call_expr.span,
+                infer::FnCall,
+                fn_sig).0;
 
         // Call the generic checker.
         check_argument_types(fcx,
@@ -3605,8 +3608,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                    expr: &ast::Expr,
                    lvalue_pref: LvaluePreference,
                    base: &ast::Expr,
-                   field: &ast::SpannedIdent,
-                   _tys: &[P<ast::Ty>]) {
+                   field: &ast::SpannedIdent) {
         let tcx = fcx.ccx.tcx;
         check_expr_with_lvalue_pref(fcx, base, lvalue_pref);
         let expr_t = structurally_resolved_type(fcx, expr.span,
@@ -3666,8 +3668,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                        expr: &ast::Expr,
                        lvalue_pref: LvaluePreference,
                        base: &ast::Expr,
-                       idx: codemap::Spanned<uint>,
-                       _tys: &[P<ast::Ty>]) {
+                       idx: codemap::Spanned<uint>) {
         let tcx = fcx.ccx.tcx;
         check_expr_with_lvalue_pref(fcx, base, lvalue_pref);
         let expr_t = structurally_resolved_type(fcx, expr.span,
@@ -4489,11 +4490,11 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
 
         fcx.require_expr_have_sized_type(expr, traits::StructInitializerSized);
       }
-      ast::ExprField(ref base, ref field, ref tys) => {
-        check_field(fcx, expr, lvalue_pref, &**base, field, tys.as_slice());
+      ast::ExprField(ref base, ref field, _) => {
+        check_field(fcx, expr, lvalue_pref, &**base, field);
       }
-      ast::ExprTupField(ref base, idx, ref tys) => {
-        check_tup_field(fcx, expr, lvalue_pref, &**base, idx, tys.as_slice());
+      ast::ExprTupField(ref base, idx, _) => {
+        check_tup_field(fcx, expr, lvalue_pref, &**base, idx);
       }
       ast::ExprIndex(ref base, ref idx) => {
           check_expr_with_lvalue_pref(fcx, &**base, lvalue_pref);

src/librustc/middle/typeck/infer/error_reporting.rs

@@ -1434,11 +1434,11 @@ impl<'a, 'tcx> ErrorReportingHelpers for InferCtxt<'a, 'tcx> {
             infer::AddrOfSlice(_) => " for slice expression".to_string(),
             infer::Autoref(_) => " for autoref".to_string(),
             infer::Coercion(_) => " for automatic coercion".to_string(),
-            infer::LateBoundRegion(_, br) => {
+            infer::LateBoundRegion(_, br, infer::FnCall) => {
                 format!(" for {}in function call",
                         bound_region_to_string(self.tcx, "lifetime parameter ", true, br))
             }
-            infer::BoundRegionInFnType(_, br) => {
+            infer::LateBoundRegion(_, br, infer::FnType) => {
                 format!(" for {}in function type",
                         bound_region_to_string(self.tcx, "lifetime parameter ", true, br))
             }

src/librustc/middle/typeck/infer/glb.rs

@@ -15,12 +15,13 @@ use middle::ty;
 use middle::typeck::infer::combine::*;
 use middle::typeck::infer::lattice::*;
 use middle::typeck::infer::equate::Equate;
+use middle::typeck::infer::FnType;
+use middle::typeck::infer::fold_regions_in_sig;
 use middle::typeck::infer::lub::Lub;
+use middle::typeck::infer::region_inference::RegionMark;
 use middle::typeck::infer::sub::Sub;
 use middle::typeck::infer::{cres, InferCtxt};
 use middle::typeck::infer::{TypeTrace, Subtype};
-use middle::typeck::infer::fold_regions_in_sig;
-use middle::typeck::infer::region_inference::RegionMark;
 use syntax::ast::{Many, Once, MutImmutable, MutMutable};
 use syntax::ast::{NormalFn, UnsafeFn, NodeId};
 use syntax::ast::{Onceness, FnStyle};
@@ -140,12 +141,12 @@ impl<'f, 'tcx> Combine<'tcx> for Glb<'f, 'tcx> {
 
         // Instantiate each bound region with a fresh region variable.
         let (a_with_fresh, a_map) =
-            self.fields.infcx.replace_late_bound_regions_with_fresh_regions(
-                self.trace(), a);
+            self.fields.infcx.replace_late_bound_regions_with_fresh_var(
+                a.binder_id, self.trace().span(), FnType, a);
         let a_vars = var_ids(self, &a_map);
         let (b_with_fresh, b_map) =
-            self.fields.infcx.replace_late_bound_regions_with_fresh_regions(
-                self.trace(), b);
+            self.fields.infcx.replace_late_bound_regions_with_fresh_var(
+                b.binder_id, self.trace().span(), FnType, b);
         let b_vars = var_ids(self, &b_map);
 
         // Collect constraints.

src/librustc/middle/typeck/infer/lub.rs

@@ -13,6 +13,7 @@ use middle::ty::RegionVid;
 use middle::ty;
 use middle::typeck::infer::combine::*;
 use middle::typeck::infer::equate::Equate;
+use middle::typeck::infer::FnType;
 use middle::typeck::infer::glb::Glb;
 use middle::typeck::infer::lattice::*;
 use middle::typeck::infer::sub::Sub;
@@ -126,11 +127,11 @@ impl<'f, 'tcx> Combine<'tcx> for Lub<'f, 'tcx> {
 
         // Instantiate each bound region with a fresh region variable.
         let (a_with_fresh, a_map) =
-            self.fields.infcx.replace_late_bound_regions_with_fresh_regions(
-                self.trace(), a);
+            self.fields.infcx.replace_late_bound_regions_with_fresh_var(
+                a.binder_id, self.trace().span(), FnType, a);
         let (b_with_fresh, _) =
-            self.fields.infcx.replace_late_bound_regions_with_fresh_regions(
-                self.trace(), b);
+            self.fields.infcx.replace_late_bound_regions_with_fresh_var(
+                b.binder_id, self.trace().span(), FnType, b);
 
         // Collect constraints.
         let sig0 = try!(super_fn_sigs(self, &a_with_fresh, &b_with_fresh));

src/librustc/middle/typeck/infer/mod.rs

@@ -36,7 +36,7 @@ use syntax::ast;
 use syntax::codemap;
 use syntax::codemap::Span;
 use util::common::indent;
-use util::ppaux::{bound_region_to_string, ty_to_string};
+use util::ppaux::{ty_to_string};
 use util::ppaux::{trait_ref_to_string, Repr};
 
 use self::coercion::Coerce;
@@ -222,6 +222,16 @@ pub enum SubregionOrigin {
     AutoBorrow(Span),
 }
 
+/// Times when we replace late-bound regions with variables:
+#[deriving(Clone, Show)]
+pub enum LateBoundRegionConversionTime {
+    /// when a fn is called
+    FnCall,
+
+    /// when two fn types are compared
+    FnType,
+}
+
 /// Reasons to create a region inference variable
 ///
 /// See `error_reporting.rs` for more details
@@ -251,11 +261,7 @@ pub enum RegionVariableOrigin {
 
     // Region variables created for bound regions
     // in a function or method that is called
-    LateBoundRegion(Span, ty::BoundRegion),
-
-    // Region variables created for bound regions
-    // when doing subtyping/lub/glb computations
-    BoundRegionInFnType(Span, ty::BoundRegion),
+    LateBoundRegion(Span, ty::BoundRegion, LateBoundRegionConversionTime),
 
     UpvarRegion(ty::UpvarId, Span),
 
@@ -959,36 +965,20 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     }
 
     pub fn replace_late_bound_regions_with_fresh_var<T>(&self,
-                                                    binder_id: ast::NodeId,
-                                                    span: Span,
-                                                    value: &T)
-                                                    -> T
-        where T : TypeFoldable + Repr
+                                                        binder_id: ast::NodeId,
+                                                        span: Span,
+                                                        lbrct: LateBoundRegionConversionTime,
+                                                        value: &T)
+                                                        -> (T, HashMap<ty::BoundRegion,ty::Region>)
+                                                        where T : TypeFoldable + Repr
     {
-        let (_, value) = replace_late_bound_regions(
-            self.tcx,
-            binder_id,
-            value,
-            |br| self.next_region_var(LateBoundRegion(span, br)));
-        value
-    }
-
-    pub fn replace_late_bound_regions_with_fresh_regions(&self,
-                                                         trace: TypeTrace,
-                                                         fsig: &ty::FnSig)
-                                                    -> (ty::FnSig,
-                                                        HashMap<ty::BoundRegion,
-                                                                ty::Region>) {
-        let (map, fn_sig) =
-            replace_late_bound_regions(self.tcx, fsig.binder_id, fsig, |br| {
-                let rvar = self.next_region_var(
-                    BoundRegionInFnType(trace.origin.span(), br));
-                debug!("Bound region {} maps to {}",
-                       bound_region_to_string(self.tcx, "", false, br),
-                       rvar);
-                rvar
-            });
-        (fn_sig, map)
+        let (map, value) =
+            replace_late_bound_regions(
+                self.tcx,
+                binder_id,
+                value,
+                |br| self.next_region_var(LateBoundRegion(span, br, lbrct)));
+        (value, map)
     }
 }
 
@@ -1170,8 +1160,7 @@ impl RegionVariableOrigin {
             Autoref(a) => a,
             Coercion(ref a) => a.span(),
             EarlyBoundRegion(a, _) => a,
-            LateBoundRegion(a, _) => a,
-            BoundRegionInFnType(a, _) => a,
+            LateBoundRegion(a, _, _) => a,
             BoundRegionInCoherence(_) => codemap::DUMMY_SP,
             UpvarRegion(_, a) => a
         }
@@ -1196,12 +1185,8 @@ impl Repr for RegionVariableOrigin {
             EarlyBoundRegion(a, b) => {
                 format!("EarlyBoundRegion({},{})", a.repr(tcx), b.repr(tcx))
             }
-            LateBoundRegion(a, b) => {
-                format!("LateBoundRegion({},{})", a.repr(tcx), b.repr(tcx))
-            }
-            BoundRegionInFnType(a, b) => {
-                format!("bound_regionInFnType({},{})", a.repr(tcx),
-                b.repr(tcx))
+            LateBoundRegion(a, b, c) => {
+                format!("LateBoundRegion({},{},{})", a.repr(tcx), b.repr(tcx), c)
             }
             BoundRegionInCoherence(a) => {
                 format!("bound_regionInCoherence({})", a.repr(tcx))