Remove resources

Also fixed shapes for classes with dtors, as well as handling
offsets for classes with dtors correctly in take glue.

Closes #2485

Author: catamorphism

src/libsyntax/ast.rs

@@ -670,9 +670,6 @@ enum item_ {
     item_native_mod(native_mod),
     item_ty(@ty, [ty_param], region_param),
     item_enum([variant], [ty_param], region_param),
-    item_res(fn_decl /* dtor */, [ty_param], blk /* dtor body */,
-             node_id /* dtor id */, node_id /* ctor id */,
-             region_param),
     item_class([ty_param], /* ty params for class */
                [@iface_ref],   /* ifaces this class implements */
                [@class_member], /* methods, etc. */

src/libsyntax/ast_map.rs

@@ -43,18 +43,14 @@ enum ast_node {
     // order they are introduced.
     node_arg(arg, uint),
     node_local(uint),
-    // Constructor for either a resource or a class
-    node_ctor(ident, [ty_param], a_ctor, @path),
+    // Constructor for a class
+    // def_id is parent id
+    node_ctor(ident, [ty_param], @class_ctor, def_id, @path),
     // Destructor for a class
     node_dtor([ty_param], @class_dtor, def_id, @path),
     node_block(blk),
 }
 
-enum a_ctor {
-  res_ctor(fn_decl, node_id, codemap::span),
-  class_ctor(@class_ctor, def_id /* ID for parent class */),
-}
-
 type map = std::map::hashmap<node_id, ast_node>;
 type ctx = {map: map, mut path: path,
             mut local_id: uint, diag: span_handler};
@@ -138,7 +134,7 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
                     span: sp};
           cx.map.insert(id, node_ctor(/* FIXME (#2543) */ copy nm,
                                       /* FIXME (#2543) */ copy tps,
-                                      class_ctor(ct, parent_id),
+                                      ct, parent_id,
                                       @/* FIXME (#2543) */ copy cx.path));
        }
       visit::fk_dtor(tps, self_id, parent_id) {
@@ -199,15 +195,6 @@ fn map_item(i: @item, cx: ctx, v: vt) {
                        cx);
         }
       }
-      item_res(decl, tps, _, dtor_id, ctor_id, _) {
-        cx.map.insert(ctor_id, node_ctor(/* FIXME (#2543) */ copy i.ident,
-                                         /* FIXME (#2543) */ copy tps,
-                                         res_ctor(/* FIXME (#2543) */
-                                                  copy decl,
-                                                  ctor_id, i.span),
-                                         item_path));
-        cx.map.insert(dtor_id, node_item(i, item_path));
-      }
       item_enum(vs, _, _) {
         for vs.each {|v|
             cx.map.insert(v.node.id, node_variant(

src/libsyntax/ast_util.rs

@@ -425,7 +425,6 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
         visit_item: fn@(i: @item) {
             vfn(i.id);
             alt i.node {
-              item_res(_, _, _, d_id, c_id, _) { vfn(d_id); vfn(c_id); }
               item_enum(vs, _, _) { for vs.each {|v| vfn(v.node.id); } }
               _ {}
             }
@@ -497,8 +496,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
                 vfn(self_id);
                 vfn(parent_id.node);
               }
-              visit::fk_item_fn(_, tps) |
-              visit::fk_res(_, tps, _) {
+              visit::fk_item_fn(_, tps) {
                 vec::iter(tps) {|tp| vfn(tp.id)}
               }
               visit::fk_method(_, tps, m) {

src/libsyntax/fold.rs

@@ -281,14 +281,6 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
                        rp,
                        /* FIXME (#2543) */ copy methods)
           }
-          item_res(decl, typms, body, did, cid, rp) {
-            item_res(fold_fn_decl(decl, fld),
-                     fold_ty_params(typms, fld),
-                     fld.fold_block(body),
-                     fld.new_id(did),
-                     fld.new_id(cid),
-                     rp)
-          }
         };
 }
 

src/libsyntax/parse/parser.rs

@@ -1917,29 +1917,6 @@ class parser {
         (ident, item_impl(tps, rp, ifce, ty, meths), none)
     }
 
-    fn parse_item_res() -> item_info {
-        let ident = self.parse_value_ident();
-        let rp = self.parse_region_param();
-        let ty_params = self.parse_ty_params();
-        self.expect(token::LPAREN);
-        let arg_ident = self.parse_value_ident();
-        self.expect(token::COLON);
-        let t = self.parse_ty(false);
-        self.expect(token::RPAREN);
-        let dtor = self.parse_block_no_value();
-        let decl = {
-            inputs: [{mode: expl(by_ref), ty: t,
-                      ident: arg_ident, id: self.get_id()}],
-            output: @{id: self.get_id(), node: ty_nil,
-                      span: ast_util::dummy_sp()},
-            purity: impure_fn,
-            cf: return_val,
-            constraints: []
-        };
-        (ident, item_res(decl, ty_params, dtor,
-                         self.get_id(), self.get_id(), rp), none)
-    }
-
     // Instantiates ident <i> with references to <typarams> as arguments.
     // Used to create a path that refers to a class which will be defined as
     // the return type of the ctor function.
@@ -2341,8 +2318,6 @@ class parser {
             self.parse_item_iface()
         } else if self.eat_keyword("impl") {
             self.parse_item_impl()
-        } else if self.eat_keyword("resource") {
-            self.parse_item_res()
         } else if self.eat_keyword("class") {
             self.parse_item_class()
         } else { ret none; };

src/libsyntax/parse/token.rs

@@ -293,8 +293,7 @@ fn restricted_keyword_table() -> hashmap<str, ()> {
         "let", "log", "loop",
         "mod", "mut",
         "native", "new",
-        "pure",
-        "resource", "ret",
+        "pure", "ret",
         "true", "trait", "type",
         "unchecked", "unsafe",
         "while"

src/libsyntax/print/pprust.rs

@@ -130,38 +130,6 @@ fn test_fun_to_str() {
     assert fun_to_str(decl, "a", []) == "fn a()";
 }
 
-fn res_to_str(decl: ast::fn_decl, name: ast::ident,
-              params: [ast::ty_param], rp: ast::region_param) -> str {
-    let buffer = io::mem_buffer();
-    let s = rust_printer(io::mem_buffer_writer(buffer));
-    print_res(s, decl, name, params, rp);
-    end(s); // Close the head box
-    end(s); // Close the outer box
-    eof(s.s);
-    io::mem_buffer_str(buffer)
-}
-
-#[test]
-fn test_res_to_str() {
-    let decl: ast::fn_decl = {
-        inputs: [{
-            mode: ast::expl(ast::by_val),
-            ty: @{id: 0,
-                  node: ast::ty_nil,
-                  span: ast_util::dummy_sp()},
-            ident: "b",
-            id: 0
-        }],
-        output: @{id: 0,
-                  node: ast::ty_nil,
-                  span: ast_util::dummy_sp()},
-        purity: ast::impure_fn,
-        cf: ast::return_val,
-        constraints: []
-    };
-    assert res_to_str(decl, "a", []) == "resource a(b: ())";
-}
-
 fn block_to_str(blk: ast::blk) -> str {
     let buffer = io::mem_buffer();
     let s = rust_printer(io::mem_buffer_writer(buffer));
@@ -615,27 +583,10 @@ fn print_item(s: ps, &&item: @ast::item) {
         for methods.each {|meth| print_ty_method(s, meth); }
         bclose(s, item.span);
       }
-      ast::item_res(decl, tps, body, dt_id, ct_id, rp) {
-        print_res(s, decl, item.ident, tps, rp);
-        print_block(s, body);
-      }
     }
     s.ann.post(ann_node);
 }
 
-fn print_res(s: ps, decl: ast::fn_decl, name: ast::ident,
-             typarams: [ast::ty_param], rp: ast::region_param) {
-    head(s, "resource");
-    word(s.s, *name);
-    print_region_param(s, rp);
-    print_type_params(s, typarams);
-    popen(s);
-    word_space(s, *decl.inputs[0].ident + ":");
-    print_type(s, decl.inputs[0].ty);
-    pclose(s);
-    space(s.s);
-}
-
 fn print_variant(s: ps, v: ast::variant) {
     word(s.s, *v.node.name);
     if vec::len(v.node.args) > 0u {

src/libsyntax/visit.rs

@@ -15,7 +15,6 @@ enum vt<E> { mk_vt(visitor<E>), }
 enum fn_kind {
     fk_item_fn(ident, [ty_param]), //< an item declared with fn()
     fk_method(ident, [ty_param], @method),
-    fk_res(ident, [ty_param], region_param),
     fk_anon(proto, capture_clause),  //< an anonymous function like fn@(...)
     fk_fn_block(capture_clause),     //< a block {||...}
     fk_ctor(ident, [ty_param], node_id /* self id */,
@@ -27,7 +26,7 @@ enum fn_kind {
 
 fn name_of_fn(fk: fn_kind) -> ident {
     alt fk {
-      fk_item_fn(name, _) | fk_method(name, _, _) | fk_res(name, _, _)
+      fk_item_fn(name, _) | fk_method(name, _, _)
           | fk_ctor(name, _, _, _) { /* FIXME (#2543) */ copy name }
       fk_anon(*) | fk_fn_block(*) { @"anon" }
       fk_dtor(*)                  { @"drop" }
@@ -36,7 +35,7 @@ fn name_of_fn(fk: fn_kind) -> ident {
 
 fn tps_of_fn(fk: fn_kind) -> [ty_param] {
     alt fk {
-      fk_item_fn(_, tps) | fk_method(_, tps, _) | fk_res(_, tps, _)
+      fk_item_fn(_, tps) | fk_method(_, tps, _)
               | fk_ctor(_, tps, _, _) | fk_dtor(tps, _, _) {
           /* FIXME (#2543) */ copy tps
       }
@@ -130,12 +129,6 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
         v.visit_ty(t, e, v);
         v.visit_ty_params(tps, e, v);
       }
-      item_res(decl, tps, body, dtor_id, _, rp) {
-        v.visit_fn(fk_res(/* FIXME (#2543) */ copy i.ident,
-                          /* FIXME (#2543) */ copy tps,
-                          rp),
-                   decl, body, i.span, dtor_id, e, v);
-      }
       item_enum(variants, tps, _) {
         v.visit_ty_params(tps, e, v);
         for variants.each {|vr|

src/rt/rust_box_annihilator.cpp

@@ -138,15 +138,14 @@ class annihilator : public shape::data<annihilator,shape::ptr> {
         void *data;
     };
 
-    typedef void (*dtor)(void **retptr, void *env, void *dptr);
+    typedef void (*dtor)(void **retptr, void *dptr);
 
     static void run_dtor(run_dtor_args *args) {
         dtor f = (dtor)args->dtor;
-        f(NULL, args->dtor->env, args->data);
+        f(NULL, args->data);
     }
 
-    void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp,
-                   bool live) {
+    void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp) {
         void *data = (void*)(uintptr_t)dp;
         // Switch back to the Rust stack to run the destructor
         run_dtor_args args = {dtor, data};

src/rt/rust_cc.cpp

@@ -147,8 +147,7 @@ class irc : public shape::data<irc,shape::ptr> {
     void walk_tydesc2(char) {
     }
 
-    void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp,
-                   bool live) {
+    void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp) {
         while (this->sp != end_sp) {
             this->walk();
             align = true;
@@ -394,8 +393,7 @@ class mark : public shape::data<mark,shape::ptr> {
         }
     }
 
-    void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp,
-                   bool live) {
+    void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp) {
         while (this->sp != end_sp) {
             this->walk();
             align = true;

src/rt/rust_shape.cpp

@@ -304,8 +304,7 @@ class cmp : public data<cmp,ptr_pair> {
     void walk_tag2(tag_info &tinfo,
                    const data_pair<tag_variant_t> &tag_variants);
     void walk_struct2(const uint8_t *end_sp);
-    void walk_res2(const rust_fn *dtor, const uint8_t *end_sp,
-                   const data_pair<uintptr_t> &live);
+    void walk_res2(const rust_fn *dtor, const uint8_t *end_sp);
     void walk_variant2(tag_info &tinfo,
                        tag_variant_t variant_id,
                        const std::pair<const uint8_t *,const uint8_t *>
@@ -356,8 +355,7 @@ cmp::walk_struct2(const uint8_t *end_sp) {
 }
 
 void
-cmp::walk_res2(const rust_fn *dtor, const uint8_t *end_sp,
-              const data_pair<uintptr_t> &live) {
+cmp::walk_res2(const rust_fn *dtor, const uint8_t *end_sp) {
     abort();    // TODO
 }
 
@@ -463,7 +461,7 @@ log::walk_variant2(tag_info &tinfo,
 }
 
 void
-log::walk_res2(const rust_fn *dtor, const uint8_t *end_sp, bool live) {
+log::walk_res2(const rust_fn *dtor, const uint8_t *end_sp) {
     out << prefix << "res";
 
     if (this->sp == end_sp)

src/rt/rust_shape.h

@@ -950,9 +950,8 @@ class data : public ctxt< data<T,U> > {
     }
 
     void walk_res1(const rust_fn *dtor, const uint8_t *end_sp) {
-        typename U::template data<uintptr_t>::t live = bump_dp<uintptr_t>(dp);
         // Delegate to the implementation.
-        static_cast<T *>(this)->walk_res2(dtor, end_sp, live);
+        static_cast<T *>(this)->walk_res2(dtor, end_sp);
     }
 
     template<typename WN>
@@ -1287,7 +1286,7 @@ class log : public data<log,ptr> {
                        const std::pair<const uint8_t *,const uint8_t *>
                        variant_ptr_and_end);
     void walk_string2(const std::pair<ptr,ptr> &data);
-    void walk_res2(const rust_fn *dtor, const uint8_t *end_sp, bool live);
+    void walk_res2(const rust_fn *dtor, const uint8_t *end_sp);
 
     template<typename T>
     inline void walk_number2() {

src/rustc/metadata/encoder.rs

@@ -186,17 +186,6 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
               encode_name_and_def_id(ebml_w, it.ident, it.id);
             }
           }
-          item_res(_, tps, _, _, ctor_id, _) {
-            ebml_w.wr_tag(tag_paths_data_item) {||
-                encode_name_and_def_id(ebml_w, it.ident, ctor_id);
-            }
-            // The same ident has to be added twice (with different positions)
-            // because it's for both the ctor and the dtor.
-            add_to_index(ebml_w, path, index, it.ident);
-            ebml_w.wr_tag(tag_paths_data_item) {||
-                encode_name_and_def_id(ebml_w, it.ident, it.id);
-            }
-          }
           item_class(_, _, items, ctor, m_dtor, _) {
             ebml_w.wr_tag(tag_paths_data_item) {||
                 encode_name_and_def_id(ebml_w, it.ident, it.id);
@@ -698,34 +687,6 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_index(ebml_w, bkts, write_int);
         ebml_w.end_tag();
       }
-      item_res(_, tps, _, _, ctor_id, rp) {
-        add_to_index();
-        let fn_ty = node_id_to_type(tcx, ctor_id);
-
-        ebml_w.start_tag(tag_items_data_item);
-        encode_def_id(ebml_w, local_def(ctor_id));
-        encode_family(ebml_w, 'y');
-        encode_type_param_bounds(ebml_w, ecx, tps);
-        encode_type(ecx, ebml_w, ty::ty_fn_ret(fn_ty));
-        encode_name(ebml_w, item.ident);
-        ecx.encode_inlined_item(ecx, ebml_w, path, ii_item(item));
-        if (tps.len() == 0u) {
-            encode_symbol(ecx, ebml_w, item.id);
-        }
-        encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        encode_region_param(ebml_w, rp);
-        ebml_w.end_tag();
-
-        *index += [{val: ctor_id, pos: ebml_w.writer.tell()}];
-        ebml_w.start_tag(tag_items_data_item);
-        encode_def_id(ebml_w, local_def(ctor_id));
-        encode_family(ebml_w, 'f');
-        encode_type_param_bounds(ebml_w, ecx, tps);
-        encode_type(ecx, ebml_w, fn_ty);
-        encode_parent_item(ebml_w, local_def(item.id));
-        encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml_w.end_tag();
-      }
       item_impl(tps, rp, ifce, _, methods) {
         add_to_index();
         ebml_w.start_tag(tag_items_data_item);