---

yaml
---
r: 64223
b: refs/heads/snap-stage3
c: 7e97277
h: refs/heads/master
i:
  64221: 0f4bd73
  64219: d17572a
  64215: 6495056
  64207: 63c2753
  64191: 91e4ac4
v: v3

Author: dotdash

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 278ed50e0a66f4c549e43c82e4a545890091e9ba
+refs/heads/snap-stage3: 7e972772890ec0d28d2aa4e7ff5c7b004e5463e8
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/middle/trans/closure.rs

@@ -220,24 +220,16 @@ pub fn store_environment(bcx: block,
     // compute the type of the closure
     let cdata_ty = mk_closure_tys(tcx, bound_values);
 
+    // allocate closure in the heap
+    let Result {bcx: bcx, val: llbox} = allocate_cbox(bcx, sigil, cdata_ty);
+
     // cbox_ty has the form of a tuple: (a, b, c) we want a ptr to a
     // tuple.  This could be a ptr in uniq or a box or on stack,
     // whatever.
     let cbox_ty = tuplify_box_ty(tcx, cdata_ty);
     let cboxptr_ty = ty::mk_ptr(tcx, ty::mt {ty:cbox_ty, mutbl:ast::m_imm});
-    let llboxptr_ty = type_of(ccx, cboxptr_ty);
-
-    // If there are no bound values, no point in allocating anything.
-    if bound_values.is_empty() {
-        return ClosureResult {llbox: C_null(llboxptr_ty),
-                              cdata_ty: cdata_ty,
-                              bcx: bcx};
-    }
 
-    // allocate closure in the heap
-    let Result {bcx: bcx, val: llbox} = allocate_cbox(bcx, sigil, cdata_ty);
-
-    let llbox = PointerCast(bcx, llbox, llboxptr_ty);
+    let llbox = PointerCast(bcx, llbox, type_of(ccx, cboxptr_ty));
     debug!("tuplify_box_ty = %s", ty_to_str(tcx, cbox_ty));
 
     // Copy expr values into boxed bindings.
@@ -276,7 +268,6 @@ pub fn build_closure(bcx0: block,
                      sigil: ast::Sigil,
                      include_ret_handle: Option<ValueRef>) -> ClosureResult {
     let _icx = push_ctxt("closure::build_closure");
-
     // If we need to, package up the iterator body to call
     let bcx = bcx0;
 

branches/snap-stage3/src/librustc/middle/trans/foreign.rs

@@ -725,24 +725,21 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
             }
 
             if !ty::type_is_nil(out_type) {
-                // NB: Do not use a Load and Store here. This causes massive
-                // code bloat when `transmute` is used on large structural
-                // types.
                 let lldestptr = fcx.llretptr.get();
-                let lldestptr = PointerCast(bcx, lldestptr, Type::i8p());
-
                 let llsrcval = get_param(decl, first_real_arg);
-                let llsrcptr = if ty::type_is_immediate(ccx.tcx, in_type) {
-                    let llsrcptr = alloca(bcx, llintype, "__llsrcptr");
-                    Store(bcx, llsrcval, llsrcptr);
-                    llsrcptr
+                if ty::type_is_immediate(ccx.tcx, in_type) {
+                    let lldestptr = PointerCast(bcx, lldestptr, llintype.ptr_to());
+                    Store(bcx, llsrcval, lldestptr);
                 } else {
-                    llsrcval
+                    // NB: Do not use a Load and Store here. This causes massive
+                    // code bloat when `transmute` is used on large structural
+                    // types.
+                    let lldestptr = PointerCast(bcx, lldestptr, Type::i8p());
+                    let llsrcptr = PointerCast(bcx, llsrcval, Type::i8p());
+
+                    let llsize = llsize_of(ccx, llintype);
+                    call_memcpy(bcx, lldestptr, llsrcptr, llsize, 1);
                 };
-                let llsrcptr = PointerCast(bcx, llsrcptr, Type::i8p());
-
-                let llsize = llsize_of(ccx, llintype);
-                call_memcpy(bcx, lldestptr, llsrcptr, llsize, 1);
             }
         }
         "needs_drop" => {

branches/snap-stage3/src/librustc/middle/typeck/check/regionck.rs

@@ -48,10 +48,7 @@ use syntax::visit;
 
 pub struct Rcx {
     fcx: @mut FnCtxt,
-    errors_reported: uint,
-
-    // id of innermost fn or loop
-    repeating_scope: ast::node_id,
+    errors_reported: uint
 }
 
 pub type rvt = visit::vt<@mut Rcx>;
@@ -81,12 +78,6 @@ impl Rcx {
         self.fcx.ccx.tcx
     }
 
-    pub fn set_repeating_scope(&mut self, scope: ast::node_id) -> ast::node_id {
-        let old_scope = self.repeating_scope;
-        self.repeating_scope = scope;
-        old_scope
-    }
-
     pub fn resolve_type(&mut self, unresolved_ty: ty::t) -> ty::t {
         /*!
          * Try to resolve the type for the given node, returning
@@ -143,8 +134,7 @@ impl Rcx {
 }
 
 pub fn regionck_expr(fcx: @mut FnCtxt, e: @ast::expr) {
-    let rcx = @mut Rcx { fcx: fcx, errors_reported: 0,
-                         repeating_scope: e.id };
+    let rcx = @mut Rcx { fcx: fcx, errors_reported: 0 };
     if fcx.err_count_since_creation() == 0 {
         // regionck assumes typeck succeeded
         let v = regionck_visitor();
@@ -154,8 +144,7 @@ pub fn regionck_expr(fcx: @mut FnCtxt, e: @ast::expr) {
 }
 
 pub fn regionck_fn(fcx: @mut FnCtxt, blk: &ast::blk) {
-    let rcx = @mut Rcx { fcx: fcx, errors_reported: 0,
-                         repeating_scope: blk.node.id };
+    let rcx = @mut Rcx { fcx: fcx, errors_reported: 0 };
     if fcx.err_count_since_creation() == 0 {
         // regionck assumes typeck succeeded
         let v = regionck_visitor();
@@ -242,8 +231,7 @@ fn constrain_bindings_in_pat(pat: @ast::pat, rcx: @mut Rcx) {
 }
 
 fn visit_expr(expr: @ast::expr, (rcx, v): (@mut Rcx, rvt)) {
-    debug!("regionck::visit_expr(e=%s, repeating_scope=%?)",
-           expr.repr(rcx.fcx.tcx()), rcx.repeating_scope);
+    debug!("regionck::visit_expr(e=?)");
 
     let has_method_map = rcx.fcx.inh.method_map.contains_key(&expr.id);
 
@@ -286,9 +274,6 @@ fn visit_expr(expr: @ast::expr, (rcx, v): (@mut Rcx, rvt)) {
                 }
             }
         }
-        ast::expr_loop(ref body, _) => {
-            tcx.region_maps.record_cleanup_scope(body.node.id);
-        }
         ast::expr_while(cond, ref body) => {
             tcx.region_maps.record_cleanup_scope(cond.id);
             tcx.region_maps.record_cleanup_scope(body.node.id);
@@ -328,14 +313,10 @@ fn visit_expr(expr: @ast::expr, (rcx, v): (@mut Rcx, rvt)) {
         ast::expr_call(callee, ref args, _) => {
             constrain_callee(rcx, callee.id, expr, callee);
             constrain_call(rcx, callee.id, expr, None, *args, false);
-
-            visit::visit_expr(expr, (rcx, v));
         }
 
         ast::expr_method_call(callee_id, arg0, _, _, ref args, _) => {
             constrain_call(rcx, callee_id, expr, Some(arg0), *args, false);
-
-            visit::visit_expr(expr, (rcx, v));
         }
 
         ast::expr_index(callee_id, lhs, rhs) |
@@ -346,31 +327,23 @@ fn visit_expr(expr: @ast::expr, (rcx, v): (@mut Rcx, rvt)) {
             // implicit "by ref" sort of passing style here.  This
             // should be converted to an adjustment!
             constrain_call(rcx, callee_id, expr, Some(lhs), [rhs], true);
-
-            visit::visit_expr(expr, (rcx, v));
         }
 
         ast::expr_unary(callee_id, _, lhs) if has_method_map => {
             // As above.
             constrain_call(rcx, callee_id, expr, Some(lhs), [], true);
-
-            visit::visit_expr(expr, (rcx, v));
         }
 
         ast::expr_unary(_, ast::deref, base) => {
             // For *a, the lifetime of a must enclose the deref
             let base_ty = rcx.resolve_node_type(base.id);
             constrain_derefs(rcx, expr, 1, base_ty);
-
-            visit::visit_expr(expr, (rcx, v));
         }
 
         ast::expr_index(_, vec_expr, _) => {
             // For a[b], the lifetime of a must enclose the deref
             let vec_type = rcx.resolve_expr_type_adjusted(vec_expr);
             constrain_index(rcx, expr, vec_type);
-
-            visit::visit_expr(expr, (rcx, v));
         }
 
         ast::expr_cast(source, _) => {
@@ -399,8 +372,6 @@ fn visit_expr(expr: @ast::expr, (rcx, v): (@mut Rcx, rvt)) {
                 }
                 _ => ()
             }
-
-            visit::visit_expr(expr, (rcx, v));
         }
 
         ast::expr_addr_of(_, base) => {
@@ -416,87 +387,29 @@ fn visit_expr(expr: @ast::expr, (rcx, v): (@mut Rcx, rvt)) {
             let ty0 = rcx.resolve_node_type(expr.id);
             constrain_regions_in_type(rcx, ty::re_scope(expr.id),
                                       infer::AddrOf(expr.span), ty0);
-            visit::visit_expr(expr, (rcx, v));
         }
 
         ast::expr_match(discr, ref arms) => {
             guarantor::for_match(rcx, discr, *arms);
-
-            visit::visit_expr(expr, (rcx, v));
-        }
-
-        ast::expr_loop_body(subexpr) => {
-            check_expr_fn_block(rcx, subexpr, v, true);
         }
 
         ast::expr_fn_block(*) => {
-            check_expr_fn_block(rcx, expr, v, false);
-        }
-
-        ast::expr_loop(ref body, _) => {
-            let repeating_scope = rcx.set_repeating_scope(body.node.id);
-            visit::visit_expr(expr, (rcx, v));
-            rcx.set_repeating_scope(repeating_scope);
-        }
-
-        ast::expr_while(cond, ref body) => {
-            let repeating_scope = rcx.set_repeating_scope(cond.id);
-            (v.visit_expr)(cond, (rcx, v));
-
-            rcx.set_repeating_scope(body.node.id);
-            (v.visit_block)(body, (rcx, v));
-
-            rcx.set_repeating_scope(repeating_scope);
-        }
-
-        _ => {
-            visit::visit_expr(expr, (rcx, v));
-        }
-    }
-}
-
-fn check_expr_fn_block(rcx: @mut Rcx,
-                       expr: @ast::expr,
-                       v: rvt,
-                       is_loop_body: bool) {
-    let tcx = rcx.fcx.tcx();
-    match expr.node {
-        ast::expr_fn_block(_, ref body) => {
+            // The lifetime of a block fn must not outlive the variables
+            // it closes over
             let function_type = rcx.resolve_node_type(expr.id);
             match ty::get(function_type).sty {
-                ty::ty_closure(
-                    ty::ClosureTy {
-                        sigil: ast::BorrowedSigil, region: region, _}) => {
-                    if get_freevars(tcx, expr.id).is_empty() && !is_loop_body {
-                        // No free variables means that the environment
-                        // will be NULL at runtime and hence the closure
-                        // has static lifetime.
-                    } else {
-                        // Otherwise, the closure must not outlive the
-                        // variables it closes over, nor can it
-                        // outlive the innermost repeating scope
-                        // (since otherwise that would require
-                        // infinite stack).
-                        constrain_free_variables(rcx, region, expr);
-                        let repeating_scope = ty::re_scope(rcx.repeating_scope);
-                        rcx.fcx.mk_subr(true, infer::InfStackClosure(expr.span),
-                                        region, repeating_scope);
-                    }
+                ty::ty_closure(ty::ClosureTy {sigil: ast::BorrowedSigil,
+                                              region: region, _}) => {
+                    constrain_free_variables(rcx, region, expr);
                 }
                 _ => ()
             }
-
-            let repeating_scope = rcx.set_repeating_scope(body.node.id);
-            visit::visit_expr(expr, (rcx, v));
-            rcx.set_repeating_scope(repeating_scope);
         }
 
-        _ => {
-            tcx.sess.span_bug(
-                expr.span,
-                "Expected expr_fn_block");
-        }
+        _ => ()
     }
+
+    visit::visit_expr(expr, (rcx, v));
 }
 
 fn constrain_callee(rcx: @mut Rcx,

branches/snap-stage3/src/librustc/middle/typeck/infer/error_reporting.rs

@@ -231,21 +231,6 @@ impl ErrorReporting for InferCtxt {
                     sup,
                     "");
             }
-            infer::InfStackClosure(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    "closure outlives stack frame");
-                note_and_explain_region(
-                    self.tcx,
-                    "...the closure must be valid for ",
-                    sub,
-                    "...");
-                note_and_explain_region(
-                    self.tcx,
-                    "...but the closure's stack frame is only valid for ",
-                    sup,
-                    "");
-            }
             infer::InvokeClosure(span) => {
                 self.tcx.sess.span_err(
                     span,

branches/snap-stage3/src/librustc/middle/typeck/infer/mod.rs

@@ -141,10 +141,6 @@ pub enum SubregionOrigin {
     // Arose from a subtyping relation
     Subtype(TypeTrace),
 
-    // Stack-allocated closures cannot outlive innermost loop
-    // or function so as to ensure we only require finite stack
-    InfStackClosure(span),
-
     // Invocation of closure must be within its lifetime
     InvokeClosure(span),
 
@@ -833,7 +829,6 @@ impl SubregionOrigin {
     pub fn span(&self) -> span {
         match *self {
             Subtype(a) => a.span(),
-            InfStackClosure(a) => a,
             InvokeClosure(a) => a,
             DerefPointer(a) => a,
             FreeVariable(a) => a,
@@ -855,7 +850,6 @@ impl Repr for SubregionOrigin {
     fn repr(&self, tcx: ty::ctxt) -> ~str {
         match *self {
             Subtype(a) => fmt!("Subtype(%s)", a.repr(tcx)),
-            InfStackClosure(a) => fmt!("InfStackClosure(%s)", a.repr(tcx)),
             InvokeClosure(a) => fmt!("InvokeClosure(%s)", a.repr(tcx)),
             DerefPointer(a) => fmt!("DerefPointer(%s)", a.repr(tcx)),
             FreeVariable(a) => fmt!("FreeVariable(%s)", a.repr(tcx)),