Make moves explicit in arguments

Author: catamorphism

src/libcore/at_vec.rs

@@ -177,7 +177,7 @@ mod unsafe {
         (**repr).fill += sys::size_of::<T>();
         let p = ptr::addr_of((**repr).data);
         let p = ptr::offset(p, fill) as *mut T;
-        rusti::move_val_init(*p, initval);
+        rusti::move_val_init(*p, move initval);
     }
 
     unsafe fn push_slow<T>(&v: @[const T], +initval: T) {

src/libcore/comm.rs

@@ -181,7 +181,7 @@ fn send<T: Send>(ch: Chan<T>, +data: T) {
     let res = rustrt::rust_port_id_send(p, data_ptr);
     if res != 0 unsafe {
         // Data sent successfully
-        unsafe::forget(data);
+        unsafe::forget(move data);
     }
     task::yield();
 }

src/libcore/dlist.rs

@@ -198,27 +198,27 @@ impl<T> DList<T> {
 
     /// Add data to the head of the list. O(1).
     fn push_head(+data: T) {
-        self.add_head(self.new_link(data));
+        self.add_head(self.new_link(move data));
     }
     /**
      * Add data to the head of the list, and get the new containing
      * node. O(1).
      */
     fn push_head_n(+data: T) -> DListNode<T> {
-        let mut nobe = self.new_link(data);
+        let mut nobe = self.new_link(move data);
         self.add_head(nobe);
         option::get(nobe)
     }
     /// Add data to the tail of the list. O(1).
     fn push(+data: T) {
-        self.add_tail(self.new_link(data));
+        self.add_tail(self.new_link(move data));
     }
     /**
      * Add data to the tail of the list, and get the new containing
      * node. O(1).
      */
     fn push_n(+data: T) -> DListNode<T> {
-        let mut nobe = self.new_link(data);
+        let mut nobe = self.new_link(move data);
         self.add_tail(nobe);
         option::get(nobe)
     }
@@ -227,7 +227,7 @@ impl<T> DList<T> {
      * O(1).
      */
     fn insert_before(+data: T, neighbour: DListNode<T>) {
-        self.insert_left(self.new_link(data), neighbour);
+        self.insert_left(self.new_link(move data), neighbour);
     }
     /**
      * Insert an existing node in the middle of the list, left of the
@@ -242,7 +242,7 @@ impl<T> DList<T> {
      * and get its containing node. O(1).
      */
     fn insert_before_n(+data: T, neighbour: DListNode<T>) -> DListNode<T> {
-        let mut nobe = self.new_link(data);
+        let mut nobe = self.new_link(move data);
         self.insert_left(nobe, neighbour);
         option::get(nobe)
     }
@@ -251,7 +251,7 @@ impl<T> DList<T> {
      * O(1).
      */
     fn insert_after(+data: T, neighbour: DListNode<T>) {
-        self.insert_right(neighbour, self.new_link(data));
+        self.insert_right(neighbour, self.new_link(move data));
     }
     /**
      * Insert an existing node in the middle of the list, right of the
@@ -266,7 +266,7 @@ impl<T> DList<T> {
      * and get its containing node. O(1).
      */
     fn insert_after_n(+data: T, neighbour: DListNode<T>) -> DListNode<T> {
-        let mut nobe = self.new_link(data);
+        let mut nobe = self.new_link(move data);
         self.insert_right(neighbour, nobe);
         option::get(nobe)
     }

src/libcore/dvec.rs

@@ -95,7 +95,7 @@ priv impl<A> DVec<A> {
             data <-> self.data;
             let data_ptr: *() = unsafe::reinterpret_cast(&data);
             if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
-            return f(data);
+            return f(move data);
         }
     }
 
@@ -123,15 +123,15 @@ impl<A> DVec<A> {
      */
     #[inline(always)]
     fn swap(f: fn(-~[mut A]) -> ~[mut A]) {
-        self.check_out(|v| self.give_back(f(v)))
+        self.check_out(|v| self.give_back(f(move v)))
     }
 
     /// Returns the number of elements currently in the dvec
     pure fn len() -> uint {
         unchecked {
             do self.check_out |v| {
                 let l = v.len();
-                self.give_back(v);
+                self.give_back(move v);
                 l
             }
         }
@@ -148,7 +148,7 @@ impl<A> DVec<A> {
         do self.check_out |v| {
             let mut v <- v;
             let result = vec::pop(v);
-            self.give_back(v);
+            self.give_back(move v);
             move result
         }
     }
@@ -162,7 +162,7 @@ impl<A> DVec<A> {
             if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
             log(error, ~"a");
             self.data <- ~[mut move t];
-            vec::push_all_move(self.data, data);
+            vec::push_all_move(self.data, move data);
             log(error, ~"b");
         }
     }
@@ -187,15 +187,15 @@ impl<A> DVec<A> {
     fn reverse() {
         do self.check_out |v| {
             vec::reverse(v);
-            self.give_back(v);
+            self.give_back(move v);
         }
     }
 
     /// Gives access to the vector as a slice with immutable contents
     fn borrow<R>(op: fn(x: &[A]) -> R) -> R {
         do self.check_out |v| {
             let result = op(v);
-            self.give_back(v);
+            self.give_back(move v);
             move result
         }
     }
@@ -204,7 +204,7 @@ impl<A> DVec<A> {
     fn borrow_mut<R>(op: fn(x: &[mut A]) -> R) -> R {
         do self.check_out |v| {
             let result = op(v);
-            self.give_back(v);
+            self.give_back(move v);
             move result
         }
     }
@@ -269,7 +269,7 @@ impl<A: Copy> DVec<A> {
         unchecked {
             do self.check_out |v| {
                 let w = vec::from_mut(copy v);
-                self.give_back(v);
+                self.give_back(move v);
                 move w
             }
         }

src/libcore/future.rs

@@ -90,7 +90,7 @@ fn from_port<A:Send>(+port: future_pipe::client::waiting<A>) -> Future<A> {
     do from_fn |move port| {
         let mut port_ = None;
         port_ <-> *port;
-        let port = option::unwrap(port_);
+        let port = option::unwrap(move port_);
         match recv(move port) {
             future_pipe::completed(move data) => move data
         }

src/libcore/option.rs

@@ -74,7 +74,7 @@ pure fn map_consume<T, U>(+opt: Option<T>, f: fn(+T) -> U) -> Option<U> {
      * As `map`, but consumes the option and gives `f` ownership to avoid
      * copying.
      */
-    if opt.is_some() { Some(f(option::unwrap(opt))) } else { None }
+    if opt.is_some() { Some(f(option::unwrap(move opt))) } else { None }
 }
 
 pure fn chain<T, U>(opt: Option<T>, f: fn(T) -> Option<U>) -> Option<U> {
@@ -112,7 +112,7 @@ pure fn while_some<T>(+x: Option<T>, blk: fn(+T) -> Option<T>) {
 
     let mut opt <- x;
     while opt.is_some() {
-        opt = blk(unwrap(opt));
+        opt = blk(unwrap(move opt));
     }
 }
 
@@ -186,7 +186,7 @@ fn swap_unwrap<T>(opt: &mut Option<T>) -> T {
 pure fn unwrap_expect<T>(+opt: Option<T>, reason: &str) -> T {
     //! As unwrap, but with a specified failure message.
     if opt.is_none() { fail reason.to_unique(); }
-    unwrap(opt)
+    unwrap(move opt)
 }
 
 // Some of these should change to be &Option<T>, some should not. See below.