---

yaml
---
r: 3343
b: refs/heads/master
c: 61fc12d
h: refs/heads/master
i:
  3341: b67ad48
  3339: f231e5f
  3335: 51cac9d
  3327: a69d790
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 781a265b88f7fc3c8c406b327e8a548e742d6224
+refs/heads/master: 61fc12d0d0d1b8acb7472bfc6223882b32acd3d2

trunk/src/comp/front/ast.rs

@@ -335,7 +335,7 @@ tag ty_ {
      /* bot represents the value of functions that don't return a value
         locally to their context. in contrast, things like log that do
         return, but don't return a meaningful value, have result type nil. */
-     ty_bool;
+    ty_bool;
     ty_int;
     ty_uint;
     ty_float;
@@ -478,7 +478,7 @@ type attribute_ = rec(attr_style style, meta_item value);
 
 type item = rec(ident ident,
                 vec[attribute] attrs,
-                node_id id, // For objs, this is the type's def_id
+                node_id id, // For objs and resources, this is the type def_id
                 item_ node,
                 span span);
 
@@ -490,6 +490,8 @@ tag item_ {
     item_ty(@ty, vec[ty_param]);
     item_tag(vec[variant], vec[ty_param]);
     item_obj(_obj, vec[ty_param], node_id /* constructor id */);
+    item_res(_fn /* dtor */, node_id /* dtor id */,
+             vec[ty_param], node_id /* ctor id */);
 }
 
 type native_item = rec(ident ident,

trunk/src/comp/front/creader.rs

@@ -281,6 +281,11 @@ fn parse_ty(@pstate st, str_def sd) -> ty::t {
             st.pos += 1u;
             ret ty::mk_obj(st.tcx, methods);
         }
+        case ('r') {
+            auto def = parse_def(st, sd);
+            auto inner = parse_ty(st, sd);
+            ret ty::mk_res(st.tcx, def, inner);
+        }
         case ('X') { ret ty::mk_var(st.tcx, parse_int(st)); }
         case ('E') { ret ty::mk_native(st.tcx); }
         case ('Y') { ret ty::mk_type(st.tcx); }

trunk/src/comp/front/parser.rs

@@ -139,6 +139,7 @@ fn bad_expr_word_table() -> hashmap[str, ()] {
     words.insert("be", ());
     words.insert("fail", ());
     words.insert("type", ());
+    words.insert("res", ());
     words.insert("check", ());
     words.insert("assert", ());
     words.insert("claim", ());
@@ -1656,7 +1657,6 @@ fn parse_ty_params(&parser p) -> vec[ast::ty_param] {
 }
 
 fn parse_fn_decl(&parser p, ast::purity purity) -> ast::fn_decl {
-    auto pf = parse_arg;
     let util::common::spanned[vec[ast::arg]] inputs =
         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_arg,
                   p);
@@ -1765,10 +1765,9 @@ fn parse_item_obj(&parser p, ast::layer lyr, vec[ast::attribute] attrs) ->
     auto lo = p.get_last_lo_pos();
     auto ident = parse_value_ident(p);
     auto ty_params = parse_ty_params(p);
-    auto pf = parse_obj_field;
     let util::common::spanned[vec[ast::obj_field]] fields =
         parse_seq[ast::obj_field](token::LPAREN, token::RPAREN,
-                                  some(token::COMMA), pf, p);
+                                  some(token::COMMA), parse_obj_field, p);
     let vec[@ast::method] meths = [];
     let option::t[@ast::method] dtor = none;
     expect(p, token::LBRACE);
@@ -1784,6 +1783,27 @@ fn parse_item_obj(&parser p, ast::layer lyr, vec[ast::attribute] attrs) ->
                                                 p.get_id()), attrs);
 }
 
+fn parse_item_res(&parser p, ast::layer lyr, vec[ast::attribute] attrs) ->
+   @ast::item {
+    auto lo = p.get_last_lo_pos();
+    auto ident = parse_value_ident(p);
+    auto ty_params = parse_ty_params(p);
+    expect(p, token::LPAREN);
+    auto t = parse_ty(p);
+    auto arg_ident = parse_value_ident(p);
+    expect(p, token::RPAREN);
+    auto dtor = parse_block(p);
+    auto decl = rec(inputs=[rec(mode=ast::alias(false), ty=t, ident=arg_ident,
+                                id=p.get_id())],
+                    output=@spanned(lo, lo, ast::ty_nil),
+                    purity=ast::impure_fn,
+                    cf=ast::return,
+                    constraints=[]);
+    auto f = rec(decl=decl, proto=ast::proto_fn, body=dtor);
+    ret mk_item(p, lo, dtor.span.hi, ident,
+                ast::item_res(f, p.get_id(), ty_params, p.get_id()), attrs);
+}
+
 fn parse_mod_items(&parser p, token::token term,
                    vec[ast::attribute] first_item_attrs) -> ast::_mod {
     auto view_items = if (vec::len(first_item_attrs) == 0u) {
@@ -2028,6 +2048,8 @@ fn parse_item(&parser p, vec[ast::attribute] attrs) -> parsed_item {
         ret got_item(parse_item_tag(p, attrs));
     } else if (eat_word(p, "obj")) {
         ret got_item(parse_item_obj(p, lyr, attrs));
+    } else if (eat_word(p, "res")) {
+        ret got_item(parse_item_res(p, lyr, attrs));
     } else { ret no_item; }
 }
 

trunk/src/comp/middle/metadata.rs

@@ -231,6 +231,12 @@ mod encode {
                 }
                 w.write_char(']');
             }
+            case (ty::ty_res(?def, ?ty)) {
+                w.write_char('r');
+                w.write_str(cx.ds(def));
+                w.write_char('|');
+                enc_ty(w, cx, ty);
+            }
             case (ty::ty_var(?id)) {
                 w.write_char('X');
                 w.write_str(common::istr(id));
@@ -393,6 +399,18 @@ fn encode_module_item_paths(&ebml::writer ebml_w, &_mod module,
                 encode_def_id(ebml_w, local_def(it.id));
                 ebml::end_tag(ebml_w);
             }
+            case (item_res(_, _, ?tps, ?ctor_id)) {
+                add_to_index(ebml_w, path, index, it.ident);
+                ebml::start_tag(ebml_w, tag_paths_data_item);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, local_def(ctor_id));
+                ebml::end_tag(ebml_w);
+                add_to_index(ebml_w, path, index, it.ident);
+                ebml::start_tag(ebml_w, tag_paths_data_item);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, local_def(it.id));
+                ebml::end_tag(ebml_w);
+            }
             case (item_tag(?variants, ?tps)) {
                 add_to_index(ebml_w, path, index, it.ident);
                 ebml::start_tag(ebml_w, tag_paths_data_item);
@@ -553,6 +571,23 @@ fn encode_info_for_item(@trans::crate_ctxt cx, &ebml::writer ebml_w,
             encode_tag_variant_info(cx, ebml_w, item.id, variants, index,
                                     tps);
         }
+        case (item_res(_, _, ?tps, ?ctor_id)) {
+            ebml::start_tag(ebml_w, tag_items_data_item);
+            encode_def_id(ebml_w, local_def(ctor_id));
+            encode_kind(ebml_w, 'f' as u8);
+            encode_type_param_count(ebml_w, tps);
+            auto fn_ty = trans::node_id_type(cx, item.id);
+            encode_type(cx, ebml_w, fn_ty);
+            encode_symbol(cx, ebml_w, ctor_id);
+            ebml::end_tag(ebml_w);
+            index += [tup(item.id, ebml_w.writer.tell())];
+            ebml::start_tag(ebml_w, tag_items_data_item);
+            encode_def_id(ebml_w, local_def(item.id));
+            encode_kind(ebml_w, 'y' as u8);
+            encode_type_param_count(ebml_w, tps);
+            encode_type(cx, ebml_w, ty::ty_fn_ret(cx.tcx, fn_ty));
+            ebml::end_tag(ebml_w);
+        }
         case (item_obj(_, ?tps, ?ctor_id)) {
             ebml::start_tag(ebml_w, tag_items_data_item);
             encode_def_id(ebml_w, local_def(ctor_id));

trunk/src/comp/middle/resolve.rs

@@ -819,6 +819,14 @@ fn found_def_item(&@ast::item i, namespace ns) -> option::t[def] {
                 ret some(ast::def_ty(local_def(i.id)));
             }
         }
+        case (ast::item_res(_, _, _, ?ctor_id)) {
+            alt (ns) {
+                case (ns_value) { ret some(ast::def_fn(local_def(ctor_id),
+                                                       ast::impure_fn)); }
+                case (ns_type) { ret some(ast::def_ty(local_def(i.id))); }
+                case (_) { }
+            }
+        }
         case (ast::item_tag(_, _)) {
             if (ns == ns_type) {
                 ret some(ast::def_ty(local_def(i.id)));
@@ -1085,6 +1093,9 @@ fn index_mod(&ast::_mod md) -> mod_index {
             case (ast::item_ty(_, _)) {
                 add_to_index(index, it.ident, mie_item(it));
             }
+            case (ast::item_res(_, _, _, _)) {
+                add_to_index(index, it.ident, mie_item(it));
+            }
             case (ast::item_tag(?variants, _)) {
                 add_to_index(index, it.ident, mie_item(it));
                 let uint variant_idx = 0u;
@@ -1282,6 +1293,10 @@ fn check_block(@env e, &ast::block b, &() x, &vt[()] v) {
                             case (ast::item_ty(_, _)) {
                                 add_name(types, it.span, it.ident);
                             }
+                            case (ast::item_res(_, _, _, _)) {
+                                add_name(types, it.span, it.ident);
+                                add_name(values, it.span, it.ident);
+                            }
                             case (ast::item_obj(_, _, _)) {
                                 add_name(types, it.span, it.ident);
                                 add_name(values, it.span, it.ident);

trunk/src/comp/middle/trans.rs

@@ -881,6 +881,9 @@ fn type_of_inner(&@crate_ctxt cx, &span sp, &ty::t t) -> TypeRef {
             abs_pair = llvm::LLVMResolveTypeHandle(th.llth);
             llty = abs_pair;
         }
+        case (ty::ty_res(_, ?sub)) {
+            ret type_of_inner(cx, sp, sub);
+        }
         case (ty::ty_var(_)) {
             cx.tcx.sess.span_fatal(sp, "trans::type_of called on ty_var");
         }
@@ -1217,6 +1220,7 @@ fn simplify_type(&@crate_ctxt ccx, &ty::t typ) -> ty::t {
                                     ty::mk_imm_box(ccx.tcx,
                                                    ty::mk_nil(ccx.tcx))]);
             }
+            case (ty::ty_res(_, ?sub)) { ret simplify_type(ccx, sub);}
             case (_) { ret typ; }
         }
     }
@@ -2064,7 +2068,7 @@ fn make_drop_glue(&@block_ctxt cx, ValueRef v0, &ty::t t) {
         case (ty::ty_vec(_)) { decr_refcnt_maybe_free(cx, v0, v0, t) }
         case (ty::ty_ivec(?tm)) {
             auto v1;
-            if (ty::type_has_dynamic_size(cx.fcx.lcx.ccx.tcx, tm.ty)) {
+            if (ty::type_has_dynamic_size(ccx.tcx, tm.ty)) {
                 v1 = cx.build.PointerCast(v0, T_ptr(T_opaque_ivec()));
             } else {
                 v1 = v0;
@@ -2082,6 +2086,18 @@ fn make_drop_glue(&@block_ctxt cx, ValueRef v0, &ty::t t) {
                 cx.build.GEP(v0, [C_int(0), C_int(abi::obj_field_box)]);
             decr_refcnt_maybe_free(cx, box_cell, v0, t)
         }
+        case (ty::ty_res(?did, ?inner)) {
+            auto dtor = alt (ccx.ast_map.get(did._1)) {
+                case (ast_map::node_item(?i)) {
+                    alt (i.node) {
+                        case (ast::item_res(?dtor, _, _, _)) { dtor }
+                    }
+                }
+            };
+            cx.fcx.llargs.insert(dtor.decl.inputs.(0).id, v0);
+            auto rs = trans_block(cx, dtor.body, return);
+            drop_ty(rs.bcx, v0, inner)
+        }
         case (ty::ty_fn(_, _, _, _, _)) {
             auto box_cell =
                 cx.build.GEP(v0, [C_int(0), C_int(abi::fn_field_box)]);
@@ -2549,6 +2565,10 @@ fn iter_structural_ty_full(&@block_ctxt cx, ValueRef av, ValueRef bv,
                 i += 1;
             }
         }
+        case (ty::ty_res(_, ?inner)) {
+            f(r.bcx, load_if_immediate(r.bcx, av, inner),
+              load_if_immediate(r.bcx, bv, inner), inner);
+        }
         case (ty::ty_tag(?tid, ?tps)) {
             auto variants = ty::tag_variants(cx.fcx.lcx.ccx.tcx, tid);
             auto n_variants = vec::len[ty::variant_info](variants);
@@ -4633,12 +4653,10 @@ fn lval_generic_fn(&@block_ctxt cx, &ty::ty_param_count_and_ty tpt,
     auto lv;
     if (cx.fcx.lcx.ccx.sess.get_targ_crate_num() == fn_id._0) {
         // Internal reference.
-
         assert (cx.fcx.lcx.ccx.fn_pairs.contains_key(fn_id._1));
         lv = lval_val(cx, cx.fcx.lcx.ccx.fn_pairs.get(fn_id._1));
     } else {
         // External reference.
-
         lv = trans_external_path(cx, fn_id, tpt);
     }
     auto tys = ty::node_id_to_type_params(cx.fcx.lcx.ccx.tcx, id);
@@ -7621,6 +7639,26 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id,
     finish_fn(fcx, lltop);
 }
 
+fn trans_res(@local_ctxt cx, &span sp, &ast::_fn f, ast::node_id ctor_id,
+             &vec[ast::ty_param] ty_params) {
+    auto llctor_decl = cx.ccx.item_ids.get(ctor_id);
+    auto fcx = new_fn_ctxt(cx, sp, llctor_decl);
+    auto ret_ty = ty::ret_ty_of_fn(cx.ccx.tcx, ctor_id);
+    create_llargs_for_fn_args(fcx, ast::proto_fn, none[ty_self_pair],
+                              ret_ty, f.decl.inputs, ty_params);
+    auto bcx = new_top_block_ctxt(fcx);
+    auto lltop = bcx.llbb;
+    auto self_ty = ty::ret_ty_of_fn(cx.ccx.tcx, ctor_id);
+    auto llself_ty = type_of(cx.ccx, sp, self_ty);
+    auto arg_ty = arg_tys_of_fn(cx.ccx, ctor_id).(0).ty;
+    auto arg = load_if_immediate
+        (bcx, fcx.llargs.get(f.decl.inputs.(0).id), arg_ty);
+    bcx = copy_val(bcx, INIT, fcx.llretptr, arg, arg_ty).bcx;
+    bcx.build.RetVoid();
+    finish_fn(fcx, lltop);
+}
+
+
 fn trans_tag_variant(@local_ctxt cx, ast::node_id tag_id,
                      &ast::variant variant, int index,
                      &vec[ast::ty_param] ty_params) {
@@ -7729,6 +7767,9 @@ fn trans_item(@local_ctxt cx, &ast::item item) {
                      with *extend_path(cx, item.ident));
             trans_obj(sub_cx, item.span, ob, ctor_id, tps);
         }
+        case (ast::item_res(?decl, _, ?tps, ?ctor_id)) {
+            trans_res(cx, item.span, decl, ctor_id, tps);
+        }
         case (ast::item_mod(?m)) {
             auto sub_cx =
                 @rec(path=cx.path + [item.ident],
@@ -8062,6 +8103,9 @@ fn collect_item_2(&@crate_ctxt ccx, &@ast::item i, &vec[str] pt,
                 ccx.obj_methods.insert(m.node.id, ());
             }
         }
+        case (ast::item_res(?decl, _, ?tps, ?ctor_id)) {
+            decl_fn_and_pair(ccx, i.span, new_pt, "res_ctor", tps, ctor_id);
+        }
         case (_) { }
     }
 }

trunk/src/comp/middle/tstate/pre_post_conditions.rs

@@ -119,7 +119,7 @@ fn find_pre_post_item(&crate_ctxt ccx, &item i) {
                     ccx=ccx);
             find_pre_post_expr(fake_fcx, e);
         }
-        case (item_fn(?f, ?ps)) {
+        case (item_fn(?f, _)) {
             assert (ccx.fm.contains_key(i.id));
             auto fcx =
                 rec(enclosing=ccx.fm.get(i.id),
@@ -132,6 +132,13 @@ fn find_pre_post_item(&crate_ctxt ccx, &item i) {
         case (item_native_mod(?nm)) { find_pre_post_native_mod(nm); }
         case (item_ty(_, _)) { ret; }
         case (item_tag(_, _)) { ret; }
+        case (item_res(?dtor, ?dtor_id, _, _)) {
+            auto fcx = rec(enclosing=ccx.fm.get(dtor_id),
+                           id=dtor_id,
+                           name=i.ident,
+                           ccx=ccx);
+            find_pre_post_fn(fcx, dtor);
+        }
         case (item_obj(?o, _, _)) { find_pre_post_obj(ccx, o); }
     }
 }