std::cell: Modernize constructors

Part of #3853

13 files changed, 75 insertions, 75 deletions

diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs
index 54db03b6069..8a8f31bbdfa 100644
--- a/src/libstd/rt/comm.rs
+++ b/src/libstd/rt/comm.rs
@@ -309,8 +309,8 @@ pub struct Port<T> {
 
 pub fn stream<T: Owned>() -> (Port<T>, Chan<T>) {
     let (pone, cone) = oneshot();
-    let port = Port { next: Cell(pone) };
-    let chan = Chan { next: Cell(cone) };
+    let port = Port { next: Cell::new(pone) };
+    let chan = Chan { next: Cell::new(cone) };
     return (port, chan);
 }
 
@@ -483,7 +483,7 @@ mod test {
     fn oneshot_multi_task_recv_then_send() {
         do run_in_newsched_task {
             let (port, chan) = oneshot::<~int>();
-            let port_cell = Cell(port);
+            let port_cell = Cell::new(port);
             do spawntask_immediately {
                 assert!(port_cell.take().recv() == ~10);
             }
@@ -496,8 +496,8 @@ mod test {
     fn oneshot_multi_task_recv_then_close() {
         do run_in_newsched_task {
             let (port, chan) = oneshot::<~int>();
-            let port_cell = Cell(port);
-            let chan_cell = Cell(chan);
+            let port_cell = Cell::new(port);
+            let chan_cell = Cell::new(chan);
             do spawntask_later {
                 let _cell = chan_cell.take();
             }
@@ -513,7 +513,7 @@ mod test {
         for stress_factor().times {
             do run_in_newsched_task {
                 let (port, chan) = oneshot::<int>();
-                let port_cell = Cell(port);
+                let port_cell = Cell::new(port);
                 let _thread = do spawntask_thread {
                     let _p = port_cell.take();
                 };
@@ -527,8 +527,8 @@ mod test {
         for stress_factor().times {
             do run_in_newsched_task {
                 let (port, chan) = oneshot::<int>();
-                let chan_cell = Cell(chan);
-                let port_cell = Cell(port);
+                let chan_cell = Cell::new(chan);
+                let port_cell = Cell::new(port);
                 let _thread1 = do spawntask_thread {
                     let _p = port_cell.take();
                 };
@@ -545,17 +545,17 @@ mod test {
         for stress_factor().times {
             do run_in_newsched_task {
                 let (port, chan) = oneshot::<int>();
-                let chan_cell = Cell(chan);
-                let port_cell = Cell(port);
+                let chan_cell = Cell::new(chan);
+                let port_cell = Cell::new(port);
                 let _thread1 = do spawntask_thread {
-                    let port_cell = Cell(port_cell.take());
+                    let port_cell = Cell::new(port_cell.take());
                     let res = do spawntask_try {
                         port_cell.take().recv();
                     };
                     assert!(res.is_err());
                 };
                 let _thread2 = do spawntask_thread {
-                    let chan_cell = Cell(chan_cell.take());
+                    let chan_cell = Cell::new(chan_cell.take());
                     do spawntask {
                         chan_cell.take();
                     }
@@ -569,8 +569,8 @@ mod test {
         for stress_factor().times {
             do run_in_newsched_task {
                 let (port, chan) = oneshot::<~int>();
-                let chan_cell = Cell(chan);
-                let port_cell = Cell(port);
+                let chan_cell = Cell::new(chan);
+                let port_cell = Cell::new(port);
                 let _thread1 = do spawntask_thread {
                     chan_cell.take().send(~10);
                 };
@@ -593,7 +593,7 @@ mod test {
                 fn send(chan: Chan<~int>, i: int) {
                     if i == 10 { return }
 
-                    let chan_cell = Cell(chan);
+                    let chan_cell = Cell::new(chan);
                     let _thread = do spawntask_thread {
                         let chan = chan_cell.take();
                         chan.send(~i);
@@ -604,7 +604,7 @@ mod test {
                 fn recv(port: Port<~int>, i: int) {
                     if i == 10 { return }
 
-                    let port_cell = Cell(port);
+                    let port_cell = Cell::new(port);
                     let _thread = do spawntask_thread {
                         let port = port_cell.take();
                         assert!(port.recv() == ~i);
diff --git a/src/libstd/rt/io/extensions.rs b/src/libstd/rt/io/extensions.rs
index fcbf31e87f2..7d6d89ce997 100644
--- a/src/libstd/rt/io/extensions.rs
+++ b/src/libstd/rt/io/extensions.rs
@@ -604,7 +604,7 @@ mod test {
     #[test]
     fn read_byte_0_bytes() {
         let mut reader = MockReader::new();
-        let count = Cell(0);
+        let count = Cell::new(0);
         reader.read = |buf| {
             do count.with_mut_ref |count| {
                 if *count == 0 {
@@ -652,7 +652,7 @@ mod test {
     #[test]
     fn read_bytes_partial() {
         let mut reader = MockReader::new();
-        let count = Cell(0);
+        let count = Cell::new(0);
         reader.read = |buf| {
             do count.with_mut_ref |count| {
                 if *count == 0 {
@@ -691,7 +691,7 @@ mod test {
     #[test]
     fn push_bytes_partial() {
         let mut reader = MockReader::new();
-        let count = Cell(0);
+        let count = Cell::new(0);
         reader.read = |buf| {
             do count.with_mut_ref |count| {
                 if *count == 0 {
@@ -725,7 +725,7 @@ mod test {
     #[test]
     fn push_bytes_error() {
         let mut reader = MockReader::new();
-        let count = Cell(0);
+        let count = Cell::new(0);
         reader.read = |buf| {
             do count.with_mut_ref |count| {
                 if *count == 0 {
@@ -754,7 +754,7 @@ mod test {
         // push_bytes unsafely sets the vector length. This is testing that
         // upon failure the length is reset correctly.
         let mut reader = MockReader::new();
-        let count = Cell(0);
+        let count = Cell::new(0);
         reader.read = |buf| {
             do count.with_mut_ref |count| {
                 if *count == 0 {
@@ -779,7 +779,7 @@ mod test {
     #[test]
     fn read_to_end() {
         let mut reader = MockReader::new();
-        let count = Cell(0);
+        let count = Cell::new(0);
         reader.read = |buf| {
             do count.with_mut_ref |count| {
                 if *count == 0 {
@@ -806,7 +806,7 @@ mod test {
     #[ignore(cfg(windows))]
     fn read_to_end_error() {
         let mut reader = MockReader::new();
-        let count = Cell(0);
+        let count = Cell::new(0);
         reader.read = |buf| {
             do count.with_mut_ref |count| {
                 if *count == 0 {
diff --git a/src/libstd/rt/io/net/tcp.rs b/src/libstd/rt/io/net/tcp.rs
index f7c03c13a58..3607f781da3 100644
--- a/src/libstd/rt/io/net/tcp.rs
+++ b/src/libstd/rt/io/net/tcp.rs
@@ -287,7 +287,7 @@ mod test {
             do spawntask_immediately {
                 let mut listener = TcpListener::bind(addr);
                 for int::range(0, MAX) |i| {
-                    let stream = Cell(listener.accept());
+                    let stream = Cell::new(listener.accept());
                     rtdebug!("accepted");
                     // Start another task to handle the connection
                     do spawntask_immediately {
@@ -326,7 +326,7 @@ mod test {
             do spawntask_immediately {
                 let mut listener = TcpListener::bind(addr);
                 for int::range(0, MAX) |_| {
-                    let stream = Cell(listener.accept());
+                    let stream = Cell::new(listener.accept());
                     rtdebug!("accepted");
                     // Start another task to handle the connection
                     do spawntask_later {
diff --git a/src/libstd/rt/local_ptr.rs b/src/libstd/rt/local_ptr.rs
index 80d797e8c65..0db903f81ee 100644
--- a/src/libstd/rt/local_ptr.rs
+++ b/src/libstd/rt/local_ptr.rs
@@ -79,7 +79,7 @@ pub unsafe fn borrow<T>(f: &fn(&mut T)) {
 
     // XXX: Need a different abstraction from 'finally' here to avoid unsafety
     let unsafe_ptr = cast::transmute_mut_region(&mut *value);
-    let value_cell = Cell(value);
+    let value_cell = Cell::new(value);
 
     do (|| {
         f(unsafe_ptr);
diff --git a/src/libstd/rt/message_queue.rs b/src/libstd/rt/message_queue.rs
index fb1a5334646..5b60543344d 100644
--- a/src/libstd/rt/message_queue.rs
+++ b/src/libstd/rt/message_queue.rs
@@ -30,7 +30,7 @@ impl<T: Owned> MessageQueue<T> {
 
     pub fn push(&mut self, value: T) {
         unsafe {
-            let value = Cell(value);
+            let value = Cell::new(value);
             self.queue.with(|q| q.push(value.take()) );
         }
     }
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index f6017b92807..f9f433b9416 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -194,7 +194,7 @@ pub fn context() -> RuntimeContext {
         return OldTaskContext;
     } else {
         if Local::exists::<Scheduler>() {
-            let context = ::cell::empty_cell();
+            let context = ::cell::Cell::new_empty();
             do Local::borrow::<Scheduler> |sched| {
                 if sched.in_task_context() {
                     context.put_back(TaskContext);
@@ -231,7 +231,7 @@ fn test_context() {
             let sched = Local::take::<Scheduler>();
             do sched.deschedule_running_task_and_then() |task| {
                 assert_eq!(context(), SchedulerContext);
-                let task = Cell(task);
+                let task = Cell::new(task);
                 do Local::borrow::<Scheduler> |sched| {
                     sched.enqueue_task(task.take());
                 }
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index 064eb63afc6..929b44f79b5 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -146,7 +146,7 @@ impl Scheduler {
         rtdebug!("ending running task");
 
         do self.deschedule_running_task_and_then |dead_task| {
-            let dead_task = Cell(dead_task);
+            let dead_task = Cell::new(dead_task);
             do Local::borrow::<Scheduler> |sched| {
                 dead_task.take().recycle(&mut sched.stack_pool);
             }
@@ -159,7 +159,7 @@ impl Scheduler {
         assert!(self.in_task_context());
 
         do self.switch_running_tasks_and_then(task) |last_task| {
-            let last_task = Cell(last_task);
+            let last_task = Cell::new(last_task);
             do Local::borrow::<Scheduler> |sched| {
                 sched.enqueue_task(last_task.take());
             }
@@ -170,7 +170,7 @@ impl Scheduler {
         assert!(self.in_task_context());
 
         do self.switch_running_tasks_and_then(task) |last_task| {
-            let last_task = Cell(last_task);
+            let last_task = Cell::new(last_task);
             do Local::borrow::<Scheduler> |sched| {
                 sched.enqueue_task(last_task.take());
             }
@@ -462,7 +462,7 @@ mod test {
                 };
                 // Context switch directly to the new task
                 do sched.switch_running_tasks_and_then(task2) |task1| {
-                    let task1 = Cell(task1);
+                    let task1 = Cell::new(task1);
                     do Local::borrow::<Scheduler> |sched| {
                         sched.enqueue_task(task1.take());
                     }
@@ -516,7 +516,7 @@ mod test {
                 let sched = Local::take::<Scheduler>();
                 assert!(sched.in_task_context());
                 do sched.deschedule_running_task_and_then() |task| {
-                    let task = Cell(task);
+                    let task = Cell::new(task);
                     do Local::borrow::<Scheduler> |sched| {
                         assert!(!sched.in_task_context());
                         sched.enqueue_task(task.take());
@@ -539,7 +539,7 @@ mod test {
                 let sched = Local::take::<Scheduler>();
                 do sched.deschedule_running_task_and_then |task| {
                     let mut sched = Local::take::<Scheduler>();
-                    let task = Cell(task);
+                    let task = Cell::new(task);
                     do sched.event_loop.callback_ms(10) {
                         rtdebug!("in callback");
                         let mut sched = Local::take::<Scheduler>();
diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs
index c60ae2bfeff..453eab09730 100644
--- a/src/libstd/rt/test.rs
+++ b/src/libstd/rt/test.rs
@@ -25,7 +25,7 @@ pub fn run_in_newsched_task(f: ~fn()) {
     use unstable::run_in_bare_thread;
     use rt::uv::uvio::UvEventLoop;
 
-    let f = Cell(f);
+    let f = Cell::new(f);
 
     do run_in_bare_thread {
         let mut sched = ~UvEventLoop::new_scheduler();
@@ -46,7 +46,7 @@ pub fn spawntask(f: ~fn()) {
                                      ~Task::without_unwinding(),
                                      f);
     do sched.switch_running_tasks_and_then(task) |task| {
-        let task = Cell(task);
+        let task = Cell::new(task);
         let sched = Local::take::<Scheduler>();
         sched.schedule_new_task(task.take());
     }
@@ -61,7 +61,7 @@ pub fn spawntask_immediately(f: ~fn()) {
                                      ~Task::without_unwinding(),
                                      f);
     do sched.switch_running_tasks_and_then(task) |task| {
-        let task = Cell(task);
+        let task = Cell::new(task);
         do Local::borrow::<Scheduler> |sched| {
             sched.enqueue_task(task.take());
         }
@@ -96,7 +96,7 @@ pub fn spawntask_random(f: ~fn()) {
 
     if run_now {
         do sched.switch_running_tasks_and_then(task) |task| {
-            let task = Cell(task);
+            let task = Cell::new(task);
             do Local::borrow::<Scheduler> |sched| {
                 sched.enqueue_task(task.take());
             }
@@ -120,10 +120,10 @@ pub fn spawntask_try(f: ~fn()) -> Result<(), ()> {
     let failed_ptr: *mut bool = &mut failed;
 
     // Switch to the scheduler
-    let f = Cell(Cell(f));
+    let f = Cell::new(Cell::new(f));
     let sched = Local::take::<Scheduler>();
     do sched.deschedule_running_task_and_then() |old_task| {
-        let old_task = Cell(old_task);
+        let old_task = Cell::new(old_task);
         let f = f.take();
         let mut sched = Local::take::<Scheduler>();
         let new_task = ~do Coroutine::new(&mut sched.stack_pool) {
@@ -134,7 +134,7 @@ pub fn spawntask_try(f: ~fn()) -> Result<(), ()> {
                 unsafe { *failed_ptr = task::failing(); }
                 let sched = Local::take::<Scheduler>();
                 do sched.switch_running_tasks_and_then(old_task.take()) |new_task| {
-                    let new_task = Cell(new_task);
+                    let new_task = Cell::new(new_task);
                     do Local::borrow::<Scheduler> |sched| {
                         sched.enqueue_task(new_task.take());
                     }
@@ -153,7 +153,7 @@ pub fn spawntask_thread(f: ~fn()) -> Thread {
     use rt::sched::*;
     use rt::uv::uvio::UvEventLoop;
 
-    let f = Cell(f);
+    let f = Cell::new(f);
     let thread = do Thread::start {
         let mut sched = ~UvEventLoop::new_scheduler();
         let task = ~Coroutine::with_task(&mut sched.stack_pool,
diff --git a/src/libstd/rt/tube.rs b/src/libstd/rt/tube.rs
index b2f475a6966..03e11dfad1d 100644
--- a/src/libstd/rt/tube.rs
+++ b/src/libstd/rt/tube.rs
@@ -105,7 +105,7 @@ mod test {
         do run_in_newsched_task {
             let mut tube: Tube<int> = Tube::new();
             let tube_clone = tube.clone();
-            let tube_clone_cell = Cell(tube_clone);
+            let tube_clone_cell = Cell::new(tube_clone);
             let sched = Local::take::<Scheduler>();
             do sched.deschedule_running_task_and_then |task| {
                 let mut tube_clone = tube_clone_cell.take();
@@ -123,7 +123,7 @@ mod test {
         do run_in_newsched_task {
             let mut tube: Tube<int> = Tube::new();
             let tube_clone = tube.clone();
-            let tube_clone = Cell(Cell(Cell(tube_clone)));
+            let tube_clone = Cell::new(Cell::new(Cell::new(tube_clone)));
             let sched = Local::take::<Scheduler>();
             do sched.deschedule_running_task_and_then |task| {
                 let tube_clone = tube_clone.take();
@@ -151,7 +151,7 @@ mod test {
         do run_in_newsched_task {
             let mut tube: Tube<int> = Tube::new();
             let tube_clone = tube.clone();
-            let tube_clone = Cell(tube_clone);
+            let tube_clone = Cell::new(tube_clone);
             let sched = Local::take::<Scheduler>();
             do sched.deschedule_running_task_and_then |task| {
                 callback_send(tube_clone.take(), 0);
@@ -159,7 +159,7 @@ mod test {
                 fn callback_send(tube: Tube<int>, i: int) {
                     if i == 100 { return; }
 
-                    let tube = Cell(Cell(tube));
+                    let tube = Cell::new(Cell::new(tube));
                     do Local::borrow::<Scheduler> |sched| {
                         let tube = tube.take();
                         do sched.event_loop.callback {
diff --git a/src/libstd/rt/uv/net.rs b/src/libstd/rt/uv/net.rs
index 563d7fd1e81..4571747cebf 100644
--- a/src/libstd/rt/uv/net.rs
+++ b/src/libstd/rt/uv/net.rs
@@ -374,7 +374,7 @@ mod test {
                 let client_tcp_watcher = TcpWatcher::new(&mut loop_);
                 let mut client_tcp_watcher = client_tcp_watcher.as_stream();
                 server_stream_watcher.accept(client_tcp_watcher);
-                let count_cell = Cell(0);
+                let count_cell = Cell::new(0);
                 let server_stream_watcher = server_stream_watcher;
                 rtdebug!("starting read");
                 let alloc: AllocCallback = |size| {
@@ -414,11 +414,11 @@ mod test {
                     let mut stream_watcher = stream_watcher;
                     let msg = ~[0, 1, 2, 3, 4, 5, 6 ,7 ,8, 9];
                     let buf = slice_to_uv_buf(msg);
-                    let msg_cell = Cell(msg);
+                    let msg_cell = Cell::new(msg);
                     do stream_watcher.write(buf) |stream_watcher, status| {
                         rtdebug!("writing");
                         assert!(status.is_none());
-                        let msg_cell = Cell(msg_cell.take());
+                        let msg_cell = Cell::new(msg_cell.take());
                         stream_watcher.close(||ignore(msg_cell.take()));
                     }
                 }
diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs
index 1d4f65f1517..964ee460c1d 100644
--- a/src/libstd/rt/uv/uvio.rs
+++ b/src/libstd/rt/uv/uvio.rs
@@ -11,7 +11,7 @@
 use option::*;
 use result::*;
 use ops::Drop;
-use cell::{Cell, empty_cell};
+use cell::Cell;
 use cast::transmute;
 use clone::Clone;
 use rt::io::IoError;
@@ -115,7 +115,7 @@ impl IoFactory for UvIoFactory {
     fn tcp_connect(&mut self, addr: IpAddr) -> Result<~RtioTcpStreamObject, IoError> {
         // Create a cell in the task to hold the result. We will fill
         // the cell before resuming the task.
-        let result_cell = empty_cell();
+        let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Result<~RtioTcpStreamObject, IoError>> = &result_cell;
 
         let scheduler = Local::take::<Scheduler>();
@@ -129,7 +129,7 @@ impl IoFactory for UvIoFactory {
                 assert!(!scheduler.in_task_context());
             }
             let mut tcp_watcher = TcpWatcher::new(self.uv_loop());
-            let task_cell = Cell(task);
+            let task_cell = Cell::new(task);
 
             // Wait for a connection
             do tcp_watcher.connect(addr) |stream_watcher, status| {
@@ -146,7 +146,7 @@ impl IoFactory for UvIoFactory {
                     scheduler.resume_task_immediately(task_cell.take());
                 } else {
                     rtdebug!("status is some");
-                    let task_cell = Cell(task_cell.take());
+                    let task_cell = Cell::new(task_cell.take());
                     do stream_watcher.close {
                         let res = Err(uv_error_to_io_error(status.get()));
                         unsafe { (*result_cell_ptr).put_back(res); }
@@ -168,7 +168,7 @@ impl IoFactory for UvIoFactory {
             Err(uverr) => {
                 let scheduler = Local::take::<Scheduler>();
                 do scheduler.deschedule_running_task_and_then |task| {
-                    let task_cell = Cell(task);
+                    let task_cell = Cell::new(task);
                     do watcher.as_stream().close {
                         let scheduler = Local::take::<Scheduler>();
                         scheduler.resume_task_immediately(task_cell.take());
@@ -204,7 +204,7 @@ impl Drop for UvTcpListener {
         let watcher = self.watcher();
         let scheduler = Local::take::<Scheduler>();
         do scheduler.deschedule_running_task_and_then |task| {
-            let task_cell = Cell(task);
+            let task_cell = Cell::new(task);
             do watcher.as_stream().close {
                 let scheduler = Local::take::<Scheduler>();
                 scheduler.resume_task_immediately(task_cell.take());
@@ -225,9 +225,9 @@ impl RtioTcpListener for UvTcpListener {
         self.listening = true;
 
         let server_tcp_watcher = self.watcher();
-        let incoming_streams_cell = Cell(self.incoming_streams.clone());
+        let incoming_streams_cell = Cell::new(self.incoming_streams.clone());
 
-        let incoming_streams_cell = Cell(incoming_streams_cell.take());
+        let incoming_streams_cell = Cell::new(incoming_streams_cell.take());
         let mut server_tcp_watcher = server_tcp_watcher;
         do server_tcp_watcher.listen |server_stream_watcher, status| {
             let maybe_stream = if status.is_none() {
@@ -266,7 +266,7 @@ impl Drop for UvTcpStream {
         let watcher = self.watcher();
         let scheduler = Local::take::<Scheduler>();
         do scheduler.deschedule_running_task_and_then |task| {
-            let task_cell = Cell(task);
+            let task_cell = Cell::new(task);
             do watcher.close {
                 let scheduler = Local::take::<Scheduler>();
                 scheduler.resume_task_immediately(task_cell.take());
@@ -277,7 +277,7 @@ impl Drop for UvTcpStream {
 
 impl RtioTcpStream for UvTcpStream {
     fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
-        let result_cell = empty_cell();
+        let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Result<uint, IoError>> = &result_cell;
 
         let scheduler = Local::take::<Scheduler>();
@@ -290,7 +290,7 @@ impl RtioTcpStream for UvTcpStream {
                 assert!(!scheduler.in_task_context());
             }
             let mut watcher = watcher;
-            let task_cell = Cell(task);
+            let task_cell = Cell::new(task);
             // XXX: We shouldn't reallocate these callbacks every
             // call to read
             let alloc: AllocCallback = |_| unsafe {
@@ -324,7 +324,7 @@ impl RtioTcpStream for UvTcpStream {
     }
 
     fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
-        let result_cell = empty_cell();
+        let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
         let scheduler = Local::take::<Scheduler>();
         assert!(scheduler.in_task_context());
@@ -332,7 +332,7 @@ impl RtioTcpStream for UvTcpStream {
         let buf_ptr: *&[u8] = &buf;
         do scheduler.deschedule_running_task_and_then |task| {
             let mut watcher = watcher;
-            let task_cell = Cell(task);
+            let task_cell = Cell::new(task);
             let buf = unsafe { slice_to_uv_buf(*buf_ptr) };
             do watcher.write(buf) |_watcher, status| {
                 let result = if status.is_none() {
@@ -425,7 +425,7 @@ fn test_read_and_block() {
                 // will trigger a read callback while we are
                 // not ready for it
                 do scheduler.deschedule_running_task_and_then |task| {
-                    let task = Cell(task);
+                    let task = Cell::new(task);
                     do Local::borrow::<Scheduler> |scheduler| {
                         scheduler.enqueue_task(task.take());
                     }
diff --git a/src/libstd/rt/uvio.rs b/src/libstd/rt/uvio.rs
index c7467364b4d..070ccf7fb44 100644
--- a/src/libstd/rt/uvio.rs
+++ b/src/libstd/rt/uvio.rs
@@ -16,7 +16,7 @@ use super::uv::*;
 use super::rtio::*;
 use ops::Drop;
 use old_iter::CopyableIter;
-use cell::{Cell, empty_cell};
+use cell::Cell;
 use cast::transmute;
 use super::sched::{Scheduler, local_sched};
 
@@ -103,7 +103,7 @@ impl IoFactory for UvIoFactory {
     fn connect(&mut self, addr: IpAddr) -> Option<~StreamObject> {
         // Create a cell in the task to hold the result. We will fill
         // the cell before resuming the task.
-        let result_cell = empty_cell();
+        let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Option<~StreamObject>> = &result_cell;
 
         let scheduler = local_sched::take();
@@ -117,7 +117,7 @@ impl IoFactory for UvIoFactory {
                 assert!(!scheduler.in_task_context());
             }
             let mut tcp_watcher = TcpWatcher::new(self.uv_loop());
-            let task_cell = Cell(task);
+            let task_cell = Cell::new(task);
 
             // Wait for a connection
             do tcp_watcher.connect(addr) |stream_watcher, status| {
@@ -175,7 +175,7 @@ impl TcpListener for UvTcpListener {
 
     fn listen(&mut self) -> Option<~StreamObject> {
         rtdebug!("entering listen");
-        let result_cell = empty_cell();
+        let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Option<~StreamObject>> = &result_cell;
 
         let server_tcp_watcher = self.watcher();
@@ -184,7 +184,7 @@ impl TcpListener for UvTcpListener {
         assert!(scheduler.in_task_context());
 
         do scheduler.deschedule_running_task_and_then |task| {
-            let task_cell = Cell(task);
+            let task_cell = Cell::new(task);
             let mut server_tcp_watcher = server_tcp_watcher;
             do server_tcp_watcher.listen |server_stream_watcher, status| {
                 let maybe_stream = if status.is_none() {
@@ -239,7 +239,7 @@ impl Drop for UvStream {
 
 impl Stream for UvStream {
     fn read(&mut self, buf: &mut [u8]) -> Result<uint, ()> {
-        let result_cell = empty_cell();
+        let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Result<uint, ()>> = &result_cell;
 
         let scheduler = local_sched::take();
@@ -252,7 +252,7 @@ impl Stream for UvStream {
                 assert!(!scheduler.in_task_context());
             }
             let mut watcher = watcher;
-            let task_cell = Cell(task);
+            let task_cell = Cell::new(task);
             // XXX: We shouldn't reallocate these callbacks every
             // call to read
             let alloc: AllocCallback = |_| unsafe {
@@ -286,7 +286,7 @@ impl Stream for UvStream {
     }
 
     fn write(&mut self, buf: &[u8]) -> Result<(), ()> {
-        let result_cell = empty_cell();
+        let result_cell = Cell::new_empty();
         let result_cell_ptr: *Cell<Result<(), ()>> = &result_cell;
         let scheduler = local_sched::take();
         assert!(scheduler.in_task_context());
@@ -294,7 +294,7 @@ impl Stream for UvStream {
         let buf_ptr: *&[u8] = &buf;
         do scheduler.deschedule_running_task_and_then |task| {
             let mut watcher = watcher;
-            let task_cell = Cell(task);
+            let task_cell = Cell::new(task);
             let buf = unsafe { &*buf_ptr };
             // XXX: OMGCOPIES
             let buf = buf.to_vec();
@@ -390,7 +390,7 @@ fn test_read_and_block() {
                 // will trigger a read callback while we are
                 // not ready for it
                 do scheduler.deschedule_running_task_and_then |task| {
-                    let task = Cell(task);
+                    let task = Cell::new(task);
                     do local_sched::borrow |scheduler| {
                         scheduler.task_queue.push_back(task.take());
                     }
diff --git a/src/libstd/rt/work_queue.rs b/src/libstd/rt/work_queue.rs
index 58d36113f0e..cfffc55a58c 100644
--- a/src/libstd/rt/work_queue.rs
+++ b/src/libstd/rt/work_queue.rs
@@ -30,7 +30,7 @@ impl<T: Owned> WorkQueue<T> {
 
     pub fn push(&mut self, value: T) {
         unsafe {
-            let value = Cell(value);
+            let value = Cell::new(value);
             self.queue.with(|q| q.unshift(value.take()) );
         }
     }