Make remaining moves explicit in libstd

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;
+    let ARC { x: x } <- rc;
-    unsafe { unwrap_shared_mutable_state(x) }
+    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 MutexARC { x: x } <- arc;
-    let inner = unsafe { unwrap_shared_mutable_state(x) };
+    let inner = unsafe { unwrap_shared_mutable_state(move x) };
-    let MutexARCInner { failed: failed, data: data, _ } = inner;
+    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,9 +353,9 @@ 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.)
@@ -363,7 +363,7 @@ impl<T: Const Send> &RWARC<T> {
         // 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 RWARC { x: x, _ } <- arc;
-    let inner = unsafe { unwrap_shared_mutable_state(x) };
+    let inner = unsafe { unwrap_shared_mutable_state(move x) };
-    let RWARCInner { failed: failed, data: data, _ } = inner;
+    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

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

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);
+        self.put_back(move v);
-        return move r;
+        move r
     }
 }
 

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

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

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 {

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

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

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

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

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

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

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

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

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

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 WaitEnd   = Some(move WaitEnd);
-        let mut SignalEnd = Some(SignalEnd);
+        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));
                     }

src/libstd/test.rs

@@ -291,9 +291,9 @@ fn run_tests(opts: TestOpts, tests: ~[TestDesc],
     debug!("using %u test tasks", concurrency);
 
     let total = vec::len(filtered_tests);
-    let mut run_idx = 0u;
+    let mut run_idx = 0;
-    let mut wait_idx = 0u;
+    let mut wait_idx = 0;
-    let mut done_idx = 0u;
+    let mut done_idx = 0;
 
     let p = core::comm::Port();
     let ch = core::comm::Chan(p);
@@ -301,24 +301,24 @@ fn run_tests(opts: TestOpts, tests: ~[TestDesc],
     while done_idx < total {
         while wait_idx < concurrency && run_idx < total {
             let test = copy filtered_tests[run_idx];
-            if concurrency == 1u {
+            if concurrency == 1 {
                 // We are doing one test at a time so we can print the name
                 // of the test before we run it. Useful for debugging tests
                 // that hang forever.
                 callback(TeWait(copy test));
             }
-            run_test(test, ch);
+            run_test(move test, ch);
-            wait_idx += 1u;
+            wait_idx += 1;
-            run_idx += 1u;
+            run_idx += 1;
         }
 
         let (test, result) = core::comm::recv(p);
-        if concurrency != 1u {
+        if concurrency != 1 {
             callback(TeWait(copy test));
         }
-        callback(TeResult(test, result));
+        callback(TeResult(move test, result));
-        wait_idx -= 1u;
+        wait_idx -= 1;
-        done_idx += 1u;
+        done_idx += 1;
     }
 }
 
@@ -342,7 +342,7 @@ fn filter_tests(opts: TestOpts,
 
     // Remove tests that don't match the test filter
     filtered = if option::is_none(opts.filter) {
-        filtered
+        move filtered
     } else {
         let filter_str =
             match opts.filter {
@@ -362,7 +362,7 @@ fn filter_tests(opts: TestOpts,
 
     // Maybe pull out the ignored test and unignore them
     filtered = if !opts.run_ignored {
-        filtered
+        move filtered
     } else {
         fn filter(test: TestDesc) -> Option<TestDesc> {
             if test.ignore {
@@ -384,7 +384,7 @@ fn filter_tests(opts: TestOpts,
         sort::merge_sort(lteq, filtered)
     };
 
-    return filtered;
+    move filtered
 }
 
 type TestFuture = {test: TestDesc, wait: fn@() -> TestResult};
@@ -395,12 +395,12 @@ fn run_test(+test: TestDesc, monitor_ch: comm::Chan<MonitorMsg>) {
         return;
     }
 
-    do task::spawn {
+    do task::spawn |move test| {
         let testfn = copy test.fn;
         let mut result_future = None; // task::future_result(builder);
         task::task().unlinked().future_result(|+r| {
-            result_future = Some(r);
+            result_future = Some(move r);
-        }).spawn(testfn);
+        }).spawn(move testfn);
         let task_result = future::get(&option::unwrap(result_future));
         let test_result = calc_result(test, task_result == task::Success);
         comm::send(monitor_ch, (copy test, test_result));

src/libstd/uv_iotask.rs

@@ -64,7 +64,7 @@ fn spawn_iotask(-task: task::TaskBuilder) -> IoTask {
  */
 unsafe fn interact(iotask: IoTask,
                    -cb: fn~(*c_void)) {
-    send_msg(iotask, Interaction(cb));
+    send_msg(iotask, Interaction(move cb));
 }
 
 /**
@@ -129,7 +129,7 @@ type IoTaskLoopData = {
 
 fn send_msg(iotask: IoTask,
             -msg: IoTaskMsg) unsafe {
-    iotask.op_chan.send(msg);
+    iotask.op_chan.send(move msg);
     ll::async_send(iotask.async_handle);
 }