distinguish "any closure" and "stack closure" (block)

Author: nikomatsakis

src/comp/metadata/tydecode.rs

@@ -161,6 +161,17 @@ fn parse_ty_rust_fn(st: @pstate, conv: conv_did, p: ast::proto) -> ty::t {
     ret ty::mk_fn(st.tcx, {proto: p with parse_ty_fn(st, conv)});
 }
 
+fn parse_proto(c: char) -> ast::proto {
+    alt c {
+      '~' { ast::proto_uniq }
+      '@' { ast::proto_box }
+      '*' { ast::proto_any }
+      '&' { ast::proto_block }
+      'n' { ast::proto_bare }
+      _ { fail "illegal fn type kind " + str::from_char(c); }
+    }
+}
+
 fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
     alt next(st) as char {
       'n' { ret ty::mk_nil(st.tcx); }
@@ -230,17 +241,9 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         st.pos = st.pos + 1u;
         ret ty::mk_tup(st.tcx, params);
       }
-      's' {
-        ret parse_ty_rust_fn(st, conv, ast::proto_uniq);
-      }
-      'F' {
-        ret parse_ty_rust_fn(st, conv, ast::proto_box);
-      }
       'f' {
-        ret parse_ty_rust_fn(st, conv, ast::proto_bare);
-      }
-      'B' {
-        ret parse_ty_rust_fn(st, conv, ast::proto_block);
+        let proto = parse_proto(next(st) as char);
+        parse_ty_rust_fn(st, conv, proto)
       }
       'N' {
         let func = parse_ty_fn(st, conv);

src/comp/metadata/tyencode.rs

@@ -192,10 +192,11 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
 }
 fn enc_proto(w: io::writer, proto: proto) {
     alt proto {
-      proto_uniq. { w.write_char('s'); }
-      proto_box. { w.write_char('F'); }
-      proto_block. { w.write_char('B'); }
-      proto_bare. { w.write_char('f'); }
+      proto_uniq. { w.write_str("f~"); }
+      proto_box. { w.write_str("f@"); }
+      proto_block. { w.write_str("f&"); }
+      proto_any. { w.write_str("f*"); }
+      proto_bare. { w.write_str("fn"); }
     }
 }
 

src/comp/middle/alias.rs

@@ -88,11 +88,14 @@ fn visit_fn(cx: @ctx, _fk: visit::fn_kind, decl: ast::fn_decl,
     // Blocks need to obey any restrictions from the enclosing scope, and may
     // be called multiple times.
     let proto = ty::ty_fn_proto(cx.tcx, fty);
-    if proto == ast::proto_block {
+    alt proto {
+      ast::proto_block. | ast::proto_any. {
         check_loop(*cx, sc) {|| v.visit_block(body, sc, v);}
-    } else {
+      }
+      ast::proto_box. | ast::proto_uniq. | ast::proto_bare. {
         let sc = {bs: [], invalid: @mutable list::nil};
         v.visit_block(body, sc, v);
+      }
     }
 }
 

src/comp/middle/block_use.rs

@@ -14,7 +14,7 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) {
 fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
     if !cx.allow_block {
         alt ty::struct(cx.tcx, ty::expr_ty(cx.tcx, ex)) {
-          ty::ty_fn({proto: proto_block., _}) {
+          ty::ty_fn({proto: p, _}) if is_blockish(p) {
             cx.tcx.sess.span_err(ex.span, "expressions with block type \
                 can only appear in callee or (by-ref) argument position");
           }

src/comp/middle/capture.rs

@@ -75,7 +75,7 @@ fn check_capture_clause(tcx: ty::ctxt,
     };
 
     alt fn_proto {
-      ast::proto_block. {
+      ast::proto_any. | ast::proto_block. {
         check_block_captures(cap_clause.copies);
         check_block_captures(cap_clause.moves);
       }
@@ -113,7 +113,7 @@ fn compute_capture_vars(tcx: ty::ctxt,
     }
 
     let implicit_mode = alt fn_proto {
-      ast::proto_block. { cap_ref }
+      ast::proto_any. | ast::proto_block. { cap_ref }
       ast::proto_bare. | ast::proto_box. | ast::proto_uniq. { cap_copy }
     };
 

src/comp/middle/kind.rs

@@ -63,8 +63,8 @@ fn with_appropriate_checker(cx: ctx, id: node_id,
     alt ty::ty_fn_proto(cx.tcx, fty) {
       proto_uniq. { b(check_send); }
       proto_box. { b(check_copy); }
-      proto_block. { /* no check needed */ }
       proto_bare. { b(check_none); }
+      proto_any. | proto_block. { /* no check needed */ }
     }
 }
 

src/comp/middle/last_use.rs

@@ -63,9 +63,9 @@ fn find_last_uses(c: @crate, def_map: resolve::def_map,
     ret mini_table;
 }
 
-fn is_block(cx: ctx, id: node_id) -> bool {
+fn ex_is_blockish(cx: ctx, id: node_id) -> bool {
     alt ty::struct(cx.tcx, ty::node_id_to_monotype(cx.tcx, id)) {
-      ty::ty_fn({proto: proto_block., _}) { true }
+      ty::ty_fn({proto: p, _}) if is_blockish(p) { true }
       _ { false }
     }
 }
@@ -152,8 +152,12 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
         let arg_ts = ty::ty_fn_args(cx.tcx, ty::expr_ty(cx.tcx, f));
         for arg in args {
             alt arg.node {
-              expr_fn(proto_block., _, _, _) { fns += [arg]; }
-              expr_fn_block(_, _) if is_block(cx, arg.id) { fns += [arg]; }
+              expr_fn(p, _, _, _) if is_blockish(p) {
+                fns += [arg];
+              }
+              expr_fn_block(_, _) if ex_is_blockish(cx, arg.id) {
+                fns += [arg];
+              }
               _ {
                 alt arg_ts[i].mode {
                   by_mut_ref. { clear_if_path(cx, arg, v, false); }
@@ -174,11 +178,13 @@ fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
             cx: ctx, v: visit::vt<ctx>) {
     let fty = ty::node_id_to_type(cx.tcx, id);
     let proto = ty::ty_fn_proto(cx.tcx, fty);
-    if proto == proto_block {
+    alt proto {
+      proto_any. | proto_block. {
         visit_block(func, cx, {||
             visit::visit_fn(fk, decl, body, sp, id, cx, v);
         });
-    } else {
+      }
+      proto_box. | proto_uniq. | proto_bare. {
         alt cx.tcx.freevars.find(id) {
           some(vars) {
             for v in *vars {
@@ -193,6 +199,7 @@ fn visit_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
         visit::visit_fn(fk, decl, body, sp, id, cx, v);
         cx.blocks <-> old;
         leave_fn(cx);
+      }
     }
 }
 

src/comp/middle/mut.rs

@@ -269,7 +269,7 @@ fn is_immutable_def(cx: @ctx, def: def) -> option::t<str> {
         let ty = ty::node_id_to_monotype(cx.tcx, node_id);
         let proto = ty::ty_fn_proto(cx.tcx, ty);
         ret alt proto {
-          proto_block. { is_immutable_def(cx, *inner) }
+          proto_any. | proto_block. { is_immutable_def(cx, *inner) }
           _ { some("upvar") }
         };
       }

src/comp/middle/trans_closure.rs

@@ -523,6 +523,7 @@ fn trans_expr_fn(bcx: @block_ctxt,
     };
 
     let closure = alt proto {
+      ast::proto_any. { fail "proto_any cannot appear in an expr"; }
       ast::proto_block. { trans_closure_env(ty::ck_block) }
       ast::proto_box. { trans_closure_env(ty::ck_box) }
       ast::proto_uniq. { trans_closure_env(ty::ck_uniq) }
@@ -664,6 +665,7 @@ fn make_fn_glue(
     ret alt ty::struct(tcx, t) {
       ty::ty_native_fn(_, _) | ty::ty_fn({proto: ast::proto_bare., _}) { bcx }
       ty::ty_fn({proto: ast::proto_block., _}) { bcx }
+      ty::ty_fn({proto: ast::proto_any., _}) { bcx }
       ty::ty_fn({proto: ast::proto_uniq., _}) { fn_env(ty::ck_uniq) }
       ty::ty_fn({proto: ast::proto_box., _}) { fn_env(ty::ck_box) }
       _ { fail "make_fn_glue invoked on non-function type" }

src/comp/middle/ty.rs

@@ -993,6 +993,7 @@ pure fn kind_can_be_sent(k: kind) -> bool {
 
 fn proto_kind(p: proto) -> kind {
     alt p {
+      ast::proto_any. { kind_noncopyable }
       ast::proto_block. { kind_noncopyable }
       ast::proto_box. { kind_copyable }
       ast::proto_uniq. { kind_sendable }
@@ -1925,7 +1926,8 @@ mod unify {
         // subtype).
         fn sub_proto(p_sub: ast::proto, p_sup: ast::proto) -> bool {
             ret alt (p_sub, p_sup) {
-              (_, ast::proto_block.) { true }
+              (_, ast::proto_any.) { true }
+              (_, ast::proto_block.) { true } /* NDM temporary */
               (ast::proto_bare., _) { true }
 
               // Equal prototypes are always subprotos: