---

yaml
---
r: 36651
b: refs/heads/try2
c: 3fcdb7d
h: refs/heads/master
i:
  36649: db4ab17
  36647: deff816
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: ed686aeac4c717a85175a0f3b63d3ff50c2f50a7
+refs/heads/try2: 3fcdb7d6a758ac4ed1f27fcda77c372edaab4c09
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try2/src/libcore/rt.rs

@@ -26,9 +26,6 @@ use gc::{cleanup_stack_for_failure, gc, Word};
 pub type rust_task = c_void;
 
 extern mod rustrt {
-    #[rust_stack]
-    fn rust_upcall_fail(expr: *c_char, file: *c_char, line: size_t);
-
     #[rust_stack]
     fn rust_upcall_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char;
 
@@ -47,11 +44,7 @@ extern mod rustrt {
 // gather_rust_rtcalls.
 #[rt(fail_)]
 pub fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) -> ! {
-    unsafe {
-        cleanup_stack_for_failure();
-        rustrt::rust_upcall_fail(expr, file, line);
-        cast::transmute(())
-    }
+    sys::begin_unwind_(expr, file, line);
 }
 
 #[rt(fail_bounds_check)]

branches/try2/src/libcore/sys.rs

@@ -15,7 +15,7 @@
 #[forbid(deprecated_pattern)];
 
 use cmp::{Eq, Ord};
-use libc::c_void;
+use libc::{c_void, c_char, size_t};
 
 pub type FreeGlue = fn(*TypeDesc, *c_void);
 
@@ -43,6 +43,11 @@ extern mod rusti {
     fn min_align_of<T>() -> uint;
 }
 
+extern mod rustrt {
+    #[rust_stack]
+    fn rust_upcall_fail(expr: *c_char, file: *c_char, line: size_t);
+}
+
 /// Compares contents of two pointers using the default method.
 /// Equivalent to `*x1 == *x2`.  Useful for hashtables.
 pub pure fn shape_eq<T:Eq>(x1: &T, x2: &T) -> bool {
@@ -108,6 +113,28 @@ pub pure fn log_str<T>(t: &T) -> ~str {
     }
 }
 
+/** Initiate task failure */
+pub pure fn begin_unwind(msg: ~str, file: ~str, line: uint) -> ! {
+    do str::as_buf(msg) |msg_buf, _msg_len| {
+        do str::as_buf(file) |file_buf, _file_len| {
+            unsafe {
+                let msg_buf = cast::transmute(msg_buf);
+                let file_buf = cast::transmute(file_buf);
+                begin_unwind_(msg_buf, file_buf, line as libc::size_t)
+            }
+        }
+    }
+}
+
+// XXX: Temorary until rt::rt_fail_ goes away
+pub pure fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
+    unsafe {
+        gc::cleanup_stack_for_failure();
+        rustrt::rust_upcall_fail(msg, file, line);
+        cast::transmute(())
+    }
+}
+
 #[cfg(test)]
 pub mod tests {
 

branches/try2/src/libsyntax/ext/expand.rs

@@ -378,21 +378,10 @@ fn core_macros() -> ~str {
 
     macro_rules! die(
         ($msg: expr) => (
-            {
-                do core::str::as_buf($msg) |msg_buf, _msg_len| {
-                    do core::str::as_buf(file!()) |file_buf, _file_len| {
-                        unsafe {
-                            let msg_buf = core::cast::transmute(msg_buf);
-                            let file_buf = core::cast::transmute(file_buf);
-                            let line = line!() as core::libc::size_t;
-                            core::rt::rt_fail_(msg_buf, file_buf, line)
-                        }
-                    }
-                }
-            }
+            core::sys::begin_unwind($msg, file!(), line!())
         );
         () => (
-            die!(\"explicit failure\")
+            die!(~\"explicit failure\")
         )
     )
 }";

branches/try2/src/test/compile-fail/die-not-unique.rs

@@ -0,0 +1,5 @@
+// error-pattern:mismatched types
+
+fn main() {
+    die!("test");
+}

branches/try2/src/test/run-fail/die-macro-expr.rs

@@ -0,0 +1,5 @@
+// error-pattern:test
+
+fn main() {
+    let i: int = die!(~"test");
+}

branches/try2/src/test/run-fail/die-macro-pure.rs

@@ -0,0 +1,9 @@
+// error-pattern:test
+
+pure fn f() {
+    die!(~"test");
+}
+
+fn main() {
+    f();
+}

branches/try2/src/test/run-fail/die-macro.rs

@@ -0,0 +1,5 @@
+// error-pattern:test
+
+fn main() {
+    die!(~"test");
+}

branches/try2/src/test/run-pass/die-macro.rs

@@ -0,0 +1,11 @@
+// Just testing that die!() type checks in statement or expr
+
+fn f() {
+    die!();
+
+    let x: int = die!();
+}
+
+fn main() {
+
+}