---

yaml
---
r: 13694
b: refs/heads/master
c: 6322eda
h: refs/heads/master
v: v3

Author: bstrie

[refs]

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

trunk/RELEASES.txt

@@ -7,7 +7,6 @@ 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
@@ -18,13 +17,12 @@ Version 0.3  (June 2012) - not yet!
   * Experimental new language features
     * Slices and fixed-size, interior-allocated vectors
     * #!-comments for lang versioning, shell execution
-    * Destructors and iface implementation for classes;
-       type-parameterized classes and class methods
+    * 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, resources
+    * Constructs: do-while loops, fn binding, 
 
   * Compiler reorganization
     * Syntax-layer of compiler split into separate crate
@@ -41,9 +39,6 @@ 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,8 +311,13 @@ 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,40 +1127,30 @@ enum list<T> {
 let a: list<int> = cons(7, @cons(13, @nil));
 ~~~~
 
-### Classes
+### Resources
 
-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:
+_Resources_ are values that have a destructor associated with them. A
+_resource item_ is used to declare resource type and constructor.
 
 ~~~~
-class file_descriptor {
-    let fd: libc::c_int;
-    new(fd: libc::c_int) { self.fd = fd; }
-    drop { libc::close(self.fd); }
+resource file_descriptor(fd: libc::c_int) {
+    libc::close(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. 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`.
+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).
 
 ### Interfaces
 

trunk/doc/tutorial.md

@@ -1377,7 +1377,26 @@ 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.
 
-NOTE: Section on resources removed. ToDo: document classes and destructors
+## 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.
 
 # Argument passing
 
@@ -1562,7 +1581,7 @@ without any sophistication).
 ## Kinds
 
 Perhaps surprisingly, the 'copy' (duplicate) operation is not defined
-for all Rust types. Resource types (classes with destructors) cannot be
+for all Rust types. Resource types (types with destructors) can not 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,6 +9,9 @@ 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
@@ -143,7 +146,7 @@ ifdef CFG_UNIXY
       CFG_VALGRIND += wine
     endif
 
-    CFG_GCCISH_CFLAGS := -march=i586
+    CFG_GCCISH_CFLAGS := -fno-strict-aliasing -march=i586
     CFG_GCCISH_PRE_LIB_FLAGS :=
     CFG_GCCISH_POST_LIB_FLAGS :=
     CFG_GCCISH_DEF_FLAG :=

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/box.rs

@@ -2,9 +2,9 @@
 
 export ptr_eq;
 
-pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
+pure fn ptr_eq<T>(a: @T, b: @T) -> bool unchecked {
     #[doc = "Determine if two shared boxes point to the same object"];
-    unsafe { ptr::addr_of(*a) == ptr::addr_of(*b) }
+    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() {
+fn test_is_ascii() unsafe {
    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 {
+fn peek_(p: *rust_port) -> bool unsafe {
     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> {
+    -> either<A, B> unsafe {
     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,24 +12,9 @@ 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] {
+    fn parse_fmt_string(s: str, error: error_fn) -> [piece] unsafe {
         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} {
+       {ty: ty, next: uint} unsafe {
         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 {
+    fn conv_str(cv: conv, s: str) -> str unsafe {
         // 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 {
+    fn pad(cv: conv, &s: str, mode: pad_mode) -> str unsafe {
         let uwidth : uint = alt cv.width {
           count_implied { ret s; }
           count_is(width) {

trunk/src/libcore/f32.rs

@@ -4,8 +4,9 @@
 
 import cmath::c_float::*;
 import cmath::c_float_targ_consts::*;
+import num::num;
 
-export add, sub, mul, div, rem, lt, le, gt, eq, ne;
+export add, sub, mul, div, rem, lt, le, gt, eq, 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;
@@ -17,7 +18,6 @@ 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::num for f32 {
+impl num of 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; }