Remove uses of binary move - <- - from tests and libraries

Author: catamorphism

src/fuzzer/ivec_fuzz.rs

@@ -2,7 +2,7 @@
 
 Idea: provide functions for 'exhaustive' and 'random' modification of vecs.
 
-  two functions, "return all edits" and "return a random edit" <--
+  two functions, "return all edits" and "return a random edit" = move-
     leaning toward this model or two functions, "return the number of
     possible edits" and "return edit #n"
 

src/libcore/dvec.rs

@@ -72,7 +72,7 @@ pub fn from_vec<A>(v: ~[A]) -> DVec<A> {
 
 /// Consumes the vector and returns its contents
 pub fn unwrap<A>(d: DVec<A>) -> ~[A] {
-    let DVec_({data: v}) <- d;
+    let DVec_({data: v}) = move d;
     move v
 }
 
@@ -150,13 +150,13 @@ impl<A> DVec<A> {
     /// Overwrite the current contents
     fn set(w: ~[A]) {
         self.check_not_borrowed();
-        self.data <- w;
+        self.data = move w;
     }
 
     /// Remove and return the last element
     fn pop() -> A {
         do self.check_out |v| {
-            let mut v <- v;
+            let mut v = move v;
             let result = v.pop();
             self.give_back(move v);
             move result
@@ -171,7 +171,7 @@ impl<A> DVec<A> {
             let data_ptr: *() = cast::reinterpret_cast(&data);
             if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
             log(error, ~"a");
-            self.data <- ~[move t];
+            self.data = move ~[move t];
             self.data.push_all_move(move data);
             log(error, ~"b");
         }
@@ -235,7 +235,7 @@ impl<A: Copy> DVec<A> {
     /// Appends elements from `from_idx` to `to_idx` (exclusive)
     fn push_slice(ts: &[const A], from_idx: uint, to_idx: uint) {
         do self.swap |v| {
-            let mut v <- v;
+            let mut v = move v;
             let new_len = vec::len(v) + to_idx - from_idx;
             vec::reserve(&mut v, new_len);
             let mut i = from_idx;
@@ -260,7 +260,7 @@ impl<A: Copy> DVec<A> {
              none { v }
              Some(h) {
                let len = v.len() + h;
-               let mut v <- v;
+               let mut v = move v;
                vec::reserve(v, len);
                v
             }

src/libcore/io.rs

@@ -698,7 +698,7 @@ pub struct BytesWriter {
 impl BytesWriter: Writer {
     fn write(v: &[const u8]) {
         do self.bytes.swap |bytes| {
-            let mut bytes <- bytes;
+            let mut bytes = move bytes;
             let v_len = v.len();
             let bytes_len = bytes.len();
 

src/libcore/iter.rs

@@ -128,7 +128,7 @@ pub pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
 pub pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, b0: B,
                                       blk: fn(&B, &A) -> B)
     -> B {
-    let mut b <- b0;
+    let mut b = move b0;
     for self.each |a| {
         b = blk(&b, a);
     }

src/libcore/option.rs

@@ -149,7 +149,7 @@ pub pure fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> {
 pub pure fn while_some<T>(x: Option<T>, blk: fn(v: T) -> Option<T>) {
     //! Applies a function zero or more times until the result is none.
 
-    let mut opt <- x;
+    let mut opt = move x;
     while opt.is_some() {
         opt = blk(unwrap(move opt));
     }

src/libcore/pipes.rs

@@ -86,7 +86,7 @@ use option::unwrap;
 const SPIN_COUNT: uint = 0;
 
 macro_rules! move_it (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); move y } }
+    { $x:expr } => { unsafe { let y = move *ptr::addr_of(&($x)); move y } }
 )
 
 #[doc(hidden)]
@@ -363,7 +363,7 @@ pub fn send<T: Send, Tbuffer: Send>(p: SendPacketBuffered<T, Tbuffer>,
     let p = unsafe { &*p_ };
     assert ptr::addr_of(&(p.header)) == header;
     assert p.payload.is_none();
-    p.payload <- Some(move payload);
+    p.payload = move Some(move payload);
     let old_state = swap_state_rel(&mut p.header.state, Full);
     match old_state {
         Empty => {
@@ -708,7 +708,7 @@ pub fn select<T: Send, Tb: Send>(endpoints: ~[RecvPacketBuffered<T, Tb>])
     -> (uint, Option<T>, ~[RecvPacketBuffered<T, Tb>])
 {
     let ready = wait_many(endpoints.map(|p| p.header()));
-    let mut remaining <- endpoints;
+    let mut remaining = move endpoints;
     let port = remaining.swap_remove(ready);
     let result = try_recv(move port);
     (ready, move result, move remaining)

src/libcore/private.rs

@@ -562,9 +562,9 @@ impl<T: Send> Exclusive<T> {
 
 // FIXME(#3724) make this a by-move method on the exclusive
 pub fn unwrap_exclusive<T: Send>(arc: Exclusive<T>) -> T {
-    let Exclusive { x: x } <- arc;
+    let Exclusive { x: x } = move arc;
     let inner = unsafe { unwrap_shared_mutable_state(move x) };
-    let ExData { data: data, _ } <- inner;
+    let ExData { data: data, _ } = move inner;
     move data
 }
 

src/libcore/str.rs

@@ -176,7 +176,7 @@ pub fn push_str(lhs: &mut ~str, rhs: &str) {
 /// Concatenate two strings together
 #[inline(always)]
 pub pure fn append(lhs: ~str, rhs: &str) -> ~str {
-    let mut v <- lhs;
+    let mut v = move lhs;
     unsafe {
         push_str_no_overallocate(&mut v, rhs);
     }

src/libcore/task/spawn.rs

@@ -67,7 +67,7 @@ use rt::rust_task;
 use rt::rust_closure;
 
 macro_rules! move_it (
-    { $x:expr } => { unsafe { let y <- *ptr::addr_of(&($x)); move y } }
+    { $x:expr } => { unsafe { let y = move *ptr::addr_of(&($x)); move y } }
 )
 
 type TaskSet = send_map::linear::LinearMap<*rust_task,()>;
@@ -168,10 +168,10 @@ fn each_ancestor(list:        &mut AncestorList,
         if coalesce_this.is_some() {
             // Needed coalesce. Our next ancestor becomes our old
             // ancestor's next ancestor. ("next = old_next->next;")
-            *list <- option::unwrap(move coalesce_this);
+            *list = move option::unwrap(move coalesce_this);
         } else {
             // No coalesce; restore from tmp. ("next = old_next;")
-            *list <- tmp_list;
+            *list = move tmp_list;
         }
         return early_break;
     }
@@ -265,7 +265,7 @@ fn each_ancestor(list:        &mut AncestorList,
             // If this trips, more likely the problem is 'blk' failed inside.
             let tmp_arc = option::swap_unwrap(parent_group);
             let result = do access_group(&tmp_arc) |tg_opt| { blk(tg_opt) };
-            *parent_group <- Some(move tmp_arc);
+            *parent_group = move Some(move tmp_arc);
             move result
         }
     }
@@ -480,7 +480,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
         if tmp.is_some() {
             let ancestor_arc = option::unwrap(move tmp);
             let result = ancestor_arc.clone();
-            **ancestors <- Some(move ancestor_arc);
+            **ancestors = move Some(move ancestor_arc);
             AncestorList(Some(move result))
         } else {
             AncestorList(None)

src/libcore/util.rs

@@ -51,7 +51,7 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
  */
 #[inline(always)]
 pub fn replace<T>(dest: &mut T, src: T) -> T {
-    let mut tmp <- src;
+    let mut tmp = move src;
     swap(dest, &mut tmp);
     move tmp
 }

src/libcore/vec.rs

@@ -399,10 +399,10 @@ pub fn shift<T>(v: &mut ~[T]) -> T {
         let mut rr;
         {
             let vv = raw::to_ptr(vv);
-            rr <- *vv;
+            rr = move *vv;
 
             for uint::range(1, ln) |i| {
-                let r <- *ptr::offset(vv, i);
+                let r = move *ptr::offset(vv, i);
                 v.push(move r);
             }
         }
@@ -424,7 +424,7 @@ pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) unsafe {
 
     do as_imm_buf(v) |p, ln| {
         for uint::range(0, ln) |i| {
-            let x <- *ptr::offset(p, i);
+            let x = move *ptr::offset(p, i);
             f(i, move x);
         }
     }
@@ -515,7 +515,7 @@ pub fn push_all_move<T>(v: &mut ~[T], rhs: ~[T]) {
     unsafe {
         do as_imm_buf(rhs) |p, len| {
             for uint::range(0, len) |i| {
-                let x <- *ptr::offset(p, i);
+                let x = move *ptr::offset(p, i);
                 push(v, move x);
             }
         }
@@ -530,7 +530,7 @@ pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
         unsafe {
             // This loop is optimized out for non-drop types.
             for uint::range(newlen, oldlen) |i| {
-                let _dropped <- *ptr::offset(p, i);
+                let _dropped = move *ptr::offset(p, i);
             }
             raw::set_len(v, newlen);
         }
@@ -553,12 +553,12 @@ pub fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
             // last_written < next_to_read < ln
             if *ptr::mut_offset(p, next_to_read) ==
                 *ptr::mut_offset(p, last_written) {
-                let _dropped <- *ptr::mut_offset(p, next_to_read);
+                let _dropped = move *ptr::mut_offset(p, next_to_read);
             } else {
                 last_written += 1;
                 // last_written <= next_to_read < ln
                 if next_to_read != last_written {
-                    *ptr::mut_offset(p, last_written) <-
+                    *ptr::mut_offset(p, last_written) = move
                         *ptr::mut_offset(p, next_to_read);
                 }
             }
@@ -575,7 +575,7 @@ pub fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
 // Appending
 #[inline(always)]
 pub pure fn append<T: Copy>(lhs: ~[T], rhs: &[const T]) -> ~[T] {
-    let mut v <- lhs;
+    let mut v = move lhs;
     unsafe {
         v.push_all(rhs);
     }
@@ -584,7 +584,7 @@ pub pure fn append<T: Copy>(lhs: ~[T], rhs: &[const T]) -> ~[T] {
 
 #[inline(always)]
 pub pure fn append_one<T>(lhs: ~[T], x: T) -> ~[T] {
-    let mut v <- lhs;
+    let mut v = move lhs;
     unsafe { v.push(move x); }
     move v
 }
@@ -1052,9 +1052,9 @@ pub fn swap<T>(v: &[mut T], a: uint, b: uint) {
 
 /// Reverse the order of elements in a vector, in place
 pub fn reverse<T>(v: &[mut T]) {
-    let mut i: uint = 0u;
+    let mut i: uint = 0;
     let ln = len::<T>(v);
-    while i < ln / 2u { v[i] <-> v[ln - i - 1u]; i += 1u; }
+    while i < ln / 2 { v[i] <-> v[ln - i - 1]; i += 1; }
 }
 
 /// Returns a vector with the order of elements reversed

src/libstd/arc.rs

@@ -99,7 +99,7 @@ pub 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 } = move rc;
     unsafe { unwrap_shared_mutable_state(move x) }
 }
 
@@ -192,9 +192,9 @@ impl<T: Send> &MutexARC<T> {
  */
 // FIXME(#3724) make this a by-move method on the arc
 pub fn unwrap_mutex_arc<T: Send>(arc: MutexARC<T>) -> T {
-    let MutexARC { x: x } <- arc;
+    let MutexARC { x: x } = move arc;
     let inner = unsafe { unwrap_shared_mutable_state(move x) };
-    let MutexARCInner { failed: failed, data: data, _ } <- inner;
+    let MutexARCInner { failed: failed, data: data, _ } = move inner;
     if failed {
         fail ~"Can't unwrap poisoned MutexARC - another task failed inside!"
     }
@@ -347,7 +347,7 @@ 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)) = move token;
         // Let readers in
         let new_token = (&state.lock).downgrade(move t);
         // Whatever region the input reference had, it will be safe to use
@@ -370,9 +370,9 @@ impl<T: Const Send> &RWARC<T> {
  */
 // FIXME(#3724) make this a by-move method on the arc
 pub fn unwrap_rw_arc<T: Const Send>(arc: RWARC<T>) -> T {
-    let RWARC { x: x, _ } <- arc;
+    let RWARC { x: x, _ } = move arc;
     let inner = unsafe { unwrap_shared_mutable_state(move x) };
-    let RWARCInner { failed: failed, data: data, _ } <- inner;
+    let RWARCInner { failed: failed, data: data, _ } = move inner;
     if failed {
         fail ~"Can't unwrap poisoned RWARC - another task failed inside!"
     }

src/libstd/map.rs

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