libextra: Another round of de-`Cell`-ing.

34 uses of `Cell` remain.

11 files changed, 124 insertions, 228 deletions

diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index aa7a64d2210..122ededfbc3 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -146,7 +146,6 @@ impl Acceptor<TcpStream> for TcpAcceptor {
 #[cfg(test)]
 mod test {
     use super::*;
-    use cell::Cell;
     use rt::test::*;
     use io::net::ip::{Ipv4Addr, SocketAddr};
     use io::*;
@@ -196,12 +195,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 stream.read(buf);
@@ -209,7 +206,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]);
             }
@@ -221,12 +218,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 stream.read(buf);
@@ -234,7 +229,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]);
             }
@@ -246,12 +241,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -259,7 +252,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -271,12 +264,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -284,7 +275,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -296,12 +287,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -319,7 +308,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -331,12 +320,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let mut buf = [0];
                 let nread = stream.read(buf);
@@ -354,7 +341,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -366,12 +353,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let buf = [0];
                 loop {
@@ -392,7 +377,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -404,12 +389,10 @@ mod test {
         do run_in_mt_newsched_task {
             let addr = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 let mut stream = acceptor.accept();
                 let buf = [0];
                 loop {
@@ -430,7 +413,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let _stream = TcpStream::connect(addr);
                 // Close
             }
@@ -443,12 +426,10 @@ mod test {
             let addr = next_test_ip4();
             let max = 10;
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for ref mut stream in acceptor.incoming().take(max) {
                     let mut buf = [0];
                     stream.read(buf);
@@ -457,7 +438,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 max.times(|| {
                     let mut stream = TcpStream::connect(addr);
                     stream.write([99]);
@@ -472,12 +453,10 @@ mod test {
             let addr = next_test_ip6();
             let max = 10;
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for ref mut stream in acceptor.incoming().take(max) {
                     let mut buf = [0];
                     stream.read(buf);
@@ -486,7 +465,7 @@ mod test {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 max.times(|| {
                     let mut stream = TcpStream::connect(addr);
                     stream.write([99]);
@@ -501,16 +480,14 @@ mod test {
             let addr = next_test_ip4();
             static MAX: int = 10;
             let (port, chan) = oneshot();
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                    let stream = Cell::new(stream);
                     // Start another task to handle the connection
                     do spawntask {
-                        let mut stream = stream.take();
+                        let mut stream = stream;
                         let mut buf = [0];
                         stream.read(buf);
                         assert!(buf[0] == i as u8);
@@ -543,16 +520,14 @@ mod test {
             let addr = next_test_ip6();
             static MAX: int = 10;
             let (port, chan) = oneshot();
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                    let stream = Cell::new(stream);
                     // Start another task to handle the connection
                     do spawntask {
-                        let mut stream = stream.take();
+                        let mut stream = stream;
                         let mut buf = [0];
                         stream.read(buf);
                         assert!(buf[0] == i as u8);
@@ -585,16 +560,14 @@ mod test {
             let addr = next_test_ip4();
             static MAX: int = 10;
             let (port, chan) = oneshot();
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for stream in acceptor.incoming().take(MAX as uint) {
-                    let stream = Cell::new(stream);
                     // Start another task to handle the connection
                     do spawntask_later {
-                        let mut stream = stream.take();
+                        let mut stream = stream;
                         let mut buf = [0];
                         stream.read(buf);
                         assert!(buf[0] == 99);
@@ -626,16 +599,14 @@ mod test {
             let addr = next_test_ip6();
             static MAX: int = 10;
             let (port, chan) = oneshot();
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
                 for stream in acceptor.incoming().take(MAX as uint) {
-                    let stream = Cell::new(stream);
                     // Start another task to handle the connection
                     do spawntask_later {
-                        let mut stream = stream.take();
+                        let mut stream = stream;
                         let mut buf = [0];
                         stream.read(buf);
                         assert!(buf[0] == 99);
@@ -682,18 +653,16 @@ mod test {
     fn peer_name(addr: SocketAddr) {
         do run_in_mt_newsched_task {
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = TcpListener::bind(addr).listen();
-                chan.take().send(());
+                chan.send(());
 
                 acceptor.accept();
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 let stream = TcpStream::connect(addr);
 
                 assert!(stream.is_some());
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index f02fc1ae447..2e07269ed0c 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -110,7 +110,6 @@ mod test {
     use io::*;
     use option::{Some, None};
     use rt::comm::oneshot;
-    use cell::Cell;
 
     #[test]  #[ignore]
     fn bind_error() {
@@ -134,13 +133,11 @@ mod test {
             let server_ip = next_test_ip4();
             let client_ip = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(ref mut server) => {
-                        chan.take().send(());
+                        chan.send(());
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -158,7 +155,7 @@ mod test {
             do spawntask {
                 match UdpSocket::bind(client_ip) {
                     Some(ref mut client) => {
-                        port.take().recv();
+                        port.recv();
                         client.sendto([99], server_ip)
                     }
                     None => fail!()
@@ -173,13 +170,11 @@ mod test {
             let server_ip = next_test_ip6();
             let client_ip = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(ref mut server) => {
-                        chan.take().send(());
+                        chan.send(());
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -197,7 +192,7 @@ mod test {
             do spawntask {
                 match UdpSocket::bind(client_ip) {
                     Some(ref mut client) => {
-                        port.take().recv();
+                        port.recv();
                         client.sendto([99], server_ip)
                     }
                     None => fail!()
@@ -212,15 +207,13 @@ mod test {
             let server_ip = next_test_ip4();
             let client_ip = next_test_ip4();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(server) => {
                         let server = ~server;
                         let mut stream = server.connect(client_ip);
-                        chan.take().send(());
+                        chan.send(());
                         let mut buf = [0];
                         match stream.read(buf) {
                             Some(nread) => {
@@ -239,7 +232,7 @@ mod test {
                     Some(client) => {
                         let client = ~client;
                         let mut stream = client.connect(server_ip);
-                        port.take().recv();
+                        port.recv();
                         stream.write([99]);
                     }
                     None => fail!()
@@ -254,15 +247,13 @@ mod test {
             let server_ip = next_test_ip6();
             let client_ip = next_test_ip6();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 match UdpSocket::bind(server_ip) {
                     Some(server) => {
                         let server = ~server;
                         let mut stream = server.connect(client_ip);
-                        chan.take().send(());
+                        chan.send(());
                         let mut buf = [0];
                         match stream.read(buf) {
                             Some(nread) => {
@@ -281,7 +272,7 @@ mod test {
                     Some(client) => {
                         let client = ~client;
                         let mut stream = client.connect(server_ip);
-                        port.take().recv();
+                        port.recv();
                         stream.write([99]);
                     }
                     None => fail!()
diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs
index 6d2deccaa4c..7cbf3108a80 100644
--- a/src/libstd/io/net/unix.rs
+++ b/src/libstd/io/net/unix.rs
@@ -152,32 +152,26 @@ impl Acceptor<UnixStream> for UnixAcceptor {
 mod tests {
     use prelude::*;
     use super::*;
-    use cell::Cell;
     use rt::test::*;
     use io::*;
     use rt::comm::oneshot;
 
     fn smalltest(server: proc(UnixStream), client: proc(UnixStream)) {
-        let server = Cell::new(server);
-        let client = Cell::new(client);
         do run_in_mt_newsched_task {
-            let server = Cell::new(server.take());
-            let client = Cell::new(client.take());
             let path1 = next_test_unix();
             let path2 = path1.clone();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
+            let (client, server) = (client, server);
 
             do spawntask {
                 let mut acceptor = UnixListener::bind(&path1).listen();
-                chan.take().send(());
-                server.take()(acceptor.accept().unwrap());
+                chan.send(());
+                server(acceptor.accept().unwrap());
             }
 
             do spawntask {
-                port.take().recv();
-                client.take()(UnixStream::connect(&path2).unwrap());
+                port.recv();
+                client(UnixStream::connect(&path2).unwrap());
             }
         }
     }
@@ -260,12 +254,10 @@ mod tests {
             let path1 = next_test_unix();
             let path2 = path1.clone();
             let (port, chan) = oneshot();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             do spawntask {
                 let mut acceptor = UnixListener::bind(&path1).listen();
-                chan.take().send(());
+                chan.send(());
                 times.times(|| {
                     let mut client = acceptor.accept();
                     let mut buf = [0];
@@ -275,7 +267,7 @@ mod tests {
             }
 
             do spawntask {
-                port.take().recv();
+                port.recv();
                 times.times(|| {
                     let mut stream = UnixStream::connect(&path2);
                     stream.write([100]);
diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs
index 06743bce9bf..1b5303e76c9 100644
--- a/src/libstd/rt/comm.rs
+++ b/src/libstd/rt/comm.rs
@@ -843,9 +843,8 @@ mod test {
     fn oneshot_multi_task_recv_then_send() {
         do run_in_newsched_task {
             let (port, chan) = oneshot::<~int>();
-            let port_cell = Cell::new(port);
             do spawntask {
-                assert!(port_cell.take().recv() == ~10);
+                assert!(port.recv() == ~10);
             }
 
             chan.send(~10);
@@ -856,13 +855,11 @@ mod test {
     fn oneshot_multi_task_recv_then_close() {
         do run_in_newsched_task {
             let (port, chan) = oneshot::<~int>();
-            let port_cell = Cell::new(port);
-            let chan_cell = Cell::new(chan);
             do spawntask_later {
-                let _cell = chan_cell.take();
+                let _ = chan;
             }
             let res = do spawntask_try {
-                assert!(port_cell.take().recv() == ~10);
+                assert!(port.recv() == ~10);
             };
             assert!(res.is_err());
         }
@@ -874,9 +871,8 @@ mod test {
         stress_factor().times(|| {
             do run_in_newsched_task {
                 let (port, chan) = oneshot::<int>();
-                let port_cell = Cell::new(port);
                 let thread = do spawntask_thread {
-                    let _p = port_cell.take();
+                    let _ = port;
                 };
                 let _chan = chan;
                 thread.join();
@@ -890,14 +886,11 @@ mod test {
         stress_factor().times(|| {
             do run_in_newsched_task {
                 let (port, chan) = oneshot::<int>();
-                let chan_cell = Cell::new(chan);
-                let port_cell = Cell::new(port);
                 let thread1 = do spawntask_thread {
-                    let _p = port_cell.take();
+                    let _ = port;
                 };
                 let thread2 = do spawntask_thread {
-                    let c = chan_cell.take();
-                    c.send(1);
+                    chan.send(1);
                 };
                 thread1.join();
                 thread2.join();
@@ -911,19 +904,17 @@ mod test {
         stress_factor().times(|| {
             do run_in_newsched_task {
                 let (port, chan) = oneshot::<int>();
-                let chan_cell = Cell::new(chan);
-                let port_cell = Cell::new(port);
                 let thread1 = do spawntask_thread {
-                    let port_cell = Cell::new(port_cell.take());
+                    let port = port;
                     let res = do spawntask_try {
-                        port_cell.take().recv();
+                        port.recv();
                     };
                     assert!(res.is_err());
                 };
                 let thread2 = do spawntask_thread {
-                    let chan_cell = Cell::new(chan_cell.take());
+                    let chan = chan;
                     do spawntask {
-                        chan_cell.take();
+                        let _ = chan;
                     }
                 };
                 thread1.join();
@@ -938,13 +929,11 @@ mod test {
         stress_factor().times(|| {
             do run_in_newsched_task {
                 let (port, chan) = oneshot::<~int>();
-                let chan_cell = Cell::new(chan);
-                let port_cell = Cell::new(port);
                 let thread1 = do spawntask_thread {
-                    chan_cell.take().send(~10);
+                    chan.send(~10);
                 };
                 let thread2 = do spawntask_thread {
-                    assert!(port_cell.take().recv() == ~10);
+                    assert!(port.recv() == ~10);
                 };
                 thread1.join();
                 thread2.join();
@@ -965,9 +954,7 @@ mod test {
                 fn send(chan: Chan<~int>, i: int) {
                     if i == 10 { return }
 
-                    let chan_cell = Cell::new(chan);
                     do spawntask_random {
-                        let chan = chan_cell.take();
                         chan.send(~i);
                         send(chan, i + 1);
                     }
@@ -976,9 +963,7 @@ mod test {
                 fn recv(port: Port<~int>, i: int) {
                     if i == 10 { return }
 
-                    let port_cell = Cell::new(port);
                     do spawntask_random {
-                        let port = port_cell.take();
                         assert!(port.recv() == ~i);
                         recv(port, i + 1);
                     };
@@ -1141,14 +1126,11 @@ mod test {
             let cshared = SharedChan::new(cshared);
             let mp = megapipe();
 
-            let pone = Cell::new(pone);
-            do spawntask { pone.take().recv(); }
-            let pstream = Cell::new(pstream);
-            do spawntask { pstream.take().recv(); }
-            let pshared = Cell::new(pshared);
-            do spawntask { pshared.take().recv(); }
-            let p_mp = Cell::new(mp.clone());
-            do spawntask { p_mp.take().recv(); }
+            do spawntask { pone.recv(); }
+            do spawntask { pstream.recv(); }
+            do spawntask { pshared.recv(); }
+            let p_mp = mp.clone();
+            do spawntask { p_mp.recv(); }
 
             let cs = Cell::new((cone, cstream, cshared, mp));
             unsafe {
diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index 56c77ffaa0d..e3f9cd09632 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -151,7 +151,6 @@ There are two known issues with the current scheme for exit code propagation.
 */
 
 use cast;
-use cell::Cell;
 use option::{Option, Some, None};
 use prelude::*;
 use rt::task::Task;
@@ -256,8 +255,10 @@ impl Death {
 
     /// Collect failure exit codes from children and propagate them to a parent.
     pub fn collect_failure(&mut self, result: UnwindResult) {
-        let result = Cell::new(result);
-        self.on_exit.take().map(|on_exit| on_exit(result.take()));
+        match self.on_exit.take() {
+            None => {}
+            Some(on_exit) => on_exit(result),
+        }
     }
 
     /// Enter a possibly-nested "atomic" section of code. Just for assertions.
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 3d0222cefae..ce8d1ab1983 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -57,7 +57,6 @@ Several modules in `core` are clients of `rt`:
 // XXX: this should not be here.
 #[allow(missing_doc)];
 
-use cell::Cell;
 use clone::Clone;
 use container::Container;
 use iter::Iterator;
@@ -274,7 +273,7 @@ fn run_(main: proc(), use_main_sched: bool) -> int {
 
     let nscheds = util::default_sched_threads();
 
-    let main = Cell::new(main);
+    let mut main = Some(main);
 
     // The shared list of sleeping schedulers.
     let sleepers = SleeperList::new();
@@ -376,24 +375,24 @@ fn run_(main: proc(), use_main_sched: bool) -> int {
     };
 
     let mut threads = ~[];
-
-    let on_exit = Cell::new(on_exit);
+    let mut on_exit = Some(on_exit);
 
     if !use_main_sched {
 
         // In the case where we do not use a main_thread scheduler we
         // run the main task in one of our threads.
 
-        let mut main_task = ~Task::new_root(&mut scheds[0].stack_pool, None, main.take());
+        let mut main_task = ~Task::new_root(&mut scheds[0].stack_pool,
+                                            None,
+                                            ::util::replace(&mut main,
+                                                            None).unwrap());
         main_task.name = Some(SendStrStatic("<main>"));
-        main_task.death.on_exit = Some(on_exit.take());
-        let main_task_cell = Cell::new(main_task);
+        main_task.death.on_exit = ::util::replace(&mut on_exit, None);
 
         let sched = scheds.pop();
-        let sched_cell = Cell::new(sched);
+        let main_task = main_task;
         let thread = do Thread::start {
-            let sched = sched_cell.take();
-            sched.bootstrap(main_task_cell.take());
+            sched.bootstrap(main_task);
         };
         threads.push(thread);
     }
@@ -401,9 +400,8 @@ fn run_(main: proc(), use_main_sched: bool) -> int {
     // Run each remaining scheduler in a thread.
     for sched in scheds.move_rev_iter() {
         rtdebug!("creating regular schedulers");
-        let sched_cell = Cell::new(sched);
         let thread = do Thread::start {
-            let mut sched = sched_cell.take();
+            let mut sched = sched;
             let bootstrap_task = ~do Task::new_root(&mut sched.stack_pool, None) || {
                 rtdebug!("boostraping a non-primary scheduler");
             };
@@ -415,16 +413,19 @@ fn run_(main: proc(), use_main_sched: bool) -> int {
     // If we do have a main thread scheduler, run it now.
 
     if use_main_sched {
-
         rtdebug!("about to create the main scheduler task");
 
         let mut main_sched = main_sched.unwrap();
 
         let home = Sched(main_sched.make_handle());
-        let mut main_task = ~Task::new_root_homed(&mut main_sched.stack_pool, None,
-                                                  home, main.take());
+        let mut main_task = ~Task::new_root_homed(&mut main_sched.stack_pool,
+                                                  None,
+                                                  home,
+                                                  ::util::replace(&mut main,
+                                                                  None).
+                                                                  unwrap());
         main_task.name = Some(SendStrStatic("<main>"));
-        main_task.death.on_exit = Some(on_exit.take());
+        main_task.death.on_exit = ::util::replace(&mut on_exit, None);
         rtdebug!("bootstrapping main_task");
 
         main_sched.bootstrap(main_task);
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index 5ad1d92fb15..af8de06adb7 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -924,7 +924,6 @@ mod test {
     use unstable::run_in_bare_thread;
     use borrow::to_uint;
     use rt::sched::{Scheduler};
-    use cell::Cell;
     use rt::deque::BufferPool;
     use rt::thread::Thread;
     use rt::task::{Task, Sched};
@@ -1050,7 +1049,7 @@ mod test {
                 queues.clone(),
                 sleepers.clone());
 
-            let normal_handle = Cell::new(normal_sched.make_handle());
+            let normal_handle = normal_sched.make_handle();
 
             let friend_handle = normal_sched.make_handle();
 
@@ -1063,7 +1062,7 @@ mod test {
                 false,
                 Some(friend_handle));
 
-            let special_handle = Cell::new(special_sched.make_handle());
+            let special_handle = special_sched.make_handle();
 
             let t1_handle = special_sched.make_handle();
             let t4_handle = special_sched.make_handle();
@@ -1094,26 +1093,19 @@ mod test {
             };
             rtdebug!("task4 id: **{}**", borrow::to_uint(task4));
 
-            let task1 = Cell::new(task1);
-            let task2 = Cell::new(task2);
-            let task3 = Cell::new(task3);
-            let task4 = Cell::new(task4);
-
             // Signal from the special task that we are done.
             let (port, chan) = oneshot::<()>();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             let normal_task = ~do Task::new_root(&mut normal_sched.stack_pool, None) {
                 rtdebug!("*about to submit task2*");
-                Scheduler::run_task(task2.take());
+                Scheduler::run_task(task2);
                 rtdebug!("*about to submit task4*");
-                Scheduler::run_task(task4.take());
+                Scheduler::run_task(task4);
                 rtdebug!("*normal_task done*");
-                port.take().recv();
-                let mut nh = normal_handle.take();
+                port.recv();
+                let mut nh = normal_handle;
                 nh.send(Shutdown);
-                let mut sh = special_handle.take();
+                let mut sh = special_handle;
                 sh.send(Shutdown);
             };
 
@@ -1121,27 +1113,24 @@ mod test {
 
             let special_task = ~do Task::new_root(&mut special_sched.stack_pool, None) {
                 rtdebug!("*about to submit task1*");
-                Scheduler::run_task(task1.take());
+                Scheduler::run_task(task1);
                 rtdebug!("*about to submit task3*");
-                Scheduler::run_task(task3.take());
+                Scheduler::run_task(task3);
                 rtdebug!("*done with special_task*");
-                chan.take().send(());
+                chan.send(());
             };
 
             rtdebug!("special task: {}", borrow::to_uint(special_task));
 
-            let special_sched = Cell::new(special_sched);
-            let normal_sched = Cell::new(normal_sched);
-            let special_task = Cell::new(special_task);
-            let normal_task = Cell::new(normal_task);
-
+            let normal_sched = normal_sched;
             let normal_thread = do Thread::start {
-                normal_sched.take().bootstrap(normal_task.take());
+                normal_sched.bootstrap(normal_task);
                 rtdebug!("finished with normal_thread");
             };
 
+            let special_sched = special_sched;
             let special_thread = do Thread::start {
-                special_sched.take().bootstrap(special_task.take());
+                special_sched.bootstrap(special_task);
                 rtdebug!("finished with special_sched");
             };
 
@@ -1180,20 +1169,18 @@ mod test {
 
         do run_in_bare_thread {
             let (port, chan) = oneshot::<()>();
-            let port = Cell::new(port);
-            let chan = Cell::new(chan);
 
             let thread_one = do Thread::start {
-                let chan = Cell::new(chan.take());
+                let chan = chan;
                 do run_in_newsched_task_core {
-                    chan.take().send(());
+                    chan.send(());
                 }
             };
 
             let thread_two = do Thread::start {
-                let port = Cell::new(port.take());
+                let port = port;
                 do run_in_newsched_task_core {
-                    port.take().recv();
+                    port.recv();
                 }
             };
 
@@ -1224,10 +1211,9 @@ mod test {
 
                 let mut handle = sched.make_handle();
 
-                let sched = Cell::new(sched);
-
+                let sched = sched;
                 let thread = do Thread::start {
-                    let mut sched = sched.take();
+                    let mut sched = sched;
                     let bootstrap_task =
                         ~Task::new_root(&mut sched.stack_pool,
                                         None,
@@ -1258,9 +1244,8 @@ mod test {
             let mut ports = ~[];
             10.times(|| {
                 let (port, chan) = oneshot();
-                let chan_cell = Cell::new(chan);
                 do spawntask_later {
-                    chan_cell.take().send(());
+                    chan.send(());
                 }
                 ports.push(port);
             });
diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs
index 2ab543a4c36..96b80d11129 100644
--- a/src/libstd/rt/test.rs
+++ b/src/libstd/rt/test.rs
@@ -10,7 +10,6 @@
 
 use io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
 
-use cell::Cell;
 use clone::Clone;
 use container::Container;
 use iter::{Iterator, range};
@@ -65,16 +64,14 @@ pub fn new_test_sched() -> Scheduler {
 }
 
 pub fn run_in_uv_task(f: proc()) {
-    let f = Cell::new(f);
     do run_in_bare_thread {
-        run_in_uv_task_core(f.take());
+        run_in_uv_task_core(f);
     }
 }
 
 pub fn run_in_newsched_task(f: proc()) {
-    let f = Cell::new(f);
     do run_in_bare_thread {
-        run_in_newsched_task_core(f.take());
+        run_in_newsched_task_core(f);
     }
 }
 
@@ -206,8 +203,6 @@ pub fn run_in_mt_newsched_task(f: proc()) {
     // see comment in other function (raising fd limits)
     prepare_for_lots_of_tests();
 
-    let f = Cell::new(f);
-
     do run_in_bare_thread {
         let nthreads = match os::getenv("RUST_RT_TEST_THREADS") {
             Some(nstr) => FromStr::from_str(nstr).unwrap(),
@@ -254,18 +249,18 @@ pub fn run_in_mt_newsched_task(f: proc()) {
 
             rtassert!(exit_status.is_success());
         };
-        let mut main_task = ~Task::new_root(&mut scheds[0].stack_pool, None, f.take());
+        let mut main_task = ~Task::new_root(&mut scheds[0].stack_pool,
+                                            None,
+                                            f);
         main_task.death.on_exit = Some(on_exit);
 
         let mut threads = ~[];
-        let main_task = Cell::new(main_task);
 
         let main_thread = {
             let sched = scheds.pop();
-            let sched_cell = Cell::new(sched);
+            let main_task = main_task;
             do Thread::start {
-                let sched = sched_cell.take();
-                sched.bootstrap(main_task.take());
+                sched.bootstrap(main_task);
             }
         };
         threads.push(main_thread);
@@ -275,11 +270,9 @@ pub fn run_in_mt_newsched_task(f: proc()) {
             let bootstrap_task = ~do Task::new_root(&mut sched.stack_pool, None) || {
                 rtdebug!("bootstrapping non-primary scheduler");
             };
-            let bootstrap_task_cell = Cell::new(bootstrap_task);
-            let sched_cell = Cell::new(sched);
+            let sched = sched;
             let thread = do Thread::start {
-                let sched = sched_cell.take();
-                sched.bootstrap(bootstrap_task_cell.take());
+                sched.bootstrap(bootstrap_task);
             };
 
             threads.push(thread);
@@ -335,11 +328,8 @@ pub fn spawntask_try(f: proc()) -> Result<(),()> {
 
 /// Spawn a new task in a new scheduler and return a thread handle.
 pub fn spawntask_thread(f: proc()) -> Thread<()> {
-
-    let f = Cell::new(f);
-
     let thread = do Thread::start {
-        run_in_newsched_task_core(f.take());
+        run_in_newsched_task_core(f);
     };
 
     return thread;
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index a587515bb16..1777a523073 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -55,7 +55,6 @@
 
 use prelude::*;
 
-use cell::Cell;
 use comm::{stream, Chan, GenericChan, GenericPort, Port, Peekable};
 use result::{Result, Ok, Err};
 use rt::in_green_task_context;
@@ -284,10 +283,8 @@ impl TaskBuilder {
                 f
             }
         };
-        let prev_gen_body = Cell::new(prev_gen_body);
         let next_gen_body = {
             let f: proc(proc()) -> proc() = proc(body) {
-                let prev_gen_body = prev_gen_body.take();
                 wrapper(prev_gen_body(body))
             };
             f
@@ -548,11 +545,9 @@ struct Wrapper {
 fn test_add_wrapper() {
     let (po, ch) = stream::<()>();
     let mut b0 = task();
-    let ch = Cell::new(ch);
     do b0.add_wrapper |body| {
-        let ch = Cell::new(ch.take());
+        let ch = ch;
         let result: proc() = proc() {
-            let ch = ch.take();
             body();
             ch.send(());
         };
@@ -642,12 +637,10 @@ fn test_spawn_sched_childs_on_default_sched() {
     // Assuming tests run on the default scheduler
     let default_id = get_sched_id();
 
-    let ch = Cell::new(ch);
     do spawn_sched(SingleThreaded) {
         let parent_sched_id = get_sched_id();
-        let ch = Cell::new(ch.take());
+        let ch = ch;
         do spawn {
-            let ch = ch.take();
             let child_sched_id = get_sched_id();
             assert!(parent_sched_id != child_sched_id);
             assert_eq!(child_sched_id, default_id);
@@ -671,10 +664,10 @@ fn test_spawn_sched_blocking() {
             let (fin_po, fin_ch) = stream();
 
             let mut lock = Mutex::new();
-            let lock2 = Cell::new(lock.clone());
+            let lock2 = lock.clone();
 
             do spawn_sched(SingleThreaded) {
-                let mut lock = lock2.take();
+                let mut lock = lock2;
                 lock.lock();
 
                 start_ch.send(());
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
index 153b3e4ce25..4ab7b74d300 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -77,7 +77,6 @@
 
 use prelude::*;
 
-use cell::Cell;
 use comm::{GenericChan, oneshot};
 use rt::local::Local;
 use rt::sched::{Scheduler, Shutdown, TaskFromFriend};
@@ -134,23 +133,19 @@ pub fn spawn_raw(mut opts: TaskOpts, f: proc()) {
             // Create a task that will later be used to join with the new scheduler
             // thread when it is ready to terminate
             let (thread_port, thread_chan) = oneshot();
-            let thread_port_cell = Cell::new(thread_port);
             let join_task = do Task::build_child(None) {
                 debug!("running join task");
-                let thread_port = thread_port_cell.take();
                 let thread: Thread<()> = thread_port.recv();
                 thread.join();
             };
 
             // Put the scheduler into another thread
-            let new_sched_cell = Cell::new(new_sched);
-            let orig_sched_handle_cell = Cell::new((*sched).make_handle());
-            let join_task_cell = Cell::new(join_task);
+            let orig_sched_handle = (*sched).make_handle();
 
+            let new_sched = new_sched;
             let thread = do Thread::start {
-                let mut new_sched = new_sched_cell.take();
-                let mut orig_sched_handle = orig_sched_handle_cell.take();
-                let join_task = join_task_cell.take();
+                let mut new_sched = new_sched;
+                let mut orig_sched_handle = orig_sched_handle;
 
                 let bootstrap_task = ~do Task::new_root(&mut new_sched.stack_pool, None) || {
                     debug!("boostrapping a 1:1 scheduler");
@@ -178,9 +173,8 @@ pub fn spawn_raw(mut opts: TaskOpts, f: proc()) {
 
     if opts.notify_chan.is_some() {
         let notify_chan = opts.notify_chan.take_unwrap();
-        let notify_chan = Cell::new(notify_chan);
         let on_exit: proc(UnwindResult) = proc(task_result) {
-            notify_chan.take().send(task_result)
+            notify_chan.send(task_result)
         };
         task.death.on_exit = Some(on_exit);
     }
diff --git a/src/libstd/unstable/mod.rs b/src/libstd/unstable/mod.rs
index 63528036ffa..f8e2ea54f44 100644
--- a/src/libstd/unstable/mod.rs
+++ b/src/libstd/unstable/mod.rs
@@ -37,15 +37,13 @@ The executing thread has no access to a task pointer and will be using
 a normal large stack.
 */
 pub fn run_in_bare_thread(f: proc()) {
-    use cell::Cell;
     use rt::thread::Thread;
 
-    let f_cell = Cell::new(f);
     let (port, chan) = comm::stream();
     // FIXME #4525: Unfortunate that this creates an extra scheduler but it's
     // necessary since rust_raw_thread_join is blocking
     do task::spawn_sched(task::SingleThreaded) {
-        Thread::start(f_cell.take()).join();
+        Thread::start(f).join();
         chan.send(());
     }
     port.recv();