librustc: Require explicit lifetime binders

Author: pcwalton

src/librustc/middle/typeck/astconv.rs

@@ -58,13 +58,15 @@ use middle::const_eval;
 use middle::ty::{arg, field, substs};
 use middle::ty::{ty_param_substs_and_ty};
 use middle::ty;
-use middle::typeck::rscope::{in_binding_rscope};
+use middle::typeck::rscope::{in_binding_rscope, in_binding_rscope_ext};
 use middle::typeck::rscope::{region_scope, type_rscope, RegionError};
+use middle::typeck::rscope::{RegionParamNames};
 
 use core::result;
 use core::vec;
 use syntax::{ast, ast_util};
 use syntax::codemap::span;
+use syntax::opt_vec::OptVec;
 use syntax::print::pprust::{lifetime_to_str, path_to_str};
 use syntax::parse::token::special_idents;
 use util::common::indenter;
@@ -348,9 +350,15 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>(
                                             bf.abi, &bf.decl))
       }
       ast::ty_closure(ref f) => {
-          let fn_decl = ty_of_closure(self, rscope, f.sigil,
-                                      f.purity, f.onceness,
-                                      f.region, &f.decl, None,
+          let fn_decl = ty_of_closure(self,
+                                      rscope,
+                                      f.sigil,
+                                      f.purity,
+                                      f.onceness,
+                                      f.region,
+                                      &f.decl,
+                                      None,
+                                      &f.lifetimes,
                                       ast_ty.span);
           ty::mk_closure(tcx, fn_decl)
       }
@@ -507,7 +515,7 @@ pub fn ty_of_bare_fn<AC:AstConv,RS:region_scope + Copy + Durable>(
         abi: ast::Abi,
         decl: &ast::fn_decl)
      -> ty::BareFnTy {
-    debug!("ty_of_fn_decl");
+    debug!("ty_of_bare_fn");
 
     // new region names that appear inside of the fn decl are bound to
     // that function type
@@ -526,6 +534,33 @@ pub fn ty_of_bare_fn<AC:AstConv,RS:region_scope + Copy + Durable>(
     }
 }
 
+pub fn ty_of_bare_fn_ext<AC:AstConv,RS:region_scope + Copy + Durable>(
+        self: &AC,
+        rscope: &RS,
+        purity: ast::purity,
+        abi: ast::Abi,
+        decl: &ast::fn_decl,
+        +region_param_names: RegionParamNames)
+     -> ty::BareFnTy {
+    debug!("ty_of_bare_fn_ext");
+
+    // new region names that appear inside of the fn decl are bound to
+    // that function type
+    let rb = in_binding_rscope_ext(rscope, region_param_names);
+
+    let input_tys = decl.inputs.map(|a| ty_of_arg(self, &rb, *a, None));
+    let output_ty = match decl.output.node {
+        ast::ty_infer => self.ty_infer(decl.output.span),
+        _ => ast_ty_to_ty(self, &rb, decl.output)
+    };
+
+    ty::BareFnTy {
+        purity: purity,
+        abi: abi,
+        sig: ty::FnSig {inputs: input_tys, output: output_ty}
+    }
+}
+
 pub fn ty_of_closure<AC:AstConv,RS:region_scope + Copy + Durable>(
         self: &AC,
         rscope: &RS,
@@ -535,6 +570,7 @@ pub fn ty_of_closure<AC:AstConv,RS:region_scope + Copy + Durable>(
         opt_lifetime: Option<@ast::Lifetime>,
         decl: &ast::fn_decl,
         expected_tys: Option<ty::FnSig>,
+        lifetimes: &OptVec<ast::Lifetime>,
         span: span)
      -> ty::ClosureTy {
     debug!("ty_of_fn_decl");
@@ -563,7 +599,8 @@ pub fn ty_of_closure<AC:AstConv,RS:region_scope + Copy + Durable>(
 
     // new region names that appear inside of the fn decl are bound to
     // that function type
-    let rb = in_binding_rscope(rscope);
+    let region_param_names = RegionParamNames::from_lifetimes(lifetimes);
+    let rb = in_binding_rscope_ext(rscope, region_param_names);
 
     let input_tys = do decl.inputs.mapi |i, a| {
         let expected_arg_ty = do expected_tys.chain_ref |e| {

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

@@ -100,7 +100,7 @@ use middle::typeck::CrateCtxt;
 use middle::typeck::infer::{resolve_type, force_tvar, mk_eqty};
 use middle::typeck::infer;
 use middle::typeck::rscope::{binding_rscope, bound_self_region};
-use middle::typeck::rscope::{RegionError};
+use middle::typeck::rscope::{RegionError, RegionParameterization};
 use middle::typeck::rscope::{in_binding_rscope, region_scope, type_rscope};
 use middle::typeck::rscope;
 use middle::typeck::{isr_alist, lookup_def_ccx, method_map_entry};
@@ -126,10 +126,11 @@ use syntax::ast_util::{Private, Public, is_local, local_def};
 use syntax::ast_util;
 use syntax::codemap::{span, spanned, respan};
 use syntax::codemap;
+use syntax::opt_vec::OptVec;
+use syntax::opt_vec;
 use syntax::parse::token::special_idents;
 use syntax::print::pprust;
 use syntax::visit;
-use syntax::opt_vec::OptVec;
 use syntax;
 
 pub mod _match;
@@ -570,10 +571,12 @@ pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) {
       ast::item_fn(ref decl, _, _, ref body) => {
         check_bare_fn(ccx, decl, body, it.id, None);
       }
-      ast::item_impl(_, _, ty, ref ms) => {
+      ast::item_impl(ref generics, _, ty, ref ms) => {
         let rp = ccx.tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
         debug!("item_impl %s with id %d rp %?",
                *ccx.tcx.sess.str_of(it.ident), it.id, rp);
+        let rp = RegionParameterization::from_variance_and_generics(
+            rp, generics);
         let self_ty = ccx.to_ty(&rscope::type_rscope(rp), ty);
         for ms.each |m| {
             check_method(ccx, *m, self_ty);
@@ -1069,9 +1072,13 @@ pub fn impl_self_ty(vcx: &VtableContext,
                   node: ast::item_impl(ref ts, _, st, _),
                   _
               }, _)) => {
+            let region_parameterization =
+                RegionParameterization::from_variance_and_generics(
+                    region_param,
+                    ts);
             (ts.ty_params.len(),
              region_param,
-             vcx.ccx.to_ty(&rscope::type_rscope(region_param), st))
+             vcx.ccx.to_ty(&rscope::type_rscope(region_parameterization), st))
           }
           Some(&ast_map::node_item(@ast::item {
                   node: ast::item_struct(_, ref ts),
@@ -1654,10 +1661,16 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         };
 
         // construct the function type
-        let mut fn_ty = astconv::ty_of_closure(
-            fcx, fcx,
-            sigil, purity, expected_onceness,
-            None, decl, expected_tys, expr.span);
+        let mut fn_ty = astconv::ty_of_closure(fcx,
+                                               fcx,
+                                               sigil,
+                                               purity,
+                                               expected_onceness,
+                                               None,
+                                               decl,
+                                               expected_tys,
+                                               &opt_vec::Empty,
+                                               expr.span);
 
         let mut fty_sig;
         let fty = if error_happened {