---

yaml
---
r: 42883
b: refs/heads/try
c: 7868b6b
h: refs/heads/master
i:
  42881: ebbf5f9
  42879: 7970bfd
v: v3

Author: Nick Desaulniers

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: 76679c1f91fc68134c850b2d77ff2b83b32a108f
+refs/heads/try: 7868b6bf550dcb1b74f25178bcac73d6ec767993
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/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", "fail": "else-style",
+    "do": "else-style", "return": "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/try/doc/rust.md

@@ -216,7 +216,7 @@ break
 const copy
 do drop
 else enum extern
-fail false fn for
+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 {
         ...
-# fail;
+# die!();
     }
     fn cos(f: f64) -> f64 {
         ...
-# fail;
+# die!();
     }
     fn tan(f: f64) -> f64 {
         ...
-# fail;
+# die!();
     }
 }
 ~~~~~~~~
@@ -989,13 +989,13 @@ output slot type would normally be. For example:
 ~~~~
 fn my_err(s: &str) -> ! {
     log(info, s);
-    fail;
+    die!();
 }
 ~~~~
 
 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`](#fail-expressions) or a call to another diverging function on every
+`fail!()` 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$.
@@ -1007,7 +1007,7 @@ were declared without the `!` annotation, the following code would not
 typecheck:
 
 ~~~~
-# fn my_err(s: &str) -> ! { fail }
+# fn my_err(s: &str) -> ! { die!() }
 
 fn f(i: int) -> int {
    if i == 42 {
@@ -2291,9 +2291,9 @@ enum List<X> { Nil, Cons(X, @List<X>) }
 let x: List<int> = Cons(10, @Cons(11, @Nil));
 
 match x {
-    Cons(_, @Nil) => fail ~"singleton list",
+    Cons(_, @Nil) => die!(~"singleton list"),
     Cons(*)       => return,
-    Nil           => fail ~"empty list"
+    Nil           => die!(~"empty list")
 }
 ~~~~
 
@@ -2330,7 +2330,7 @@ match x {
         return;
     }
     _ => {
-        fail;
+        die!();
     }
 }
 ~~~~
@@ -2418,23 +2418,10 @@ 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 => fail
+  None => die!()
 };
 ~~~~
 
-
-### 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}
@@ -3154,7 +3141,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` expression. Once *failing*, a task unwinds its stack and
+`fail!()` macro. 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/try/doc/tutorial-macros.md

@@ -218,7 +218,7 @@ match x {
                 // complicated stuff goes here
                 return result + val;
             },
-            _ => fail ~"Didn't get good_2"
+            _ => die!(~"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 { fail ~"Didn't get good_2" };
+                  else { die!(~"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 { fail ~"Didn't get good_2" };
+    (g1.body) ~ (good_2(result) ) else { die!(~"Didn't get good_2") };
     binds val, result )
 // complicated stuff goes here
 return result + val;

branches/try/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` 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
+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
 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 { fail }
+do spawn { die!() }
 
 // 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 {
-        fail ~"oops!";
+        die!(~"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 {
-        fail;  // All three tasks will die.
+        die!();  // 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();
-fail;  // Will kill grandchild even if child has already exited
+die!();  // 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
-    fail;
+    die!();
 }
 sleep_for(time1);  // Won't get forced awake
-fail;
+die!();
 // It will take MAX(time1,time2) for the program to finish.
 # };
 ~~~

branches/try/mk/target.mk

@@ -14,6 +14,13 @@
 # $(2) is the target triple
 # $(3) is the host triple
 
+# If you are making non-backwards compatible changes to the runtime
+# (resp.  corelib), set this flag to 1.  It will cause stage1 to use
+# the snapshot runtime (resp. corelib) rather than the runtime
+# (resp. corelib) from the working directory.
+USE_SNAPSHOT_RUNTIME=0
+USE_SNAPSHOT_CORELIB=0
+USE_SNAPSHOT_STDLIB=0
 
 define TARGET_STAGE_N
 
@@ -52,17 +59,86 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBSYNTAX): \
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) $(BORROWCK) -o $$@ $$< && touch $$@
 
+endef
+
+# The stage0 (snapshot) compiler produces binaries that expect the
+# snapshot runtime.  Normally the working directory runtime and
+# snapshot runtime are compatible, so this is no problem. But
+# sometimes we want to make non-backwards-compatible changes.  In
+# those cases, the stage1 compiler and libraries (which are produced
+# by stage0) should use the runtime from the snapshot.  The stage2
+# compiler and libraries (which are produced by stage1) will be the
+# first that are expecting to run against the runtime as defined in
+# the working directory.
+#
+# The catch is that you may not add new functions to the runtime
+# in this case!
+#
+# Arguments are the same as for TARGET_BASE_STAGE_N
+define TARGET_RT_FROM_SNAPSHOT
+
+$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUNTIME): \
+		$$(HLIB$(1)_H_$(3))/$$(CFG_RUNTIME)
+	@$$(call E, cp: $$@)
+	$$(Q)cp $$< $$@
+
+endef
+
+# This rule copies from the runtime for the working directory.  It
+# applies to targets produced by stage1 or later.  See comment on
+# previous rule.
+#
+# Arguments are the same as for TARGET_BASE_STAGE_N
+define TARGET_RT_FROM_WD
+
 $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUNTIME): \
 		rt/$(2)/$$(CFG_RUNTIME)
 	@$$(call E, cp: $$@)
 	$$(Q)cp $$< $$@
 
+endef
+
+# As above, but builds the corelib either by taking it out of the
+# snapshot or from the working directory.
+
+define TARGET_CORELIB_FROM_SNAPSHOT
+
+$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_CORELIB): \
+		$$(HLIB$(1)_H_$(3))/$$(CFG_CORELIB) \
+		$$(CORELIB_INPUTS) \
+		$$(TSREQ$(1)_T_$(2)_H_$(3))
+	@$$(call E, cp: $$@)
+	$$(Q)cp $$< $$@
+	$$(Q)cp $$(HLIB$(1)_H_$(3))/$$(CORELIB_GLOB) \
+		$$(TLIB$(1)_T_$(2)_H_$(3))
+
+endef
+
+define TARGET_CORELIB_FROM_WD
+
 $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_CORELIB): \
 		$$(CORELIB_CRATE) $$(CORELIB_INPUTS) \
 		$$(TSREQ$(1)_T_$(2)_H_$(3))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< && touch $$@
 
+endef
+
+define TARGET_STDLIB_FROM_SNAPSHOT
+
+$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB): \
+		$$(HLIB$(1)_H_$(3))/$$(CFG_STDLIB) \
+		$$(STDLIB_INPUTS) \
+		$$(TSREQ$(1)_T_$(2)_H_$(3))
+	@$$(call E, cp: $$@)
+	$$(Q)cp $$< $$@
+	$$(Q)cp $$(HLIB$(1)_H_$(3))/$$(STDLIB_GLOB) \
+		$$(TLIB$(1)_T_$(2)_H_$(3))
+
+endef
+
+define TARGET_STDLIB_FROM_WD
+
 $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB): \
 		$$(STDLIB_CRATE) $$(STDLIB_INPUTS) \
 	        $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_CORELIB) \
@@ -79,3 +155,52 @@ $(foreach source,$(CFG_TARGET_TRIPLES),				\
   $(eval $(call TARGET_STAGE_N,1,$(target),$(source)))		\
   $(eval $(call TARGET_STAGE_N,2,$(target),$(source)))		\
   $(eval $(call TARGET_STAGE_N,3,$(target),$(source)))))
+
+# Host triple either uses the snapshot runtime or runtime from
+# working directory, depending on the USE_SNAPSHOT_RUNTIME var.
+ifeq ($(USE_SNAPSHOT_RUNTIME),1)
+    $(foreach src,$(CFG_HOST_TRIPLE),\
+		$(eval $(call TARGET_RT_FROM_SNAPSHOT,0,$(src),$(src))))
+else 
+    $(foreach src,$(CFG_HOST_TRIPLE),\
+		$(eval $(call TARGET_RT_FROM_WD,0,$(src),$(src))))
+endif
+
+ifeq ($(USE_SNAPSHOT_CORELIB),1)
+    $(foreach src,$(CFG_HOST_TRIPLE),\
+		$(eval $(call TARGET_CORELIB_FROM_SNAPSHOT,0,$(src),$(src))))
+else 
+    $(foreach src,$(CFG_HOST_TRIPLE),\
+		$(eval $(call TARGET_CORELIB_FROM_WD,0,$(src),$(src))))
+endif
+
+ifeq ($(USE_SNAPSHOT_STDLIB),1)
+    $(foreach src,$(CFG_HOST_TRIPLE),\
+		$(eval $(call TARGET_STDLIB_FROM_SNAPSHOT,0,$(src),$(src))))
+else
+    $(foreach src,$(CFG_HOST_TRIPLE),\
+		$(eval $(call TARGET_STDLIB_FROM_WD,0,$(src),$(src))))
+endif
+
+# Non-host triples build the stage0 runtime from the working directory
+$(foreach source,$(CFG_TARGET_TRIPLES),				\
+ $(foreach target,$(NON_HOST_TRIPLES),				\
+  $(eval $(call TARGET_RT_FROM_WD,0,$(target),$(source)))       \
+  $(eval $(call TARGET_CORELIB_FROM_WD,0,$(target),$(source)))  \
+  $(eval $(call TARGET_STDLIB_FROM_WD,0,$(target),$(source)))  \
+))
+
+# After stage0, always build the stage0 runtime from the working directory
+$(foreach source,$(CFG_TARGET_TRIPLES),				\
+ $(foreach target,$(CFG_TARGET_TRIPLES),			\
+  $(eval $(call TARGET_RT_FROM_WD,1,$(target),$(source)))	\
+  $(eval $(call TARGET_RT_FROM_WD,2,$(target),$(source)))	\
+  $(eval $(call TARGET_RT_FROM_WD,3,$(target),$(source)))  	\
+  $(eval $(call TARGET_CORELIB_FROM_WD,1,$(target),$(source)))	\
+  $(eval $(call TARGET_CORELIB_FROM_WD,2,$(target),$(source)))	\
+  $(eval $(call TARGET_CORELIB_FROM_WD,3,$(target),$(source)))	\
+  $(eval $(call TARGET_STDLIB_FROM_WD,1,$(target),$(source)))	\
+  $(eval $(call TARGET_STDLIB_FROM_WD,2,$(target),$(source)))	\
+  $(eval $(call TARGET_STDLIB_FROM_WD,3,$(target),$(source)))	\
+))
+

branches/try/src/libcargo/cargo.rc

@@ -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,
-                _ => fail ~"needed 'url' field in source"
+                _ => die!(~"needed 'url' field in source")
             };
             let method = match j.find(&~"method") {
                 Some(&json::String(u)) => copy u,