---

yaml
---
r: 16269
b: refs/heads/try
c: 49c6dac
h: refs/heads/master
i:
  16267: 23b67f1
v: v3

Author: pcwalton

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 8972588583398b207f0f7033b2af20bca509eba7
+refs/heads/try: 49c6dac47aa93d11b2d4c8deeded4626e23081e7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/rustc/driver/rustc.rs

@@ -15,7 +15,8 @@ import std::map::hashmap;
 import getopts::{opt_present};
 import rustc::driver::driver::*;
 import syntax::codemap;
-import rustc::driver::{diagnostic, session};
+import syntax::diagnostic;
+import rustc::driver::session;
 import rustc::middle::lint;
 import io::reader_util;
 

branches/try/src/rustc/metadata/decoder.rs

@@ -7,14 +7,14 @@ import syntax::{ast, ast_util};
 import syntax::attr;
 import middle::ty;
 import syntax::ast_map;
-import common::*;
 import tydecode::{parse_ty_data, parse_def_id, parse_bounds_data,
         parse_ident};
 import syntax::print::pprust;
 import cmd=cstore::crate_metadata;
 import util::ppaux::ty_to_str;
 import ebml::deserializer;
 import syntax::diagnostic::span_handler;
+import common::*;
 
 export class_dtor;
 export get_class_fields;

branches/try/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)
+                           dtor.node.id, psubsts, some(hash_id), parent_id, s)
       }
       // 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,7 +2448,19 @@ 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) { cast_self(cx, s) }
+          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) }
+           }
+          }
           none { cx.sess().bug("trans_local_var: reference to self \
                                  out of context"); }
         };
@@ -2523,29 +2535,17 @@ 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);
-
-    /* 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]) };
+    let val = GEPi(bcx, val, [0u, ix]);
 
     ret {bcx: bcx, val: val, kind: owned};
 }
@@ -4887,8 +4887,9 @@ 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)
-    -> ValueRef {
+                    hash_id: option<mono_id>, parent_id: ast::def_id,
+                    // mangled exported name for dtor
+                    s: str) -> 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;
@@ -4902,7 +4903,6 @@ 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,7 +4912,9 @@ fn trans_class_dtor(ccx: @crate_ctxt, path: path,
   option::iter(hash_id) {|h_id|
     ccx.monomorphized.insert(h_id, lldecl);
   }
-  /* Translate the dtor body */
+  /* Register the symbol for the dtor, and generate the code for its
+     body */
+  ccx.item_symbols.insert(dtor_id, s);
   trans_fn(ccx, path, ast_util::dtor_dec(),
            body, lldecl, impl_self(class_ty), substs, dtor_id);
   lldecl
@@ -4995,8 +4997,11 @@ 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));
+               dtor.node.id, none, none, local_def(item.id), s);
           };
         }
         // If there are ty params, the ctor will get monomorphized
@@ -5157,21 +5162,8 @@ 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 }
@@ -5250,8 +5242,11 @@ 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());
-            let s = get_dtor_symbol(ccx, *pt, dt.node.id);
-
+            /* 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"); }
+            };
             /* Make the declaration for the dtor */
             let llfn = decl_internal_cdecl_fn(ccx.llmod, s, lldty);
             lib::llvm::SetLinkage(llfn, lib::llvm::ExternalLinkage);

branches/try/src/rustc/middle/tstate/auxiliary.rs

@@ -13,9 +13,8 @@ import tstate::ann::{pre_and_post, pre_and_post_state, empty_ann, prestate,
                      set_postcondition, ts_ann,
                      clear_in_postcond,
                      clear_in_poststate_};
-import tritv::*;
-import bitvectors::promises_;
 import driver::session::session;
+import tritv::{dont_care, tfalse, tritv_get, ttrue};
 
 import syntax::print::pprust::{constr_args_to_str, lit_to_str};
 
@@ -811,7 +810,7 @@ fn copy_in_poststate_two(fcx: fn_ctxt, src_post: poststate,
         // dest def_id
         let insts = find_instances(fcx, subst, val);
         for insts.each {|p|
-            if promises_(p.from, src_post) {
+            if bitvectors::promises_(p.from, src_post) {
                 set_in_poststate_(p.to, target_post);
             }
         }

branches/try/src/rustc/middle/ty.rs

@@ -4,19 +4,19 @@ import std::map::hashmap;
 import driver::session;
 import session::session;
 import syntax::{ast, ast_map};
-import syntax::ast::*;
 import syntax::ast_util;
 import syntax::ast_util::{is_local, local_def, split_class_items,
                           new_def_hash};
 import syntax::codemap::span;
 import metadata::csearch;
-import util::common::*;
 import util::ppaux::region_to_str;
 import util::ppaux::vstore_to_str;
 import util::ppaux::{ty_to_str, tys_to_str, ty_constr_to_str};
-import syntax::print::pprust::*;
 import middle::lint::{get_warning_level, vecs_not_implicitly_copyable,
                       ignore};
+import syntax::ast::*;
+import syntax::print::pprust::*;
+
 export ty_vid, region_vid, vid;
 export br_hashmap;
 export is_instantiable;

branches/try/src/rustc/middle/typeck/astconv.rs

@@ -45,7 +45,8 @@ an rptr (`&r.T`) use the region `r` that appears in the rptr.
 "];
 
 import check::fn_ctxt;
-import rscope::*;
+import rscope::{anon_rscope, binding_rscope, empty_rscope, in_anon_rscope};
+import rscope::{in_binding_rscope, region_scope, type_rscope};
 
 iface ast_conv {
     fn tcx() -> ty::ctxt;

branches/try/src/rustc/middle/typeck/check.rs

@@ -71,7 +71,8 @@ import collect::{methods}; // ccx.to_ty()
 import method::{methods};  // methods for method::lookup
 import middle::ty::tys_in_fn_ty;
 import regionmanip::{replace_bound_regions_in_fn_ty, region_of};
-import rscope::*;
+import rscope::{anon_rscope, binding_rscope, empty_rscope, in_anon_rscope};
+import rscope::{in_binding_rscope, region_scope, type_rscope};
 
 type fn_ctxt =
     // var_bindings, locals and next_var_id are shared

branches/try/src/rustc/util/ppaux.rs

@@ -1,6 +1,14 @@
 import std::map::hashmap;
 import middle::ty;
-import middle::ty::*;
+import middle::ty::{arg, bound_region, br_anon, br_named, canon_mode};
+import middle::ty::{ck_block, ck_box, ck_uniq, constr, ctxt, field, method};
+import middle::ty::{mt, re_bound, re_free, re_scope, re_var, region, t};
+import middle::ty::{ty_bool, ty_bot, ty_box, ty_class, ty_constr, ty_enum};
+import middle::ty::{ty_estr, ty_evec, ty_float, ty_fn, ty_iface, ty_int};
+import middle::ty::{ty_nil, ty_opaque_box, ty_opaque_closure_ptr, ty_param};
+import middle::ty::{ty_ptr, ty_rec, ty_res, ty_rptr, ty_self, ty_str, ty_tup};
+import middle::ty::{ty_type, ty_uniq, ty_uint, ty_var, ty_var_integral};
+import middle::ty::{ty_vec, vid};
 import metadata::encoder;
 import syntax::codemap;
 import syntax::print::pprust;

branches/try/src/test/run-fail/morestack2.rs

@@ -20,21 +20,18 @@ fn getbig_call_c_and_fail(i: int) {
     }
 }
 
-class and_then_get_big_again {
-  new() {}
-  drop {
+resource and_then_get_big_again(_i: ()) {
     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);
     };
 }

branches/try/src/test/run-fail/morestack3.rs

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

branches/try/src/test/run-fail/morestack4.rs

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

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

@@ -1,19 +1,15 @@
 // error-pattern:whatever
 
-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
-  drop {
-    os::set_exit_status(50);
-  }
-  new() {}
-}
-
 fn main() {
     log(error, "whatever");
     task::spawn {||
-      let i = r();
+        resource r(_i: ()) {
+            // 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(());
     };
     fail;
 }

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

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

branches/try/src/test/run-fail/unwind-box-res.rs

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

branches/try/src/test/run-fail/unwind-resource-fail.rs

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