---

yaml
---
r: 55130
b: refs/heads/snap-stage3
c: c1fdace
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 76ec35ae743ee299484a48b233bc64cf3779097d
+refs/heads/snap-stage3: c1fdace588034ae76f7ccb920ddadd9c2722a5cd
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcore/task/mod.rs

@@ -42,6 +42,7 @@ use result;
 use task::rt::{task_id, sched_id, rust_task};
 use util;
 use util::replace;
+use unstable::finally::Finally;
 
 #[cfg(test)] use comm::SharedChan;
 
@@ -591,76 +592,40 @@ pub fn get_scheduler() -> Scheduler {
  * ~~~
  */
 pub unsafe fn unkillable<U>(f: &fn() -> U) -> U {
-    struct AllowFailure {
-        t: *rust_task,
-        drop {
-            unsafe {
-                rt::rust_task_allow_kill(self.t);
-            }
-        }
-    }
-
-    fn AllowFailure(t: *rust_task) -> AllowFailure{
-        AllowFailure {
-            t: t
-        }
-    }
-
     let t = rt::rust_get_task();
-    let _allow_failure = AllowFailure(t);
-    rt::rust_task_inhibit_kill(t);
-    f()
+    do (|| {
+        rt::rust_task_inhibit_kill(t);
+        f()
+    }).finally {
+        rt::rust_task_allow_kill(t);
+    }
 }
 
 /// The inverse of unkillable. Only ever to be used nested in unkillable().
 pub unsafe fn rekillable<U>(f: &fn() -> U) -> U {
-    struct DisallowFailure {
-        t: *rust_task,
-        drop {
-            unsafe {
-                rt::rust_task_inhibit_kill(self.t);
-            }
-        }
-    }
-
-    fn DisallowFailure(t: *rust_task) -> DisallowFailure {
-        DisallowFailure {
-            t: t
-        }
-    }
-
     let t = rt::rust_get_task();
-    let _allow_failure = DisallowFailure(t);
-    rt::rust_task_allow_kill(t);
-    f()
+    do (|| {
+        rt::rust_task_allow_kill(t);
+        f()
+    }).finally {
+        rt::rust_task_inhibit_kill(t);
+    }
 }
 
 /**
  * A stronger version of unkillable that also inhibits scheduling operations.
  * For use with exclusive ARCs, which use pthread mutexes directly.
  */
 pub unsafe fn atomically<U>(f: &fn() -> U) -> U {
-    struct DeferInterrupts {
-        t: *rust_task,
-        drop {
-            unsafe {
-                rt::rust_task_allow_yield(self.t);
-                rt::rust_task_allow_kill(self.t);
-            }
-        }
-    }
-
-    fn DeferInterrupts(t: *rust_task) -> DeferInterrupts {
-        DeferInterrupts {
-            t: t
-        }
-    }
-
     let t = rt::rust_get_task();
-    let _interrupts = DeferInterrupts(t);
-    rt::rust_task_inhibit_kill(t);
-    rt::rust_task_inhibit_yield(t);
-    f()
+    do (|| {
+        rt::rust_task_inhibit_kill(t);
+        rt::rust_task_inhibit_yield(t);
+        f()
+    }).finally {
+        rt::rust_task_allow_yield(t);
+        rt::rust_task_allow_kill(t);
+    }
 }
 
 #[test] #[should_fail] #[ignore(cfg(windows))]

branches/snap-stage3/src/test/run-pass/alt-type-simple.rs

@@ -0,0 +1,14 @@
+
+// xfail-test
+
+fn altsimple(any x) {
+  match type (f) {
+    case (int i) { print("int"); }
+    case (str s) { print("str"); }
+  }
+}
+
+pub fn main() {
+  altsimple(5);
+  altsimple("asdfasdfsDF");
+}

branches/snap-stage3/src/test/run-pass/clone-with-exterior.rs

@@ -8,21 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+//xfail-test
+
 extern mod std;
-use core::task::spawn;
 
-struct Pair {
-    a: int,
-    b: int
+fn f(x : @{a:int, b:int}) {
+    assert!((x.a == 10));
+    assert!((x.b == 12));
 }
 
 pub fn main() {
-    let z = ~Pair { a : 10, b : 12};
-    
-    let f: ~fn() = || {
-        assert!((z.a == 10));
-        assert!((z.b == 12));
-    };
-
-    spawn(f);
+    let z : @{a:int, b:int} = @{ a : 10, b : 12};
+    let p = task::_spawn(bind f(z));
+    task::join_id(p);
 }

branches/snap-stage3/src/test/run-pass/infinite-loops.rs

@@ -15,15 +15,16 @@
 // xfail-test
 
 extern mod std;
+use task::join;
+
+fn loop(n: int) {
+    let t1: task;
+    let t2: task;
+
+    if n > 0 { t1 = spawn loop(n - 1); t2 = spawn loop(n - 1); }
+
 
-fn loopy(n: int) {
-    if n > 0 { do spawn { loopy(n - 1) }; do spawn { loopy(n - 1) }; }
     loop { }
 }
 
-pub fn main() { 
-    // Commenting this out, as this will hang forever otherwise.
-    // Even after seeing the comment above, I'm not sure what the
-    // intention of this test is.
-    // do spawn { loopy(5) }; 
-}
+pub fn main() { let t: task = spawn loop(5); join(t); }