---

yaml
---
r: 13695
b: refs/heads/master
c: f1acc69
h: refs/heads/master
i:
  13693: 99d7116
  13691: 924014d
  13687: 32a1156
  13679: 347d1ec
  13663: ccd8425
  13631: 4849b1e
  13567: aad563c
v: v3

Author: catamorphism

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6322eda35ca0e5d05247eccfa820f0aa730591ce
+refs/heads/master: f1acc69a2a81c9f82b78c4d9773202f39e8ada5c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/RELEASES.txt

@@ -7,6 +7,7 @@ Version 0.3  (June 2012) - not yet!
     * Integer-literal suffix inference
     * Per-module control over warnings, errors
     * #[cfg(windows)] and #[cfg(unix)] attributes
+    * *-patterns (wildcard extended to all constructor fields)
 
   * Semantic cleanup
     * Resolve pass and exhaustiveness checker rewritten
@@ -17,12 +18,13 @@ Version 0.3  (June 2012) - not yet!
   * Experimental new language features
     * Slices and fixed-size, interior-allocated vectors
     * #!-comments for lang versioning, shell execution
-    * More work on classes
+    * Destructors and iface implementation for classes;
+       type-parameterized classes and class methods
     * Type reflection
 
   * Removal of various obsolete features
     * Keywords: be, prove, syntax, note, mutable, do, bind
-    * Constructs: do-while loops, fn binding, 
+    * Constructs: do-while loops, fn binding, resources
 
   * Compiler reorganization
     * Syntax-layer of compiler split into separate crate
@@ -39,6 +41,9 @@ Version 0.3  (June 2012) - not yet!
     * Syntax extensions: #line, #col, #file, #mod,
       #stringify, #include, #include_str, #include_bin.
 
+  * Tool improvements
+    * Cargo automatically resolves dependencies
+
 Version 0.2  (March 2012)
 -------------------------
 

trunk/configure

@@ -311,13 +311,8 @@ fi
 step_msg "looking for build programs"
 
 probe_need CFG_PERL        perl
+probe_need CFG_PYTHON      python python2.6 python2 python3
 probe_need CFG_CURL        curl
-probe_need CFG_PYTHON      python2.7 python2.6 python2 python
-
-python_version=$($CFG_PYTHON -V 2>&1)
-if [ $(echo $python_version | grep -c '^Python 2\.[4567]') -ne 1 ]; then
-    err "Found $python_version, but LLVM requires Python 2.4-2.7"
-fi
 
 # If we have no git directory then we are probably a tarball distribution
 # and shouldn't attempt to load submodules

trunk/doc/rust.md

@@ -1127,30 +1127,40 @@ enum list<T> {
 let a: list<int> = cons(7, @cons(13, @nil));
 ~~~~
 
-### Resources
+### Classes
 
-_Resources_ are values that have a destructor associated with them. A
-_resource item_ is used to declare resource type and constructor.
+TODO: more about classes
+
+_Classes_ are named record types that may have a destructor associated
+with them, as well as fields and methods. For historical reasons, we
+may call a class with a destructor and a single field a "resource".
+
+A _class item_ declares a class type:
 
 ~~~~
-resource file_descriptor(fd: libc::c_int) {
-    libc::close(fd);
+class file_descriptor {
+    let fd: libc::c_int;
+    new(fd: libc::c_int) { self.fd = fd; }
+    drop { libc::close(self.fd); }
 }
 ~~~~
 
 Calling the `file_descriptor` constructor function on an integer will
 produce a value with the `file_descriptor` type. Resource types have a
-noncopyable [type kind](#type-kinds), and thus may not be copied. The
-semantics guarantee that for each constructed resources value, the
-destructor will run once: when the value is disposed of (barring
-drastic program termination that somehow prevents unwinding from taking
-place). For stack-allocated values, disposal happens when the value
-goes out of scope. For values in shared boxes, it happens when the
-reference count of the box reaches zero.
-
-The argument to the resource constructor is stored in the resulting
-value, and can be accessed using the dereference (`*`) [unary
-operator](#unary-operator-expressions).
+noncopyable [type kind](#type-kinds), and thus may not be
+copied. Class types that don't have destructors may be copied if all
+their fields are copyable. The semantics guarantee that for each
+constructed resource value, the destructor will run once: when the
+value is disposed of (barring drastic program termination that somehow
+prevents unwinding from taking place). For stack-allocated values,
+disposal happens when the value goes out of scope. For values in
+shared boxes, it happens when the reference count of the box reaches
+zero.
+
+The argument or arguments to the class constructor may be stored in
+the class's named fields, and can be accessed by a field reference. In
+this case, the `file_descriptor`'s data field would be accessed like
+`f.fd`, if `f` is a value of type `file_descriptor`.
 
 ### Interfaces
 

trunk/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).
 

trunk/mk/platform.mk

@@ -9,9 +9,6 @@ endef
 $(foreach t,$(CFG_TARGET_TRIPLES),$(eval $(call DEF_HOST_VAR,$(t))))
 $(foreach t,$(CFG_TARGET_TRIPLES),$(info cfg: host for $(t) is $(HOST_$(t))))
 
-# FIXME: This appears to do nothing
-CFG_GCCISH_FLAGS += -fno-strict-aliasing
-
 # FIXME: no-omit-frame-pointer is just so that task_start_wrapper
 # has a frame pointer and the stack walker can understand it. Turning off
 # frame pointers everywhere is overkill
@@ -146,7 +143,7 @@ ifdef CFG_UNIXY
       CFG_VALGRIND += wine
     endif
 
-    CFG_GCCISH_CFLAGS := -fno-strict-aliasing -march=i586
+    CFG_GCCISH_CFLAGS := -march=i586
     CFG_GCCISH_PRE_LIB_FLAGS :=
     CFG_GCCISH_POST_LIB_FLAGS :=
     CFG_GCCISH_DEF_FLAG :=

trunk/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> {

trunk/src/libcore/box.rs

@@ -2,9 +2,9 @@
 
 export ptr_eq;
 
-pure fn ptr_eq<T>(a: @T, b: @T) -> bool unchecked {
+pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
     #[doc = "Determine if two shared boxes point to the same object"];
-    ptr::addr_of(*a) == ptr::addr_of(*b)
+    unsafe { ptr::addr_of(*a) == ptr::addr_of(*b) }
 }
 
 #[test]

trunk/src/libcore/char.rs

@@ -231,7 +231,7 @@ fn test_to_digit() {
 }
 
 #[test]
-fn test_is_ascii() unsafe {
+fn test_is_ascii() {
    assert str::all("banana", char::is_ascii);
    assert ! str::all("ประเทศไทย中华Việt Nam", char::is_ascii);
 }

trunk/src/libcore/comm.rs

@@ -210,13 +210,13 @@ fn recv_<T: send>(p: *rust_port) -> T {
     ret res;
 }
 
-fn peek_(p: *rust_port) -> bool unsafe {
+fn peek_(p: *rust_port) -> bool {
     rustrt::rust_port_size(p) != 0u as libc::size_t
 }
 
 #[doc = "Receive on one of two ports"]
 fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>)
-    -> either<A, B> unsafe {
+    -> either<A, B> {
     let ports = [(**p_a).po, (**p_b).po];
     let n_ports = 2 as libc::size_t;
     let yield = 0u, yieldp = ptr::addr_of(yield);

trunk/src/libcore/core.rs

@@ -12,9 +12,24 @@ import option_iter::extensions;
 import ptr::extensions;
 import rand::extensions;
 import result::extensions;
+import int::num;
+import i8::num;
+import i16::num;
+import i32::num;
+import i64::num;
+import uint::num;
+import u8::num;
+import u16::num;
+import u32::num;
+import u64::num;
+import float::num;
+import f32::num;
+import f64::num;
 
 export path, option, some, none, unreachable;
 export extensions;
+// The following exports are the extension impls for numeric types
+export num;
 
 // Export the log levels as global constants. Higher levels mean
 // more-verbosity. Error is the bottom level, default logging level is

trunk/src/libcore/extfmt.rs

@@ -81,7 +81,7 @@ mod ct {
     enum piece { piece_string(str), piece_conv(conv), }
     type error_fn = fn@(str) -> ! ;
 
-    fn parse_fmt_string(s: str, error: error_fn) -> [piece] unsafe {
+    fn parse_fmt_string(s: str, error: error_fn) -> [piece] {
         let mut pieces: [piece] = [];
         let lim = str::len(s);
         let mut buf = "";
@@ -225,7 +225,7 @@ mod ct {
             } else { {count: count_implied, next: i} };
     }
     fn parse_type(s: str, i: uint, lim: uint, error: error_fn) ->
-       {ty: ty, next: uint} unsafe {
+       {ty: ty, next: uint} {
         if i >= lim { error("missing type in conversion"); }
         let tstr = str::slice(s, i, i+1u);
         // TODO: Do we really want two signed types here?
@@ -314,7 +314,7 @@ mod rt {
         let mut s = str::from_char(c);
         ret pad(cv, s, pad_nozero);
     }
-    fn conv_str(cv: conv, s: str) -> str unsafe {
+    fn conv_str(cv: conv, s: str) -> str {
         // For strings, precision is the maximum characters
         // displayed
         let mut unpadded = alt cv.precision {
@@ -378,7 +378,7 @@ mod rt {
             };
     }
     enum pad_mode { pad_signed, pad_unsigned, pad_nozero, pad_float }
-    fn pad(cv: conv, &s: str, mode: pad_mode) -> str unsafe {
+    fn pad(cv: conv, &s: str, mode: pad_mode) -> str {
         let uwidth : uint = alt cv.width {
           count_implied { ret s; }
           count_is(width) {

trunk/src/libcore/f32.rs

@@ -4,9 +4,8 @@
 
 import cmath::c_float::*;
 import cmath::c_float_targ_consts::*;
-import num::num;
 
-export add, sub, mul, div, rem, lt, le, gt, eq, eq, ne;
+export add, sub, mul, div, rem, lt, le, gt, eq, ne;
 export is_positive, is_negative, is_nonpositive, is_nonnegative;
 export is_zero, is_infinite, is_finite;
 export NaN, is_NaN, infinity, neg_infinity;
@@ -18,6 +17,7 @@ export mul_add, fmax, fmin, nextafter, frexp, hypot, ldexp;
 export lgamma, ln, log_radix, ln1p, log10, log2, ilog_radix;
 export modf, pow, round, sin, sinh, sqrt, tan, tanh, tgamma, trunc;
 export signbit;
+
 export num;
 
 // These are not defined inside consts:: for consistency with
@@ -173,7 +173,7 @@ pure fn log2(n: f32) -> f32 {
     ret ln(n) / consts::ln_2;
 }
 
-impl num of num for f32 {
+impl num of num::num for f32 {
     fn add(&&other: f32)    -> f32 { ret self + other; }
     fn sub(&&other: f32)    -> f32 { ret self - other; }
     fn mul(&&other: f32)    -> f32 { ret self * other; }