---

yaml
---
r: 22443
b: refs/heads/master
c: f3e8746
h: refs/heads/master
i:
  22441: 970b2b3
  22439: bdddf57
v: v3

Author: paulstansifer

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 62e9ae04e26f60124f6760df26b517bce450ae41
+refs/heads/master: f3e874635fa4acb021947d482a7c3a32090e5910
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/doc/tutorial.md

@@ -2320,11 +2320,11 @@ and one for values. This means that this code is valid:
 ~~~~
 mod buffalo {
     type buffalo = int;
-    fn buffalo(buffalo: buffalo) -> buffalo { buffalo }
+    fn buffalo<buffalo: copy>(buffalo: buffalo) -> buffalo { buffalo }
 }
 fn main() {
     let buffalo: buffalo::buffalo = 1;
-    buffalo::buffalo(buffalo::buffalo(buffalo));
+    buffalo::buffalo::<buffalo::buffalo>(buffalo::buffalo(buffalo));
 }
 ~~~~
 

trunk/mk/target.mk

@@ -8,9 +8,9 @@
 # (resp.  corelib), set this flag to 1.  It will cause stage1 to use
 # the snapshot runtime (resp. corelib) rather than the runtime
 # (resp. corelib) from the working directory.
-USE_SNAPSHOT_RUNTIME=1
-USE_SNAPSHOT_CORELIB=1
-USE_SNAPSHOT_STDLIB=1
+USE_SNAPSHOT_RUNTIME=0
+USE_SNAPSHOT_CORELIB=0
+USE_SNAPSHOT_STDLIB=0
 
 define TARGET_STAGE_N
 

trunk/src/etc/vim/syntax/rust.vim

@@ -66,6 +66,9 @@ syn keyword   rustConstant    STDIN_FILENO STDOUT_FILENO STDERR_FILENO
 syn match     rustModPath     "\w\(\w\)*::[^<]"he=e-3,me=e-3
 syn match     rustModPathSep  "::"
 
+syn match     rustFuncCall    "\w\(\w\)*("he=e-1,me=e-1
+syn match     rustFuncCall    "\w\(\w\)*::<"he=e-3,me=e-3 " foo::<T>();
+
 syn region    rustString      start=+L\="+ skip=+\\\\\|\\"+ end=+"+ contains=rustTodo
 
 syn region    rustAttribute   start="#\[" end="\]" contains=rustString
@@ -119,6 +122,7 @@ hi def link rustAttribute     PreProc
 " Other Suggestions:
 " hi def link rustModPathSep    Conceal
 " hi rustAssert ctermfg=yellow
+" hi rustFuncCall ctermfg=magenta
 
 syn sync minlines=200
 syn sync maxlines=500

trunk/src/libcore/arc.rs

@@ -84,7 +84,7 @@ fn clone<T: const send>(rc: &arc<T>) -> arc<T> {
 }
 
 // An arc over mutable data that is protected by a lock.
-type ex_data<T: send> = {lock: sys::lock_and_signal, data: T};
+type ex_data<T: send> = {lock: sys::lock_and_signal, mut data: T};
 type exclusive<T: send> = arc_destruct<ex_data<T>>;
 
 fn exclusive<T:send >(-data: T) -> exclusive<T> {
@@ -110,12 +110,12 @@ impl methods<T: send> for exclusive<T> {
         arc_destruct(self.data)
     }
 
-    unsafe fn with<U>(f: fn(sys::condition, x: &T) -> U) -> U {
+    unsafe fn with<U>(f: fn(sys::condition, x: &mut T) -> U) -> U {
         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| f(c, &rec.data))
+            rec.lock.lock_cond(|c| f(c, &mut rec.data))
         };
         unsafe::forget(ptr);
         r

trunk/src/libcore/future.rs

@@ -12,6 +12,7 @@
  */
 
 import either::either;
+import pipes::recv;
 
 export future;
 export extensions;
@@ -60,10 +61,6 @@ fn from_value<A>(+val: A) -> future<A> {
 }
 
 fn macros() {
-    #macro[
-        [#recv[chan],
-         chan.recv()(chan)]
-    ];
     #macro[
         [#move[x],
          unsafe { let y <- *ptr::addr_of(x); y }]
@@ -77,14 +74,13 @@ fn from_port<A:send>(-port: future_pipe::client::waiting<A>) -> future<A> {
     The first time that the value is requested the task will block
     waiting for the result to be received on the port.
     "];
-    import future_pipe::client::recv;
 
     let port = ~mut some(port);
     do from_fn |move port| {
         let mut port_ = none;
         port_ <-> *port;
         let port = option::unwrap(port_);
-        alt (#recv(port)) {
+        alt recv(port) {
           future_pipe::completed(data, _next) { #move(data) }
         }
     }
@@ -137,55 +133,12 @@ fn with<A,B>(future: future<A>, blk: fn(A) -> B) -> B {
     blk(*v)
 }
 
-// The pipe protocol, generated by pipec
-/*
 proto! future_pipe {
     waiting:recv<T:send> {
         completed(T) -> terminated
     }
 
-    terminated { }
-}
-*/
-mod future_pipe {
-    fn init<T: send>() -> (client::waiting<T>, server::waiting<T>) {
-        { let (s, c) = pipes::entangle(); (c, s) }
-    }
-    enum waiting<T: send> { completed(T, client::terminated), }
-    enum terminated { }
-    mod client {
-        impl recv<T: send> for waiting<T> {
-            fn recv() -> extern fn(+waiting<T>) -> future_pipe::waiting<T> {
-                fn recv<T: send>(+pipe: waiting<T>) ->
-                   future_pipe::waiting<T> {
-                    option::unwrap(pipes::recv(pipe))
-                }
-                recv
-            }
-        }
-        type waiting<T: send> = pipes::recv_packet<future_pipe::waiting<T>>;
-        type terminated = pipes::send_packet<future_pipe::terminated>;
-    }
-    mod server {
-        fn completed<T: send>(+pipe: waiting<T>, +x_0: T) -> terminated {
-            {
-                let (s, c) = pipes::entangle();
-                let message = future_pipe::completed(x_0, s);
-                pipes::send(pipe, message);
-                c
-            }
-        }
-        type waiting<T: send> = pipes::send_packet<future_pipe::waiting<T>>;
-        impl recv for terminated {
-            fn recv() -> extern fn(+terminated) -> future_pipe::terminated {
-                fn recv(+pipe: terminated) -> future_pipe::terminated {
-                    option::unwrap(pipes::recv(pipe))
-                }
-                recv
-            }
-        }
-        type terminated = pipes::recv_packet<future_pipe::terminated>;
-    }
+    terminated:send { }
 }
 
 #[test]