bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Make remaining moves explicit in libstd

Browse source
This commit is contained in:
Tim Chevalier 2012-09-10 17:50:48 -07:00
parent 73eb894305
commit 9869d071d1
18 changed files with 68 additions and 68 deletions
Download patch file Download diff file Expand all files Collapse all files

38
src/libstd/arc.rs
View file

@ -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,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 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

2
src/libstd/bitv.rs
View file

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

4
src/libstd/cell.rs
View file

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

4
src/libstd/comm.rs
View file

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

4
src/libstd/deque.rs
View file

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

2
src/libstd/ebml.rs
View file

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

2
src/libstd/fun_treemap.rs
View file

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

2
src/libstd/getopts.rs
View file

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

6
src/libstd/json.rs
View file

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

2
src/libstd/map.rs
View file

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

8
src/libstd/net_tcp.rs
View file

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

4
src/libstd/par.rs
View file

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

4
src/libstd/rope.rs
View file

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

2
src/libstd/sha1.rs
View file

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

2
src/libstd/smallintmap.rs
View file

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

12
src/libstd/sync.rs
View file

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

34
src/libstd/test.rs
View file

@ -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 wait_idx = 0u;
let mut done_idx = 0u;
let mut run_idx = 0;
let mut wait_idx = 0;
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);
wait_idx += 1u;
run_idx += 1u;
run_test(move test, ch);
wait_idx += 1;
run_idx += 1;
}
let (test, result) = core::comm::recv(p);
if concurrency != 1u {
if concurrency != 1 {
callback(TeWait(copy test));
}
callback(TeResult(test, result));
wait_idx -= 1u;
done_idx += 1u;
callback(TeResult(move test, result));
wait_idx -= 1;
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);
}).spawn(testfn);
result_future = Some(move r);
}).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));

4
src/libstd/uv_iotask.rs
View file

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