---

yaml
---
r: 13282
b: refs/heads/master
c: d5d7b3b
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9975ad073acc408ee1bb4fe776daeeb175aa8816
+refs/heads/master: d5d7b3b921ffe7d4a1a600206c213fc92826639c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

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

@@ -2252,7 +2252,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, real_substs: [ty::t],
                                dtor"); }
           };
           trans_class_dtor(ccx, *pt, dtor.node.body,
-                           dtor.node.id, psubsts, some(hash_id), parent_id, s)
+                           dtor.node.id, psubsts, some(hash_id), parent_id)
       }
       // Ugh -- but this ensures any new variants won't be forgotten
       ast_map::node_expr(*) { ccx.tcx.sess.bug("Can't monomorphize an expr") }
@@ -2448,19 +2448,7 @@ fn trans_local_var(cx: block, def: ast::def) -> local_var_result {
       }
       ast::def_self(sid) {
         let slf = alt copy cx.fcx.llself {
-          some(s) {
-            alt option::map(ty::ty_to_def_id(s.t)) {|did|
-                     ty::ty_dtor(cx.tcx(), did)} {
-              some(some(_)) {
-                  /* self is a class with a dtor, which means we
-                     have to select out the object itself
-                     (If any other code does the same thing, that's
-                     a bug */
-                GEPi(cx, cast_self(cx, s), [0u, 1u])
-            }
-            _ { cast_self(cx, s) }
-           }
-          }
+          some(s) { cast_self(cx, s) }
           none { cx.sess().bug("trans_local_var: reference to self \
                                  out of context"); }
         };
@@ -2535,17 +2523,29 @@ fn trans_rec_field(bcx: block, base: @ast::expr,
 
 fn trans_rec_field_inner(bcx: block, val: ValueRef, ty: ty::t,
                          field: ast::ident, sp: span) -> lval_result {
+    let mut deref = false;
     let fields = alt ty::get(ty).struct {
        ty::ty_rec(fs) { fs }
        ty::ty_class(did, substs) {
+         if option::is_some(ty::ty_dtor(bcx.tcx(), did)) {
+           deref = true;
+         }
          ty::class_items_as_fields(bcx.tcx(), did, substs)
        }
        // Constraint?
        _ { bcx.tcx().sess.span_bug(sp, "trans_rec_field:\
                  base expr has non-record type"); }
     };
     let ix = field_idx_strict(bcx.tcx(), sp, field, fields);
-    let val = GEPi(bcx, val, [0u, ix]);
+
+    /* self is a class with a dtor, which means we
+       have to select out the object itself
+       (If any other code does the same thing, that's
+       a bug */
+    let val = if deref {
+        GEPi(bcx, GEPi(bcx, val, [0u, 1u]), [0u, ix])
+    }
+    else { GEPi(bcx, val, [0u, ix]) };
 
     ret {bcx: bcx, val: val, kind: owned};
 }
@@ -4887,9 +4887,8 @@ fn trans_class_ctor(ccx: @crate_ctxt, path: path, decl: ast::fn_decl,
 fn trans_class_dtor(ccx: @crate_ctxt, path: path,
     body: ast::blk,
     dtor_id: ast::node_id, substs: option<param_substs>,
-                    hash_id: option<mono_id>, parent_id: ast::def_id,
-                    // mangled exported name for dtor
-                    s: str) -> ValueRef {
+                    hash_id: option<mono_id>, parent_id: ast::def_id)
+    -> ValueRef {
   let tcx = ccx.tcx;
   /* Look up the parent class's def_id */
   let mut class_ty = ty::lookup_item_type(tcx, parent_id).ty;
@@ -4903,6 +4902,7 @@ fn trans_class_dtor(ccx: @crate_ctxt, path: path,
   let lldty = T_fn([T_ptr(type_of(ccx, ty::mk_nil(tcx))),
                     T_ptr(type_of(ccx, class_ty))],
                    llvm::LLVMVoidType());
+  let s = get_dtor_symbol(ccx, path, dtor_id);
   /* Register the dtor as a function. It has external linkage */
   let lldecl = decl_internal_cdecl_fn(ccx.llmod, s, lldty);
   lib::llvm::SetLinkage(lldecl, lib::llvm::ExternalLinkage);
@@ -4912,9 +4912,7 @@ fn trans_class_dtor(ccx: @crate_ctxt, path: path,
   option::iter(hash_id) {|h_id|
     ccx.monomorphized.insert(h_id, lldecl);
   }
-  /* Register the symbol for the dtor, and generate the code for its
-     body */
-  ccx.item_symbols.insert(dtor_id, s);
+  /* Translate the dtor body */
   trans_fn(ccx, path, ast_util::dtor_dec(),
            body, lldecl, impl_self(class_ty), substs, dtor_id);
   lldecl
@@ -4997,11 +4995,8 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
                            get_item_val(ccx, ctor.node.id), psubsts,
                            ctor.node.id, local_def(item.id), ctor.span);
           option::iter(m_dtor) {|dtor|
-             let s = mangle_exported_name(ccx, *path +
-                                         [path_name(ccx.names("dtor"))],
-                                 ty::node_id_to_type(ccx.tcx, dtor.node.id));
              trans_class_dtor(ccx, *path, dtor.node.body,
-               dtor.node.id, none, none, local_def(item.id), s);
+               dtor.node.id, none, none, local_def(item.id));
           };
         }
         // If there are ty params, the ctor will get monomorphized
@@ -5162,8 +5157,21 @@ fn item_path(ccx: @crate_ctxt, i: @ast::item) -> path {
     } + [path_name(i.ident)]
 }
 
+/* If there's already a symbol for the dtor with <id>, return it;
+   otherwise, create one and register it, returning it as well */
+fn get_dtor_symbol(ccx: @crate_ctxt, path: path, id: ast::node_id) -> str {
+  alt ccx.item_symbols.find(id) {
+     some(s) { s }
+     none    {
+         let s = mangle_exported_name(ccx, path +
+           [path_name(ccx.names("dtor"))], ty::node_id_to_type(ccx.tcx, id));
+         ccx.item_symbols.insert(id, s);
+         s
+     }
+  }
+}
+
 fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef {
-    #debug("get_item_val: %d", id);
     let tcx = ccx.tcx;
     alt ccx.item_vals.find(id) {
       some(v) { v }
@@ -5242,11 +5250,8 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef {
             let lldty = T_fn([T_ptr(type_of(ccx, ty::mk_nil(tcx))),
                     T_ptr(type_of(ccx, class_ty))],
                                    llvm::LLVMVoidType());
-            /* The symbol for the dtor should have already been registered */
-            let s: str = alt ccx.item_symbols.find(id) {
-                    some(s) { s }
-                    none { ccx.sess.bug("in get_item_val, dtor is unbound"); }
-            };
+            let s = get_dtor_symbol(ccx, *pt, dt.node.id);
+
             /* Make the declaration for the dtor */
             let llfn = decl_internal_cdecl_fn(ccx.llmod, s, lldty);
             lib::llvm::SetLinkage(llfn, lib::llvm::ExternalLinkage);

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

@@ -63,6 +63,10 @@ fn traverse_def_id(cx: ctx, did: def_id) {
       ast_map::node_method(_, impl_id, _) { traverse_def_id(cx, impl_id); }
       ast_map::node_native_item(item, _, _) { cx.rmap.insert(item.id, ()); }
       ast_map::node_variant(v, _, _) { cx.rmap.insert(v.node.id, ()); }
+      // If it's a class ctor, consider the parent reachable
+      ast_map::node_ctor(_, _, ast_map::class_ctor(_, parent_id), _) {
+        traverse_def_id(cx, parent_id);
+      }
       _ {}
     }
 }

trunk/src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2012-06-05 fec3b91
+  winnt-i386 36348a2b016f25d9e3b7e1a8814a352c18123839
+  linux-x86_64 7308f0eb3d6a9985c14dfbbde7e1f9eb901cc966
+  linux-i386 d4c1e1733fd30945f96ae67dbc10289f2a9ec380
+  freebsd-x86_64 d0ee6054d7d8320d64aa4dbb9b041537fa2665d5
+  macos-x86_64 652501172b4fee6631f595c90538fd95914ef444
+  macos-i386 5c54b5ecf54cc2631fdd48caa326ab44b5a2e494
+
 S 2012-06-04 7213274
   winnt-i386 94b9414433fd83c086b349ded3159f0541aace16
   linux-x86_64 eb9cf0de4cc09e8b8bfcf741eff4b20510e13a5b

trunk/src/test/run-fail/morestack2.rs

@@ -20,18 +20,21 @@ fn getbig_call_c_and_fail(i: int) {
     }
 }
 
-resource and_then_get_big_again(_i: ()) {
+class and_then_get_big_again {
+  new() {}
+  drop {
     fn getbig(i: int) {
         if i != 0 {
             getbig(i - 1);
         }
     }
     getbig(10000);
+  }
 }
 
 fn main() {
     task::spawn {||
-        let r = and_then_get_big_again(());
+        let r = and_then_get_big_again();
         getbig_call_c_and_fail(10000);
     };
 }

trunk/src/test/run-fail/morestack3.rs

@@ -5,21 +5,24 @@
 use std;
 
 fn getbig_and_fail(&&i: int) {
-    let r = and_then_get_big_again(@0);
+    let _r = and_then_get_big_again();
     if i != 0 {
         getbig_and_fail(i - 1);
     } else {
         fail;
     }
 }
 
-resource and_then_get_big_again(_i: @int) {
+class and_then_get_big_again {
+  new() {}
+  drop {
     fn getbig(i: int) {
         if i != 0 {
             getbig(i - 1);
         }
     }
     getbig(100);
+  }
 }
 
 fn main() {

trunk/src/test/run-fail/morestack4.rs

@@ -5,15 +5,17 @@
 use std;
 
 fn getbig_and_fail(&&i: int) {
-    let r = and_then_get_big_again(@0);
+    let r = and_then_get_big_again();
     if i != 0 {
         getbig_and_fail(i - 1);
     } else {
         fail;
     }
 }
 
-resource and_then_get_big_again(_i: @int) {
+class and_then_get_big_again {
+  new() {}
+  drop {}
 }
 
 fn main() {

trunk/src/test/run-fail/rt-set-exit-status-fail2.rs

@@ -1,15 +1,19 @@
 // error-pattern:whatever
 
-fn main() {
-    log(error, "whatever");
-    task::spawn {||
-        resource r(_i: ()) {
+class r {
             // Setting the exit status after the runtime has already
             // failed has no effect and the process exits with the
             // runtime's exit code
-            os::set_exit_status(50);
-        }
-        let i = r(());
+  drop {
+    os::set_exit_status(50);
+  }
+  new() {}
+}
+
+fn main() {
+    log(error, "whatever");
+    task::spawn {||
+      let i = r();
     };
     fail;
 }

trunk/src/test/run-fail/too-much-recursion-unwinding.rs

@@ -9,11 +9,15 @@ fn recurse() {
     recurse();
 }
 
-resource r(recursed: *mut bool) unsafe {
+class r {
+  let recursed: *mut bool;
+  new(recursed: *mut bool) unsafe { self.recursed = recursed; }
+  drop unsafe { 
     if !*recursed {
         *recursed = true;
         recurse();
     }
+  }
 }
 
 fn main() {

trunk/src/test/run-fail/unwind-box-res.rs

@@ -4,8 +4,12 @@ fn failfn() {
     fail;
 }
 
-resource r(v: *int) unsafe {
-    let v2: ~int = unsafe::reinterpret_cast(v);
+class r {
+  let v: *int;
+  new(v: *int) { self.v = v; }
+  drop unsafe {
+    let _v2: ~int = unsafe::reinterpret_cast(self.v);
+  }
 }
 
 fn main() unsafe {

trunk/src/test/run-fail/unwind-resource-fail.rs

@@ -1,9 +1,9 @@
 // error-pattern:fail
 // xfail-test
 
-resource r(i: int) {
-    // What happens when destructors throw?
-    fail;
+class r {
+  new(i:int) {}
+  drop { fail; }
 }
 
 fn main() {

trunk/src/test/run-fail/unwind-resource-fail2.rs

@@ -1,9 +1,9 @@
 // error-pattern:fail
 // xfail-test
 
-resource r(i: int) {
-    // Double-fail!!
-    fail;
+class r {
+  new(i:int) {}
+  drop { fail; }
 }
 
 fn main() {

trunk/src/test/run-fail/unwind-resource-fail3.rs

@@ -1,9 +1,11 @@
 // error-pattern:quux
 // xfail-test
 
-resource faily_box(_i: @int) {
-    // What happens to the box pointer owned by this resource?
-    fail "quux";
+class faily_box {
+  let i: @int;
+  new(i: @int) { self.i = i; }
+  // What happens to the box pointer owned by this class?
+  drop { fail "quux"; }
 }
 
 fn main() {