---

yaml
---
r: 93047
b: refs/heads/auto
c: cefb2c7
h: refs/heads/master
i:
  93045: b1626c1
  93043: 1720826
  93039: 6b3916e
v: v3

Author: vadimcn

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: b432e82515f4cc145cf41bbcb92ff9b874b23afe
+refs/heads/auto: cefb2c7e45140e1492b3cb45601a538478f40577
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/doc/rust.md

@@ -3605,8 +3605,10 @@ failed destructor. Nonetheless, the outermost unwinding activity will continue
 until the stack is unwound and the task transitions to the *dead*
 state. There is no way to "recover" from task failure.  Once a task has
 temporarily suspended its unwinding in the *failing* state, failure
-occurring from within this destructor results in *hard* failure.
-A hard failure currently results in the process aborting.
+occurring from within this destructor results in *hard* failure.  The
+unwinding procedure of hard failure frees resources but does not execute
+destructors.  The original (soft) failure is still resumed at the point where
+it was temporarily suspended.
 
 A task in the *dead* state cannot transition to other states; it exists
 only to have its termination status inspected by other tasks, and/or to await

branches/auto/doc/tutorial-conditions.md

@@ -43,13 +43,12 @@ $ ./example numbers.txt
 
 An example program that does this task reads like this:
 
-~~~~
+~~~~{.xfail-test}
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::buffered::BufferedReader;
-use std::io::File;
+use std::io::fs::File;
 # mod BufferedReader {
-#     use std::io::File;
+#     use std::io::fs::File;
 #     use std::io::mem::MemReader;
 #     use std::io::buffered::BufferedReader;
 #     static s : &'static [u8] = bytes!("1 2\n\
@@ -72,9 +71,10 @@ fn main() {
 fn read_int_pairs() -> ~[(int,int)] {
     let mut pairs = ~[];
 
+    let args = std::os::args();
+
     // Path takes a generic by-value, rather than by reference
-#    let _g = std::io::ignore_io_error();
-    let path = Path::new(&"foo.txt");
+    let path = Path::new(args.get_opt(1).expect("No input file parameter!").as_slice());
     let mut reader = BufferedReader::new(File::open(&path));
 
     // 1. Iterate over the lines of our file.
@@ -242,14 +242,13 @@ If the example is rewritten to use failure, these error cases can be trapped.
 In this rewriting, failures are trapped by placing the I/O logic in a sub-task,
 and trapping its exit status using `task::try`:
 
-~~~~
+~~~~{.xfail-test}
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::buffered::BufferedReader;
-use std::io::File;
+use std::io::fs::File;
 use std::task;
 # mod BufferedReader {
-#     use std::io::File;
+#     use std::io::fs::File;
 #     use std::io::mem::MemReader;
 #     use std::io::buffered::BufferedReader;
 #     static s : &'static [u8] = bytes!("1 2\n\
@@ -281,8 +280,8 @@ fn main() {
 
 fn read_int_pairs() -> ~[(int,int)] {
     let mut pairs = ~[];
-#    let _g = std::io::ignore_io_error();
-    let path = Path::new(&"foo.txt");
+    let args = std::os::args();
+    let path = Path::new(args.get_opt(1).expect("No input file parameter!").as_slice());
 
     let mut reader = BufferedReader::new(File::open(&path));
     for line in reader.lines() {
@@ -347,13 +346,12 @@ If no handler is found, `Condition::raise` will fail the task with an appropriat
 Rewriting the example to use a condition in place of ignoring malformed lines makes it slightly longer,
 but similarly clear as the version that used `fail!` in the logic where the error occurs:
 
-~~~~
+~~~~{.xfail-test}
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::buffered::BufferedReader;
-use std::io::File;
+use std::io::fs::File;
 # mod BufferedReader {
-#     use std::io::File;
+#     use std::io::fs::File;
 #     use std::io::mem::MemReader;
 #     use std::io::buffered::BufferedReader;
 #     static s : &'static [u8] = bytes!("1 2\n\
@@ -380,8 +378,8 @@ fn main() {
 
 fn read_int_pairs() -> ~[(int,int)] {
     let mut pairs = ~[];
-#    let _g = std::io::ignore_io_error();
-    let path = Path::new(&"foo.txt");
+    let args = std::os::args();
+    let path = Path::new(args.get_opt(1).expect("No input file parameter!").as_slice());
 
     let mut reader = BufferedReader::new(File::open(&path));
     for line in reader.lines() {
@@ -417,13 +415,12 @@ To trap a condition, use `Condition::trap` in some caller of the site that calls
 For example, this version of the program traps the `malformed_line` condition
 and replaces bad input lines with the pair `(-1,-1)`:
 
-~~~~
+~~~~{.xfail-test}
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::buffered::BufferedReader;
-use std::io::File;
+use std::io::fs::File;
 # mod BufferedReader {
-#     use std::io::File;
+#     use std::io::fs::File;
 #     use std::io::mem::MemReader;
 #     use std::io::buffered::BufferedReader;
 #     static s : &'static [u8] = bytes!("1 2\n\
@@ -455,8 +452,8 @@ fn main() {
 
 fn read_int_pairs() -> ~[(int,int)] {
     let mut pairs = ~[];
-#    let _g = std::io::ignore_io_error();
-    let path = Path::new(&"foo.txt");
+    let args = std::os::args();
+    let path = Path::new(args.get_opt(1).expect("No input file parameter!").as_slice());
 
     let mut reader = BufferedReader::new(File::open(&path));
     for line in reader.lines() {
@@ -493,13 +490,12 @@ In the example program, the first form of the `malformed_line` API implicitly as
 This assumption may not be correct; some callers may wish to skip malformed lines, for example.
 Changing the condition's return type from `(int,int)` to `Option<(int,int)>` will suffice to support this type of recovery:
 
-~~~~
+~~~~{.xfail-test}
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::buffered::BufferedReader;
-use std::io::File;
+use std::io::fs::File;
 # mod BufferedReader {
-#     use std::io::File;
+#     use std::io::fs::File;
 #     use std::io::mem::MemReader;
 #     use std::io::buffered::BufferedReader;
 #     static s : &'static [u8] = bytes!("1 2\n\
@@ -532,8 +528,8 @@ fn main() {
 
 fn read_int_pairs() -> ~[(int,int)] {
     let mut pairs = ~[];
-#    let _g = std::io::ignore_io_error();
-    let path = Path::new(&"foo.txt");
+    let args = std::os::args();
+    let path = Path::new(args.get_opt(1).expect("No input file parameter!").as_slice());
 
     let mut reader = BufferedReader::new(File::open(&path));
     for line in reader.lines() {
@@ -579,13 +575,12 @@ until all relevant combinations encountered in practice are encoded.
 In the example, suppose a third possible recovery form arose: reusing the previous value read.
 This can be encoded in the handler API by introducing a helper type: `enum MalformedLineFix`.
 
-~~~~
+~~~~{.xfail-test}
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::buffered::BufferedReader;
-use std::io::File;
+use std::io::fs::File;
 # mod BufferedReader {
-#     use std::io::File;
+#     use std::io::fs::File;
 #     use std::io::mem::MemReader;
 #     use std::io::buffered::BufferedReader;
 #     static s : &'static [u8] = bytes!("1 2\n\
@@ -627,8 +622,8 @@ fn main() {
 
 fn read_int_pairs() -> ~[(int,int)] {
     let mut pairs = ~[];
-#    let _g = std::io::ignore_io_error();
-    let path = Path::new(&"foo.txt");
+    let args = std::os::args();
+    let path = Path::new(args.get_opt(1).expect("No input file parameter!").as_slice());
 
     let mut reader = BufferedReader::new(File::open(&path));
     for line in reader.lines() {
@@ -704,13 +699,12 @@ task <unnamed> failed at 'called `Option::unwrap()` on a `None` value', .../libs
 To make the program robust &mdash; or at least flexible &mdash; in the face of this potential failure,
 a second condition and a helper function will suffice:
 
-~~~~
+~~~~{.xfail-test}
 # #[allow(unused_imports)];
-# extern mod extra;
 use std::io::buffered::BufferedReader;
-use std::io::File;
+use std::io::fs::File;
 # mod BufferedReader {
-#     use std::io::File;
+#     use std::io::fs::File;
 #     use std::io::mem::MemReader;
 #     use std::io::buffered::BufferedReader;
 #     static s : &'static [u8] = bytes!("1 2\n\
@@ -766,8 +760,8 @@ fn parse_int(x: &str) -> int {
 
 fn read_int_pairs() -> ~[(int,int)] {
     let mut pairs = ~[];
-#    let _g = std::io::ignore_io_error();
-    let path = Path::new(&"foo.txt");
+    let args = std::os::args();
+    let path = Path::new(args.get_opt(1).expect("No input file parameter!").as_slice());
 
     let mut reader = BufferedReader::new(File::open(&path));
     for line in reader.lines() {

branches/auto/doc/tutorial.md

@@ -1431,8 +1431,8 @@ For a more in-depth explanation of borrowed pointers, read the
 ## Freezing
 
 Lending an immutable pointer to an object freezes it and prevents mutation.
-`Freeze` objects have freezing enforced statically at compile-time. An example
-of a non-`Freeze` type is [`RefCell<T>`][refcell].
+`Freeze` objects have freezing enforced statically at compile-time. Examples
+of non-`Freeze` types are `@mut` and [`RefCell<T>`][refcell].
 
 ~~~~
 let mut x = 5;
@@ -1443,6 +1443,20 @@ let mut x = 5;
 # x = 3;
 ~~~~
 
+Mutable managed boxes handle freezing dynamically when any of their contents
+are borrowed, and the task will fail if an attempt to modify them is made while
+they are frozen:
+
+~~~~
+let x = @mut 5;
+let y = x;
+{
+    let z = &*y; // the managed box is now frozen
+    // modifying it through x or y will cause a task failure
+}
+// the box is now unfrozen again
+~~~~
+
 [refcell]: http://static.rust-lang.org/doc/master/std/cell/struct.RefCell.html
 
 # Dereferencing pointers
@@ -1463,12 +1477,13 @@ assignments. Such an assignment modifies the value that the pointer
 points to.
 
 ~~~
-let managed = @10;
+let managed = @mut 10;
 let mut owned = ~20;
 
 let mut value = 30;
 let borrowed = &mut value;
 
+*managed = *owned + 10;
 *owned = *borrowed + 100;
 *borrowed = *managed + 1000;
 ~~~
@@ -2098,7 +2113,8 @@ unless they contain managed boxes, managed closures, or borrowed pointers.
 
 * `Freeze` - Constant (immutable) types.
 These are types that do not contain anything intrinsically mutable.
-Intrinsically mutable values include `Cell` in the standard library.
+Intrinsically mutable values include `@mut`
+and `Cell` in the standard library.
 
 * `'static` - Non-borrowed types.
 These are types that do not contain any data whose lifetime is bound to

branches/auto/mk/llvm.mk

@@ -47,11 +47,11 @@ endef
 $(foreach host,$(CFG_HOST), \
     $(eval LLVM_CONFIGS := $(LLVM_CONFIGS) $(LLVM_CONFIG_$(host))))
 
-$(foreach host,$(CFG_HOST), \
- $(eval $(call DEF_LLVM_RULES,$(host))))
-
 $(S)src/librustc/lib/llvmdeps.rs: \
 		    $(LLVM_CONFIGS) \
 		    $(S)src/etc/mklldeps.py
 	$(Q)$(CFG_PYTHON) $(S)src/etc/mklldeps.py \
 	    "$@" "$(LLVM_COMPONENTS)" $(LLVM_CONFIGS)
+
+$(foreach host,$(CFG_HOST), \
+ $(eval $(call DEF_LLVM_RULES,$(host))))