Make more moves explicit in libcore

Author: catamorphism

src/libcore/at_vec.rs

@@ -50,7 +50,7 @@ pure fn capacity<T>(&&v: @[const T]) -> uint {
 pure fn build_sized<A>(size: uint, builder: fn(push: pure fn(+A))) -> @[A] {
     let mut vec = @[];
     unsafe { unsafe::reserve(vec, size); }
-    builder(|+x| unsafe { unsafe::push(vec, x) });
+    builder(|+x| unsafe { unsafe::push(vec, move x) });
     return vec;
 }
 
@@ -163,10 +163,10 @@ mod unsafe {
         let repr: **VecRepr = ::unsafe::reinterpret_cast(&addr_of(v));
         let fill = (**repr).fill;
         if (**repr).alloc > fill {
-            push_fast(v, initval);
+            push_fast(v, move initval);
         }
         else {
-            push_slow(v, initval);
+            push_slow(v, move initval);
         }
     }
     // This doesn't bother to make sure we have space.
@@ -182,7 +182,7 @@ mod unsafe {
 
     unsafe fn push_slow<T>(&v: @[const T], +initval: T) {
         reserve_at_least(v, v.len() + 1u);
-        push_fast(v, initval);
+        push_fast(v, move initval);
     }
 
     /**

src/libcore/comm.rs

@@ -76,7 +76,7 @@ fn Port<T: Send>() -> Port<T> {
 impl<T: Send> Port<T> {
 
     fn chan() -> Chan<T> { Chan(self) }
-    fn send(+v: T) { self.chan().send(v) }
+    fn send(+v: T) { self.chan().send(move v) }
     fn recv() -> T { recv(self) }
     fn peek() -> bool { peek(self) }
 
@@ -85,7 +85,7 @@ impl<T: Send> Port<T> {
 impl<T: Send> Chan<T> {
 
     fn chan() -> Chan<T> { self }
-    fn send(+v: T) { send(self, v) }
+    fn send(+v: T) { send(self, move v) }
     fn recv() -> T { recv_chan(self) }
     fn peek() -> bool { peek_chan(self) }
 
@@ -103,17 +103,17 @@ struct PortPtr<T:Send> {
       do task::unkillable {
         // Once the port is detached it's guaranteed not to receive further
         // messages
-        let yield = 0u;
+        let yield = 0;
         let yieldp = ptr::addr_of(yield);
         rustrt::rust_port_begin_detach(self.po, yieldp);
-        if yield != 0u {
+        if yield != 0 {
             // Need to wait for the port to be detached
             task::yield();
         }
         rustrt::rust_port_end_detach(self.po);
 
         // Drain the port so that all the still-enqueued items get dropped
-        while rustrt::rust_port_size(self.po) > 0u as size_t {
+        while rustrt::rust_port_size(self.po) > 0 as size_t {
             recv_::<T>(self.po);
         }
         rustrt::del_port(self.po);
@@ -179,7 +179,7 @@ fn send<T: Send>(ch: Chan<T>, +data: T) {
     let Chan_(p) = ch;
     let data_ptr = ptr::addr_of(data) as *();
     let res = rustrt::rust_port_id_send(p, data_ptr);
-    if res != 0u unsafe {
+    if res != 0 unsafe {
         // Data sent successfully
         unsafe::forget(data);
     }
@@ -206,35 +206,35 @@ fn peek_chan<T: Send>(ch: comm::Chan<T>) -> bool {
 
 /// Receive on a raw port pointer
 fn recv_<T: Send>(p: *rust_port) -> T {
-    let yield = 0u;
+    let yield = 0;
     let yieldp = ptr::addr_of(yield);
     let mut res;
     res = rusti::init::<T>();
     rustrt::port_recv(ptr::addr_of(res) as *uint, p, yieldp);
 
-    if yield != 0u {
+    if yield != 0 {
         // Data isn't available yet, so res has not been initialized.
         task::yield();
     } else {
         // In the absence of compiler-generated preemption points
         // this is a good place to yield
         task::yield();
     }
-    return res;
+    move res
 }
 
 fn peek_(p: *rust_port) -> bool {
     // Yield here before we check to see if someone sent us a message
-    // FIXME #524, if the compilergenerates yields, we don't need this
+    // FIXME #524, if the compiler generates yields, we don't need this
     task::yield();
-    rustrt::rust_port_size(p) != 0u as libc::size_t
+    rustrt::rust_port_size(p) != 0 as libc::size_t
 }
 
 /// Receive on one of two ports
 fn select2<A: Send, B: Send>(p_a: Port<A>, p_b: Port<B>)
     -> Either<A, B> {
     let ports = ~[(**p_a).po, (**p_b).po];
-    let yield = 0u, yieldp = ptr::addr_of(yield);
+    let yield = 0, yieldp = ptr::addr_of(yield);
 
     let mut resport: *rust_port;
     resport = rusti::init::<*rust_port>();
@@ -243,7 +243,7 @@ fn select2<A: Send, B: Send>(p_a: Port<A>, p_b: Port<B>)
                                  n_ports as size_t, yieldp);
     }
 
-    if yield != 0u {
+    if yield != 0 {
         // Wait for data
         task::yield();
     } else {
@@ -380,16 +380,16 @@ fn test_select2_rendezvous() {
     let ch_a = Chan(po_a);
     let ch_b = Chan(po_b);
 
-    for iter::repeat(10u) {
+    for iter::repeat(10) {
         do task::spawn {
-            for iter::repeat(10u) { task::yield() }
+            for iter::repeat(10) { task::yield() }
             send(ch_a, ~"a");
         };
 
         assert select2(po_a, po_b) == either::Left(~"a");
 
         do task::spawn {
-            for iter::repeat(10u) { task::yield() }
+            for iter::repeat(10) { task::yield() }
             send(ch_b, ~"b");
         };
 
@@ -404,7 +404,7 @@ fn test_select2_stress() {
     let ch_a = Chan(po_a);
     let ch_b = Chan(po_b);
 
-    let msgs = 100u;
+    let msgs = 100;
     let times = 4u;
 
     for iter::repeat(times) {
@@ -490,7 +490,7 @@ fn test_listen() {
 #[test]
 #[ignore(cfg(windows))]
 fn test_port_detach_fail() {
-    for iter::repeat(100u) {
+    for iter::repeat(100) {
         do task::spawn_unlinked {
             let po = Port();
             let ch = po.chan();

src/libcore/dlist.rs

@@ -80,7 +80,7 @@ impl<T> DListNode<T> {
 
 /// Creates a new dlist node with the given data.
 pure fn new_dlist_node<T>(+data: T) -> DListNode<T> {
-    DListNode(@{data: data, mut linked: false,
+    DListNode(@{data: move data, mut linked: false,
                  mut prev: None, mut next: None})
 }
 
@@ -92,7 +92,7 @@ pure fn DList<T>() -> DList<T> {
 /// Creates a new dlist with a single element
 pure fn from_elem<T>(+data: T) -> DList<T> {
     let list = DList();
-    unchecked { list.push(data); }
+    unchecked { list.push(move data); }
     list
 }
 
@@ -115,7 +115,7 @@ fn concat<T>(lists: DList<DList<T>>) -> DList<T> {
 
 priv impl<T> DList<T> {
     pure fn new_link(-data: T) -> DListLink<T> {
-        Some(DListNode(@{data: data, mut linked: true,
+        Some(DListNode(@{data: move data, mut linked: true,
                           mut prev: None, mut next: None}))
     }
     pure fn assert_mine(nobe: DListNode<T>) {
@@ -442,7 +442,7 @@ impl<T: Copy> DList<T> {
                 v[index] = data;
             }
         }
-        v
+        move v
     }
 }
 

src/libcore/dvec.rs

@@ -64,18 +64,18 @@ fn DVec<A>() -> DVec<A> {
 
 /// Creates a new dvec with a single element
 fn from_elem<A>(+e: A) -> DVec<A> {
-    DVec_({mut data: ~[mut e]})
+    DVec_({mut data: ~[mut move e]})
 }
 
 /// Creates a new dvec with the contents of a vector
 fn from_vec<A>(+v: ~[mut A]) -> DVec<A> {
-    DVec_({mut data: v})
+    DVec_({mut data: move v})
 }
 
 /// Consumes the vector and returns its contents
 fn unwrap<A>(+d: DVec<A>) -> ~[mut A] {
     let DVec_({data: v}) <- d;
-    return v;
+    move v
 }
 
 priv impl<A> DVec<A> {
@@ -149,7 +149,7 @@ impl<A> DVec<A> {
             let mut v <- v;
             let result = vec::pop(v);
             self.give_back(v);
-            result
+            move result
         }
     }
 
@@ -161,7 +161,7 @@ impl<A> DVec<A> {
             let data_ptr: *() = unsafe::reinterpret_cast(&data);
             if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
             log(error, ~"a");
-            self.data <- ~[mut t];
+            self.data <- ~[mut move t];
             vec::push_all_move(self.data, data);
             log(error, ~"b");
         }
@@ -170,16 +170,16 @@ impl<A> DVec<A> {
     /// Append a single item to the end of the list
     fn push(+t: A) {
         self.check_not_borrowed();
-        vec::push(self.data, t);
+        vec::push(self.data, move t);
     }
 
     /// Remove and return the first element
     fn shift() -> A {
         do self.check_out |v| {
-            let mut v = vec::from_mut(v);
+            let mut v = vec::from_mut(move v);
             let result = vec::shift(v);
-            self.give_back(vec::to_mut(v));
-            result
+            self.give_back(vec::to_mut(move v));
+            move result
         }
     }
 
@@ -196,7 +196,7 @@ impl<A> DVec<A> {
         do self.check_out |v| {
             let result = op(v);
             self.give_back(v);
-            result
+            move result
         }
     }
 
@@ -205,7 +205,7 @@ impl<A> DVec<A> {
         do self.check_out |v| {
             let result = op(v);
             self.give_back(v);
-            result
+            move result
         }
     }
 }
@@ -231,7 +231,7 @@ impl<A: Copy> DVec<A> {
                 vec::push(v, ts[i]);
                 i += 1u;
             }
-            v
+            move v
         }
     }
 
@@ -270,7 +270,7 @@ impl<A: Copy> DVec<A> {
             do self.check_out |v| {
                 let w = vec::from_mut(copy v);
                 self.give_back(v);
-                w
+                move w
             }
         }
     }
@@ -297,7 +297,7 @@ impl<A: Copy> DVec<A> {
         do self.swap |v| {
             let mut v <- v;
             vec::grow_set(v, idx, initval, val);
-            v
+            move v
         }
     }
 
@@ -317,13 +317,13 @@ impl<A: Copy> DVec<A> {
     /// Iterates over the elements in reverse order
     #[inline(always)]
     fn reach(f: fn(A) -> bool) {
-        do self.swap |v| { vec::reach(v, f); v }
+        do self.swap |v| { vec::reach(v, f); move v }
     }
 
     /// Iterates over the elements and indices in reverse order
     #[inline(always)]
     fn reachi(f: fn(uint, A) -> bool) {
-        do self.swap |v| { vec::reachi(v, f); v }
+        do self.swap |v| { vec::reachi(v, f); move v }
     }
 }
 

src/libcore/either.rs

@@ -39,7 +39,7 @@ fn lefts<T: Copy, U>(eithers: &[Either<T, U>]) -> ~[T] {
           _ => { /* fallthrough */ }
         }
     }
-    return result;
+    move result
 }
 
 fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
@@ -52,7 +52,7 @@ fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
           _ => { /* fallthrough */ }
         }
     }
-    return result;
+    move result
 }
 
 fn partition<T: Copy, U: Copy>(eithers: &[Either<T, U>])
@@ -72,7 +72,7 @@ fn partition<T: Copy, U: Copy>(eithers: &[Either<T, U>])
           Right(r) => vec::push(rights, r)
         }
     }
-    return {lefts: lefts, rights: rights};
+    return {lefts: move lefts, rights: move rights};
 }
 
 pure fn flip<T: Copy, U: Copy>(eith: &Either<T, U>) -> Either<U, T> {
@@ -114,15 +114,15 @@ pure fn unwrap_left<T,U>(+eith: Either<T,U>) -> T {
     //! Retrieves the value in the left branch. Fails if the either is Right.
 
     match move eith {
-        Left(move x) => x, Right(_) => fail ~"either::unwrap_left Right"
+        Left(move x) => move x, Right(_) => fail ~"either::unwrap_left Right"
     }
 }
 
 pure fn unwrap_right<T,U>(+eith: Either<T,U>) -> U {
     //! Retrieves the value in the right branch. Fails if the either is Left.
 
     match move eith {
-        Right(move x) => x, Left(_) => fail ~"either::unwrap_right Left"
+        Right(move x) => move x, Left(_) => fail ~"either::unwrap_right Left"
     }
 }
 

src/libcore/hash.rs

@@ -201,7 +201,7 @@ fn SipState(key0: u64, key1: u64) -> SipState {
         mut ntail : 0u,
     };
     (&state).reset();
-    return state;
+    move state
 }
 
 
@@ -368,7 +368,7 @@ impl &SipState : Streaming {
         let r = self.result_bytes();
         let mut s = ~"";
         for vec::each(r) |b| { s += uint::to_str(b as uint, 16u); }
-        return s;
+        move s
     }
 
     #[inline(always)]

src/libcore/iter-trait.rs

@@ -16,7 +16,7 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
     pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
     pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
-        iter::foldl(self, b0, blk)
+        iter::foldl(self, move b0, blk)
     }
 }