Merge

Author: catamorphism

RELEASES.txt

@@ -1,3 +1,47 @@
+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)
 -------------------------
 

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]

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);
 }

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

src/libcore/core.rs

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

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) {

src/libcore/int-template.rs

@@ -93,10 +93,10 @@ fn parse_buf(buf: [u8], radix: uint) -> option<T> {
 fn from_str(s: str) -> option<T> { parse_buf(str::bytes(s), 10u) }
 
 #[doc = "Convert to a string in a given base"]
-fn to_str(n: T, radix: uint) -> str unsafe {
+fn to_str(n: T, radix: uint) -> str {
     to_str_bytes(n, radix) {|slice|
         vec::unpack_slice(slice) {|p, len|
-            str::unsafe::from_buf_len(p, len)
+            unsafe { str::unsafe::from_buf_len(p, len) }
         }
     }
 }

src/libcore/io.rs

@@ -192,13 +192,13 @@ fn convert_whence(whence: seek_style) -> i32 {
 }
 
 impl of reader for *libc::FILE {
-    fn read_bytes(len: uint) -> [u8] unsafe {
+    fn read_bytes(len: uint) -> [u8] {
         let mut buf : [mut u8] = [mut];
         vec::reserve(buf, len);
         vec::as_mut_buf(buf) {|b|
             let read = libc::fread(b as *mut c_void, 1u as size_t,
                                    len as size_t, self);
-            vec::unsafe::set_len(buf, read as uint);
+            unsafe { vec::unsafe::set_len(buf, read as uint) };
         }
         ret vec::from_mut(buf);
     }
@@ -333,7 +333,7 @@ impl <T: writer, C> of writer for {base: T, cleanup: C} {
 }
 
 impl of writer for *libc::FILE {
-    fn write(v: [const u8]/&) unsafe {
+    fn write(v: [const u8]/&) {
         vec::unpack_const_slice(v) {|vbuf, len|
             let nout = libc::fwrite(vbuf as *c_void, len as size_t,
                                     1u as size_t, self);
@@ -361,7 +361,7 @@ fn FILE_writer(f: *libc::FILE, cleanup: bool) -> writer {
 }
 
 impl of writer for fd_t {
-    fn write(v: [const u8]/&) unsafe {
+    fn write(v: [const u8]/&) {
         let mut count = 0u;
         vec::unpack_const_slice(v) {|vbuf, len|
             while count < len {

src/libcore/option.rs

@@ -70,21 +70,23 @@ pure fn iter<T>(opt: option<T>, f: fn(T)) {
     alt opt { none { } some(t) { f(t); } }
 }
 
-pure fn unwrap<T>(-opt: option<T>) -> T unsafe {
+pure fn unwrap<T>(-opt: option<T>) -> T {
     #[doc = "
     Moves a value out of an option type and returns it.
 
     Useful primarily for getting strings, vectors and unique pointers out of
     option types without copying them.
     "];
 
-    let addr = alt opt {
-      some(x) { ptr::addr_of(x) }
-      none { fail "option none" }
-    };
-    let liberated_value = unsafe::reinterpret_cast(*addr);
-    unsafe::forget(opt);
-    ret liberated_value;
+    unsafe {
+        let addr = alt opt {
+          some(x) { ptr::addr_of(x) }
+          none { fail "option none" }
+        };
+        let liberated_value = unsafe::reinterpret_cast(*addr);
+        unsafe::forget(opt);
+        ret liberated_value;
+    }
 }
 
 impl extensions<T> for option<T> {

src/libcore/os.rs

@@ -180,19 +180,21 @@ mod global_env {
         }
     }
 
-    fn global_env_task(msg_po: comm::port<msg>) unsafe {
-        priv::weaken_task {|weak_po|
-            loop {
-                alt comm::select2(msg_po, weak_po) {
-                  either::left(msg_getenv(n, resp_ch)) {
-                    comm::send(resp_ch, impl::getenv(n))
-                  }
-                  either::left(msg_setenv(n, v, resp_ch)) {
-                    comm::send(resp_ch, impl::setenv(n, v))
-                  }
-                  either::right(_) {
-                    break;
-                  }
+    fn global_env_task(msg_po: comm::port<msg>) {
+        unsafe {
+            priv::weaken_task {|weak_po|
+                loop {
+                    alt comm::select2(msg_po, weak_po) {
+                      either::left(msg_getenv(n, resp_ch)) {
+                        comm::send(resp_ch, impl::getenv(n))
+                      }
+                      either::left(msg_setenv(n, v, resp_ch)) {
+                        comm::send(resp_ch, impl::setenv(n, v))
+                      }
+                      either::right(_) {
+                        break;
+                      }
+                    }
                 }
             }
         }
@@ -201,18 +203,20 @@ mod global_env {
     mod impl {
 
         #[cfg(unix)]
-        fn getenv(n: str) -> option<str> unsafe {
-            let s = str::as_c_str(n, libc::getenv);
-            ret if unsafe::reinterpret_cast(s) == 0 {
-                option::none::<str>
-            } else {
-                let s = unsafe::reinterpret_cast(s);
-                option::some::<str>(str::unsafe::from_buf(s))
-            };
+        fn getenv(n: str) -> option<str> {
+            unsafe {
+                let s = str::as_c_str(n, libc::getenv);
+                ret if unsafe::reinterpret_cast(s) == 0 {
+                    option::none::<str>
+                } else {
+                    let s = unsafe::reinterpret_cast(s);
+                    option::some::<str>(str::unsafe::from_buf(s))
+                };
+            }
         }
 
         #[cfg(windows)]
-        fn getenv(n: str) -> option<str> unsafe {
+        fn getenv(n: str) -> option<str> {
             import libc::types::os::arch::extra::*;
             import libc::funcs::extra::kernel32::*;
             import win32::*;
@@ -362,21 +366,23 @@ fn dll_filename(base: str) -> str {
 fn self_exe_path() -> option<path> {
 
     #[cfg(target_os = "freebsd")]
-    fn load_self() -> option<path> unsafe {
-        import libc::funcs::bsd44::*;
-        import libc::consts::os::extra::*;
-        fill_charp_buf() {|buf, sz|
-            let mib = [CTL_KERN as c_int,
-                       KERN_PROC as c_int,
-                       KERN_PROC_PATHNAME as c_int, -1 as c_int];
-            sysctl(vec::unsafe::to_ptr(mib), vec::len(mib) as c_uint,
-                   buf as *mut c_void, ptr::mut_addr_of(sz),
-                   ptr::null(), 0u as size_t) == (0 as c_int)
+    fn load_self() -> option<path> {
+        unsafe {
+            import libc::funcs::bsd44::*;
+            import libc::consts::os::extra::*;
+            fill_charp_buf() {|buf, sz|
+                let mib = [CTL_KERN as c_int,
+                           KERN_PROC as c_int,
+                           KERN_PROC_PATHNAME as c_int, -1 as c_int];
+                sysctl(vec::unsafe::to_ptr(mib), vec::len(mib) as c_uint,
+                       buf as *mut c_void, ptr::mut_addr_of(sz),
+                       ptr::null(), 0u as size_t) == (0 as c_int)
+            }
         }
     }
 
     #[cfg(target_os = "linux")]
-    fn load_self() -> option<path> unsafe {
+    fn load_self() -> option<path> {
         import libc::funcs::posix01::unistd::readlink;
         fill_charp_buf() {|buf, sz|
             as_c_charp("/proc/self/exe") { |proc_self_buf|
@@ -386,17 +392,18 @@ fn self_exe_path() -> option<path> {
     }
 
     #[cfg(target_os = "macos")]
-    fn load_self() -> option<path> unsafe {
+    fn load_self() -> option<path> {
         // FIXME: remove imports when export globs work properly. #1238
         import libc::funcs::extra::*;
+
         fill_charp_buf() {|buf, sz|
             _NSGetExecutablePath(buf, ptr::mut_addr_of(sz as u32))
                 == (0 as c_int)
         }
     }
 
     #[cfg(windows)]
-    fn load_self() -> option<path> unsafe {
+    fn load_self() -> option<path> {
         // FIXME: remove imports when export globs work properly. #1238
         import libc::types::os::arch::extra::*;
         import libc::funcs::extra::kernel32::*;
@@ -525,14 +532,14 @@ fn make_dir(p: path, mode: c_int) -> bool {
     ret mkdir(p, mode);
 
     #[cfg(windows)]
-    fn mkdir(p: path, _mode: c_int) -> bool unsafe {
+    fn mkdir(p: path, _mode: c_int) -> bool {
         // FIXME: remove imports when export globs work properly. #1238
         import libc::types::os::arch::extra::*;
         import libc::funcs::extra::kernel32::*;
         import win32::*;
         // FIXME: turn mode into something useful? #2623
         as_utf16_p(p) {|buf|
-            CreateDirectoryW(buf, unsafe::reinterpret_cast(0))
+            CreateDirectoryW(buf, unsafe { unsafe::reinterpret_cast(0) })
                 != (0 as BOOL)
         }
     }
@@ -645,7 +652,7 @@ fn copy_file(from: path, to: path) -> bool {
     }
 
     #[cfg(unix)]
-    fn do_copy_file(from: path, to: path) -> bool unsafe {
+    fn do_copy_file(from: path, to: path) -> bool {
         let istream = as_c_charp(from) {|fromp|
             as_c_charp("rb") {|modebuf|
                 libc::fopen(fromp, modebuf)

src/libcore/path.rs

@@ -105,14 +105,20 @@ Given paths `pre` and `post, removes any trailing path separator on `pre` and
 any leading path separator on `post`, and returns the concatenation of the two
 with a single path separator between them.
 "]
-fn connect(pre: path, post: path) -> path unsafe {
+fn connect(pre: path, post: path) -> path {
     let mut pre_ = pre;
     let mut post_ = post;
     let sep = consts::path_sep as u8;
     let pre_len  = str::len(pre);
     let post_len = str::len(post);
-    if pre_len > 1u && pre[pre_len-1u] == sep { str::unsafe::pop_byte(pre_); }
-    if post_len > 1u && post[0] == sep { str::unsafe::shift_byte(post_); }
+    unsafe {
+        if pre_len > 1u && pre[pre_len-1u] == sep {
+            str::unsafe::pop_byte(pre_);
+        }
+        if post_len > 1u && post[0] == sep {
+            str::unsafe::shift_byte(post_);
+        }
+    }
     ret pre_ + path_sep() + post_;
 }