Convert more resource tests to use classes with dtors

And monomorphize dtors correctly.

Author: catamorphism

src/rustc/middle/trans/base.rs

@@ -423,6 +423,12 @@ impl bcx_cxs for block {
     fn tcx() -> ty::ctxt { self.fcx.ccx.tcx }
     fn sess() -> session { self.fcx.ccx.sess }
 
+    fn val_str(val: ValueRef) -> str {
+        val_str(self.ccx().tn, val)
+    }
+    fn ty_to_str(t: ty::t) -> str {
+        ty_to_str(self.tcx(), t)
+    }
     fn to_str() -> str {
         alt self.node_info {
           some(node_info) {

src/rustc/middle/trans/common.rs

@@ -6,6 +6,7 @@ import build::*;
 import driver::session::session;
 import syntax::{ast, ast_map};
 import ast_map::{path, path_mod, path_name, node_id_to_str};
+import driver::session::expect;
 import syntax::ast_util::{local_def, split_class_items};
 import metadata::csearch;
 import back::{link, abi};
@@ -247,7 +248,10 @@ fn make_impl_vtable(ccx: @crate_ctxt, impl_id: ast::def_id, substs: [ty::t],
                     vtables: typeck::vtable_res) -> ValueRef {
     let _icx = ccx.insn_ctxt("impl::make_impl_vtable");
     let tcx = ccx.tcx;
-    let ifce_id = ty::ty_to_def_id(option::get(ty::impl_iface(tcx, impl_id)));
+    let ifce_id = expect(ccx.sess,
+                         ty::ty_to_def_id(option::get(ty::impl_iface(tcx,
+                                                             impl_id))),
+                         {|| "make_impl_vtable: non-iface-type implemented"});
     let has_tps = (*ty::lookup_item_type(ccx.tcx, impl_id).bounds).len() > 0u;
     make_vtable(ccx, vec::map(*ty::iface_methods(tcx, ifce_id)) {|im|
         let fty = ty::subst_tps(tcx, substs, ty::mk_fn(tcx, im.fty));

src/rustc/middle/trans/impl.rs

@@ -90,6 +90,10 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
       ast_map::node_ctor(_, _, ast_map::class_ctor(ctor, _), _){
         handle_body(cx, ctor.node.body);
       }
+      ast_map::node_dtor(_, dtor, _, _){
+        handle_body(cx, dtor.node.body);
+      }
+
     }
     let uses = vec::from_mut(cx.uses);
     ccx.type_use_cache.insert(fn_id, uses);

src/rustc/middle/trans/type_use.rs

@@ -2375,11 +2375,12 @@ fn impl_iface(cx: ctxt, id: ast::def_id) -> option<t> {
     }
 }
 
-fn ty_to_def_id(ty: t) -> ast::def_id {
-    alt check get(ty).struct {
+fn ty_to_def_id(ty: t) -> option<ast::def_id> {
+    alt get(ty).struct {
       ty_iface(id, _) | ty_class(id, _) | ty_res(id, _, _) | ty_enum(id, _) {
-        id
+        some(id)
       }
+      _ { none }
     }
 }
 
@@ -2413,7 +2414,7 @@ fn ty_dtor(cx: ctxt, class_id: def_id) -> option<def_id> {
          some(ast_map::node_item(@{node: ast::item_class(_, _, _, _,
                                      some(dtor), _), _}, _))
              { some(local_def(dtor.node.id))  }
-          _  { none }
+         _  { none }
        }
     }
     else {

src/rustc/middle/ty.rs

@@ -1,9 +1,13 @@
-resource shrinky_pointer(i: @mut int) { *i -= 1; }
-
-fn look_at(pt: shrinky_pointer) -> int { ret **pt; }
+class shrinky_pointer {
+  let i: @@mut int;
+  fn look_at() -> int { ret **(self.i); }
+  new(i: @@mut int) { self.i = i; }
+  drop { log(error, "Hello!"); **(self.i) -= 1; }
+}
 
 fn main() {
-    let my_total = @mut 10;
-    { let pt <- shrinky_pointer(my_total); assert (look_at(pt) == 10); }
-    assert (*my_total == 9);
+    let my_total = @@mut 10;
+    { let pt <- shrinky_pointer(my_total); assert (pt.look_at() == 10); }
+    log(error, #fmt("my_total = %d", **my_total));
+    assert (**my_total == 9);
 }

src/test/run-pass/resource-destruct-with-class.rs

@@ -1,11 +1,15 @@
-resource finish<T>(arg: {val: T, fin: native fn(T)}) {
-    arg.fin(arg.val);
+class finish<T: copy> {
+  let arg: {val: T, fin: native fn(T)};
+  new(arg: {val: T, fin: native fn(T)}) {
+    self.arg = arg;
+  }
+  drop { self.arg.fin(self.arg.val); }
 }
 
 fn main() {
     let box = @mut 10;
     fn dec_box(&&i: @mut int) { *i -= 1; }
 
-    { let i <- finish({val: box, fin: dec_box}); }
+    { let _i <- finish({val: box, fin: dec_box}); }
     assert (*box == 9);
 }