---

yaml
---
r: 13647
b: refs/heads/master
c: 986662c
h: refs/heads/master
i:
  13645: 954cc94
  13643: 4e9f894
  13639: 34c1ad8
  13631: 4849b1e
v: v3

Author: msullivan

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 25aa3605952719fbfc7ccb998a7980fad6df2eb1
+refs/heads/master: 986662cebd3f41911cb72c18f4e824a4856b009b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/libcore/arc.rs

@@ -24,19 +24,17 @@ type arc_data<T> = {
     data: T
 };
 
-class arc_destruct<T> {
-  let data: *libc::c_void;
-  new(data: *libc::c_void) { self.data = data; }
-  drop unsafe {
-     let data: ~arc_data<T> = unsafe::reinterpret_cast(self.data);
-     let new_count = rustrt::rust_atomic_decrement(&mut data.count);
-     assert new_count >= 0;
-     if new_count == 0 {
-         // drop glue takes over.
-     } else {
-       unsafe::forget(data);
-     }
-  }
+resource arc_destruct<T>(data: *libc::c_void) {
+    unsafe {
+        let data: ~arc_data<T> = unsafe::reinterpret_cast(data);
+        let new_count = rustrt::rust_atomic_decrement(&mut data.count);
+        assert new_count >= 0;
+        if new_count == 0 {
+            // drop glue takes over.
+        } else {
+            unsafe::forget(data);
+        }
+    }
 }
 
 type arc<T: const> = arc_destruct<T>;
@@ -54,7 +52,7 @@ fn arc<T: const>(-data: T) -> arc<T> {
  wrapper."]
 fn get<T: const>(rc: &a.arc<T>) -> &a.T {
     unsafe {
-        let ptr: ~arc_data<T> = unsafe::reinterpret_cast((*rc).data);
+        let ptr: ~arc_data<T> = unsafe::reinterpret_cast(**rc);
         // Cast us back into the correct region
         let r = unsafe::reinterpret_cast(&ptr.data);
         unsafe::forget(ptr);
@@ -69,12 +67,12 @@ object. However, one of the `arc` objects can be sent to another task,
 allowing them to share the underlying data."]
 fn clone<T: const>(rc: &arc<T>) -> arc<T> {
     unsafe {
-        let ptr: ~arc_data<T> = unsafe::reinterpret_cast((*rc).data);
+        let ptr: ~arc_data<T> = unsafe::reinterpret_cast(**rc);
         let new_count = rustrt::rust_atomic_increment(&mut ptr.count);
         assert new_count >= 2;
         unsafe::forget(ptr);
     }
-    arc_destruct((*rc).data)
+    arc_destruct(**rc)
 }
 
 // An arc over mutable data that is protected by a lock.
@@ -95,19 +93,17 @@ impl methods<T: send> for exclusive<T> {
     fn clone() -> exclusive<T> {
         unsafe {
             // this makes me nervous...
-            let ptr: ~arc_data<ex_data<T>> =
-                  unsafe::reinterpret_cast(self.data);
+            let ptr: ~arc_data<ex_data<T>> = unsafe::reinterpret_cast(*self);
             let new_count = rustrt::rust_atomic_increment(&mut ptr.count);
             assert new_count > 1;
             unsafe::forget(ptr);
         }
-        arc_destruct(self.data)
+        arc_destruct(*self)
     }
 
     fn with<U>(f: fn(sys::condition, x: &T) -> U) -> U {
         unsafe {
-            let ptr: ~arc_data<ex_data<T>> =
-                  unsafe::reinterpret_cast(self.data);
+            let ptr: ~arc_data<ex_data<T>> = unsafe::reinterpret_cast(*self);
             let r = {
                 let rec: &ex_data<T> = &(*ptr).data;
                 rec.lock.lock_cond() {|c|
@@ -127,10 +123,8 @@ type get_chan<T: const send> = chan<chan<arc<T>>>;
 // (terminate, get)
 type shared_arc<T: const send> = (shared_arc_res, get_chan<T>);
 
-class shared_arc_res {
-   let c: comm::chan<()>;
-   new(c: comm::chan<()>) { self.c = c; }
-   drop { self.c.send(()); }
+resource shared_arc_res(c: comm::chan<()>) {
+    c.send(());
 }
 
 fn shared_arc<T: send const>(-data: T) -> shared_arc<T> {

trunk/src/libcore/io.rs

@@ -224,11 +224,7 @@ impl <T: reader, C> of reader for {base: T, cleanup: C} {
     fn tell() -> uint { self.base.tell() }
 }
 
-class FILE_res {
-    let f: *libc::FILE;
-    new(f: *libc::FILE) { self.f = f; }
-    drop { libc::fclose(self.f); }
-}
+resource FILE_res(f: *libc::FILE) { libc::fclose(f); }
 
 fn FILE_reader(f: *libc::FILE, cleanup: bool) -> reader {
     if cleanup {
@@ -387,11 +383,7 @@ impl of writer for fd_t {
     fn flush() -> int { 0 }
 }
 
-class fd_res {
-    let fd: fd_t;
-    new(fd: fd_t) { self.fd = fd; }
-    drop { libc::close(self.fd); }
-}
+resource fd_res(fd: fd_t) { libc::close(fd); }
 
 fn fd_writer(fd: fd_t, cleanup: bool) -> writer {
     if cleanup {
@@ -703,17 +695,13 @@ mod fsync {
     }
 
 
-    // Artifacts that need to fsync on destruction
-    class res<t> {
-        let arg: arg<t>;
-        new(-arg: arg<t>) { self.arg <- arg; }
-        drop {
-          alt self.arg.opt_level {
-            option::none { }
-            option::some(level) {
-              // fail hard if not succesful
-              assert(self.arg.fsync_fn(self.arg.val, level) != -1);
-            }
+    // Resource of artifacts that need to fsync on destruction
+    resource res<t>(arg: arg<t>) {
+        alt arg.opt_level {
+          option::none { }
+          option::some(level) {
+            // fail hard if not succesful
+            assert(arg.fsync_fn(arg.val, level) != -1);
           }
         }
     }
@@ -730,7 +718,7 @@ mod fsync {
     fn FILE_res_sync(&&file: FILE_res, opt_level: option<level>,
                   blk: fn(&&res<*libc::FILE>)) {
         blk(res({
-            val: file.f, opt_level: opt_level,
+            val: *file, opt_level: opt_level,
             fsync_fn: fn@(&&file: *libc::FILE, l: level) -> int {
                 ret os::fsync_fd(libc::fileno(file), l) as int;
             }
@@ -741,7 +729,7 @@ mod fsync {
     fn fd_res_sync(&&fd: fd_res, opt_level: option<level>,
                    blk: fn(&&res<fd_t>)) {
         blk(res({
-            val: fd.fd, opt_level: opt_level,
+            val: *fd, opt_level: opt_level,
             fsync_fn: fn@(&&fd: fd_t, l: level) -> int {
                 ret os::fsync_fd(fd, l) as int;
             }

trunk/src/libcore/option.rs

@@ -140,10 +140,8 @@ fn test_unwrap_str() {
 
 #[test]
 fn test_unwrap_resource() {
-    class r {
-       let i: @mut int;
-       new(i: @mut int) { self.i = i; }
-       drop { *(self.i) += 1; }
+    resource r(i: @mut int) {
+        *i += 1;
     }
     let i = @mut 0;
     {

trunk/src/libcore/priv.rs

@@ -181,12 +181,8 @@ unsafe fn weaken_task(f: fn(comm::port<()>)) unsafe {
     let _unweaken = unweaken(ch);
     f(po);
 
-    class unweaken {
-      let ch: comm::chan<()>;
-      new(ch: comm::chan<()>) { self.ch = ch; }
-      drop unsafe {
-        rustrt::rust_task_unweaken(unsafe::reinterpret_cast(self.ch));
-      }
+    resource unweaken(ch: comm::chan<()>) unsafe {
+        rustrt::rust_task_unweaken(unsafe::reinterpret_cast(ch));
     }
 }
 

trunk/src/libcore/rand.rs

@@ -230,14 +230,10 @@ impl extensions for rng {
 
 }
 
-class rand_res {
-    let c: *rctx;
-    new(c: *rctx) { self.c = c; }
-    drop { rustrt::rand_free(self.c); }
-}
+resource rand_res(c: *rctx) { rustrt::rand_free(c); }
 
 impl of rng for @rand_res {
-    fn next() -> u32 { ret rustrt::rand_next((*self).c); }
+    fn next() -> u32 { ret rustrt::rand_next(**self); }
 }
 
 #[doc = "Create a new random seed for seeded_rng"]

trunk/src/libcore/run.rs

@@ -170,9 +170,9 @@ fn run_program(prog: str, args: [str]) -> int {
 #[doc ="
 Spawns a process and returns a program
 
-The returned value is a boxed class containing a <program> object that can
-be used for sending and receiving data over the standard file descriptors.
-The class will ensure that file descriptors are closed properly.
+The returned value is a boxed resource containing a <program> object that can
+be used for sending and recieving data over the standard file descriptors.
+The resource will ensure that file descriptors are closed properly.
 
 # Arguments
 
@@ -181,7 +181,7 @@ The class will ensure that file descriptors are closed properly.
 
 # Return value
 
-A class with a <program> field
+A boxed resource of <program>
 "]
 fn start_program(prog: str, args: [str]) -> program {
     let pipe_input = os::pipe();
@@ -221,20 +221,16 @@ fn start_program(prog: str, args: [str]) -> program {
        libc::fclose(r.out_file);
        libc::fclose(r.err_file);
     }
-    class prog_res {
-        let r: prog_repr;
-        new(-r: prog_repr) { self.r = r; }
-        drop { destroy_repr(self.r); }
-    }
+    resource prog_res(r: prog_repr) { destroy_repr(r); }
 
     impl of program for prog_res {
-        fn get_id() -> pid_t { ret self.r.pid; }
-        fn input() -> io::writer { io::fd_writer(self.r.in_fd, false) }
-        fn output() -> io::reader { io::FILE_reader(self.r.out_file, false) }
-        fn err() -> io::reader { io::FILE_reader(self.r.err_file, false) }
-        fn close_input() { close_repr_input(self.r); }
-        fn finish() -> int { finish_repr(self.r) }
-        fn destroy() { destroy_repr(self.r); }
+        fn get_id() -> pid_t { ret self.pid; }
+        fn input() -> io::writer { io::fd_writer(self.in_fd, false) }
+        fn output() -> io::reader { io::FILE_reader(self.out_file, false) }
+        fn err() -> io::reader { io::FILE_reader(self.err_file, false) }
+        fn close_input() { close_repr_input(*self); }
+        fn finish() -> int { finish_repr(*self) }
+        fn destroy() { destroy_repr(*self); }
     }
     let repr = {pid: pid,
                 mut in_fd: pipe_input.out,

trunk/src/libcore/sys.rs

@@ -85,20 +85,16 @@ pure fn log_str<T>(t: T) -> str {
     }
 }
 
-class lock_and_signal {
-    let lock: rust_cond_lock;
-    new(lock: rust_cond_lock) { self.lock = lock; }
-    drop { rustrt::rust_destroy_cond_lock(self.lock); }
+resource lock_and_signal(lock: rust_cond_lock) {
+    rustrt::rust_destroy_cond_lock(lock);
 }
 
 enum condition {
     condition_(rust_cond_lock)
 }
 
-class unlock {
-    let lock: rust_cond_lock;
-    new(lock: rust_cond_lock) { self.lock = lock; }
-    drop { rustrt::rust_unlock_cond_lock(self.lock); }
+resource unlock(lock: rust_cond_lock) {
+    rustrt::rust_unlock_cond_lock(lock);
 }
 
 fn create_lock() -> lock_and_signal {
@@ -107,15 +103,15 @@ fn create_lock() -> lock_and_signal {
 
 impl methods for lock_and_signal {
     fn lock<T>(f: fn() -> T) -> T {
-        rustrt::rust_lock_cond_lock(self.lock);
-        let _r = unlock(self.lock);
+        rustrt::rust_lock_cond_lock(*self);
+        let _r = unlock(*self);
         f()
     }
 
     fn lock_cond<T>(f: fn(condition) -> T) -> T {
-        rustrt::rust_lock_cond_lock(self.lock);
-        let _r = unlock(self.lock);
-        f(condition_(self.lock))
+        rustrt::rust_lock_cond_lock(*self);
+        let _r = unlock(*self);
+        f(condition_(*self))
     }
 }
 

trunk/src/libcore/task.rs

@@ -482,12 +482,9 @@ Temporarily make the task unkillable
 
 "]
 unsafe fn unkillable(f: fn()) {
-    class allow_failure {
-      let i: (); // since a class must have at least one field
-      new(_i: ()) { self.i = (); }
-      drop { rustrt::rust_task_allow_kill(); }
+    resource allow_failure(_i: ()) {
+        rustrt::rust_task_allow_kill();
     }
-
     let _allow_failure = allow_failure(());
     rustrt::rust_task_inhibit_kill();
     f();

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

@@ -209,11 +209,7 @@ fn traverse_all_resources(cx: ctx, crate_mod: _mod) {
         visit_item: {|i, cx, v|
             visit::visit_item(i, cx, v);
             alt i.node {
-              item_res(*) {
-                traverse_public_item(cx, i);
-              }
-              // Classes with dtors too!
-              item_class(_, _, _, _, some(_), _) {
+              item_res(_, _, _, _, _, _) {
                 traverse_public_item(cx, i);
               }
               _ {}

trunk/src/rustc/middle/ty.rs

@@ -1496,7 +1496,7 @@ fn type_kind(cx: ctxt, ty: t) -> kind {
       ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
       ty_ptr(_) { kind_implicitly_sendable() | kind_const() }
       // Implicit copyability of strs is configurable
-      ty_str {
+      ty_str | ty_estr(vstore_uniq) {
         if cx.vecs_implicitly_copyable {
             kind_implicitly_sendable() | kind_const()
         } else { kind_sendable() | kind_const() }
@@ -1526,7 +1526,7 @@ fn type_kind(cx: ctxt, ty: t) -> kind {
         remove_implicit(mutable_type_kind(cx, tm))
       }
       // Implicit copyability of vecs is configurable
-      ty_vec(tm) {
+      ty_vec(tm) | ty_evec(tm, vstore_uniq) {
           if cx.vecs_implicitly_copyable {
               mutable_type_kind(cx, tm)
           } else { remove_implicit(mutable_type_kind(cx, tm)) }
@@ -1544,17 +1544,13 @@ fn type_kind(cx: ctxt, ty: t) -> kind {
             kind_implicitly_copyable()
         }
       }
-      ty_evec(tm, vstore_uniq) {
-        remove_implicit(mutable_type_kind(cx, tm))
-      }
       ty_evec(tm, vstore_fixed(_)) {
         mutable_type_kind(cx, tm)
       }
 
       // All estrs are copyable; uniques and interiors are sendable.
       ty_estr(vstore_box) |
       ty_estr(vstore_slice(_)) { kind_implicitly_copyable() | kind_const() }
-      ty_estr(vstore_uniq) { kind_sendable() | kind_const() }
       ty_estr(vstore_fixed(_)) { kind_implicitly_sendable() | kind_const() }
 
       // Records lower to the lowest of their members.