---

yaml
---
r: 41431
b: refs/heads/snap-stage3
c: dffc3f8
h: refs/heads/master
i:
  41429: c77a092
  41427: d2bee6c
  41423: 41549be
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 09bb07bed9166105ea961a42b5fff7739ae0d2e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: b2c01b5892f9f2ae8d779e4dd69a352e1ff138dd
+refs/heads/snap-stage3: dffc3f82b25dc8a5398ecb3a40bb7057cb2e7c5e
 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/README.txt

@@ -17,7 +17,6 @@ rt/sync            - Concurrency utils
 rt/util            - Small utility classes for the runtime.
 rt/vg              - Valgrind headers
 rt/msvc            - MSVC support
-rt/linenoise       - a readline-like line editing library
 
 test/              Testsuite
 test/compile-fail  - Tests that should fail to compile

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

@@ -12,25 +12,24 @@ 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     copy do drop else extern
 syn keyword   rustKeyword     for if impl let log
-syn keyword   rustKeyword     loop match mod move mut once priv pure
-syn match     rustKeyword     "\<pub\>"
+syn keyword   rustKeyword     loop match mod move once priv pub pure
 syn keyword   rustKeyword     ref return static
-syn match     rustKeyword     "\<unsafe\>" " Allows also matching unsafe::foo()
-syn keyword   rustKeyword     use while
+syn keyword   rustKeyword     unsafe use while
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite
 syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite
+syn keyword   rustStorage     const mut
 
 syn match     rustIdentifier  contains=rustIdentifierPrime "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
 syn match     rustFuncName    "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
 
 " Reserved words
-syn keyword   rustKeyword     m32 m64 m128 f80 f16 f128
+syn keyword   rustKeyword     m32 m64 m128 f80 f16 f128 be
 
 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
@@ -134,6 +133,7 @@ hi def link rustMacro         Macro
 hi def link rustType          Type
 hi def link rustTodo          Todo
 hi def link rustAttribute     PreProc
+hi def link rustStorage       StorageClass
 
 " Other Suggestions:
 " hi rustAssert ctermfg=yellow

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
             }
         }
     }