Task killing, linked failure, and exit code propagation in the new runtime.

src/libextra/arc.rs

@@ -50,9 +50,9 @@ use std::borrow;
 
 /// As sync::condvar, a mechanism for unlock-and-descheduling and signaling.
 pub struct Condvar<'self> {
-    is_mutex: bool,
-    failed: &'self mut bool,
-    cond: &'self sync::Condvar<'self>
+    priv is_mutex: bool,
+    priv failed: &'self mut bool,
+    priv cond: &'self sync::Condvar<'self>
 }
 
 impl<'self> Condvar<'self> {
@@ -108,7 +108,7 @@ impl<'self> Condvar<'self> {
  ****************************************************************************/
 
 /// An atomically reference counted wrapper for shared immutable state.
-pub struct ARC<T> { x: UnsafeAtomicRcBox<T> }
+pub struct ARC<T> { priv x: UnsafeAtomicRcBox<T> }
 
 /// Create an atomically reference counted wrapper.
 pub fn ARC<T:Freeze + Send>(data: T) -> ARC<T> {
@@ -123,6 +123,20 @@ impl<T:Freeze+Send> ARC<T> {
     pub fn get<'a>(&'a self) -> &'a T {
         unsafe { &*self.x.get_immut() }
     }
+
+    /**
+     * Retrieve the data back out of the ARC. This function blocks until the
+     * reference given to it is the last existing one, and then unwrap the data
+     * instead of destroying it.
+     *
+     * If multiple tasks call unwrap, all but the first will fail. Do not call
+     * unwrap from a task that holds another reference to the same ARC; it is
+     * guaranteed to deadlock.
+     */
+    pub fn unwrap(self) -> T {
+        let ARC { x: x } = self;
+        unsafe { x.unwrap() }
+    }
 }
 
 /**
@@ -143,9 +157,9 @@ impl<T:Freeze + Send> Clone for ARC<T> {
  ****************************************************************************/
 
 #[doc(hidden)]
-struct MutexARCInner<T> { lock: Mutex, failed: bool, data: T }
+struct MutexARCInner<T> { priv lock: Mutex, priv failed: bool, priv data: T }
 /// An ARC with mutable data protected by a blocking mutex.
-struct MutexARC<T> { x: UnsafeAtomicRcBox<MutexARCInner<T>> }
+struct MutexARC<T> { priv x: UnsafeAtomicRcBox<MutexARCInner<T>> }
 
 /// Create a mutex-protected ARC with the supplied data.
 pub fn MutexARC<T:Send>(user_data: T) -> MutexARC<T> {
@@ -225,6 +239,22 @@ impl<T:Send> MutexARC<T> {
                           cond: cond })
         }
     }
+
+    /**
+     * Retrieves the data, blocking until all other references are dropped,
+     * exactly as arc::unwrap.
+     *
+     * Will additionally fail if another task has failed while accessing the arc.
+     */
+    pub fn unwrap(self) -> T {
+        let MutexARC { x: x } = self;
+        let inner = unsafe { x.unwrap() };
+        let MutexARCInner { failed: failed, data: data, _ } = inner;
+        if failed {
+            fail!(~"Can't unwrap poisoned MutexARC - another task failed inside!");
+        }
+        data
+    }
 }
 
 // Common code for {mutex.access,rwlock.write}{,_cond}.
@@ -268,7 +298,7 @@ fn PoisonOnFail<'r>(failed: &'r mut bool) -> PoisonOnFail {
  ****************************************************************************/
 
 #[doc(hidden)]
-struct RWARCInner<T> { lock: RWlock, failed: bool, data: T }
+struct RWARCInner<T> { priv lock: RWlock, priv failed: bool, priv data: T }
 /**
  * A dual-mode ARC protected by a reader-writer lock. The data can be accessed
  * mutably or immutably, and immutably-accessing tasks may run concurrently.
@@ -278,7 +308,7 @@ struct RWARCInner<T> { lock: RWlock, failed: bool, data: T }
 #[mutable] // XXX remove after snap
 #[no_freeze]
 struct RWARC<T> {
-    x: UnsafeAtomicRcBox<RWARCInner<T>>,
+    priv x: UnsafeAtomicRcBox<RWARCInner<T>>,
 }
 
 /// Create a reader/writer ARC with the supplied data.
@@ -429,6 +459,23 @@ impl<T:Freeze + Send> RWARC<T> {
             }
         }
     }
+
+    /**
+     * Retrieves the data, blocking until all other references are dropped,
+     * exactly as arc::unwrap.
+     *
+     * Will additionally fail if another task has failed while accessing the arc
+     * in write mode.
+     */
+    pub fn unwrap(self) -> T {
+        let RWARC { x: x, _ } = self;
+        let inner = unsafe { x.unwrap() };
+        let RWARCInner { failed: failed, data: data, _ } = inner;
+        if failed {
+            fail!(~"Can't unwrap poisoned RWARC - another task failed inside!")
+        }
+        data
+    }
 }
 
 // Borrowck rightly complains about immutably aliasing the rwlock in order to
@@ -611,6 +658,23 @@ mod tests {
         }
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
+    pub fn test_mutex_arc_unwrap_poison() {
+        let arc = MutexARC(1);
+        let arc2 = ~(&arc).clone();
+        let (p, c) = comm::stream();
+        do task::spawn {
+            unsafe {
+                do arc2.access |one| {
+                    c.send(());
+                    assert!(*one == 2);
+                }
+            }
+        }
+        let _ = p.recv();
+        let one = arc.unwrap();
+        assert!(one == 1);
+    }
+    #[test] #[should_fail] #[ignore(cfg(windows))]
     fn test_rw_arc_poison_wr() {
         let arc = ~RWARC(1);
         let arc2 = (*arc).clone();

src/libextra/dlist.rs

@@ -208,7 +208,7 @@ impl<T> Deque<T> for DList<T> {
     ///
     /// O(1)
     fn pop_front(&mut self) -> Option<T> {
-        match util::replace(&mut self.list_head, None) {
+        match self.list_head.take() {
             None => None,
             Some(old_head) => {
                 self.length -= 1;

src/libextra/ringbuf.rs

@@ -14,7 +14,6 @@
 //! extra::container::Deque`.
 
 use std::num;
-use std::util;
 use std::uint;
 use std::vec;
 use std::iterator::{FromIterator, InvertIterator};
@@ -72,7 +71,7 @@ impl<T> Deque<T> for RingBuf<T> {
 
     /// Remove and return the first element in the RingBuf, or None if it is empty
     fn pop_front(&mut self) -> Option<T> {
-        let result = util::replace(&mut self.elts[self.lo], None);
+        let result = self.elts[self.lo].take();
         if result.is_some() {
             self.lo = (self.lo + 1u) % self.elts.len();
             self.nelts -= 1u;
@@ -85,7 +84,7 @@ impl<T> Deque<T> for RingBuf<T> {
         if self.nelts > 0 {
             self.nelts -= 1;
             let hi = self.raw_index(self.nelts);
-            util::replace(&mut self.elts[hi], None)
+            self.elts[hi].take()
         } else {
             None
         }

src/libextra/smallintmap.rs

@@ -118,7 +118,7 @@ impl<V> MutableMap<uint, V> for SmallIntMap<V> {
         if *key >= self.v.len() {
             return None;
         }
-        replace(&mut self.v[*key], None)
+        self.v[*key].take()
     }
 }
 

src/libextra/sort.rs

@@ -1020,8 +1020,6 @@ mod big_tests {
 
     use sort::*;
 
-    use std::cast::unsafe_copy;
-    use std::local_data;
     use std::rand::RngUtil;
     use std::rand;
     use std::uint;

src/libextra/treemap.rs

@@ -697,7 +697,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
         }
       }
     }
-    return match replace(node, None) {
+    return match node.take() {
         Some(~TreeNode{value, _}) => Some(value), None => fail!()
     };
 }

src/libextra/workcache.rs

@@ -27,7 +27,6 @@ use std::result;
 use std::run;
 use std::task;
 use std::to_bytes;
-use std::util::replace;
 
 /**
 *
@@ -353,7 +352,7 @@ impl TPrep for Prep {
 
             _ => {
                 let (port, chan) = oneshot();
-                let blk = replace(&mut bo, None).unwrap();
+                let blk = bo.take_unwrap();
                 let chan = Cell::new(chan);
 
                 do task::spawn {
@@ -385,7 +384,7 @@ fn unwrap<T:Send +
             Decodable<json::Decoder>>( // FIXME(#5121)
         w: Work<T>) -> T {
     let mut ww = w;
-    let s = replace(&mut ww.res, None);
+    let s = ww.res.take();
 
     match s {
         None => fail!(),

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.

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")

src/libstd/either.rs

@@ -18,6 +18,7 @@ use cmp::Eq;
 use iterator::IteratorUtil;
 use result::Result;
 use result;
+use str::StrSlice;
 use vec;
 use vec::{OwnedVector, ImmutableVector};
 
@@ -121,24 +122,37 @@ pub fn is_right<T, U>(eith: &Either<T, U>) -> bool {
     }
 }
 
-/// Retrieves the value in the left branch. Fails if the either is Right.
+/// Retrieves the value in the left branch.
+/// Fails with a specified reason if the either is Right.
 #[inline]
-pub fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
+pub fn expect_left<T,U>(eith: Either<T,U>, reason: &str) -> T {
     match eith {
         Left(x) => x,
-        Right(_) => fail!("either::unwrap_left Right")
+        Right(_) => fail!(reason.to_owned())
     }
 }
 
-/// Retrieves the value in the right branch. Fails if the either is Left.
+/// Retrieves the value in the left branch. Fails if the either is Right.
 #[inline]
-pub fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
+pub fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
+    expect_left(eith, "either::unwrap_left Right")
+}
+
+/// Retrieves the value in the right branch.
+/// Fails with a specified reason if the either is Left.
+#[inline]
+pub fn expect_right<T,U>(eith: Either<T,U>, reason: &str) -> U {
     match eith {
         Right(x) => x,
-        Left(_) => fail!("either::unwrap_right Left")
+        Left(_) => fail!(reason.to_owned())
     }
 }
 
+/// Retrieves the value in the right branch. Fails if the either is Left.
+pub fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
+    expect_right(eith, "either::unwrap_right Left")
+}
+
 impl<T, U> Either<T, U> {
     #[inline]
     pub fn either<V>(&self, f_left: &fn(&T) -> V, f_right: &fn(&U) -> V) -> V {
@@ -157,9 +171,15 @@ impl<T, U> Either<T, U> {
     #[inline]
     pub fn is_right(&self) -> bool { is_right(self) }
 
+    #[inline]
+    pub fn expect_left(self, reason: &str) -> T { expect_left(self, reason) }
+
     #[inline]
     pub fn unwrap_left(self) -> T { unwrap_left(self) }
 
+    #[inline]
+    pub fn expect_right(self, reason: &str) -> U { expect_right(self, reason) }
+
     #[inline]
     pub fn unwrap_right(self) -> U { unwrap_right(self) }
 }