Merge remote-tracking branch 'mozilla/incoming'

Author: brson

RELEASES.txt

@@ -1,3 +1,44 @@
+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.
+
 Version 0.2  (March 2012)
 -------------------------
 

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_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/priv.rs

@@ -232,5 +232,5 @@ fn test_weaken_task_fail() unsafe {
             fail;
         }
     };
-    assert result::is_failure(res);
+    assert result::is_err(res);
 }

src/libcore/result.rs

@@ -43,16 +43,16 @@ pure fn get_err<T, U: copy>(res: result<T, U>) -> U {
 }
 
 #[doc = "Returns true if the result is `ok`"]
-pure fn is_success<T, U>(res: result<T, U>) -> bool {
+pure fn is_ok<T, U>(res: result<T, U>) -> bool {
     alt res {
       ok(_) { true }
       err(_) { false }
     }
 }
 
-#[doc = "Returns true if the result is `error`"]
-pure fn is_failure<T, U>(res: result<T, U>) -> bool {
-    !is_success(res)
+#[doc = "Returns true if the result is `err`"]
+pure fn is_err<T, U>(res: result<T, U>) -> bool {
+    !is_ok(res)
 }
 
 #[doc = "
@@ -180,22 +180,10 @@ fn map_err<T: copy, E, F: copy>(res: result<T, E>, op: fn(E) -> F)
     }
 }
 
-impl extensions<T:copy, E:copy> for result<T,E> {
-    fn get() -> T { get(self) }
-
-    fn get_err() -> E { get_err(self) }
-
-    fn is_success() -> bool { is_success(self) }
-
-    fn is_failure() -> bool { is_failure(self) }
-
-    fn chain<U:copy>(op: fn(T) -> result<U,E>) -> result<U,E> {
-        chain(self, op)
-    }
+impl extensions<T, E> for result<T, E> {
+    fn is_ok() -> bool { is_ok(self) }
 
-    fn chain_err<F:copy>(op: fn(E) -> result<T,F>) -> result<T,F> {
-        chain_err(self, op)
-    }
+    fn is_err() -> bool { is_err(self) }
 
     fn iter(f: fn(T)) {
         alt self {
@@ -210,19 +198,37 @@ impl extensions<T:copy, E:copy> for result<T,E> {
           err(e) { f(e) }
         }
     }
+}
+
+impl extensions<T:copy, E> for result<T, E> {
+    fn get() -> T { get(self) }
+
+    fn map_err<F:copy>(op: fn(E) -> F) -> result<T,F> {
+        alt self {
+          ok(t) { ok(t) }
+          err(e) { err(op(e)) }
+        }
+    }
+}
+
+impl extensions<T, E:copy> for result<T, E> {
+    fn get_err() -> E { get_err(self) }
 
     fn map<U:copy>(op: fn(T) -> U) -> result<U,E> {
         alt self {
           ok(t) { ok(op(t)) }
           err(e) { err(e) }
         }
     }
+}
 
-    fn map_err<F:copy>(op: fn(E) -> F) -> result<T,F> {
-        alt self {
-          ok(t) { ok(t) }
-          err(e) { err(op(e)) }
-        }
+impl extensions<T:copy, E:copy> for result<T,E> {
+    fn chain<U:copy>(op: fn(T) -> result<U,E>) -> result<U,E> {
+        chain(self, op)
+    }
+
+    fn chain_err<F:copy>(op: fn(E) -> result<T,F>) -> result<T,F> {
+        chain_err(self, op)
     }
 }
 

src/libcore/vec.rs

@@ -385,7 +385,6 @@ fn shift<T>(&v: [T]) -> T {
             let mut r <- *vv;
 
             for uint::range(1u, ln) {|i|
-                // FIXME (#2703): this isn't legal, per se...
                 let r <- *ptr::offset(vv, i);
                 push(v, r);
             }
@@ -397,6 +396,15 @@ fn shift<T>(&v: [T]) -> T {
     }
 }
 
+#[doc = "Prepend an element to the vector"]
+fn unshift<T>(&v: [T], +x: T) {
+    let mut vv = [x];
+    v <-> vv;
+    while len(vv) > 0 {
+        push(v, shift(vv));
+    }
+}
+
 #[doc = "Remove the last element from a vector and return it"]
 fn pop<T>(&v: [const T]) -> T unsafe {
     let ln = len(v);
@@ -2198,6 +2206,13 @@ mod tests {
         assert addr == addr_imm;
     }
 
+    #[test]
+    fn test_unshift() {
+        let mut x = [1, 2, 3];
+        unshift(x, 0);
+        assert x == [0, 1, 2, 3];
+    }
+
     #[test]
     fn test_capacity() {
         let mut v = [0u64];

src/libstd/net_tcp.rs

@@ -813,7 +813,7 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
     log(debug, "starting tcp::read");
     let iotask = (*socket_data).iotask;
     let rs_result = read_start_common_impl(socket_data);
-    if result::is_failure(rs_result) {
+    if result::is_err(rs_result) {
         let err_data = result::get_err(rs_result);
         result::err(err_data)
     }
@@ -1424,7 +1424,7 @@ mod test {
 
                         let accept_result = accept(new_conn);
                         log(debug, "SERVER: after accept()");
-                        if result::is_failure(accept_result) {
+                        if result::is_err(accept_result) {
                             log(debug, "SERVER: error accept connection");
                             let err_data = result::get_err(accept_result);
                             comm::send(kill_ch, some(err_data));
@@ -1465,7 +1465,7 @@ mod test {
                 log(debug, "SERVER: recv'd on cont_ch..leaving listen cb");
             });
             // err check on listen_result
-            if result::is_failure(listen_result) {
+            if result::is_err(listen_result) {
                 let err_data = result::get_err(listen_result);
                 log(debug, #fmt("SERVER: exited abnormally name %s msg %s",
                                 err_data.err_name, err_data.err_msg));
@@ -1486,7 +1486,7 @@ mod test {
             let server_ip_addr = ip::v4::parse_addr(server_ip);
             let new_listener_result =
                 new_listener(server_ip_addr, server_port, 128u, iotask);
-            if result::is_failure(new_listener_result) {
+            if result::is_err(new_listener_result) {
                 let err_data = result::get_err(new_listener_result);
                 log(debug, #fmt("SERVER: exited abnormally name %s msg %s",
                                 err_data.err_name, err_data.err_msg));
@@ -1498,7 +1498,7 @@ mod test {
             // in a loop {}, but we're just going to take a single
             // client.. get their req, write a resp and then exit
             let new_conn_result = server_port.recv();
-            if result::is_failure(new_conn_result) {
+            if result::is_err(new_conn_result) {
                 let err_data = result::get_err(new_conn_result);
                 log(debug, #fmt("SERVER: exited abnormally name %s msg %s",
                                 err_data.err_name, err_data.err_msg));
@@ -1535,7 +1535,7 @@ mod test {
 
         log(debug, "CLIENT: starting..");
         let connect_result = connect(server_ip_addr, server_port, iotask);
-        if result::is_failure(connect_result) {
+        if result::is_err(connect_result) {
             log(debug, "CLIENT: failed to connect");
             let err_data = result::get_err(connect_result);
             log(debug, #fmt("CLIENT: connect err name: %s msg: %s",
@@ -1547,7 +1547,7 @@ mod test {
             let resp_bytes = str::bytes(resp);
             tcp_write_single(sock, resp_bytes);
             let read_result = sock.read(0u);
-            if read_result.is_failure() {
+            if read_result.is_err() {
                 log(debug, "CLIENT: failure to read");
                 ""
             }
@@ -1564,7 +1564,7 @@ mod test {
     fn tcp_write_single(sock: tcp_socket, val: [u8]) {
         let write_result_future = sock.write_future(val);
         let write_result = write_result_future.get();
-        if result::is_failure(write_result) {
+        if result::is_err(write_result) {
             log(debug, "tcp_write_single: write failed!");
             let err_data = result::get_err(write_result);
             log(debug, #fmt("tcp_write_single err name: %s msg: %s",

src/libsyntax/ext/auto_serialize.rs

@@ -452,10 +452,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
         []
       }
 
-      ast::ty_vstore(_, _) {
-        cx.span_unimpl(ty.span, "serialization for vstore types");
-      }
-
+      ast::ty_vstore(@{node: ast::ty_vec(mt),_}, ast::vstore_uniq) |
       ast::ty_vec(mt) {
         let ser_e =
             cx.expr(
@@ -472,6 +469,11 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
             std::serialization::emit_from_vec($(s), $(v), {|__e| $(ser_e) })
         }]
       }
+
+      ast::ty_vstore(_, _) {
+        cx.span_unimpl(ty.span, "serialization for vstore types");
+      }
+
     }
 }
 
@@ -673,14 +675,15 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
         #ast{ fail }
       }
 
-      ast::ty_vstore(_, _) {
-        cx.span_unimpl(ty.span, "deserialization for vstore types");
-      }
-
+      ast::ty_vstore(@{node: ast::ty_vec(mt),_}, ast::vstore_uniq) |
       ast::ty_vec(mt) {
         let l = deser_lambda(cx, tps, mt.ty, cx.clone(d));
         #ast{ std::serialization::read_to_vec($(d), $(l)) }
       }
+
+      ast::ty_vstore(_, _) {
+        cx.span_unimpl(ty.span, "deserialization for vstore types");
+      }
     }
 }
 

src/libsyntax/parse/parser.rs

@@ -1979,7 +1979,7 @@ class parser {
         let rp = self.parse_region_param();
         let ty_params = self.parse_ty_params();
         let class_path = self.ident_to_path_tys(class_name, rp, ty_params);
-        let ifaces : [@iface_ref] = if self.eat_keyword("implements")
+        let ifaces : [@iface_ref] = if self.eat(token::COLON)
             { self.parse_iface_ref_list() }
         else { [] };
         self.expect(token::LBRACE);

src/libsyntax/parse/token.rs

@@ -251,7 +251,6 @@ fn contextual_keyword_table() -> hashmap<str, ()> {
     let keys = [
         "as",
         "else",
-        "implements",
         "move",
         "of",
         "priv", "pub",

src/libsyntax/print/pprust.rs

@@ -527,9 +527,11 @@ fn print_item(s: ps, &&item: @ast::item) {
           word_nbsp(s, *item.ident);
           print_region_param(s, rp);
           print_type_params(s, tps);
-          word_space(s, "implements");
-          commasep(s, inconsistent, ifaces, {|s, p|
-                      print_path(s, p.path, false)});
+          if vec::len(ifaces) != 0u {
+              word_space(s, ":");
+              commasep(s, inconsistent, ifaces, {|s, p|
+                  print_path(s, p.path, false)});
+          }
           bopen(s);
           hardbreak_if_not_bol(s);
           maybe_print_comment(s, ctor.span.lo);

src/rt/rust_builtin.cpp

@@ -891,9 +891,7 @@ rust_unlock_cond_lock(rust_cond_lock *lock) {
 extern "C" void
 rust_wait_cond_lock(rust_cond_lock *lock) {
     rust_task *task = rust_get_current_task();
-#ifdef DEBUG_LOCKS
-    assert(lock->lock.lock_held_by_current_thread());
-#endif
+    lock->lock.must_have_lock();
     assert(NULL == lock->waiting);
     lock->waiting = task;
     task->block(lock, "waiting for signal");
@@ -905,9 +903,7 @@ rust_wait_cond_lock(rust_cond_lock *lock) {
 
 extern "C" bool
 rust_signal_cond_lock(rust_cond_lock *lock) {
-#ifdef DEBUG_LOCKS
-    assert(lock->lock.lock_held_by_current_thread());
-#endif
+    lock->lock.must_have_lock();
     if(NULL == lock->waiting) {
         return false;
     }

src/rustc/middle/trans/base.rs

@@ -1797,7 +1797,6 @@ fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop,
             arg_exprs([src]), save_in(target));
 
         ret move_val(bcx, DROP_EXISTING, lhs_res.val,
-                     // FIXME (#2704): should kind be owned?
                      {bcx: bcx, val: target, kind: owned},
                      dty);
       }