---

yaml
---
r: 133983
b: refs/heads/master
c: e86c87a
h: refs/heads/master
i:
  133981: 27dd268
  133979: 096557a
  133975: adee4b8
  133967: 558f74f
  133951: 1f6673b
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: df34b082abb184054961a641bbe40a450ec92b0d
+refs/heads/master: e86c87a81e69de51cfed5719888840f25266a8d8
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 437179ed8bf7f7672f84b19265df1ce569e70490
 refs/heads/try: 777654cfccbfa39bc7f671d8e9629018ed8ca12d

trunk/configure

@@ -453,8 +453,6 @@ valopt datadir "${CFG_PREFIX}/share" "install data"
 valopt infodir "${CFG_PREFIX}/share/info" "install additional info"
 valopt mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
 
-valopt release-channel "source" "the name of the release channel to build"
-
 # On windows we just store the libraries in the bin directory because
 # there's no rpath. This is where the build system itself puts libraries;
 # --libdir is used to configure the installation directory.
@@ -483,23 +481,6 @@ CFG_BUILD=`echo "${CFG_BUILD}" | sed 's/-pc-mingw32/-w64-mingw32/g'`
 CFG_HOST=`echo "${CFG_HOST}" | sed 's/-pc-mingw32/-w64-mingw32/g'`
 CFG_TARGET=`echo "${CFG_TARGET}" | sed 's/-pc-mingw32/-w64-mingw32/g'`
 
-# Validate the release channel
-case "$CFG_RELEASE_CHANNEL" in
-    (source | nightly | beta | stable)
-	;;
-    (*)
-        err "release channel must be 'source', 'nightly', 'beta' or 'stable'"
-        ;;
-esac
-
-# Continue supporting the old --enable-nightly flag to transition the bots
-# XXX Remove me
-if [ $CFG_ENABLE_NIGHTLY -eq 1 ]
-then
-    CFG_RELEASE_CHANNEL=nightly
-    putvar CFG_RELEASE_CHANNEL
-fi
-
 step_msg "looking for build programs"
 
 probe_need CFG_PERL        perl
@@ -655,7 +636,7 @@ then
             # check that gcc, cc and g++ all point to the same compiler.
             # note that for xcode 5, g++ points to clang, not clang++
             if !((chk_cc gcc clang  && chk_cc g++ clang) ||
-                (chk_cc gcc gcc  &&( chk_cc g++ g++ || chk g++ gcc))); then
+                (chk_cc gcc gcc  &&( chk_cc g++ g++ || chk g++ gcc))) then
                 err "the gcc and g++ in your path point to different compilers.
     Check which versions are in your path with gcc --version and g++ --version.
     To resolve this problem, either fix your PATH  or run configure with --enable-clang"

trunk/man/rustc.1

@@ -1,4 +1,4 @@
-.TH RUSTC "1" "March 2014" "rustc 0.12.0" "User Commands"
+.TH RUSTC "1" "March 2014" "rustc 0.12.0-pre" "User Commands"
 .SH NAME
 rustc \- The Rust compiler
 .SH SYNOPSIS

trunk/man/rustdoc.1

@@ -1,4 +1,4 @@
-.TH RUSTDOC "1" "March 2014" "rustdoc 0.12.0" "User Commands"
+.TH RUSTDOC "1" "March 2014" "rustdoc 0.12.0-pre" "User Commands"
 .SH NAME
 rustdoc \- generate documentation from Rust source code
 .SH SYNOPSIS

trunk/mk/main.mk

@@ -14,32 +14,22 @@
 
 # The version number
 CFG_RELEASE_NUM=0.12.0
+CFG_RELEASE_LABEL=-pre
 
 CFG_FILENAME_EXTRA=4e7c5e5c
 
-ifeq ($(CFG_RELEASE_CHANNEL),stable)
-# This is the normal semver version string, e.g. "0.12.0", "0.12.0-nightly"
-CFG_RELEASE=$(CFG_RELEASE_NUM)
-# This is the string used in dist artifact file names, e.g. "0.12.0", "nightly"
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)
-endif
-ifeq ($(CFG_RELEASE_CHANNEL),beta)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-beta
-# When building beta/nightly distributables just reuse the same "beta"
-# name so when we upload we'll always override the previous
-# nighly. This doesn't actually impact the version reported by rustc -
-# it's just for file naming.
-CFG_PACKAGE_VERS=beta
-endif
-ifeq ($(CFG_RELEASE_CHANNEL),nightly)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-nightly
+ifndef CFG_ENABLE_NIGHTLY
+# This is the normal version string
+CFG_RELEASE=$(CFG_RELEASE_NUM)$(CFG_RELEASE_LABEL)
+CFG_PACKAGE_VERS=$(CFG_RELEASE)
+else
+# Modify the version label for nightly builds
+CFG_RELEASE=$(CFG_RELEASE_NUM)$(CFG_RELEASE_LABEL)-nightly
+# When building nightly distributables just reuse the same "rust-nightly" name
+# so when we upload we'll always override the previous nighly. This doesn't actually
+# impact the version reported by rustc - it's just for file naming.
 CFG_PACKAGE_VERS=nightly
 endif
-ifeq ($(CFG_RELEASE_CHANNEL),source)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-pre
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-pre
-endif
-
 # The name of the package to use for creating tarballs, installers etc.
 CFG_PACKAGE_NAME=rust-$(CFG_PACKAGE_VERS)
 

trunk/src/compiletest/compiletest.rs

@@ -259,7 +259,7 @@ pub fn run_tests(config: &Config) {
     // parallel (especially when we have lots and lots of child processes).
     // For context, see #8904
     io::test::raise_fd_limit();
-    let res = test::run_tests_console(&opts, tests.into_iter().collect());
+    let res = test::run_tests_console(&opts, tests.move_iter().collect());
     match res {
         Ok(true) => {}
         Ok(false) => fail!("Some tests failed"),
@@ -400,4 +400,4 @@ fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
         },
         _ => None
     }
-}
+}

trunk/src/compiletest/procsrv.rs

@@ -40,7 +40,7 @@ pub fn run(lib_path: &str,
     let mut cmd = Command::new(prog);
     cmd.args(args);
     add_target_env(&mut cmd, lib_path, aux_path);
-    for (key, val) in env.into_iter() {
+    for (key, val) in env.move_iter() {
         cmd.env(key, val);
     }
 
@@ -72,7 +72,7 @@ pub fn run_background(lib_path: &str,
     let mut cmd = Command::new(prog);
     cmd.args(args);
     add_target_env(&mut cmd, lib_path, aux_path);
-    for (key, val) in env.into_iter() {
+    for (key, val) in env.move_iter() {
         cmd.env(key, val);
     }
 

trunk/src/compiletest/runtest.rs

@@ -768,7 +768,7 @@ fn cleanup_debug_info_options(options: &Option<String>) -> Option<String> {
         "--debuginfo".to_string()
     ];
     let new_options =
-        split_maybe_args(options).into_iter()
+        split_maybe_args(options).move_iter()
                                  .filter(|x| !options_to_remove.contains(x))
                                  .collect::<Vec<String>>()
                                  .connect(" ");
@@ -1461,7 +1461,7 @@ fn _arm_exec_compiled_test(config: &Config,
 
     // run test via adb_run_wrapper
     runargs.push("shell".to_string());
-    for (key, val) in env.into_iter() {
+    for (key, val) in env.move_iter() {
         runargs.push(format!("{}={}", key, val));
     }
     runargs.push(format!("{}/adb_run_wrapper.sh", config.adb_test_dir));

trunk/src/doc/guide-tasks.md

@@ -235,10 +235,10 @@ fn partial_sum(start: uint) -> f64 {
 }
 
 fn main() {
-    let mut futures = Vec::from_fn(200, |ind| Future::spawn( proc() { partial_sum(ind) }));
+    let mut futures = Vec::from_fn(1000, |ind| Future::spawn( proc() { partial_sum(ind) }));
 
     let mut final_res = 0f64;
-    for ft in futures.iter_mut()  {
+    for ft in futures.mut_iter()  {
         final_res += ft.get();
     }
     println!("π^2/6 is not far from : {}", final_res);

trunk/src/doc/guide.md

@@ -29,11 +29,8 @@ $ curl -s https://static.rust-lang.org/rustup.sh | sudo sh
 (If you're concerned about `curl | sudo sh`, please keep reading. Disclaimer
 below.)
 
-If you're on Windows, please download either the [32-bit
-installer](https://static.rust-lang.org/dist/rust-nightly-i686-w64-mingw32.exe)
-or the [64-bit
-installer](https://static.rust-lang.org/dist/rust-nightly-x86_64-w64-mingw32.exe)
-and run it.
+If you're on Windows, please [download this .exe and run
+it](https://static.rust-lang.org/dist/rust-nightly-install.exe).
 
 If you decide you don't want Rust anymore, we'll be a bit sad, but that's okay.
 Not every programming language is great for everyone. Just pass an argument to
@@ -188,8 +185,8 @@ Next up is this line:
 This line does all of the work in our little program. There are a number of
 details that are important here. The first is that it's indented with four
 spaces, not tabs. Please configure your editor of choice to insert four spaces
-with the tab key. We provide some [sample configurations for various
-editors](https://github.com/rust-lang/rust/tree/master/src/etc).
+with the tab key. We provide some sample configurations for various editors
+[here](https://github.com/rust-lang/rust/tree/master/src/etc).
 
 The second point is the `println!()` part. This is calling a Rust **macro**,
 which is how metaprogramming is done in Rust. If it were a function instead, it
@@ -395,10 +392,14 @@ By the way, in these examples, `i` indicates that the number is an integer.
 
 Rust is a statically typed language, which means that we specify our types up
 front. So why does our first example compile? Well, Rust has this thing called
-"type inference." If it can figure out what the type of something is, Rust
+"[Hindley-Milner type
+inference](http://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system)",
+named after some really smart type theorists. If you clicked that link, don't
+be scared: what this means for you is that Rust will attempt to infer the types
+in your program, and it's pretty good at it. If it can infer the type, Rust
 doesn't require you to actually type it out.
 
-We can add the type if we want to, though. Types come after a colon (`:`):
+We can add the type if we want to. Types come after a colon (`:`):
 
 ```{rust}
 let x: int = 5;
@@ -1280,15 +1281,15 @@ two main looping constructs: `for` and `while`.
 
 The `for` loop is used to loop a particular number of times. Rust's `for` loops
 work a bit differently than in other systems languages, however. Rust's `for`
-loop doesn't look like this "C style" `for` loop:
+loop doesn't look like this C `for` loop:
 
-```{c}
+```{ignore,c}
 for (x = 0; x < 10; x++) {
     printf( "%d\n", x );
 }
 ```
 
-Instead, it looks like this:
+It looks like this:
 
 ```{rust}
 for x in range(0i, 10i) {
@@ -1311,13 +1312,14 @@ valid for the loop body. Once the body is over, the next value is fetched from
 the iterator, and we loop another time. When there are no more values, the
 `for` loop is over.
 
-In our example, `range` is a function that takes a start and an end position,
-and gives an iterator over those values. The upper bound is exclusive, though,
-so our loop will print `0` through `9`, not `10`.
+In our example, the `range` function is a function, provided by Rust, that
+takes a start and an end position, and gives an iterator over those values. The
+upper bound is exclusive, though, so our loop will print `0` through `9`, not
+`10`.
 
 Rust does not have the "C style" `for` loop on purpose. Manually controlling
 each element of the loop is complicated and error prone, even for experienced C
-developers.
+developers. 
 
 We'll talk more about `for` when we cover **iterator**s, later in the Guide.
 
@@ -4271,7 +4273,7 @@ very common with iterators: we can ignore unnecessary bounds checks, but still
 know that we're safe.
 
 There's another detail here that's not 100% clear because of how `println!`
-works. `num` is actually of type `&int`. That is, it's a reference to an `int`,
+works. `num` is actually of type `&int`, that is, it's a reference to an `int`,
 not an `int` itself. `println!` handles the dereferencing for us, so we don't
 see it. This code works fine too:
 

trunk/src/doc/index.md

@@ -86,10 +86,10 @@ There are questions that are asked quite often, and so we've made FAQs for them:
 
 # The standard library
 
-We have [API documentation for the entire standard
-library](std/index.html). There's a list of crates on the left with more
-specific sections, or you can use the search bar at the top to search for
-something if you know its name.
+You can find function-level documentation for the entire standard library
+[here](std/index.html). There's a list of crates on the left with more specific
+sections, or you can use the search bar at the top to search for something if
+you know its name.
 
 # External documentation
 

trunk/src/doc/rust.md

@@ -3698,7 +3698,7 @@ There are two varieties of pointer in Rust:
     they exist to support interoperability with foreign code,
     and writing performance-critical or low-level functions.
 
-The standard library contains additional 'smart pointer' types beyond references
+The standard library contains addtional 'smart pointer' types beyond references
 and raw pointers.
 
 ### Function types

trunk/src/etc/kate/rust.xml

@@ -7,7 +7,7 @@
 	<!ENTITY rustIdent "[a-zA-Z_][a-zA-Z_0-9]*">
 	<!ENTITY rustIntSuf "([iu](8|16|32|64)?)?">
 ]>
-<language name="Rust" version="0.12.0" kateversion="2.4" section="Sources" extensions="*.rs" mimetype="text/x-rust" priority="15">
+<language name="Rust" version="0.12.0-pre" kateversion="2.4" section="Sources" extensions="*.rs" mimetype="text/x-rust" priority="15">
 <highlighting>
 	<list name="fn">
 		<item> fn </item>

trunk/src/etc/licenseck.py

@@ -49,6 +49,7 @@
     "test/bench/shootout-mandelbrot.rs", # BSD
     "test/bench/shootout-meteor.rs", # BSD
     "test/bench/shootout-nbody.rs", # BSD
+    "test/bench/shootout-pidigits.rs", # BSD
     "test/bench/shootout-regex-dna.rs", # BSD
     "test/bench/shootout-reverse-complement.rs", # BSD
     "test/bench/shootout-threadring.rs", # BSD

trunk/src/liballoc/heap.rs

@@ -140,7 +140,7 @@ static MIN_ALIGN: uint = 16;
 #[cfg(jemalloc)]
 mod imp {
     use core::option::{None, Option};
-    use core::ptr::{RawPtr, null_mut, null};
+    use core::ptr::{RawPtr, mut_null, null};
     use core::num::Int;
     use libc::{c_char, c_int, c_void, size_t};
     use super::MIN_ALIGN;
@@ -230,7 +230,7 @@ mod imp {
 
     pub fn stats_print() {
         unsafe {
-            je_malloc_stats_print(None, null_mut(), null())
+            je_malloc_stats_print(None, mut_null(), null())
         }
     }
 }

trunk/src/liballoc/libc_heap.rs

@@ -12,15 +12,15 @@
 //! The global (exchange) heap.
 
 use libc::{c_void, size_t, free, malloc, realloc};
-use core::ptr::{RawPtr, null_mut};
+use core::ptr::{RawPtr, mut_null};
 
 /// A wrapper around libc::malloc, aborting on out-of-memory.
 #[inline]
 pub unsafe fn malloc_raw(size: uint) -> *mut u8 {
     // `malloc(0)` may allocate, but it may also return a null pointer
     // http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html
     if size == 0 {
-        null_mut()
+        mut_null()
     } else {
         let p = malloc(size as size_t);
         if p.is_null() {
@@ -37,7 +37,7 @@ pub unsafe fn realloc_raw(ptr: *mut u8, size: uint) -> *mut u8 {
     // http://pubs.opengroup.org/onlinepubs/9699919799/functions/realloc.html
     if size == 0 {
         free(ptr as *mut c_void);
-        null_mut()
+        mut_null()
     } else {
         let p = realloc(ptr as *mut c_void, size as size_t);
         if p.is_null() {

trunk/src/libarena/lib.rs

@@ -448,7 +448,7 @@ impl<T> TypedArena<T> {
     #[inline]
     pub fn with_capacity(capacity: uint) -> TypedArena<T> {
         unsafe {
-            let chunk = TypedArenaChunk::<T>::new(ptr::null_mut(), capacity);
+            let chunk = TypedArenaChunk::<T>::new(ptr::mut_null(), capacity);
             TypedArena {
                 ptr: Cell::new((*chunk).start() as *const T),
                 end: Cell::new((*chunk).end() as *const T),

trunk/src/libcollections/bitv.rs

@@ -178,7 +178,7 @@ impl Bitv {
         // `op` is a bitwise operation, since any bits that should've
         // been masked were fine to change anyway. `b` is masked to
         // make sure its unmasked bits do not cause damage.
-        for (a, (_, b)) in self.storage.iter_mut()
+        for (a, (_, b)) in self.storage.mut_iter()
                            .zip(other.mask_words(0)) {
             let w = op(*a, b);
             if *a != w {
@@ -310,7 +310,7 @@ impl Bitv {
     /// ```
     #[inline]
     pub fn set_all(&mut self) {
-        for w in self.storage.iter_mut() { *w = !0u; }
+        for w in self.storage.mut_iter() { *w = !0u; }
     }
 
     /// Flips all bits.
@@ -329,7 +329,7 @@ impl Bitv {
     /// ```
     #[inline]
     pub fn negate(&mut self) {
-        for w in self.storage.iter_mut() { *w = !*w; }
+        for w in self.storage.mut_iter() { *w = !*w; }
     }
 
     /// Calculates the union of two bitvectors. This acts like the bitwise `or`
@@ -797,7 +797,7 @@ impl Collection for Bitv {
 impl Mutable for Bitv {
     #[inline]
     fn clear(&mut self) {
-        for w in self.storage.iter_mut() { *w = 0u; }
+        for w in self.storage.mut_iter() { *w = 0u; }
     }
 }
 
@@ -831,7 +831,7 @@ impl Clone for Bitv {
     fn clone_from(&mut self, source: &Bitv) {
         self.nbits = source.nbits;
         self.storage.reserve(source.storage.len());
-        for (i, w) in self.storage.iter_mut().enumerate() { *w = source.storage[i]; }
+        for (i, w) in self.storage.mut_iter().enumerate() { *w = source.storage[i]; }
     }
 }