---

yaml
---
r: 32528
b: refs/heads/dist-snap
c: 9869d07
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 73eb89430569d80a2f3ff124514f2905b25dbe68
+refs/heads/dist-snap: 9869d071d101c580e1b54f077a30af8ee0fc960c
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/libstd/arc.rs

@@ -73,7 +73,7 @@ struct ARC<T: Const Send> { x: SharedMutableState<T> }
 
 /// Create an atomically reference counted wrapper.
 fn ARC<T: Const Send>(+data: T) -> ARC<T> {
-    ARC { x: unsafe { shared_mutable_state(data) } }
+    ARC { x: unsafe { shared_mutable_state(move data) } }
 }
 
 /**
@@ -105,8 +105,8 @@ fn clone<T: Const Send>(rc: &ARC<T>) -> ARC<T> {
  * guaranteed to deadlock.
  */
 fn unwrap<T: Const Send>(+rc: ARC<T>) -> T {
-    let ARC { x: x } = rc;
-    unsafe { unwrap_shared_mutable_state(x) }
+    let ARC { x: x } <- rc;
+    unsafe { unwrap_shared_mutable_state(move x) }
 }
 
 /****************************************************************************
@@ -120,7 +120,7 @@ struct MutexARC<T: Send> { x: SharedMutableState<MutexARCInner<T>> }
 
 /// Create a mutex-protected ARC with the supplied data.
 fn MutexARC<T: Send>(+user_data: T) -> MutexARC<T> {
-    mutex_arc_with_condvars(user_data, 1)
+    mutex_arc_with_condvars(move user_data, 1)
 }
 /**
  * Create a mutex-protected ARC with the supplied data and a specified number
@@ -131,7 +131,7 @@ fn mutex_arc_with_condvars<T: Send>(+user_data: T,
     let data =
         MutexARCInner { lock: mutex_with_condvars(num_condvars),
                           failed: false, data: user_data };
-    MutexARC { x: unsafe { shared_mutable_state(data) } }
+    MutexARC { x: unsafe { shared_mutable_state(move data) } }
 }
 
 impl<T: Send> &MutexARC<T> {
@@ -198,13 +198,13 @@ impl<T: Send> &MutexARC<T> {
  */
 // FIXME(#2585) make this a by-move method on the arc
 fn unwrap_mutex_arc<T: Send>(+arc: MutexARC<T>) -> T {
-    let MutexARC { x: x } = arc;
-    let inner = unsafe { unwrap_shared_mutable_state(x) };
-    let MutexARCInner { failed: failed, data: data, _ } = inner;
+    let MutexARC { x: x } <- arc;
+    let inner = unsafe { unwrap_shared_mutable_state(move x) };
+    let MutexARCInner { failed: failed, data: data, _ } <- inner;
     if failed {
         fail ~"Can't unwrap poisoned MutexARC - another task failed inside!"
     }
-    data
+    move data
 }
 
 // Common code for {mutex.access,rwlock.write}{,_cond}.
@@ -254,7 +254,7 @@ struct RWARC<T: Const Send> {
 
 /// Create a reader/writer ARC with the supplied data.
 fn RWARC<T: Const Send>(+user_data: T) -> RWARC<T> {
-    rw_arc_with_condvars(user_data, 1)
+    rw_arc_with_condvars(move user_data, 1)
 }
 /**
  * Create a reader/writer ARC with the supplied data and a specified number
@@ -265,7 +265,7 @@ fn rw_arc_with_condvars<T: Const Send>(+user_data: T,
     let data =
         RWARCInner { lock: rwlock_with_condvars(num_condvars),
                      failed: false, data: user_data };
-    RWARC { x: unsafe { shared_mutable_state(data) }, cant_nest: () }
+    RWARC { x: unsafe { shared_mutable_state(move data) }, cant_nest: () }
 }
 
 impl<T: Const Send> &RWARC<T> {
@@ -344,7 +344,7 @@ impl<T: Const Send> &RWARC<T> {
         let state = unsafe { get_shared_mutable_state(&self.x) };
         do borrow_rwlock(state).write_downgrade |write_mode| {
             check_poison(false, state.failed);
-            blk(RWWriteMode((&mut state.data, write_mode,
+            blk(RWWriteMode((&mut state.data, move write_mode,
                               PoisonOnFail(&mut state.failed))))
         }
     }
@@ -353,17 +353,17 @@ impl<T: Const Send> &RWARC<T> {
     fn downgrade(+token: RWWriteMode/&a<T>) -> RWReadMode/&a<T> {
         // The rwlock should assert that the token belongs to us for us.
         let state = unsafe { get_shared_immutable_state(&self.x) };
-        let RWWriteMode((data, t, _poison)) = token;
+        let RWWriteMode((data, t, _poison)) <- token;
         // Let readers in
-        let new_token = (&state.lock).downgrade(t);
+        let new_token = (&state.lock).downgrade(move t);
         // Whatever region the input reference had, it will be safe to use
         // the same region for the output reference. (The only 'unsafe' part
         // of this cast is removing the mutability.)
         let new_data = unsafe { unsafe::transmute_immut(data) };
         // Downgrade ensured the token belonged to us. Just a sanity check.
         assert ptr::ref_eq(&state.data, new_data);
         // Produce new token
-        RWReadMode((new_data, new_token))
+        RWReadMode((new_data, move new_token))
     }
 }
 
@@ -376,13 +376,13 @@ impl<T: Const Send> &RWARC<T> {
  */
 // FIXME(#2585) make this a by-move method on the arc
 fn unwrap_rw_arc<T: Const Send>(+arc: RWARC<T>) -> T {
-    let RWARC { x: x, _ } = arc;
-    let inner = unsafe { unwrap_shared_mutable_state(x) };
-    let RWARCInner { failed: failed, data: data, _ } = inner;
+    let RWARC { x: x, _ } <- arc;
+    let inner = unsafe { unwrap_shared_mutable_state(move x) };
+    let RWARCInner { failed: failed, data: data, _ } <- inner;
     if failed {
         fail ~"Can't unwrap poisoned RWARC - another task failed inside!"
     }
-    data
+    move data
 }
 
 // Borrowck rightly complains about immutably aliasing the rwlock in order to

branches/dist-snap/src/libstd/bitv.rs

@@ -541,7 +541,7 @@ fn from_fn(len: uint, f: fn(index: uint) -> bool) -> Bitv {
     for uint::range(0, len) |i| {
         bitv.set(i, f(i));
     }
-    return bitv;
+    move bitv
 }
 
 const uint_bits: uint = 32u + (1u << 32u >> 27u);

branches/dist-snap/src/libstd/cell.rs

@@ -46,8 +46,8 @@ impl<T> Cell<T> {
     fn with_ref<R>(op: fn(v: &T) -> R) -> R {
         let v = self.take();
         let r = op(&v);
-        self.put_back(v);
-        return move r;
+        self.put_back(move v);
+        move r
     }
 }
 

branches/dist-snap/src/libstd/comm.rs

@@ -20,11 +20,11 @@ struct DuplexStream<T: Send, U: Send> {
 
 impl<T: Send, U: Send> DuplexStream<T, U> : Channel<T> {
     fn send(+x: T) {
-        self.chan.send(x)
+        self.chan.send(move x)
     }
 
     fn try_send(+x: T) -> bool {
-        self.chan.try_send(x)
+        self.chan.try_send(move x)
     }
 }
 

branches/dist-snap/src/libstd/deque.rs

@@ -38,7 +38,7 @@ fn create<T: Copy>() -> Deque<T> {
             i += 1u;
         }
 
-        return rv;
+        move rv
     }
     fn get<T: Copy>(elts: DVec<Cell<T>>, i: uint) -> T {
         match elts.get_elt(i) { Some(t) => t, _ => fail }
@@ -111,7 +111,7 @@ fn create<T: Copy>() -> Deque<T> {
                 vec::to_mut(
                     vec::from_elem(initial_capacity, None)))
     };
-    repr as Deque::<T>
+    move (repr as Deque::<T>)
 }
 
 #[cfg(test)]

branches/dist-snap/src/libstd/ebml.rs

@@ -452,7 +452,7 @@ priv impl EbmlDeserializer {
         let r = f();
         self.parent = old_parent;
         self.pos = old_pos;
-        return r;
+        move r
     }
 
     fn _next_uint(exp_tag: EbmlSerializerTag) -> uint {

branches/dist-snap/src/libstd/fun_treemap.rs

@@ -54,7 +54,7 @@ fn find<K: Eq Ord, V: Copy>(m: Treemap<K, V>, +k: K) -> Option<V> {
       Node(@kk, @v, left, right) => {
         if k == kk {
             Some(v)
-        } else if k < kk { find(left, k) } else { find(right, k) }
+        } else if k < kk { find(left, move k) } else { find(right, move k) }
       }
     }
 }

branches/dist-snap/src/libstd/getopts.rs

@@ -343,7 +343,7 @@ fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
         i += 1u;
     }
     return Ok({opts: vec::from_slice(opts),
-               vals: vec::from_mut(vals),
+               vals: vec::from_mut(move vals),
                free: free});
 }
 

branches/dist-snap/src/libstd/json.rs

@@ -646,15 +646,15 @@ pure fn lt(value0: Json, value1: Json) -> bool {
                         let (d0_flat, d1_flat) = {
                             let d0_flat = dvec::DVec();
                             for d0.each |k, v| { d0_flat.push((k, v)); }
-                            let d0_flat = dvec::unwrap(d0_flat);
+                            let d0_flat = dvec::unwrap(move d0_flat);
                             d0_flat.qsort();
 
                             let mut d1_flat = dvec::DVec();
                             for d1.each |k, v| { d1_flat.push((k, v)); }
-                            let d1_flat = dvec::unwrap(d1_flat);
+                            let d1_flat = dvec::unwrap(move d1_flat);
                             d1_flat.qsort();
 
-                            (d0_flat, d1_flat)
+                            (move d0_flat, move d1_flat)
                         };
 
                         d0_flat < d1_flat

branches/dist-snap/src/libstd/map.rs

@@ -183,7 +183,7 @@ mod chained {
                 entry.next = new_chains[idx];
                 new_chains[idx] = Some(entry);
             }
-            self.chains = new_chains;
+            self.chains <- new_chains;
         }
 
         pure fn each_entry(blk: fn(@Entry<K,V>) -> bool) {

branches/dist-snap/src/libstd/net_tcp.rs

@@ -577,7 +577,7 @@ fn listen(-host_ip: ip::IpAddr, port: uint, backlog: uint,
     -> result::Result<(), TcpListenErrData> unsafe {
     do listen_common(host_ip, port, backlog, iotask, on_establish_cb)
         // on_connect_cb
-        |handle| unsafe {
+        |move new_connect_cb, handle| unsafe {
             let server_data_ptr = uv::ll::get_data_for_uv_handle(handle)
                 as *TcpListenFcData;
             let new_conn = NewTcpConn(handle);
@@ -727,7 +727,7 @@ fn listen_common(-host_ip: ip::IpAddr, port: uint, backlog: uint,
  * A buffered wrapper that you can cast as an `io::reader` or `io::writer`
  */
 fn socket_buf(-sock: TcpSocket) -> TcpSocketBuf {
-    TcpSocketBuf(@{ sock: sock, mut buf: ~[] })
+    TcpSocketBuf(@{ sock: move sock, mut buf: ~[] })
 }
 
 /// Convenience methods extending `net::tcp::tcp_socket`
@@ -1520,7 +1520,7 @@ mod test {
                         log(debug,
                             ~"SERVER/WORKER: send on cont ch");
                         cont_ch.send(());
-                        let sock = result::unwrap(accept_result);
+                        let sock = result::unwrap(move accept_result);
                         log(debug, ~"SERVER: successfully accepted"+
                             ~"connection!");
                         let received_req_bytes = read(sock, 0u);
@@ -1607,7 +1607,7 @@ mod test {
             Err(err_data)
         }
         else {
-            let sock = result::unwrap(connect_result);
+            let sock = result::unwrap(move connect_result);
             let resp_bytes = str::to_bytes(resp);
             tcp_write_single(sock, resp_bytes);
             let read_result = sock.read(0u);

branches/dist-snap/src/libstd/par.rs

@@ -41,7 +41,7 @@ fn map_slices<A: Copy Send, B: Copy Send>(
             let end = uint::min(len, base + items_per_task);
             do vec::as_buf(xs) |p, _len| {
                 let f = f();
-                let f = do future_spawn() |copy base| {
+                let f = do future_spawn() |move f, copy base| {
                     unsafe {
                         let len = end - base;
                         let slice = (ptr::offset(p, base),
@@ -55,7 +55,7 @@ fn map_slices<A: Copy Send, B: Copy Send>(
                         f(base, slice)
                     }
                 };
-                vec::push(futures, f);
+                vec::push(futures, move f);
             };
             base += items_per_task;
         }

branches/dist-snap/src/libstd/rope.rs

@@ -1112,13 +1112,13 @@ mod node {
 
         fn empty() -> T {
             let stack : ~[mut @Node] = ~[mut];
-            return {stack: stack, mut stackpos: -1}
+            return {stack: move stack, mut stackpos: -1}
         }
 
         fn start(node: @Node) -> T {
             let stack = vec::to_mut(vec::from_elem(height(node)+1u, node));
             return {
-                stack:             stack,
+                stack:         move stack,
                 mut stackpos:  0
             }
         }

branches/dist-snap/src/libstd/sha1.rs

@@ -253,7 +253,7 @@ fn sha1() -> Sha1 {
         mut computed: false,
         work_buf: @vec::to_mut(vec::from_elem(work_buf_len, 0u32))
     };
-    let sh = st as Sha1;
+    let sh <- st as Sha1;
     sh.reset();
     return sh;
 }

branches/dist-snap/src/libstd/smallintmap.rs

@@ -21,7 +21,7 @@ enum SmallIntMap<T:Copy> {
 /// Create a smallintmap
 fn mk<T: Copy>() -> SmallIntMap<T> {
     let v = DVec();
-    return SmallIntMap_(@{v: v});
+    return SmallIntMap_(@{v: move v});
 }
 
 /**

branches/dist-snap/src/libstd/sync.rs

@@ -84,7 +84,7 @@ fn new_sem_and_signal(count: int, num_condvars: uint)
     for num_condvars.times {
         vec::push(queues, new_waitqueue());
     }
-    new_sem(count, queues)
+    new_sem(count, move queues)
 }
 
 #[doc(hidden)]
@@ -98,9 +98,9 @@ impl<Q: Send> &Sem<Q> {
                     // Create waiter nobe.
                     let (SignalEnd, WaitEnd) = pipes::oneshot();
                     // Tell outer scope we need to block.
-                    waiter_nobe = Some(WaitEnd);
+                    waiter_nobe = Some(move WaitEnd);
                     // Enqueue ourself.
-                    state.waiters.tail.send(SignalEnd);
+                    state.waiters.tail.send(move SignalEnd);
                 }
             }
         }
@@ -203,8 +203,8 @@ impl &Condvar {
     fn wait_on(condvar_id: uint) {
         // Create waiter nobe.
         let (SignalEnd, WaitEnd) = pipes::oneshot();
-        let mut WaitEnd   = Some(WaitEnd);
-        let mut SignalEnd = Some(SignalEnd);
+        let mut WaitEnd   = Some(move WaitEnd);
+        let mut SignalEnd = Some(move SignalEnd);
         let mut reacquire = None;
         let mut out_of_bounds = None;
         unsafe {
@@ -219,7 +219,7 @@ impl &Condvar {
                         }
                         // Enqueue ourself to be woken up by a signaller.
                         let SignalEnd = option::swap_unwrap(&mut SignalEnd);
-                        state.blocked[condvar_id].tail.send(SignalEnd);
+                        state.blocked[condvar_id].tail.send(move SignalEnd);
                     } else {
                         out_of_bounds = Some(vec::len(state.blocked));
                     }