refactor region manipulation routines to eliminate duplication

nikomatsakis · nikomatsakis · commit e6b9db08841c · 2012-05-30T11:04:12.000-07:00
fn subtyping is starting to work, but it's exposing bugs in the
code which checks for iface conformance, which doesn't properly
skolemize the self region
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
@@ -70,7 +70,7 @@ import astconv::{ast_conv, ast_ty_to_ty};
 import collect::{methods}; // ccx.to_ty()
 import method::{methods};  // methods for method::lookup
 import middle::ty::tys_in_fn_ty;
-import regionmanip::{universally_quantify_from_sty,
+import regionmanip::{replace_bound_regions_in_fn_ty,
                      region_of, replace_bound_regions,
                      collect_bound_regions_in_tys};
 import rscope::*;
@@ -84,7 +84,6 @@ type fn_ctxt =
      // Used by loop bodies that return from the outer function
      indirect_ret_ty: option<ty::t>,
      purity: ast::purity,
-     proto: ast::proto,
      infcx: infer::infer_ctxt,
      locals: hashmap<ast::node_id, ty_vid>,
 
@@ -128,55 +127,41 @@ fn check_bare_fn(ccx: @crate_ctxt,
                  id: ast::node_id,
                  self_ty: option<ty::t>) {
     let fty = ty::node_id_to_type(ccx.tcx, id);
-    let ret_ty = ty::ty_fn_ret(fty);
-    let arg_tys = vec::map(ty::ty_fn_args(fty)) {|a| a.ty };
-    check_fn(ccx, ast::proto_bare, decl, body,
-             ret_ty, arg_tys, false, none, self_ty);
+    let fn_ty = alt check ty::get(fty).struct { ty::ty_fn(f) {f} };
+    check_fn(ccx, self_ty, fn_ty, decl, body, false, none);
 }
 
 fn check_fn(ccx: @crate_ctxt,
-            proto: ast::proto,
+            self_ty: option<ty::t>,
+            fn_ty: ty::fn_ty,
             decl: ast::fn_decl,
             body: ast::blk,
-            ret_ty: ty::t,
-            arg_tys: [ty::t],
             indirect_ret: bool,
-            old_fcx: option<@fn_ctxt>,
-            self_ty: option<ty::t>) {
+            old_fcx: option<@fn_ctxt>) {
 
     let tcx = ccx.tcx;
 
-    let isr = {
-        // Find the list of in-scope regions.  These are derived from the
-        // various regions that are bound in the argument, return, and self
-        // types.  For each of those bound regions, we will create a mapping
-        // to a free region tied to the node_id of this function.  For an
-        // in-depth discussion of why we must distinguish bound/free regions,
-        // see the big comment in region.rs.
-        let all_tys = arg_tys + [ret_ty] + self_ty.to_vec();
-        let old_isr = option::map_default(old_fcx, @nil) {
-            |fcx| fcx.in_scope_regions };
-        collect_bound_regions_in_tys(tcx, old_isr, all_tys) {
-            |br| ty::re_free(body.node.id, br) }
-    };
+    // ______________________________________________________________________
+    // First, we have to replace any bound regions in the fn and self
+    // types with free ones.  The free region references will be bound
+    // the node_id of the body block.
 
-    // Replace the bound regions that appear in the arg tys, ret ty, etc with
-    // the free versions we just collected.
-    let arg_tys = arg_tys.map {
-        |arg_ty| replace_bound_regions(tcx, body.span, isr, arg_ty)
-    };
-    let ret_ty = {
-        replace_bound_regions(tcx, body.span, isr, ret_ty)
-    };
-    let self_ty = option::map(self_ty) {
-        |self_ty| replace_bound_regions(tcx, body.span, isr, self_ty)
+    let {isr, self_ty, fn_ty} = {
+        let old_isr = option::map_default(old_fcx, @nil,
+                                         { |fcx| fcx.in_scope_regions });
+        replace_bound_regions_in_fn_ty(tcx, old_isr, self_ty, fn_ty,
+                                       { |br| ty::re_free(body.node.id, br) })
     };
 
+    let arg_tys = fn_ty.inputs.map { |a| a.ty };
+    let ret_ty = fn_ty.output;
+
     #debug["check_fn(arg_tys=%?, ret_ty=%?, self_ty=%?)",
            arg_tys.map {|a| ty_to_str(tcx, a) },
            ty_to_str(tcx, ret_ty),
            option::map(self_ty) {|st| ty_to_str(tcx, st) }];
 
+    // ______________________________________________________________________
     // Create the function context.  This is either derived from scratch or,
     // in the case of function expressions, based on the outer context.
     let fcx: @fn_ctxt = {
@@ -211,7 +196,6 @@ fn check_fn(ccx: @crate_ctxt,
           ret_ty: ret_ty,
           indirect_ret_ty: indirect_ret_ty,
           purity: purity,
-          proto: proto,
           infcx: infcx,
           locals: locals,
           mut blocks: [],
@@ -708,74 +692,66 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
     // A generic function to factor out common logic from call and bind
     // expressions.
     fn check_call_or_bind(
-        fcx: @fn_ctxt, sp: span, call_expr_id: ast::node_id, fty: ty::t,
+        fcx: @fn_ctxt, sp: span, call_expr_id: ast::node_id, in_fty: ty::t,
         args: [option<@ast::expr>]) -> {fty: ty::t, bot: bool} {
 
         let mut bot = false;
 
         // Replace all region parameters in the arguments and return
         // type with fresh region variables.
 
-        #debug["check_call_or_bind: before universal quant., fty=%s",
-               fcx.infcx.ty_to_str(fty)];
+        #debug["check_call_or_bind: before universal quant., in_fty=%s",
+               fcx.infcx.ty_to_str(in_fty)];
 
         // This is subtle: we expect `fty` to be a function type, which
         // normally introduce a level of binding.  In this case, we want to
         // process the types bound by the function but not by any nested
         // functions.  Therefore, we match one level of structure.
-        let fty =
-            alt structure_of(fcx, sp, fty) {
-              sty @ ty::ty_fn(inner_fty) {
-                let all_tys = tys_in_fn_ty(inner_fty);
-                universally_quantify_from_sty(fcx, sp, all_tys, sty)
+        let fn_ty =
+            alt structure_of(fcx, sp, in_fty) {
+              sty @ ty::ty_fn(fn_ty) {
+                replace_bound_regions_in_fn_ty(
+                    fcx.ccx.tcx, @nil, none, fn_ty,
+                    { |_br| fcx.infcx.next_region_var() }).fn_ty
               }
               sty {
-                #debug["not a fn ty: %?", sty];
-
-                // if not a function type, we're gonna' report an error at
-                // some point, since the user is trying to call this thing
-                fty
+                // I would like to make this span_err, but it's
+                // really hard due to the way that expr_bind() is
+                // written.
+                fcx.ccx.tcx.sess.span_fatal(sp, "mismatched types: \
+                                                 expected function or native \
+                                                 function but found "
+                                            + fcx.infcx.ty_to_str(in_fty));
               }
             };
 
+        let fty = ty::mk_fn(fcx.tcx(), fn_ty);
         #debug["check_call_or_bind: after universal quant., fty=%s",
                fcx.infcx.ty_to_str(fty)];
 
         let supplied_arg_count = vec::len(args);
 
-        // Grab the argument types
-        let arg_tys = alt structure_of(fcx, sp, fty) {
-          ty::ty_fn({inputs: arg_tys, output: ret_ty, _}) {
-            let expected_arg_count = vec::len(arg_tys);
-            if expected_arg_count == supplied_arg_count {
-                arg_tys.map { |a| a.ty }
-            } else {
-                fcx.ccx.tcx.sess.span_err(
-                    sp, #fmt["this function takes %u parameter%s but %u \
-                              parameter%s supplied", expected_arg_count,
-                             if expected_arg_count == 1u {
-                                 ""
-                             } else {
-                                 "s"
-                             },
-                             supplied_arg_count,
-                             if supplied_arg_count == 1u {
-                                 " was"
-                             } else {
-                                 "s were"
-                             }]);
-                fcx.infcx.next_ty_vars(supplied_arg_count)
-            }
-          }
-
-          _ {
-            // I would like to make this span_err, but it's really hard due to
-            // the way that expr_bind() is written.
-            fcx.ccx.tcx.sess.span_fatal(sp, "mismatched types: \
-                                             expected function or native \
-                                             function but found "
-                                        + fcx.infcx.ty_to_str(fty));
-          }
+        // Grab the argument types, supplying fresh type variables
+        // if the wrong number of arguments were supplied
+        let expected_arg_count = vec::len(fn_ty.inputs);
+        let arg_tys = if expected_arg_count == supplied_arg_count {
+            fn_ty.inputs.map { |a| a.ty }
+        } else {
+            fcx.ccx.tcx.sess.span_err(
+                sp, #fmt["this function takes %u parameter%s but %u \
+                          parameter%s supplied", expected_arg_count,
+                         if expected_arg_count == 1u {
+                             ""
+                         } else {
+                             "s"
+                         },
+                         supplied_arg_count,
+                         if supplied_arg_count == 1u {
+                             " was"
+                         } else {
+                             "s were"
+                         }]);
+            fcx.infcx.next_ty_vars(supplied_arg_count)
         };
 
         // Check the arguments.
@@ -1049,21 +1025,17 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         };
 
         // construct the function type
-        let fty = ty::mk_fn(tcx,
-                            astconv::ty_of_fn_decl(fcx, fcx, proto, decl,
-                                                   expected_tys));
+        let fn_ty = astconv::ty_of_fn_decl(fcx, fcx, proto,
+                                           decl, expected_tys);
+        let fty = ty::mk_fn(tcx, fn_ty);
 
         #debug("check_expr_fn_with_unifier %s fty=%s",
                expr_to_str(expr), fcx.infcx.ty_to_str(fty));
 
         fcx.write_ty(expr.id, fty);
 
-        let ret_ty = ty::ty_fn_ret(fty);
-        let arg_tys = vec::map(ty::ty_fn_args(fty)) {|a| a.ty };
-
-        check_fn(fcx.ccx, proto, decl, body,
-                 ret_ty, arg_tys, is_loop_body, some(fcx),
-                 fcx.self_ty);
+        check_fn(fcx.ccx, fcx.self_ty, fn_ty, decl, body,
+                 is_loop_body, some(fcx));
     }
 
 
@@ -1825,7 +1797,6 @@ fn check_const(ccx: @crate_ctxt, _sp: span, e: @ast::expr, id: ast::node_id) {
           ret_ty: rty,
           indirect_ret_ty: none,
           purity: ast::pure_fn,
-          proto: ast::proto_box,
           infcx: infer::new_infer_ctxt(ccx.tcx),
           locals: int_hash(),
           mut blocks: [],
@@ -1865,7 +1836,6 @@ fn check_enum_variants(ccx: @crate_ctxt,
           ret_ty: rty,
           indirect_ret_ty: none,
           purity: ast::pure_fn,
-          proto: ast::proto_box,
           infcx: infer::new_infer_ctxt(ccx.tcx),
           locals: int_hash(),
           mut blocks: [],
diff --git a/src/rustc/middle/typeck/check/method.rs b/src/rustc/middle/typeck/check/method.rs
@@ -1,7 +1,6 @@
 /* Code to handle method lookups (which can be quite complex) */
 
 import syntax::ast_map;
-import regionmanip::universally_quantify_from_sty;
 import middle::typeck::infer::methods; // next_ty_vars
 
 enum lookup = {
diff --git a/src/rustc/middle/typeck/check/regionmanip.rs b/src/rustc/middle/typeck/check/regionmanip.rs
@@ -2,33 +2,40 @@ import syntax::print::pprust::{expr_to_str};
 
 // Helper functions related to manipulating region types.
 
-// Extracts the bound regions from bound_tys and then replaces those same
-// regions in `sty` with fresh region variables, returning the resulting type.
-// Does not descend into fn types.  This is used when deciding whether an impl
-// applies at a given call site.
-fn universally_quantify_from_sty(fcx: @fn_ctxt,
-                                 span: span,
-                                 bound_tys: [ty::t],
-                                 sty: ty::sty) -> ty::t {
-
-    #debug["universally_quantify_from_sty(bound_tys=%?)",
-           bound_tys.map {|x| fcx.infcx.ty_to_str(x) }];
-    indent {||
-        let tcx = fcx.tcx();
-        let isr = collect_bound_regions_in_tys(tcx, @nil, bound_tys) { |br|
-            let rvar = fcx.infcx.next_region_var();
-            #debug["Bound region %s maps to %s",
-                   bound_region_to_str(fcx.ccx.tcx, br),
-                   region_to_str(fcx.ccx.tcx, rvar)];
-            rvar
-        };
-        let t_res = ty::fold_sty_to_ty(fcx.ccx.tcx, sty) { |t|
-            replace_bound_regions(tcx, span, isr, t)
-        };
-        #debug["Result of universal quant. is %s",
-               fcx.infcx.ty_to_str(t_res)];
-        t_res
-    }
+fn replace_bound_regions_in_fn_ty(
+    tcx: ty::ctxt,
+    isr: isr_alist,
+    self_ty: option<ty::t>,
+    fn_ty: ty::fn_ty,
+    mapf: fn(ty::bound_region) -> ty::region) -> {isr: isr_alist,
+                                                  self_ty: option<ty::t>,
+                                                  fn_ty: ty::fn_ty} {
+
+    let mut all_tys = ty::tys_in_fn_ty(fn_ty);
+    for self_ty.each { |t| all_tys += [t] }
+
+    #debug["replace_bound_regions_in_fn_ty(self_ty=%?, fn_ty=%s, all_tys=%?)",
+           self_ty.map { |t| ty_to_str(tcx, t) },
+           ty_to_str(tcx, ty::mk_fn(tcx, fn_ty)),
+           all_tys.map { |t| ty_to_str(tcx, t) }];
+    let _i = indenter();
+
+    let isr = collect_bound_regions_in_tys(tcx, isr, all_tys) { |br|
+        #debug["br=%?", br];
+        mapf(br)
+    };
+    let t_fn = ty::fold_sty_to_ty(tcx, ty::ty_fn(fn_ty)) { |t|
+        replace_bound_regions(tcx, isr, t)
+    };
+    let t_self = self_ty.map { |t| replace_bound_regions(tcx, isr, t) };
+
+    #debug["result of replace_bound_regions_in_fn_ty: self_ty=%?, fn_ty=%s",
+           t_self.map { |t| ty_to_str(tcx, t) },
+           ty_to_str(tcx, t_fn)];
+
+    ret {isr: isr,
+         self_ty: t_self,
+         fn_ty: alt check ty::get(t_fn).struct { ty::ty_fn(o) {o} }};
 }
 
 // Takes `isr`, a mapping from in-scope region names ("isr"s) to their
@@ -38,7 +45,6 @@ fn universally_quantify_from_sty(fcx: @fn_ctxt,
 // with the corresponding bindings in `isr`.
 fn replace_bound_regions(
     tcx: ty::ctxt,
-    span: span,
     isr: isr_alist,
     ty: ty::t) -> ty::t {
 
@@ -58,8 +64,7 @@ fn replace_bound_regions(
               // within that remain bound:
               none if in_fn { r }
               none {
-                tcx.sess.span_bug(
-                    span,
+                tcx.sess.bug(
                     #fmt["Bound region not found in \
                           in_scope_regions list: %s",
                          region_to_str(tcx, r)]);
diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs
