---

yaml
---
r: 116383
b: refs/heads/snap-stage3
c: 2f221c7
h: refs/heads/master
i:
  116381: ed4b04f
  116379: 9034b9d
  116375: 492c1ba
  116367: 808c73c
  116351: f61254c
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: bee4e6adac17f87b1cdc26ab69f8c0f5d82575a3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: cd844c5fb54913bced99a046230e9af7b3704c9e
+refs/heads/snap-stage3: 2f221c766b10867a30d799d0899125b2dcccb872
 refs/heads/try: 009d898a9422ac04c1aa60c0e9aff3abc5fa4672
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/.gitignore

@@ -60,7 +60,6 @@ config.mk
 /rt/
 /rustllvm/
 /test/
-/build
 /inst/
 /mingw-build/
 src/.DS_Store
@@ -85,7 +84,7 @@ config.stamp
 .DS_Store
 src/etc/dl
 .settings/
-build/
+/build
 i686-pc-mingw32/
 src/librustc/lib/llvmdeps.rs
 *.pot

branches/snap-stage3/mk/crates.mk

@@ -51,7 +51,7 @@
 
 TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-		 workcache url log regex graphviz core rlibc alloc debug
+                 url log regex graphviz core rlibc alloc debug
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -60,9 +60,9 @@ DEPS_core :=
 DEPS_rlibc :=
 DEPS_alloc := core libc native:jemalloc
 DEPS_debug := std
-DEPS_std := core libc alloc native:rustrt native:backtrace
+DEPS_std := core rand libc alloc native:rustrt native:backtrace
 DEPS_graphviz := std
-DEPS_green := std rand native:context_switch
+DEPS_green := std native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
 DEPS_syntax := std term serialize collections log fmt_macros debug
@@ -77,18 +77,17 @@ DEPS_glob := std
 DEPS_serialize := std collections log
 DEPS_term := std collections log
 DEPS_semver := std
-DEPS_uuid := std serialize rand
+DEPS_uuid := std serialize
 DEPS_sync := std alloc
 DEPS_getopts := std
-DEPS_collections := std rand debug
+DEPS_collections := std debug
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
-DEPS_num := std rand
+DEPS_num := std
 DEPS_test := std collections getopts serialize term time regex
 DEPS_time := std serialize sync
-DEPS_rand := std
+DEPS_rand := core
 DEPS_url := std collections
-DEPS_workcache := std serialize collections log
 DEPS_log := std sync
 DEPS_regex := std collections
 DEPS_regex_macros = syntax std regex
@@ -104,6 +103,7 @@ TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
 ONLY_RLIB_core := 1
 ONLY_RLIB_rlibc := 1
 ONLY_RLIB_alloc := 1
+ONLY_RLIB_rand := 1
 
 ################################################################################
 # You should not need to edit below this line

branches/snap-stage3/src/compiletest/common.rs

@@ -12,7 +12,7 @@ use std::from_str::FromStr;
 use std::fmt;
 use regex::Regex;
 
-#[deriving(Clone, Eq)]
+#[deriving(Clone, PartialEq)]
 pub enum Mode {
     CompileFail,
     RunFail,

branches/snap-stage3/src/compiletest/runtest.rs

@@ -73,7 +73,7 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
     let proc_res = compile_test(config, props, testfile);
 
     if proc_res.status.success() {
-        fatal_ProcRes("compile-fail test compiled successfully!".to_string(),
+        fatal_proc_rec("compile-fail test compiled successfully!".to_string(),
                       &proc_res);
     }
 
@@ -97,7 +97,7 @@ fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
         let proc_res = compile_test(config, props, testfile);
 
         if !proc_res.status.success() {
-            fatal_ProcRes("compilation failed!".to_string(), &proc_res);
+            fatal_proc_rec("compilation failed!".to_string(), &proc_res);
         }
 
         exec_compiled_test(config, props, testfile)
@@ -108,7 +108,7 @@ fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
     // The value our Makefile configures valgrind to return on failure
     static VALGRIND_ERR: int = 100;
     if proc_res.status.matches_exit_status(VALGRIND_ERR) {
-        fatal_ProcRes("run-fail test isn't valgrind-clean!".to_string(),
+        fatal_proc_rec("run-fail test isn't valgrind-clean!".to_string(),
                       &proc_res);
     }
 
@@ -120,7 +120,7 @@ fn check_correct_failure_status(proc_res: &ProcRes) {
     // The value the rust runtime returns on failure
     static RUST_ERR: int = 101;
     if !proc_res.status.matches_exit_status(RUST_ERR) {
-        fatal_ProcRes(
+        fatal_proc_rec(
             format!("failure produced the wrong error: {}", proc_res.status),
             proc_res);
     }
@@ -131,19 +131,19 @@ fn run_rpass_test(config: &Config, props: &TestProps, testfile: &Path) {
         let mut proc_res = compile_test(config, props, testfile);
 
         if !proc_res.status.success() {
-            fatal_ProcRes("compilation failed!".to_string(), &proc_res);
+            fatal_proc_rec("compilation failed!".to_string(), &proc_res);
         }
 
         proc_res = exec_compiled_test(config, props, testfile);
 
         if !proc_res.status.success() {
-            fatal_ProcRes("test run failed!".to_string(), &proc_res);
+            fatal_proc_rec("test run failed!".to_string(), &proc_res);
         }
     } else {
         let proc_res = jit_test(config, props, testfile);
 
         if !proc_res.status.success() {
-            fatal_ProcRes("jit failed!".to_string(), &proc_res);
+            fatal_proc_rec("jit failed!".to_string(), &proc_res);
         }
     }
 }
@@ -172,7 +172,7 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
                                     "normal");
 
         if !proc_res.status.success() {
-            fatal_ProcRes(format!("pretty-printing failed in round {}", round),
+            fatal_proc_rec(format!("pretty-printing failed in round {}", round),
                           &proc_res);
         }
 
@@ -204,21 +204,21 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
     let proc_res = typecheck_source(config, props, testfile, actual);
 
     if !proc_res.status.success() {
-        fatal_ProcRes("pretty-printed source does not typecheck".to_string(),
+        fatal_proc_rec("pretty-printed source does not typecheck".to_string(),
                       &proc_res);
     }
     if props.no_pretty_expanded { return }
 
     // additionally, run `--pretty expanded` and try to build it.
     let proc_res = print_source(config, props, testfile, (*srcs.get(round)).clone(), "expanded");
     if !proc_res.status.success() {
-        fatal_ProcRes(format!("pretty-printing (expanded) failed"), &proc_res);
+        fatal_proc_rec(format!("pretty-printing (expanded) failed"), &proc_res);
     }
 
     let ProcRes{ stdout: expanded_src, .. } = proc_res;
     let proc_res = typecheck_source(config, props, testfile, expanded_src);
     if !proc_res.status.success() {
-        fatal_ProcRes(format!("pretty-printed source (expanded) does \
+        fatal_proc_rec(format!("pretty-printed source (expanded) does \
                                not typecheck"),
                       &proc_res);
     }
@@ -326,7 +326,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
     // compile test file (it shoud have 'compile-flags:-g' in the header)
     let compiler_run_result = compile_test(config, props, testfile);
     if !compiler_run_result.status.success() {
-        fatal_ProcRes("compilation failed!".to_string(), &compiler_run_result);
+        fatal_proc_rec("compilation failed!".to_string(), &compiler_run_result);
     }
 
     let exe_file = make_exe_name(config, testfile);
@@ -517,7 +517,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
     // compile test file (it shoud have 'compile-flags:-g' in the header)
     let compile_result = compile_test(config, props, testfile);
     if !compile_result.status.success() {
-        fatal_ProcRes("compilation failed!".to_string(), &compile_result);
+        fatal_proc_rec("compilation failed!".to_string(), &compile_result);
     }
 
     let exe_file = make_exe_name(config, testfile);
@@ -560,7 +560,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
     let debugger_run_result = run_lldb(config, &exe_file, &debugger_script);
 
     if !debugger_run_result.status.success() {
-        fatal_ProcRes("Error while running LLDB".to_string(),
+        fatal_proc_rec("Error while running LLDB".to_string(),
                       &debugger_run_result);
     }
 
@@ -720,7 +720,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
             }
         }
         if i != num_check_lines {
-            fatal_ProcRes(format!("line not found in debugger output: {}",
+            fatal_proc_rec(format!("line not found in debugger output: {}",
                                   check_lines.get(i).unwrap()),
                           debugger_run_result);
         }
@@ -764,22 +764,22 @@ fn check_error_patterns(props: &TestProps,
     let missing_patterns =
         props.error_patterns.slice(next_err_idx, props.error_patterns.len());
     if missing_patterns.len() == 1u {
-        fatal_ProcRes(format!("error pattern '{}' not found!",
+        fatal_proc_rec(format!("error pattern '{}' not found!",
                               missing_patterns[0]),
                       proc_res);
     } else {
         for pattern in missing_patterns.iter() {
             error(format!("error pattern '{}' not found!", *pattern));
         }
-        fatal_ProcRes("multiple error patterns not found".to_string(),
+        fatal_proc_rec("multiple error patterns not found".to_string(),
                       proc_res);
     }
 }
 
 fn check_no_compiler_crash(proc_res: &ProcRes) {
     for line in proc_res.stderr.as_slice().lines() {
         if line.starts_with("error: internal compiler error:") {
-            fatal_ProcRes("compiler encountered internal error".to_string(),
+            fatal_proc_rec("compiler encountered internal error".to_string(),
                           proc_res);
         }
     }
@@ -857,7 +857,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
         }
 
         if !was_expected && is_compiler_error_or_warning(line) {
-            fatal_ProcRes(format!("unexpected compiler error or warning: '{}'",
+            fatal_proc_rec(format!("unexpected compiler error or warning: '{}'",
                                   line),
                           proc_res);
         }
@@ -866,7 +866,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
     for (i, &flag) in found_flags.iter().enumerate() {
         if !flag {
             let ee = expected_errors.get(i);
-            fatal_ProcRes(format!("expected {} on line {} not found: {}",
+            fatal_proc_rec(format!("expected {} on line {} not found: {}",
                                   ee.kind, ee.line, ee.msg),
                           proc_res);
         }
@@ -1047,7 +1047,7 @@ fn compose_and_run_compiler(
                                      config.compile_lib_path.as_slice(),
                                      None);
         if !auxres.status.success() {
-            fatal_ProcRes(
+            fatal_proc_rec(
                 format!("auxiliary build of {} failed to compile: ",
                         abs_ab.display()),
                 &auxres);
@@ -1286,7 +1286,7 @@ fn error(err: String) { println!("\nerror: {}", err); }
 
 fn fatal(err: String) -> ! { error(err); fail!(); }
 
-fn fatal_ProcRes(err: String, proc_res: &ProcRes) -> ! {
+fn fatal_proc_rec(err: String, proc_res: &ProcRes) -> ! {
     print!("\n\
 error: {}\n\
 status: {}\n\
@@ -1562,35 +1562,35 @@ fn run_codegen_test(config: &Config, props: &TestProps,
 
     let mut proc_res = compile_test_and_save_bitcode(config, props, testfile);
     if !proc_res.status.success() {
-        fatal_ProcRes("compilation failed!".to_string(), &proc_res);
+        fatal_proc_rec("compilation failed!".to_string(), &proc_res);
     }
 
     proc_res = extract_function_from_bitcode(config, props, "test", testfile, "");
     if !proc_res.status.success() {
-        fatal_ProcRes("extracting 'test' function failed".to_string(),
+        fatal_proc_rec("extracting 'test' function failed".to_string(),
                       &proc_res);
     }
 
     proc_res = disassemble_extract(config, props, testfile, "");
     if !proc_res.status.success() {
-        fatal_ProcRes("disassembling extract failed".to_string(), &proc_res);
+        fatal_proc_rec("disassembling extract failed".to_string(), &proc_res);
     }
 
 
     let mut proc_res = compile_cc_with_clang_and_save_bitcode(config, props, testfile);
     if !proc_res.status.success() {
-        fatal_ProcRes("compilation failed!".to_string(), &proc_res);
+        fatal_proc_rec("compilation failed!".to_string(), &proc_res);
     }
 
     proc_res = extract_function_from_bitcode(config, props, "test", testfile, "clang");
     if !proc_res.status.success() {
-        fatal_ProcRes("extracting 'test' function failed".to_string(),
+        fatal_proc_rec("extracting 'test' function failed".to_string(),
                       &proc_res);
     }
 
     proc_res = disassemble_extract(config, props, testfile, "clang");
     if !proc_res.status.success() {
-        fatal_ProcRes("disassembling extract failed".to_string(), &proc_res);
+        fatal_proc_rec("disassembling extract failed".to_string(), &proc_res);
     }
 
     let base = output_base_name(config, testfile);

branches/snap-stage3/src/doc/complement-cheatsheet.md

@@ -53,9 +53,8 @@ To return a Borrowed String Slice (&str) use the str helper function
 ~~~
 use std::str;
 
-let bytes = ~[104u8,105u8];
-let x: Option<&str> = str::from_utf8(bytes);
-let y: &str = x.unwrap();
+let bytes = &[104u8,105u8];
+let x: &str = str::from_utf8(bytes).unwrap();
 ~~~
 
 To return an Owned String use the str helper function
@@ -136,7 +135,7 @@ let index: Option<uint> = str.find_str("rand");
 The [`Container`](../std/container/trait.Container.html) trait provides the `len` method.
 
 ~~~
-let u: ~[u32] = ~[0, 1, 2];
+let u: Vec<u32> = vec![0, 1, 2];
 let v: &[u32] = &[0, 1, 2, 3];
 let w: [u32, .. 5] = [0, 1, 2, 3, 4];
 
@@ -148,7 +147,7 @@ println!("u: {}, v: {}, w: {}", u.len(), v.len(), w.len()); // 3, 4, 5
 Use the [`iter`](../std/vec/trait.ImmutableVector.html#tymethod.iter) method.
 
 ~~~
-let values: ~[int] = ~[1, 2, 3, 4, 5];
+let values: Vec<int> = vec![1, 2, 3, 4, 5];
 for value in values.iter() {  // value: &int
     println!("{}", *value);
 }

branches/snap-stage3/src/doc/guide-container.md

@@ -396,7 +396,7 @@ underlying iterators are.
 
 ~~~
 let xs = [1, 2, 3, 4, 5];
-let ys = ~[7, 9, 11];
+let ys = [7, 9, 11];
 let mut it = xs.iter().chain(ys.iter());
 println!("{}", it.idx(0)); // prints `Some(1)`
 println!("{}", it.idx(5)); // prints `Some(7)`

branches/snap-stage3/src/doc/guide-ffi.md

@@ -2,11 +2,11 @@
 
 # Introduction
 
-This guide will use the [snappy](https://code.google.com/p/snappy/)
+This guide will use the [snappy](https://github.com/google/snappy)
 compression/decompression library as an introduction to writing bindings for
 foreign code. Rust is currently unable to call directly into a C++ library, but
 snappy includes a C interface (documented in
-[`snappy-c.h`](https://code.google.com/p/snappy/source/browse/trunk/snappy-c.h)).
+[`snappy-c.h`](https://github.com/google/snappy/blob/master/snappy-c.h)).
 
 The following is a minimal example of calling a foreign function which will
 compile if snappy is installed:
@@ -476,6 +476,7 @@ extern crate libc;
 
 #[cfg(target_os = "win32", target_arch = "x86")]
 #[link(name = "kernel32")]
+#[allow(non_snake_case_functions)]
 extern "stdcall" {
     fn SetEnvironmentVariableA(n: *u8, v: *u8) -> libc::c_int;
 }

branches/snap-stage3/src/doc/guide-macros.md

@@ -85,7 +85,7 @@ To take as an argument a fragment of Rust code, write `$` followed by a name
   `foo`.)
 * `expr` (an expression. Examples: `2 + 2`; `if true then { 1 } else { 2 }`;
   `f(42)`.)
-* `ty` (a type. Examples: `int`, `~[(char, String)]`, `&T`.)
+* `ty` (a type. Examples: `int`, `Vec<(char, String)>`, `&T`.)
 * `pat` (a pattern, usually appearing in a `match` or on the left-hand side of
   a declaration. Examples: `Some(t)`; `(17, 'a')`; `_`.)
 * `block` (a sequence of actions. Example: `{ log(error, "hi"); return 12; }`)