---

yaml
---
r: 41423
b: refs/heads/snap-stage3
c: 405b868
h: refs/heads/master
i:
  41421: 5608604
  41419: e9be172
  41415: d608c5a
  41407: d5c6340
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 09bb07bed9166105ea961a42b5fff7739ae0d2e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9dc69382922227964ab3f38a5343ba39dfcbc0c0
+refs/heads/snap-stage3: 405b868ae708949fba91c74746f3a5dd8cbe84a9
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/lib/codemirror-rust.js

@@ -2,7 +2,7 @@ CodeMirror.defineMode("rust", function() {
   var indentUnit = 4, altIndentUnit = 2;
   var valKeywords = {
     "if": "if-style", "while": "if-style", "loop": "if-style", "else": "else-style",
-    "do": "else-style", "return": "else-style",
+    "do": "else-style", "return": "else-style", "fail": "else-style",
     "break": "atom", "cont": "atom", "const": "let", "resource": "fn",
     "let": "let", "fn": "fn", "for": "for", "match": "match", "trait": "trait",
     "impl": "impl", "type": "type", "enum": "enum", "struct": "atom", "mod": "mod",

branches/snap-stage3/doc/rust.md

@@ -216,7 +216,7 @@ break
 const copy
 do drop
 else enum extern
-false fn for
+fail false fn for
 if impl
 let log loop
 match mod move mut
@@ -692,15 +692,15 @@ mod math {
     type complex = (f64, f64);
     fn sin(f: f64) -> f64 {
         ...
-# die!();
+# fail;
     }
     fn cos(f: f64) -> f64 {
         ...
-# die!();
+# fail;
     }
     fn tan(f: f64) -> f64 {
         ...
-# die!();
+# fail;
     }
 }
 ~~~~~~~~
@@ -851,9 +851,6 @@ mod quux {
 
 In this example, the module `quux` re-exports all of the public names defined in `foo`.
 
-Also note that the paths contained in `use` items are relative to the crate root; so, in the previous
-example, the use refers to `quux::foo::*`, and not simply to `foo::*`.
-
 ### Functions
 
 A _function item_ defines a sequence of [statements](#statements) and an optional final [expression](#expressions), along with a name and a set of parameters.
@@ -992,13 +989,13 @@ output slot type would normally be. For example:
 ~~~~
 fn my_err(s: &str) -> ! {
     log(info, s);
-    die!();
+    fail;
 }
 ~~~~
 
 We call such functions "diverging" because they never return a value to the
 caller. Every control path in a diverging function must end with a
-`fail!()` or a call to another diverging function on every
+[`fail`](#fail-expressions) or a call to another diverging function on every
 control path. The `!` annotation does *not* denote a type. Rather, the result
 type of a diverging function is a special type called $\bot$ ("bottom") that
 unifies with any type. Rust has no syntax for $\bot$.
@@ -1010,7 +1007,7 @@ were declared without the `!` annotation, the following code would not
 typecheck:
 
 ~~~~
-# fn my_err(s: &str) -> ! { die!() }
+# fn my_err(s: &str) -> ! { fail }
 
 fn f(i: int) -> int {
    if i == 42 {
@@ -2294,9 +2291,9 @@ enum List<X> { Nil, Cons(X, @List<X>) }
 let x: List<int> = Cons(10, @Cons(11, @Nil));
 
 match x {
-    Cons(_, @Nil) => die!(~"singleton list"),
+    Cons(_, @Nil) => fail ~"singleton list",
     Cons(*)       => return,
-    Nil           => die!(~"empty list")
+    Nil           => fail ~"empty list"
 }
 ~~~~
 
@@ -2333,7 +2330,7 @@ match x {
         return;
     }
     _ => {
-        die!();
+        fail;
     }
 }
 ~~~~
@@ -2421,10 +2418,23 @@ guard may refer to the variables bound within the pattern they follow.
 let message = match maybe_digit {
   Some(x) if x < 10 => process_digit(x),
   Some(x) => process_other(x),
-  None => die!()
+  None => fail
 };
 ~~~~
 
+
+### Fail expressions
+
+~~~~~~~~{.ebnf .gram}
+fail_expr : "fail" expr ? ;
+~~~~~~~~
+
+Evaluating a `fail` expression causes a task to enter the *failing* state. In
+the *failing* state, a task unwinds its stack, destroying all frames and
+running all destructors until it reaches its entry frame, at which point it
+halts execution in the *dead* state.
+
+
 ### Return expressions
 
 ~~~~~~~~{.ebnf .gram}
@@ -3144,7 +3154,7 @@ unblock and transition back to *running*.
 
 A task may transition to the *failing* state at any time, due being
 killed by some external event or internally, from the evaluation of a
-`fail!()` macro. Once *failing*, a task unwinds its stack and
+`fail` expression. Once *failing*, a task unwinds its stack and
 transitions to the *dead* state. Unwinding the stack of a task is done by
 the task itself, on its own control stack. If a value with a destructor is
 freed during unwinding, the code for the destructor is run, also on the task's

branches/snap-stage3/doc/tutorial-macros.md

@@ -218,7 +218,7 @@ match x {
                 // complicated stuff goes here
                 return result + val;
             },
-            _ => die!(~"Didn't get good_2")
+            _ => fail ~"Didn't get good_2"
         }
     }
     _ => return 0 // default value
@@ -260,7 +260,7 @@ macro_rules! biased_match (
 biased_match!((x)       ~ (good_1(g1, val)) else { return 0 };
               binds g1, val )
 biased_match!((g1.body) ~ (good_2(result) )
-                  else { die!(~"Didn't get good_2") };
+                  else { fail ~"Didn't get good_2" };
               binds result )
 // complicated stuff goes here
 return result + val;
@@ -362,7 +362,7 @@ macro_rules! biased_match (
 # fn f(x: t1) -> uint {
 biased_match!(
     (x)       ~ (good_1(g1, val)) else { return 0 };
-    (g1.body) ~ (good_2(result) ) else { die!(~"Didn't get good_2") };
+    (g1.body) ~ (good_2(result) ) else { fail ~"Didn't get good_2" };
     binds val, result )
 // complicated stuff goes here
 return result + val;

branches/snap-stage3/doc/tutorial-tasks.md

@@ -13,7 +13,7 @@ cheaper to create than traditional threads, Rust can create hundreds of
 thousands of concurrent tasks on a typical 32-bit system.
 
 Tasks provide failure isolation and recovery. When an exception occurs in Rust
-code (as a result of an explicit call to `fail!()`, an assertion failure, or
+code (as a result of an explicit call to `fail`, an assertion failure, or
 another invalid operation), the runtime system destroys the entire
 task. Unlike in languages such as Java and C++, there is no way to `catch` an
 exception. Instead, tasks may monitor each other for failure.
@@ -296,9 +296,9 @@ let result = ports.foldl(0, |accum, port| *accum + port.recv() );
 
 # Handling task failure
 
-Rust has a built-in mechanism for raising exceptions. The `fail!()` macro
-(which can also be written with an error string as an argument: `fail!(
-~reason)`) and the `assert` construct (which effectively calls `fail!()` if a
+Rust has a built-in mechanism for raising exceptions. The `fail` construct
+(which can also be written with an error string as an argument: `fail
+~reason`) and the `assert` construct (which effectively calls `fail` if a
 boolean expression is false) are both ways to raise exceptions. When a task
 raises an exception the task unwinds its stack---running destructors and
 freeing memory along the way---and then exits. Unlike exceptions in C++,
@@ -313,7 +313,7 @@ of all tasks are intertwined: if one fails, so do all the others.
 # fn do_some_work() { loop { task::yield() } }
 # do task::try {
 // Create a child task that fails
-do spawn { die!() }
+do spawn { fail }
 
 // This will also fail because the task we spawned failed
 do_some_work();
@@ -337,7 +337,7 @@ let result: Result<int, ()> = do task::try {
     if some_condition() {
         calculate_result()
     } else {
-        die!(~"oops!");
+        fail ~"oops!";
     }
 };
 assert result.is_err();
@@ -354,7 +354,7 @@ an `Error` result.
 > ***Note:*** A failed task does not currently produce a useful error
 > value (`try` always returns `Err(())`). In the
 > future, it may be possible for tasks to intercept the value passed to
-> `fail!()`.
+> `fail`.
 
 TODO: Need discussion of `future_result` in order to make failure
 modes useful.
@@ -377,7 +377,7 @@ either task dies, it kills the other one.
 # do task::try {
 do task::spawn {
     do task::spawn {
-        die!();  // All three tasks will die.
+        fail;  // All three tasks will die.
     }
     sleep_forever();  // Will get woken up by force, then fail
 }
@@ -432,7 +432,7 @@ do task::spawn_supervised {
     // Intermediate task immediately exits
 }
 wait_for_a_while();
-die!();  // Will kill grandchild even if child has already exited
+fail;  // Will kill grandchild even if child has already exited
 # };
 ~~~
 
@@ -446,10 +446,10 @@ other at all, using `task::spawn_unlinked` for _isolated failure_.
 let (time1, time2) = (random(), random());
 do task::spawn_unlinked {
     sleep_for(time2);  // Won't get forced awake
-    die!();
+    fail;
 }
 sleep_for(time1);  // Won't get forced awake
-die!();
+fail;
 // It will take MAX(time1,time2) for the program to finish.
 # };
 ~~~

branches/snap-stage3/src/etc/vim/syntax/rust.vim

@@ -12,7 +12,7 @@ endif
 
 syn match     rustAssert      "\<assert\(\w\)*"
 syn keyword   rustKeyword     as break
-syn keyword   rustKeyword     const copy do drop else export extern fail
+syn keyword   rustKeyword     const copy do drop else extern fail
 syn keyword   rustKeyword     for if impl let log
 syn keyword   rustKeyword     loop match mod move mut once priv pure
 syn match     rustKeyword     "\<pub\>"
@@ -30,7 +30,7 @@ syn match     rustFuncName    "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%
 syn keyword   rustKeyword     m32 m64 m128 f80 f16 f128
 
 syn keyword   rustType        int uint float char bool u8 u16 u32 u64 f32
-syn keyword   rustType        f64 i8 i16 i32 i64 str
+syn keyword   rustType        f64 i8 i16 i32 i64 str Self
 syn keyword   rustType        Option Either
 
 " Types from libc

branches/snap-stage3/src/libcargo/cargo.rc

@@ -286,7 +286,7 @@ pub fn load_link(mis: ~[@ast::meta_item]) -> (Option<~str>,
     let mut uuid = None;
     for mis.each |a| {
         match a.node {
-            ast::meta_name_value(v, codemap::spanned { node: ast::lit_str(s),
+            ast::meta_name_value(v, ast::spanned { node: ast::lit_str(s),
                                                    _ }) => {
                 match v {
                     ~"name" => name = Some(*s),
@@ -314,7 +314,7 @@ pub fn load_crate(filename: &Path) -> Option<Crate> {
 
     for c.node.attrs.each |a| {
         match a.node.value.node {
-            ast::meta_name_value(v, codemap::spanned { node: ast::lit_str(_),
+            ast::meta_name_value(v, ast::spanned { node: ast::lit_str(_),
                                                    _ }) => {
                 match v {
                     ~"desc" => desc = Some(v),
@@ -460,7 +460,7 @@ pub fn parse_source(name: ~str, j: &json::Json) -> @Source {
         json::Object(j) => {
             let mut url = match j.find(&~"url") {
                 Some(&json::String(u)) => copy u,
-                _ => die!(~"needed 'url' field in source")
+                _ => fail ~"needed 'url' field in source"
             };
             let method = match j.find(&~"method") {
                 Some(&json::String(u)) => copy u,

branches/snap-stage3/src/libcore/dvec.rs

@@ -179,7 +179,7 @@ impl<A> DVec<A> {
             let mut data = cast::reinterpret_cast(&null::<()>());
             data <-> self.data;
             let data_ptr: *() = cast::reinterpret_cast(&data);
-            if data_ptr.is_null() { die!(~"Recursive use of dvec"); }
+            if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
             self.data = move ~[move t];
             self.data.push_all_move(move data);
         }

branches/snap-stage3/src/libcore/hashmap.rs

@@ -386,7 +386,7 @@ pub mod linear {
         pure fn get(&self, k: &K) -> &self/V {
             match self.find(k) {
                 Some(v) => v,
-                None => die!(fmt!("No entry found for key: %?", k)),
+                None => fail fmt!("No entry found for key: %?", k),
             }
         }
     }

branches/snap-stage3/src/libcore/pipes.rs

@@ -549,7 +549,7 @@ pub fn send<T,Tbuffer>(p: SendPacketBuffered<T,Tbuffer>, payload: T) -> bool {
             //unsafe { forget(p); }
             return true;
         }
-        Full => die!(~"duplicate send"),
+        Full => fail ~"duplicate send",
         Blocked => {
             debug!("waking up task for %?", p_);
             let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
@@ -1020,7 +1020,7 @@ impl<T:Owned,Tbuffer:Owned> SendPacketBuffered<T,Tbuffer> {
             //forget(packet);
             header
           },
-          None => die!(~"packet already consumed")
+          None => fail ~"packet already consumed"
         }
     }
 

branches/snap-stage3/src/libcore/private/finally.rs

@@ -71,7 +71,7 @@ fn test_fail() {
     let mut i = 0;
     do (|| {
         i = 10;
-        die!();
+        fail;
     }).finally {
         assert failing();
         assert i == 10;
@@ -95,4 +95,4 @@ fn test_compact() {
     fn but_always_run_this_function() { }
     do_some_fallible_work.finally(
         but_always_run_this_function);
-}
+}

branches/snap-stage3/src/libcore/private/global.rs

@@ -269,7 +269,7 @@ fn test_modify() {
                         Some(~shared_mutable_state(10))
                     }
                 }
-                _ => die!()
+                _ => fail
             }
         }
 
@@ -280,7 +280,7 @@ fn test_modify() {
                     assert *v == 10;
                     None
                 },
-                _ => die!()
+                _ => fail
             }
         }
 
@@ -291,7 +291,7 @@ fn test_modify() {
                         Some(~shared_mutable_state(10))
                     }
                 }
-                _ => die!()
+                _ => fail
             }
         }
     }

branches/snap-stage3/src/libcore/private/weak_task.rs

@@ -112,7 +112,7 @@ fn run_weak_task_service(port: Port<ServiceMsg>) {
                         // nobody will receive this
                         shutdown_chan.send(());
                     }
-                    None => die!()
+                    None => fail
                 }
             }
             Shutdown => break
@@ -195,7 +195,7 @@ fn test_select_stream_and_oneshot() {
             do weaken_task |signal| {
                 match select2i(&port, &signal) {
                     Left(*) => (),
-                    Right(*) => die!()
+                    Right(*) => fail
                 }
             }
         }