---

yaml
---
r: 10686
b: refs/heads/snap-stage3
c: 487cbf8
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: a8235ff85333e0d6b691603a4eec1bbc113f4df0
+refs/heads/snap-stage3: 487cbf8e906f73589df9501004abeb570b24f121
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/snap-stage3/RELEASES.txt

@@ -1,47 +1,3 @@
-Version 0.3  (June 2012) - not yet!
------------------------------------
-
-  * ~1500 changes, numerous bugfixes
-
-  * New coding conveniences
-    * Integer-literal suffix inference
-    * Per-module control over warnings, errors
-    * #[cfg(windows)] and #[cfg(unix)] attributes
-
-  * Semantic cleanup
-    * Resolve pass and exhaustiveness checker rewritten
-    * Borrow-check taking over from alias-analysis
-    * Liveness taking over from last-use, typestate
-    * Extensive work on region pointers
-
-  * Experimental new language features
-    * Slices and fixed-size, interior-allocated vectors
-    * #!-comments for lang versioning, shell execution
-    * More work on classes
-    * Type reflection
-
-  * Removal of various obsolete features
-    * Keywords: be, prove, syntax, note, mutable, do, bind
-    * Constructs: do-while loops, fn binding, 
-
-  * Compiler reorganization
-    * Syntax-layer of compiler split into separate crate
-    * Clang (from LLVM project) integrated into build
-    * Typechecker split into sub-modules
-
-  * New library code
-    * New time functions
-    * Extension methods for many built-in types
-    * Arc: atomic-refcount read-only / exclusive-use shared cells
-    * Par: parallel map and search routines
-    * Extensive work on libuv interface
-    * Much vector code moved to libraries
-    * Syntax extensions: #line, #col, #file, #mod,
-      #stringify, #include, #include_str, #include_bin.
-
-  * Tool improvements
-    * Cargo automatically resolves dependencies
-
 Version 0.2  (March 2012)
 -------------------------
 

branches/snap-stage3/doc/tutorial.md

@@ -1377,26 +1377,7 @@ Like vectors, strings are always unique. You can wrap them in a shared
 box to share them. Unlike vectors, there is no mutable variant of
 strings. They are always immutable.
 
-## Resources
-
-Resources are data types that have a destructor associated with them.
-
-~~~~
-# fn close_file_desc(x: int) {}
-resource file_desc(fd: int) {
-    close_file_desc(fd);
-}
-~~~~
-
-This defines a type `file_desc` and a constructor of the same name,
-which takes an integer. The type has an associated destructor procedure,
-whose contents are specified by the block. Values of such a type can not
-be copied, and when they are destroyed (by going out of scope, or, when
-boxed, when their box is cleaned up), their body runs. In the example
-above, this would cause the given file descriptor to be closed.
-
-NOTE: We're considering alternative approaches for data types with
-destructors. Resources might go away in the future.
+NOTE: Section on resources removed. ToDo: document classes and destructors
 
 # Argument passing
 
@@ -1581,7 +1562,7 @@ without any sophistication).
 ## Kinds
 
 Perhaps surprisingly, the 'copy' (duplicate) operation is not defined
-for all Rust types. Resource types (types with destructors) can not be
+for all Rust types. Resource types (classes with destructors) cannot be
 copied, and neither can any type whose copying would require copying a
 resource (such as records or unique boxes containing a resource).
 

branches/snap-stage3/src/libcore/arc.rs

@@ -24,17 +24,19 @@ type arc_data<T> = {
     data: T
 };
 
-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);
-        }
-    }
+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);
+     }
+  }
 }
 
 type arc<T: const> = arc_destruct<T>;
@@ -52,7 +54,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);
+        let ptr: ~arc_data<T> = unsafe::reinterpret_cast((*rc).data);
         // Cast us back into the correct region
         let r = unsafe::reinterpret_cast(&ptr.data);
         unsafe::forget(ptr);
@@ -67,12 +69,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);
+        let ptr: ~arc_data<T> = unsafe::reinterpret_cast((*rc).data);
         let new_count = rustrt::rust_atomic_increment(&mut ptr.count);
         assert new_count >= 2;
         unsafe::forget(ptr);
     }
-    arc_destruct(**rc)
+    arc_destruct((*rc).data)
 }
 
 // An arc over mutable data that is protected by a lock.
@@ -93,17 +95,19 @@ 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);
+            let ptr: ~arc_data<ex_data<T>> =
+                  unsafe::reinterpret_cast(self.data);
             let new_count = rustrt::rust_atomic_increment(&mut ptr.count);
             assert new_count > 1;
             unsafe::forget(ptr);
         }
-        arc_destruct(*self)
+        arc_destruct(self.data)
     }
 
     fn with<U>(f: fn(sys::condition, x: &T) -> U) -> U {
         unsafe {
-            let ptr: ~arc_data<ex_data<T>> = unsafe::reinterpret_cast(*self);
+            let ptr: ~arc_data<ex_data<T>> =
+                  unsafe::reinterpret_cast(self.data);
             let r = {
                 let rec: &ex_data<T> = &(*ptr).data;
                 rec.lock.lock_cond() {|c|
@@ -123,8 +127,10 @@ type get_chan<T: const send> = chan<chan<arc<T>>>;
 // (terminate, get)
 type shared_arc<T: const send> = (shared_arc_res, get_chan<T>);
 
-resource shared_arc_res(c: comm::chan<()>) {
-    c.send(());
+class shared_arc_res {
+   let c: comm::chan<()>;
+   new(c: comm::chan<()>) { self.c = c; }
+   drop { self.c.send(()); }
 }
 
 fn shared_arc<T: send const>(-data: T) -> shared_arc<T> {

branches/snap-stage3/src/libcore/comm.rs

@@ -440,7 +440,7 @@ fn test_recv_chan_wrong_task() {
     let po = port();
     let ch = chan(po);
     send(ch, "flower");
-    assert result::is_err(task::try {||
+    assert result::is_failure(task::try {||
         recv_chan(ch)
     })
 }

branches/snap-stage3/src/libcore/core.rs

@@ -11,7 +11,6 @@ import option::extensions;
 import option_iter::extensions;
 import ptr::extensions;
 import rand::extensions;
-import result::extensions;
 
 export path, option, some, none, unreachable;
 export extensions;

branches/snap-stage3/src/libcore/io.rs

@@ -224,7 +224,11 @@ impl <T: reader, C> of reader for {base: T, cleanup: C} {
     fn tell() -> uint { self.base.tell() }
 }
 
-resource FILE_res(f: *libc::FILE) { libc::fclose(f); }
+class FILE_res {
+    let f: *libc::FILE;
+    new(f: *libc::FILE) { self.f = f; }
+    drop { libc::fclose(self.f); }
+}
 
 fn FILE_reader(f: *libc::FILE, cleanup: bool) -> reader {
     if cleanup {
@@ -383,7 +387,11 @@ impl of writer for fd_t {
     fn flush() -> int { 0 }
 }
 
-resource fd_res(fd: fd_t) { libc::close(fd); }
+class fd_res {
+    let fd: fd_t;
+    new(fd: fd_t) { self.fd = fd; }
+    drop { libc::close(self.fd); }
+}
 
 fn fd_writer(fd: fd_t, cleanup: bool) -> writer {
     if cleanup {
@@ -695,13 +703,17 @@ mod fsync {
     }
 
 
-    // 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);
+    // 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);
+            }
           }
         }
     }
@@ -718,7 +730,7 @@ mod fsync {
     fn FILE_res_sync(&&file: FILE_res, opt_level: option<level>,
                   blk: fn(&&res<*libc::FILE>)) {
         blk(res({
-            val: *file, opt_level: opt_level,
+            val: file.f, opt_level: opt_level,
             fsync_fn: fn@(&&file: *libc::FILE, l: level) -> int {
                 ret os::fsync_fd(libc::fileno(file), l) as int;
             }
@@ -729,7 +741,7 @@ mod fsync {
     fn fd_res_sync(&&fd: fd_res, opt_level: option<level>,
                    blk: fn(&&res<fd_t>)) {
         blk(res({
-            val: *fd, opt_level: opt_level,
+            val: fd.fd, opt_level: opt_level,
             fsync_fn: fn@(&&fd: fd_t, l: level) -> int {
                 ret os::fsync_fd(fd, l) as int;
             }

branches/snap-stage3/src/libcore/option.rs

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

branches/snap-stage3/src/libcore/priv.rs

@@ -181,8 +181,12 @@ unsafe fn weaken_task(f: fn(comm::port<()>)) unsafe {
     let _unweaken = unweaken(ch);
     f(po);
 
-    resource unweaken(ch: comm::chan<()>) unsafe {
-        rustrt::rust_task_unweaken(unsafe::reinterpret_cast(ch));
+    class unweaken {
+      let ch: comm::chan<()>;
+      new(ch: comm::chan<()>) { self.ch = ch; }
+      drop unsafe {
+        rustrt::rust_task_unweaken(unsafe::reinterpret_cast(self.ch));
+      }
     }
 }
 
@@ -232,5 +236,5 @@ fn test_weaken_task_fail() unsafe {
             fail;
         }
     };
-    assert result::is_err(res);
+    assert result::is_failure(res);
 }

branches/snap-stage3/src/libcore/rand.rs

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