Remove resources

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

Closes #2485

8 files changed, 8 insertions, 116 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 9d3dcb0f23e..fd7c3aa9e71 100644
--- a/src/libsyntax/ast.rs
+++ b/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. */
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 9355da5779e..219769dd28c 100644
--- a/src/libsyntax/ast_map.rs
+++ b/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(
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 8ce34a06329..f402e1f6ab5 100644
--- a/src/libsyntax/ast_util.rs
+++ b/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) {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index ff296eb5aad..492210a55b8 100644
--- a/src/libsyntax/fold.rs
+++ b/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)
-          }
         };
 }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 46e838fd4be..2196ae9d4be 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/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; };
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 39327f1efad..478d7f53658 100644
--- a/src/libsyntax/parse/token.rs
+++ b/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"
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 89f3b2d3aba..54864c287ae 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/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 {
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 5d27ee1452f..714097d356d 100644
--- a/src/libsyntax/visit.rs
+++ b/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|