---

yaml
---
r: 23136
b: refs/heads/master
c: 0101125
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 99942ae430738ba43a2896973fa7f1a8ffe445a2
+refs/heads/master: 0101125a962abae18525d6014cd26ad10bbb96e6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/rustc/metadata/tydecode.rs

@@ -85,13 +85,11 @@ fn parse_ty_rust_fn(st: @pstate, conv: conv_did) -> ty::t {
     return ty::mk_fn(st.tcx, parse_ty_fn(st, conv));
 }
 
-fn parse_proto(c: char) -> ast::proto {
-    match c {
-      '~' => ast::proto_uniq,
-      '@' => ast::proto_box,
-      '&' => ast::proto_block,
-      'n' => ast::proto_bare,
-      _ => fail ~"illegal fn type kind " + str::from_char(c)
+fn parse_proto(st: @pstate) -> ty::fn_proto {
+    match next(st) {
+        'n' => ty::proto_bare,
+        'v' => ty::proto_vstore(parse_vstore(st)),
+        c => fail ~"illegal proto type kind " + str::from_char(c)
     }
 }
 
@@ -360,7 +358,7 @@ fn parse_purity(c: char) -> purity {
 }
 
 fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty {
-    let proto = parse_proto(next(st));
+    let proto = parse_proto(st);
     let purity = parse_purity(next(st));
     let bounds = parse_bounds(st, conv);
     assert (next(st) == '[');

trunk/src/rustc/metadata/tyencode.rs

@@ -306,12 +306,15 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
       }
     }
 }
-fn enc_proto(w: io::writer, proto: proto) {
+
+fn enc_proto(w: io::writer, cx: @ctxt, proto: ty::fn_proto) {
+    w.write_str(&"f");
     match proto {
-      proto_uniq => w.write_str(&"f~"),
-      proto_box => w.write_str(&"f@"),
-      proto_block => w.write_str(~"f&"),
-      proto_bare => w.write_str(&"fn")
+        ty::proto_bare => w.write_str(&"n"),
+        ty::proto_vstore(vstore) => {
+            w.write_str(&"v");
+            enc_vstore(w, cx, vstore);
+        }
     }
 }
 
@@ -335,7 +338,7 @@ fn enc_purity(w: io::writer, p: purity) {
 }
 
 fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) {
-    enc_proto(w, ft.proto);
+    enc_proto(w, cx, ft.proto);
     enc_purity(w, ft.purity);
     enc_bounds(w, cx, ft.bounds);
     w.write_char('[');

trunk/src/rustc/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 {
         match ty::get(ty::expr_ty(cx.tcx, ex)).struct {
-          ty::ty_fn({proto: p, _}) if is_blockish(p) => {
+          ty::ty_fn({proto: p, _}) if ty::is_blockish(p) => {
             cx.tcx.sess.span_err(ex.span,
                ~"expressions with stack closure type \
                 can only appear in callee or (by-ref) argument position");

trunk/src/rustc/middle/borrowck/check_loans.rs

@@ -218,10 +218,7 @@ impl check_loan_ctxt {
     fn is_stack_closure(id: ast::node_id) -> bool {
         let fn_ty = ty::node_id_to_type(self.tcx(), id);
         let proto = ty::ty_fn_proto(fn_ty);
-        match proto {
-          ast::proto_block => true,
-          ast::proto_bare | ast::proto_uniq | ast::proto_box => false
-        }
+        return ty::is_blockish(proto);
     }
 
     fn is_allowed_pure_arg(expr: @ast::expr) -> bool {

trunk/src/rustc/middle/capture.rs

@@ -59,7 +59,7 @@ fn check_capture_clause(tcx: ty::ctxt,
 
 fn compute_capture_vars(tcx: ty::ctxt,
                         fn_expr_id: ast::node_id,
-                        fn_proto: ast::proto,
+                        fn_proto: ty::fn_proto,
                         cap_clause: ast::capture_clause) -> ~[capture_var] {
     let freevars = freevars::get_freevars(tcx, fn_expr_id);
     let cap_map = map::int_hash();
@@ -101,10 +101,12 @@ fn compute_capture_vars(tcx: ty::ctxt,
     // now go through anything that is referenced but was not explicitly
     // named and add that
 
-    let implicit_mode = match fn_proto {
-      ast::proto_block => cap_ref,
-      ast::proto_bare | ast::proto_box | ast::proto_uniq => cap_copy
-    };
+    let implicit_mode;
+    if ty::is_blockish(fn_proto) {
+        implicit_mode = cap_ref;
+    } else {
+        implicit_mode = cap_copy;
+    }
 
     do vec::iter(*freevars) |fvar| {
         let fvar_def_id = ast_util::def_id_of_def(fvar.def).node;

trunk/src/rustc/middle/check_loop.rs

@@ -25,7 +25,8 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) {
                 v.visit_block(b, {in_loop: false, can_ret: false}, v);
               }
               expr_loop_body(@{node: expr_fn_block(_, b, _), _}) => {
-                let blk = is_blockish(ty::ty_fn_proto(ty::expr_ty(tcx, e)));
+                let blk = ty::is_blockish(ty::ty_fn_proto(ty::expr_ty(tcx,
+                                                                      e)));
                 v.visit_block(b, {in_loop: true, can_ret: blk}, v);
               }
               expr_break => {

trunk/src/rustc/middle/kind.rs

@@ -144,10 +144,12 @@ fn with_appropriate_checker(cx: ctx, id: node_id, b: fn(check_fn)) {
 
     let fty = ty::node_id_to_type(cx.tcx, id);
     match ty::ty_fn_proto(fty) {
-      proto_uniq => b(check_for_uniq),
-      proto_box => b(check_for_box),
-      proto_bare => b(check_for_bare),
-      proto_block => b(check_for_block)
+      ty::proto_vstore(ty::vstore_uniq) => b(check_for_uniq),
+      ty::proto_vstore(ty::vstore_box) => b(check_for_box),
+      ty::proto_bare => b(check_for_bare),
+      ty::proto_vstore(ty::vstore_slice(_)) => b(check_for_block),
+      ty::proto_vstore(ty::vstore_fixed(_)) =>
+        fail ~"fixed vstore not allowed here"
     }
 }
 

trunk/src/rustc/middle/mem_categorization.rs

@@ -383,18 +383,22 @@ impl &mem_categorization_ctxt {
             let ty = ty::node_id_to_type(self.tcx, fn_node_id);
             let proto = ty::ty_fn_proto(ty);
             match proto {
-              ast::proto_block => {
+              ty::proto_vstore(ty::vstore_slice(_)) => {
                 let upcmt = self.cat_def(id, span, expr_ty, *inner);
                 @{id:id, span:span,
                   cat:cat_stack_upvar(upcmt), lp:upcmt.lp,
                   mutbl:upcmt.mutbl, ty:upcmt.ty}
               }
-              ast::proto_bare | ast::proto_uniq | ast::proto_box => {
+              ty::proto_bare |
+              ty::proto_vstore(ty::vstore_uniq) |
+              ty::proto_vstore(ty::vstore_box) => {
                 // FIXME #2152 allow mutation of moved upvars
                 @{id:id, span:span,
                   cat:cat_special(sk_heap_upvar), lp:none,
                   mutbl:m_imm, ty:expr_ty}
               }
+              ty::proto_vstore(ty::vstore_fixed(_)) =>
+                fail ~"fixed vstore not allowed here"
             }
           }
 

trunk/src/rustc/middle/trans/base.rs

@@ -2043,7 +2043,8 @@ fn normalize_for_monomorphization(tcx: ty::ctxt, ty: ty::t) -> option<ty::t> {
       }
       ty::ty_trait(_, _) => {
         some(ty::mk_fn(tcx, {purity: ast::impure_fn,
-                             proto: ast::proto_box,
+                             proto: ty::proto_vstore(ty::vstore_slice
+                                                     (ty::re_static)),
                              bounds: @~[],
                              inputs: ~[],
                              output: ty::mk_nil(tcx),
@@ -3774,8 +3775,11 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
           }
           ast::expr_addr_of(_, x) => { return trans_addr_of(bcx, x, dest); }
           ast::expr_fn(proto, decl, body, cap_clause) => {
-            return closure::trans_expr_fn(bcx, proto, decl, body, e.id,
-                                       cap_clause, none, dest);
+            // XXX: This syntax should be reworked a bit (in the parser I
+            // guess?); @fn() { ... } won't work.
+            return closure::trans_expr_fn(bcx, ty::ast_proto_to_proto(proto),
+                                          decl, body, e.id, cap_clause, none,
+                                          dest);
           }
           ast::expr_fn_block(decl, body, cap_clause) => {
             match check ty::get(expr_ty(bcx, e)).struct {

trunk/src/rustc/middle/trans/closure.rs

@@ -347,7 +347,7 @@ fn load_environment(fcx: fn_ctxt,
 }
 
 fn trans_expr_fn(bcx: block,
-                 proto: ast::proto,
+                 proto: ty::fn_proto,
                  decl: ast::fn_decl,
                  body: ast::blk,
                  id: ast::node_id,
@@ -364,8 +364,8 @@ fn trans_expr_fn(bcx: block,
     let llfn = decl_internal_cdecl_fn(ccx.llmod, s, llfnty);
 
     let trans_closure_env = fn@(ck: ty::closure_kind) -> result {
-        let cap_vars = capture::compute_capture_vars(
-            ccx.tcx, id, proto, cap_clause);
+        let cap_vars = capture::compute_capture_vars(ccx.tcx, id, proto,
+                                                     cap_clause);
         let ret_handle = match is_loop_body { some(x) => x, none => none };
         let {llbox, cdata_ty, bcx} = build_closure(bcx, cap_vars, ck, id,
                                                    ret_handle);
@@ -382,14 +382,19 @@ fn trans_expr_fn(bcx: block,
     };
 
     let {bcx: bcx, val: closure} = match proto {
-      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),
-      ast::proto_bare => {
+      ty::proto_vstore(ty::vstore_slice(_)) =>
+        trans_closure_env(ty::ck_block),
+      ty::proto_vstore(ty::vstore_box) =>
+        trans_closure_env(ty::ck_box),
+      ty::proto_vstore(ty::vstore_uniq) =>
+        trans_closure_env(ty::ck_uniq),
+      ty::proto_bare => {
         trans_closure(ccx, sub_path, decl, body, llfn, no_self, none,
                       id, |_fcx| { }, |_bcx| { });
         {bcx: bcx, val: C_null(T_opaque_box_ptr(ccx))}
       }
+      ty::proto_vstore(ty::vstore_fixed(_)) =>
+        fail ~"vstore_fixed unexpected"
     };
     fill_fn_pair(bcx, get_dest_addr(dest), llfn, closure);
 
@@ -416,11 +421,15 @@ fn make_fn_glue(
     };
 
     return match ty::get(t).struct {
-      ty::ty_fn({proto: ast::proto_bare, _}) |
-      ty::ty_fn({proto: ast::proto_block, _}) => 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"
+      ty::ty_fn({proto: ty::proto_bare, _}) |
+      ty::ty_fn({proto: ty::proto_vstore(ty::vstore_slice(_)), _}) =>
+        bcx,
+      ty::ty_fn({proto: ty::proto_vstore(ty::vstore_uniq), _}) =>
+        fn_env(ty::ck_uniq),
+      ty::ty_fn({proto: ty::proto_vstore(ty::vstore_box), _}) =>
+        fn_env(ty::ck_box),
+      _ =>
+        fail ~"make_fn_glue invoked on non-function type"
     };
 }
 

trunk/src/rustc/middle/trans/foreign.rs

@@ -960,7 +960,7 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item,
         let frameaddress_val = Call(bcx, frameaddress, ~[C_i32(0i32)]);
         let fty = ty::mk_fn(bcx.tcx(), {
             purity: ast::impure_fn,
-            proto: ast::proto_block,
+            proto: ty::proto_vstore(ty::vstore_slice(ty::re_static)),
             bounds: @~[],
             inputs: ~[{
                 mode: ast::expl(ast::by_val),

trunk/src/rustc/middle/trans/reflect.rs

@@ -185,10 +185,12 @@ impl reflector {
               ast::extern_fn => 3u
             };
             let protoval = match fty.proto {
-              ast::proto_bare => 0u,
-              ast::proto_uniq => 2u,
-              ast::proto_box => 3u,
-              ast::proto_block => 4u
+              ty::proto_bare => 0u,
+              ty::proto_vstore(ty::vstore_uniq) => 2u,
+              ty::proto_vstore(ty::vstore_box) => 3u,
+              ty::proto_vstore(ty::vstore_slice(_)) => 4u,
+              ty::proto_vstore(ty::vstore_fixed(_)) =>
+                fail ~"fixed unexpected"
             };
             let retval = match fty.ret_style {
               ast::noreturn => 0u,

trunk/src/rustc/middle/trans/shape.rs

@@ -351,14 +351,20 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] {
       ty::ty_param(*) => {
         ccx.tcx.sess.bug(~"non-monomorphized type parameter");
       }
-      ty::ty_fn({proto: ast::proto_box, _}) => ~[shape_box_fn],
-      ty::ty_fn({proto: ast::proto_uniq, _}) => ~[shape_uniq_fn],
-      ty::ty_fn({proto: ast::proto_block, _}) => ~[shape_stack_fn],
-      ty::ty_fn({proto: ast::proto_bare, _}) => ~[shape_bare_fn],
-      ty::ty_opaque_closure_ptr(_) => ~[shape_opaque_closure_ptr],
-      ty::ty_var(_) | ty::ty_var_integral(_) | ty::ty_self => {
-        ccx.sess.bug(~"shape_of: unexpected type struct found");
-      }
+      ty::ty_fn({proto: ty::proto_vstore(ty::vstore_box), _}) =>
+        ~[shape_box_fn],
+      ty::ty_fn({proto: ty::proto_vstore(ty::vstore_uniq), _}) =>
+        ~[shape_uniq_fn],
+      ty::ty_fn({proto: ty::proto_vstore(ty::vstore_slice(_)), _}) =>
+        ~[shape_stack_fn],
+      ty::ty_fn({proto: ty::proto_vstore(ty::vstore_fixed(_)), _}) =>
+        fail ~"fixed vstore is impossible",
+      ty::ty_fn({proto: ty::proto_bare, _}) =>
+        ~[shape_bare_fn],
+      ty::ty_opaque_closure_ptr(_) =>
+        ~[shape_opaque_closure_ptr],
+      ty::ty_var(_) | ty::ty_var_integral(_) | ty::ty_self =>
+        ccx.sess.bug(~"shape_of: unexpected type struct found")
     }
 }
 

trunk/src/rustc/middle/trans/type_use.rs

@@ -202,13 +202,16 @@ fn mark_for_expr(cx: ctx, e: @expr) {
       }
       expr_fn(*) | expr_fn_block(*) => {
         match ty::ty_fn_proto(ty::expr_ty(cx.ccx.tcx, e)) {
-          proto_bare | proto_uniq => {}
-          proto_box | proto_block => {
+          ty::proto_bare | ty::proto_vstore(ty::vstore_uniq) => {}
+          ty::proto_vstore(ty::vstore_box) |
+          ty::proto_vstore(ty::vstore_slice(_)) => {
             for vec::each(*freevars::get_freevars(cx.ccx.tcx, e.id)) |fv| {
                 let node_id = ast_util::def_id_of_def(fv.def).node;
                 node_type_needs(cx, use_repr, node_id);
             }
           }
+          ty::proto_vstore(ty::vstore_fixed(_)) =>
+            fail ~"vstore_fixed not allowed here"
         }
       }
       expr_assign(val, _) | expr_swap(val, _) | expr_assign_op(_, val, _) |