---

yaml
---
r: 135167
b: refs/heads/snap-stage3
c: 75d49c8
h: refs/heads/master
i:
  135165: 3add63c
  135163: c2276c3
  135159: d29b530
  135151: 2750728
  135135: ffc358f
  135103: f654513
  135039: fb277b7
  134911: 35586fa
  134655: 0c07742
  134143: 804073f
  133119: 1b0ce5b
  131071: 126dbf5
v: v3

Author: farcaller

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 74090504219e4e37c1a6d9fdd8600f44b51c7b04
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: eb816eee0f1803f03fbf046a26a1920659c14d82
+refs/heads/snap-stage3: 75d49c8203405ab0af7a2b8b8698af02868fdbc2
 refs/heads/try: 14378ea357c06c23607ca61ade44f60a7a64a1c7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/CONTRIBUTING.md

@@ -4,12 +4,6 @@ If you're just reporting a bug, please see:
 
 http://doc.rust-lang.org/complement-bugreport.html
 
-## Submitting an issue
-
-Please submit issues here for bug reports or implementation details. For feature
-requests, language changes, or major changes to the libraries, please submit an
-issue against the [RFCs repository](https://github.com/rust-lang/rfcs).
-
 ## Pull request procedure
 
 Pull requests should be targeted at Rust's `master` branch.

branches/snap-stage3/mk/crates.mk

@@ -59,7 +59,6 @@ CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_core :=
-DEPS_libc := core
 DEPS_rlibc := core
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc

branches/snap-stage3/mk/docs.mk

@@ -29,9 +29,9 @@ DOCS := index intro tutorial guide guide-ffi guide-macros guide-lifetimes \
 	guide-tasks guide-container guide-pointers guide-testing \
 	guide-runtime complement-bugreport \
 	complement-lang-faq complement-design-faq complement-project-faq rust \
-    rustdoc guide-unsafe guide-strings reference
+    rustdoc guide-unsafe guide-strings
 
-PDF_DOCS := guide reference
+PDF_DOCS := guide rust
 
 RUSTDOC_DEPS_rust := doc/full-toc.inc
 RUSTDOC_FLAGS_rust := --html-in-header=doc/full-toc.inc

branches/snap-stage3/mk/rt.mk

@@ -203,9 +203,6 @@ LIBUV_CFLAGS_$(1) := $(subst -Werror,,$(CFG_GCCISH_CFLAGS_$(1)))
 
 $$(LIBUV_MAKEFILE_$(1)): $$(LIBUV_DEPS) $$(MKFILE_DEPS) $$(LIBUV_STAMP_$(1))
 	(cd $(S)src/libuv/ && \
-	CC="$$(CC_$(1))" \
-	CXX="$$(CXX_$(1))" \
-	AR="$$(AR_$(1))" \
 	 $$(CFG_PYTHON) ./gyp_uv.py -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) \
 	   -D ninja \
 	   -DOS=$$(LIBUV_OSTYPE_$(1)) \
@@ -228,9 +225,6 @@ else ifeq ($(OSTYPE_$(1)), apple-ios) # iOS
 $$(LIBUV_XCODEPROJ_$(1)): $$(LIBUV_DEPS) $$(MKFILE_DEPS) $$(LIBUV_STAMP_$(1))
 	cp -rf $(S)src/libuv/ $$(LIBUV_BUILD_DIR_$(1))
 	(cd $$(LIBUV_BUILD_DIR_$(1)) && \
-	CC="$$(CC_$(1))" \
-	CXX="$$(CXX_$(1))" \
-	AR="$$(AR_$(1))" \
 	 $$(CFG_PYTHON) ./gyp_uv.py -f xcode \
 	   -D ninja \
 	   -R libuv)

branches/snap-stage3/mk/tests.mk

@@ -60,14 +60,11 @@ ifdef VERBOSE
   CTEST_TESTARGS += --verbose
 endif
 
-# Setting locale ensures that gdb's output remains consistent.
-# This prevents tests from failing with some locales (fixes #17423).
-export LC_ALL=C
-
 # If we're running perf then set this environment variable
 # to put the benchmarks into 'hard mode'
 ifeq ($(MAKECMDGOALS),perf)
-  export RUST_BENCH=1
+  RUST_BENCH=1
+  export RUST_BENCH
 endif
 
 TEST_LOG_FILE=tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).log

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

@@ -273,8 +273,8 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
                             format!("--target={}", config.target),
                             "-L".to_string(),
                             aux_dir.as_str().unwrap().to_string());
-        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
-        args.extend(split_maybe_args(&props.compile_flags).into_iter());
+        args.push_all_move(split_maybe_args(&config.target_rustcflags));
+        args.push_all_move(split_maybe_args(&props.compile_flags));
         return ProcArgs {
             prog: config.rustc_path.as_str().unwrap().to_string(),
             args: args,
@@ -321,8 +321,8 @@ actual:\n\
                             config.build_base.as_str().unwrap().to_string(),
                             "-L".to_string(),
                             aux_dir.as_str().unwrap().to_string());
-        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
-        args.extend(split_maybe_args(&props.compile_flags).into_iter());
+        args.push_all_move(split_maybe_args(&config.target_rustcflags));
+        args.push_all_move(split_maybe_args(&props.compile_flags));
         // FIXME (#9639): This needs to handle non-utf8 paths
         return ProcArgs {
             prog: config.rustc_path.as_str().unwrap().to_string(),
@@ -444,8 +444,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                      "-nx".to_string(),
                      format!("-command={}", debugger_script.as_str().unwrap()));
 
-            let mut gdb_path = tool_path;
-            gdb_path.push_str("/bin/arm-linux-androideabi-gdb");
+            let gdb_path = tool_path.append("/bin/arm-linux-androideabi-gdb");
             let procsrv::Result {
                 out,
                 err,
@@ -1096,12 +1095,11 @@ fn compile_test_(config: &Config, props: &TestProps,
                  testfile: &Path, extra_args: &[String]) -> ProcRes {
     let aux_dir = aux_output_dir_name(config, testfile);
     // FIXME (#9639): This needs to handle non-utf8 paths
-    let mut link_args = vec!("-L".to_string(),
-                             aux_dir.as_str().unwrap().to_string());
-    link_args.extend(extra_args.iter().map(|s| s.clone()));
+    let link_args = vec!("-L".to_string(),
+                         aux_dir.as_str().unwrap().to_string());
     let args = make_compile_args(config,
                                  props,
-                                 link_args,
+                                 link_args.append(extra_args),
                                  |a, b| ThisFile(make_exe_name(a, b)), testfile);
     compose_and_run_compiler(config, props, testfile, args, None)
 }
@@ -1148,16 +1146,16 @@ fn compose_and_run_compiler(
     for rel_ab in props.aux_builds.iter() {
         let abs_ab = config.aux_base.join(rel_ab.as_slice());
         let aux_props = header::load_props(&abs_ab);
-        let mut crate_type = if aux_props.no_prefer_dynamic {
+        let crate_type = if aux_props.no_prefer_dynamic {
             Vec::new()
         } else {
             vec!("--crate-type=dylib".to_string())
         };
-        crate_type.extend(extra_link_args.clone().into_iter());
         let aux_args =
             make_compile_args(config,
                               &aux_props,
-                              crate_type,
+                              crate_type.append(
+                                  extra_link_args.as_slice()),
                               |a,b| {
                                   let f = make_lib_name(a, b, testfile);
                                   ThisDirectory(f.dir_path())
@@ -1248,11 +1246,11 @@ fn make_compile_args(config: &Config,
     };
     args.push(path.as_str().unwrap().to_string());
     if props.force_host {
-        args.extend(split_maybe_args(&config.host_rustcflags).into_iter());
+        args.push_all_move(split_maybe_args(&config.host_rustcflags));
     } else {
-        args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
+        args.push_all_move(split_maybe_args(&config.target_rustcflags));
     }
-    args.extend(split_maybe_args(&props.compile_flags).into_iter());
+    args.push_all_move(split_maybe_args(&props.compile_flags));
     return ProcArgs {
         prog: config.rustc_path.as_str().unwrap().to_string(),
         args: args,
@@ -1269,9 +1267,10 @@ fn make_lib_name(config: &Config, auxfile: &Path, testfile: &Path) -> Path {
 fn make_exe_name(config: &Config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
     if !os::consts::EXE_SUFFIX.is_empty() {
-        let mut fname = f.filename().unwrap().to_vec();
-        fname.extend(os::consts::EXE_SUFFIX.bytes());
-        f.set_filename(fname);
+        match f.filename().map(|s| Vec::from_slice(s).append(os::consts::EXE_SUFFIX.as_bytes())) {
+            Some(v) => f.set_filename(v),
+            None => ()
+        }
     }
     f
 }
@@ -1287,7 +1286,7 @@ fn make_run_args(config: &Config, props: &TestProps, testfile: &Path) ->
     args.push(exe_file.as_str().unwrap().to_string());
 
     // Add the arguments in the run_flags directive
-    args.extend(split_maybe_args(&props.run_flags).into_iter());
+    args.push_all_move(split_maybe_args(&props.run_flags));
 
     let prog = args.remove(0).unwrap();
     return ProcArgs {
@@ -1382,10 +1381,12 @@ fn make_out_name(config: &Config, testfile: &Path, extension: &str) -> Path {
 }
 
 fn aux_output_dir_name(config: &Config, testfile: &Path) -> Path {
-    let f = output_base_name(config, testfile);
-    let mut fname = f.filename().unwrap().to_vec();
-    fname.extend("libaux".bytes());
-    f.with_filename(fname)
+    let mut f = output_base_name(config, testfile);
+    match f.filename().map(|s| Vec::from_slice(s).append(b".libaux")) {
+        Some(v) => f.set_filename(v),
+        None => ()
+    }
+    f
 }
 
 fn output_testname(testfile: &Path) -> Path {
@@ -1597,25 +1598,22 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path {
     if suffix.len() == 0 {
         (*p).clone()
     } else {
-        let mut stem = p.filestem().unwrap().to_vec();
-        stem.extend("-".bytes());
-        stem.extend(suffix.bytes());
-        p.with_filename(stem)
+        let stem = p.filestem().unwrap();
+        p.with_filename(Vec::from_slice(stem).append(b"-").append(suffix.as_bytes()))
     }
 }
 
 fn compile_test_and_save_bitcode(config: &Config, props: &TestProps,
                                  testfile: &Path) -> ProcRes {
     let aux_dir = aux_output_dir_name(config, testfile);
     // FIXME (#9639): This needs to handle non-utf8 paths
-    let mut link_args = vec!("-L".to_string(),
-                             aux_dir.as_str().unwrap().to_string());
+    let link_args = vec!("-L".to_string(),
+                         aux_dir.as_str().unwrap().to_string());
     let llvm_args = vec!("--emit=bc,obj".to_string(),
                          "--crate-type=lib".to_string());
-    link_args.extend(llvm_args.into_iter());
     let args = make_compile_args(config,
                                  props,
-                                 link_args,
+                                 link_args.append(llvm_args.as_slice()),
                                  |a, b| ThisDirectory(output_base_name(a, b).dir_path()),
                                  testfile);
     compose_and_run_compiler(config, props, testfile, args, None)

branches/snap-stage3/src/doc/README.md

@@ -30,7 +30,7 @@ To generate an HTML version of a doc from Markdown manually, you can do
 something like:
 
 ~~~~
-pandoc --from=markdown --to=html5 --number-sections -o reference.html reference.md
+pandoc --from=markdown --to=html5 --number-sections -o rust.html rust.md
 ~~~~
 
 (rust.md being the Rust Reference Manual.)

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

@@ -505,7 +505,6 @@ As being similar to this C code:
 {
     int *x;
     x = (int *)malloc(sizeof(int));
-    *x = 5;
 
     // stuff happens
 

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

@@ -72,8 +72,8 @@ is not used.
 Tests that should not be run can be annotated with the `ignore`
 attribute. The existence of these tests will be noted in the test
 runner output, but the test will not be run. Tests can also be ignored
-by configuration using the `cfg_attr` attribute so, for example, to ignore a
-test on windows you can write `#[cfg_attr(windows, ignore)]`.
+by configuration so, for example, to ignore a test on windows you can
+write `#[ignore(cfg(target_os = "win32"))]`.
 
 Tests that are intended to fail can be annotated with the
 `should_fail` attribute. The test will be run, and if it causes its

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

@@ -466,7 +466,7 @@ fn start(_argc: int, _argv: *const *const u8) -> int {
 // provided by libstd.
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
+#[lang = "sized"] trait Sized { }
 # // fn main() {} tricked you, rustdoc!
 ```
 
@@ -489,28 +489,32 @@ pub extern fn main(argc: int, argv: *const *const u8) -> int {
 
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
+#[lang = "sized"] trait Sized { }
 # // fn main() {} tricked you, rustdoc!
 ```
 
 
 The compiler currently makes a few assumptions about symbols which are available
 in the executable to call. Normally these functions are provided by the standard
-library, but without it you must define your own.
+xlibrary, but without it you must define your own.
 
-The first of these three functions, `stack_exhausted`, is invoked whenever stack
+The first of these two functions, `stack_exhausted`, is invoked whenever stack
 overflow is detected.  This function has a number of restrictions about how it
 can be called and what it must do, but if the stack limit register is not being
 maintained then a task always has an "infinite stack" and this function
 shouldn't get triggered.
 
-The second of these three functions, `eh_personality`, is used by the
-failure mechanisms of the compiler. This is often mapped to GCC's
-personality function (see the
-[libstd implementation](std/rt/unwind/index.html) for more
-information), but crates which do not trigger failure can be assured
-that this function is never called. The final function, `fail_fmt`, is
-also used by the failure mechanisms of the compiler.
+The second of these two functions, `eh_personality`, is used by the failure
+mechanisms of the compiler. This is often mapped to GCC's personality function
+(see the [libstd implementation](std/rt/unwind/index.html) for more
+information), but crates which do not trigger failure can be assured that this
+function is never called.
+
+The final item in the example is a trait called `Sized`. This a trait
+that represents data of a known static size: it is integral to the
+Rust type system, and so the compiler expects the standard library to
+provide it. Since you are not using the standard library, you have to
+provide it yourself.
 
 ## Using libcore
 
@@ -569,8 +573,8 @@ pub extern fn dot_product(a: *const u32, a_len: u32,
     return ret;
 }
 
-#[lang = "fail_fmt"]
-extern fn fail_fmt(args: &core::fmt::Arguments,
+#[lang = "begin_unwind"]
+extern fn begin_unwind(args: &core::fmt::Arguments,
                        file: &str,
                        line: uint) -> ! {
     loop {}
@@ -583,8 +587,8 @@ extern fn fail_fmt(args: &core::fmt::Arguments,
 ```
 
 Note that there is one extra lang item here which differs from the examples
-above, `fail_fmt`. This must be defined by consumers of libcore because the
-core library declares failure, but it does not define it. The `fail_fmt`
+above, `begin_unwind`. This must be defined by consumers of libcore because the
+core library declares failure, but it does not define it. The `begin_unwind`
 lang item is this crate's definition of failure, and it must be guaranteed to
 never return.
 
@@ -690,7 +694,7 @@ fn main(argc: int, argv: *const *const u8) -> int {
 
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "fail_fmt"] fn fail_fmt() -> ! { loop {} }
+#[lang = "sized"] trait Sized {}
 ```
 
 Note the use of `abort`: the `exchange_malloc` lang item is assumed to
@@ -702,7 +706,7 @@ Other features provided by lang items include:
   `==`, `<`, dereferencing (`*`) and `+` (etc.) operators are all
   marked with lang items; those specific four are `eq`, `ord`,
   `deref`, and `add` respectively.
-- stack unwinding and general failure; the `eh_personality`, `fail`
+- stack unwinding and general failure; the `eh_personality`, `fail_`
   and `fail_bounds_checks` lang items.
 - the traits in `std::kinds` used to indicate types that satisfy
   various kinds; lang items `send`, `sync` and `copy`.

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

@@ -1507,7 +1507,6 @@ You can create an array with just square brackets:
 
 ```{rust}
 let nums = [1i, 2i, 3i];
-let nums = [1i, ..20]; // Shorthand for an array of 20 elements all initialized to 1
 ```
 
 So what's the difference? An array has a fixed size, so you can't add or
@@ -2152,10 +2151,14 @@ In this case, we say `x` is a `uint` explicitly, so Rust is able to properly
 tell `random()` what to generate. In a similar fashion, both of these work:
 
 ```{rust,ignore}
-let input_num = from_str::<uint>("5");
+let input_num = from_str::<Option<uint>>("5");
 let input_num: Option<uint> = from_str("5");
 ```
 
+In this case, I happen to prefer the latter, and in the `random()` case, I prefer
+the former. I think the nested `<>`s make the first option especially ugly and
+a bit harder to read.
+
 Anyway, with us now converting our input to a number, our code looks like this:
 
 ```{rust,ignore}
@@ -4490,8 +4493,8 @@ This will print
 ```
 
 `filter()` is an adapter that takes a closure as an argument. This closure
-returns `true` or `false`. The new iterator `filter()` produces
-only the elements that that closure returns `true` for:
+returns `true` or `false`. The new iterator `filter()` produces returns
+only the elements that that closure returned `true` for:
 
 ```{rust}
 for i in range(1i, 100i).filter(|x| x % 2 == 0) {

branches/snap-stage3/src/doc/index.md

@@ -46,7 +46,7 @@ development of Rust itself is discussed.
 # Specification
 
 Rust does not have an exact specification, but an effort to describe as much of
-the language in as much detail as possible is in [the reference](reference.html).
+the language in as much detail as possible is in [the manual](rust.html).
 
 # Guides