Use Option .take() or .take_unwrap() instead of util::replace where possible

6 files changed, 25 insertions, 36 deletions

diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs
index 53ea11f2b05..695ed0749dd 100644
--- a/src/libstd/cell.rs
+++ b/src/libstd/cell.rs
@@ -14,7 +14,6 @@
 
 use cast::transmute_mut;
 use prelude::*;
-use util::replace;
 
 /*
 A dynamic, mutable location.
@@ -48,7 +47,7 @@ impl<T> Cell<T> {
             fail!("attempt to take an empty cell");
         }
 
-        replace(&mut this.value, None).unwrap()
+        this.value.take_unwrap()
     }
 
     /// Returns the value, failing if the cell is full.
diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs
index 0acd6fee57e..b9dacc142ce 100644
--- a/src/libstd/comm.rs
+++ b/src/libstd/comm.rs
@@ -242,8 +242,7 @@ impl<T: Send> GenericChan<T> for SharedChan<T> {
                 unsafe {
                     let mut xx = Some(x);
                     do chan.with_imm |chan| {
-                        let x = replace(&mut xx, None);
-                        chan.send(x.unwrap())
+                        chan.send(xx.take_unwrap())
                     }
                 }
             }
@@ -259,8 +258,7 @@ impl<T: Send> GenericSmartChan<T> for SharedChan<T> {
                 unsafe {
                     let mut xx = Some(x);
                     do chan.with_imm |chan| {
-                        let x = replace(&mut xx, None);
-                        chan.try_send(x.unwrap())
+                        chan.try_send(xx.take_unwrap())
                     }
                 }
             }
@@ -372,7 +370,6 @@ mod pipesy {
     use pipes::{recv, try_recv, peek, PacketHeader};
     use super::{GenericChan, GenericSmartChan, GenericPort, Peekable, Selectable};
     use cast::transmute_mut;
-    use util::replace;
 
     /*proto! oneshot (
         Oneshot:send<T:Send> {
@@ -638,8 +635,7 @@ mod pipesy {
         fn send(&self, x: T) {
             unsafe {
                 let self_endp = transmute_mut(&self.endp);
-                let endp = replace(self_endp, None);
-                *self_endp = Some(streamp::client::data(endp.unwrap(), x))
+                *self_endp = Some(streamp::client::data(self_endp.take_unwrap(), x))
             }
         }
     }
@@ -649,8 +645,7 @@ mod pipesy {
         fn try_send(&self, x: T) -> bool {
             unsafe {
                 let self_endp = transmute_mut(&self.endp);
-                let endp = replace(self_endp, None);
-                match streamp::client::try_data(endp.unwrap(), x) {
+                match streamp::client::try_data(self_endp.take_unwrap(), x) {
                     Some(next) => {
                         *self_endp = Some(next);
                         true
@@ -666,7 +661,7 @@ mod pipesy {
         fn recv(&self) -> T {
             unsafe {
                 let self_endp = transmute_mut(&self.endp);
-                let endp = replace(self_endp, None);
+                let endp = self_endp.take();
                 let streamp::data(x, endp) = recv(endp.unwrap());
                 *self_endp = Some(endp);
                 x
@@ -677,7 +672,7 @@ mod pipesy {
         fn try_recv(&self) -> Option<T> {
             unsafe {
                 let self_endp = transmute_mut(&self.endp);
-                let endp = replace(self_endp, None);
+                let endp = self_endp.take();
                 match try_recv(endp.unwrap()) {
                     Some(streamp::data(x, endp)) => {
                         *self_endp = Some(endp);
@@ -694,7 +689,7 @@ mod pipesy {
         fn peek(&self) -> bool {
             unsafe {
                 let self_endp = transmute_mut(&self.endp);
-                let mut endp = replace(self_endp, None);
+                let mut endp = self_endp.take();
                 let peek = match endp {
                     Some(ref mut endp) => peek(endp),
                     None => fail!("peeking empty stream")
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index ecc5de117d0..182ee37202a 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -253,7 +253,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
         };
 
         let len_buckets = self.buckets.len();
-        let bucket = replace(&mut self.buckets[idx], None);
+        let bucket = self.buckets[idx].take();
 
         let value = match bucket {
             None => None,
@@ -267,7 +267,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
         let size = self.size - 1;
         idx = self.next_bucket(idx, len_buckets);
         while self.buckets[idx].is_some() {
-            let bucket = replace(&mut self.buckets[idx], None);
+            let bucket = self.buckets[idx].take();
             self.insert_opt_bucket(bucket);
             idx = self.next_bucket(idx, len_buckets);
         }
diff --git a/src/libstd/pipes.rs b/src/libstd/pipes.rs
index 8f43e847c24..a861c3c5f0f 100644
--- a/src/libstd/pipes.rs
+++ b/src/libstd/pipes.rs
@@ -431,7 +431,7 @@ fn try_recv_<T:Send>(p: &mut Packet<T>) -> Option<T> {
     // optimistic path
     match p.header.state {
       Full => {
-        let payload = replace(&mut p.payload, None);
+        let payload = p.payload.take();
         p.header.state = Empty;
         return Some(payload.unwrap())
       },
@@ -482,7 +482,7 @@ fn try_recv_<T:Send>(p: &mut Packet<T>) -> Option<T> {
             fail!("blocking on already blocked packet")
           },
           Full => {
-            let payload = replace(&mut p.payload, None);
+            let payload = p.payload.take();
             let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
             if !old_task.is_null() {
                 unsafe {
@@ -676,8 +676,7 @@ impl<T:Send,Tbuffer:Send> Drop for SendPacketBuffered<T,Tbuffer> {
         unsafe {
             let this: &mut SendPacketBuffered<T,Tbuffer> = transmute(self);
             if this.p != None {
-                let p = replace(&mut this.p, None);
-                sender_terminate(p.unwrap())
+                sender_terminate(this.p.take_unwrap());
             }
         }
     }
@@ -695,7 +694,7 @@ pub fn SendPacketBuffered<T,Tbuffer>(p: *mut Packet<T>)
 
 impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
     pub fn unwrap(&mut self) -> *mut Packet<T> {
-        replace(&mut self.p, None).unwrap()
+        self.p.take_unwrap()
     }
 
     pub fn header(&mut self) -> *mut PacketHeader {
@@ -711,7 +710,7 @@ impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
 
     pub fn reuse_buffer(&mut self) -> BufferResource<Tbuffer> {
         //error!("send reuse_buffer");
-        replace(&mut self.buffer, None).unwrap()
+        self.buffer.take_unwrap()
     }
 }
 
@@ -734,8 +733,7 @@ impl<T:Send,Tbuffer:Send> Drop for RecvPacketBuffered<T,Tbuffer> {
         unsafe {
             let this: &mut RecvPacketBuffered<T,Tbuffer> = transmute(self);
             if this.p != None {
-                let p = replace(&mut this.p, None);
-                receiver_terminate(p.unwrap())
+                receiver_terminate(this.p.take_unwrap())
             }
         }
     }
@@ -743,11 +741,11 @@ impl<T:Send,Tbuffer:Send> Drop for RecvPacketBuffered<T,Tbuffer> {
 
 impl<T:Send,Tbuffer:Send> RecvPacketBuffered<T, Tbuffer> {
     pub fn unwrap(&mut self) -> *mut Packet<T> {
-        replace(&mut self.p, None).unwrap()
+        self.p.take_unwrap()
     }
 
     pub fn reuse_buffer(&mut self) -> BufferResource<Tbuffer> {
-        replace(&mut self.buffer, None).unwrap()
+        self.buffer.take_unwrap()
     }
 }
 
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index a3ece0c2e0a..de6410aa82f 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -46,7 +46,6 @@ use rt::{context, OldTaskContext, TaskContext};
 use rt::local::Local;
 use task::rt::{task_id, sched_id};
 use unstable::finally::Finally;
-use util::replace;
 use util;
 
 #[cfg(test)] use cast;
@@ -224,8 +223,8 @@ impl TaskBuilder {
             fail!("Cannot copy a task_builder"); // Fake move mode on self
         }
         self.consumed = true;
-        let gen_body = replace(&mut self.gen_body, None);
-        let notify_chan = replace(&mut self.opts.notify_chan, None);
+        let gen_body = self.gen_body.take();
+        let notify_chan = self.opts.notify_chan.take();
         TaskBuilder {
             opts: TaskOpts {
                 linked: self.opts.linked,
@@ -340,7 +339,7 @@ impl TaskBuilder {
      * existing body generator to the new body generator.
      */
     pub fn add_wrapper(&mut self, wrapper: ~fn(v: ~fn()) -> ~fn()) {
-        let prev_gen_body = replace(&mut self.gen_body, None);
+        let prev_gen_body = self.gen_body.take();
         let prev_gen_body = match prev_gen_body {
             Some(gen) => gen,
             None => {
@@ -372,8 +371,8 @@ impl TaskBuilder {
      * must be greater than zero.
      */
     pub fn spawn(&mut self, f: ~fn()) {
-        let gen_body = replace(&mut self.gen_body, None);
-        let notify_chan = replace(&mut self.opts.notify_chan, None);
+        let gen_body = self.gen_body.take();
+        let notify_chan = self.opts.notify_chan.take();
         let x = self.consume();
         let opts = TaskOpts {
             linked: x.opts.linked,
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index cc73c28bba0..03e94a902c1 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -1896,12 +1896,11 @@ pub mod raw {
     use cast::transmute;
     use clone::Clone;
     use managed;
-    use option::{None, Some};
+    use option::Some;
     use ptr;
     use sys;
     use unstable::intrinsics;
     use vec::{UnboxedVecRepr, with_capacity, ImmutableVector, MutableVector};
-    use util;
     #[cfg(not(stage0))]
     use unstable::intrinsics::contains_managed;
 
@@ -2022,9 +2021,8 @@ pub mod raw {
     pub unsafe fn init_elem<T>(v: &mut [T], i: uint, val: T) {
         let mut box = Some(val);
         do v.as_mut_buf |p, _len| {
-            let box2 = util::replace(&mut box, None);
             intrinsics::move_val_init(&mut(*ptr::mut_offset(p, i)),
-                                      box2.unwrap());
+                                      box.take_unwrap());
         }
     }