---

yaml
---
r: 174444
b: refs/heads/batch
c: 35d46fa
h: refs/heads/master
v: v3

Author: benjaminp

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/issue-18208-method-dispatch-2: 9e1eae4fb9b6527315b4441cf8a0f5ca911d1671
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
-refs/heads/batch: dcaeb6aa23ecba2dc2af870668a9239136d20fa3
+refs/heads/batch: 35d46fabaf63c0b1b607bd91cd5680eeaa2f9a14
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 44a287e6eb22ec3c2a687fc156813577464017f7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928

branches/batch/LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2015 The Rust Project Developers
+Copyright (c) 2014 The Rust Project Developers
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

branches/batch/configure

@@ -612,7 +612,7 @@ putvar CFG_RELEASE_CHANNEL
 # channel.
 # Basing CFG_BOOTSTRAP_KEY on CFG_BOOTSTRAP_KEY lets it get picked up
 # during a Makefile reconfig.
-CFG_BOOTSTRAP_KEY="${CFG_BOOTSTRAP_KEY-`date +%H:%M:%S`}"
+CFG_BOOTSTRAP_KEY="${CFG_BOOTSTRAP_KEY-`date +%N`}"
 putvar CFG_BOOTSTRAP_KEY
 
 step_msg "looking for build programs"

branches/batch/mk/crates.mk

@@ -52,7 +52,7 @@
 TARGET_CRATES := libc std flate arena term \
                  serialize getopts collections test rand \
                  log regex graphviz core rbml alloc \
-                 unicode rustc_bitflags
+                 unicode
 RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
                 rustc_trans rustc_back rustc_llvm rustc_privacy
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc fmt_macros
@@ -64,8 +64,7 @@ DEPS_libc := core
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc
 DEPS_std := core libc rand alloc collections unicode \
-	native:rust_builtin native:backtrace native:rustrt_native \
-	rustc_bitflags
+	native:rust_builtin native:backtrace native:rustrt_native
 DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
 DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
@@ -84,7 +83,6 @@ DEPS_rustc_llvm := native:rustllvm libc std
 DEPS_rustc_back := std syntax rustc_llvm flate log libc
 DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
                 test
-DEPS_rustc_bitflags := core
 DEPS_flate := std native:miniz
 DEPS_arena := std
 DEPS_graphviz := std
@@ -116,7 +114,6 @@ ONLY_RLIB_alloc := 1
 ONLY_RLIB_rand := 1
 ONLY_RLIB_collections := 1
 ONLY_RLIB_unicode := 1
-ONLY_RLIB_rustc_bitflags := 1
 
 ################################################################################
 # You should not need to edit below this line

branches/batch/mk/main.mk

@@ -330,10 +330,10 @@ ifdef CFG_DISABLE_UNSTABLE_FEATURES
 CFG_INFO := $(info cfg: disabling unstable features (CFG_DISABLE_UNSTABLE_FEATURES))
 # Turn on feature-staging
 export CFG_DISABLE_UNSTABLE_FEATURES
-# Subvert unstable feature lints to do the self-build
-export RUSTC_BOOTSTRAP_KEY:=$(CFG_BOOTSTRAP_KEY)
 endif
+# Subvert unstable feature lints to do the self-build
 export CFG_BOOTSTRAP_KEY
+export RUSTC_BOOTSTRAP_KEY:=$(CFG_BOOTSTRAP_KEY)
 
 ######################################################################
 # Per-stage targets and runner

branches/batch/src/compiletest/compiletest.rs

@@ -13,7 +13,6 @@
 #![feature(slicing_syntax, unboxed_closures)]
 #![feature(box_syntax)]
 #![feature(int_uint)]
-#![allow(unstable)]
 
 #![deny(warnings)]
 

branches/batch/src/doc/intro.md

@@ -424,11 +424,11 @@ Let's see an example. This Rust code will not compile:
 use std::thread::Thread;
 
 fn main() {
-    let mut numbers = vec![1is, 2, 3];
+    let mut numbers = vec![1i, 2i, 3i];
 
-    for i in 0..3 {
+    for i in range(0u, 3u) {
         Thread::spawn(move || {
-            for j in 0..3 { numbers[j] += 1 }
+            for j in range(0, 3) { numbers[j] += 1 }
         });
     }
 }
@@ -438,15 +438,15 @@ It gives us this error:
 
 ```text
 6:71 error: capture of moved value: `numbers`
-    for j in 0..3 { numbers[j] += 1 }
-                    ^~~~~~~
+    for j in range(0, 3) { numbers[j] += 1 }
+               ^~~~~~~
 7:50 note: `numbers` moved into closure environment here
     spawn(move || {
-        for j in 0..3 { numbers[j] += 1 }
+        for j in range(0, 3) { numbers[j] += 1 }
     });
 6:79 error: cannot assign to immutable dereference (dereference is implicit, due to indexing)
-        for j in 0..3 { numbers[j] += 1 }
-                        ^~~~~~~~~~~~~~~
+        for j in range(0, 3) { numbers[j] += 1 }
+                           ^~~~~~~~~~~~~~~
 ```
 
 It mentions that "numbers moved into closure environment". Because we
@@ -478,9 +478,9 @@ use std::thread::Thread;
 use std::sync::{Arc,Mutex};
 
 fn main() {
-    let numbers = Arc::new(Mutex::new(vec![1is, 2, 3]));
+    let numbers = Arc::new(Mutex::new(vec![1i, 2i, 3i]));
 
-    for i in 0..3 {
+    for i in range(0u, 3u) {
         let number = numbers.clone();
         Thread::spawn(move || {
             let mut array = number.lock().unwrap();
@@ -541,12 +541,12 @@ safety check that makes this an error about moved values:
 use std::thread::Thread;
 
 fn main() {
-    let vec = vec![1is, 2, 3];
+    let vec = vec![1i, 2, 3];
 
-    for i in 0us..3 {
+    for i in range(0u, 3) {
         Thread::spawn(move || {
             println!("{}", vec[i]);
-        });
+        }).detach();
     }
 }
 ```
@@ -557,9 +557,9 @@ you can remove it. As an example, this is a poor way to iterate through
 a vector:
 
 ```{rust}
-let vec = vec![1, 2, 3];
+let vec = vec![1i, 2, 3];
 
-for i in 0..vec.len() {
+for i in range(0u, vec.len()) {
      println!("{}", vec[i]);
 }
 ```
@@ -569,7 +569,7 @@ that we don't try to access an invalid index. However, we can remove this
 while retaining safety. The answer is iterators:
 
 ```{rust}
-let vec = vec![1, 2, 3];
+let vec = vec![1i, 2, 3];
 
 for x in vec.iter() {
     println!("{}", x);

branches/batch/src/doc/reference.md

@@ -1413,27 +1413,6 @@ a = Animal::Cat { name: "Spotty".to_string(), weight: 2.7 };
 In this example, `Cat` is a _struct-like enum variant_,
 whereas `Dog` is simply called an enum variant.
 
-Enums have a discriminant. You can assign them explicitly:
-
-```
-enum Foo {
-    Bar = 123,
-}
-```
-
-If a discriminant isn't assigned, they start at zero, and add one for each
-variant, in order.
-
-You can cast an enum to get this value:
-
-```
-# enum Foo { Bar = 123 }
-let x = Foo::Bar as u32; // x is now 123u32
-```
-
-This only works as long as none of the variants have data attached. If
-it were `Bar(i32)`, this is disallowed.
-
 ### Constant items
 
 ```{.ebnf .gram}

branches/batch/src/doc/trpl/arrays-vectors-and-slices.md

@@ -5,7 +5,7 @@ things. The most basic is the *array*, a fixed-size list of elements of the
 same type. By default, arrays are immutable.
 
 ```{rust}
-let a = [1, 2, 3]; // a: [i32; 3]
+let a = [1, 2, 3];     // a: [i32; 3]
 let mut m = [1, 2, 3]; // mut m: [i32; 3]
 ```
 
@@ -68,7 +68,7 @@ let mut nums = vec![1, 2, 3]; // mut nums: Vec<i32>
 
 nums.push(4);
 
-println!("The length of nums is now {}", nums.len()); // Prints 4
+println!("The length of nums is now {}", nums.len());   // Prints 4
 ```
 
 Vectors have many more useful methods.
@@ -82,10 +82,10 @@ arrays:
 
 ```{rust}
 let a = [0, 1, 2, 3, 4];
-let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3
+let middle = &a[1..4];     // A slice of a: just the elements 1, 2, and 3
 
 for e in middle.iter() {
-    println!("{}", e); // Prints 1, 2, 3
+    println!("{}", e);          // Prints 1, 2, 3
 }
 ```
 

branches/batch/src/doc/trpl/compound-data-types.md

@@ -51,7 +51,7 @@ arity and contained types.
 
 ```rust
 let mut x = (1, 2); // x: (i32, i32)
-let y = (2, 3); // y: (i32, i32)
+let y = (2, 3);     // y: (i32, i32)
 
 x = y;
 ```
@@ -156,7 +156,7 @@ These two will not be equal, even if they have the same values:
 ```{rust}
 # struct Color(i32, i32, i32);
 # struct Point(i32, i32, i32);
-let black = Color(0, 0, 0);
+let black  = Color(0, 0, 0);
 let origin = Point(0, 0, 0);
 ```
 
@@ -297,7 +297,7 @@ enum StringResult {
 }
 ```
 Where a `StringResult` is either a `StringResult::StringOK`, with the result of
-a computation, or a `StringResult::ErrorReason` with a `String` explaining
+a computation, or an `StringResult::ErrorReason` with a `String` explaining
 what caused the computation to fail. These kinds of `enum`s are actually very
 useful and are even part of the standard library.
 

branches/batch/src/doc/trpl/crates-and-modules.md

@@ -1,4 +1,4 @@
-% Crates and Modules
+% The Rust Crates and Modules Guide
 
 When a project starts getting large, it's considered a good software
 engineering practice to split it up into a bunch of smaller pieces, and then

branches/batch/src/doc/trpl/error-handling.md

@@ -1,4 +1,4 @@
-% Error Handling
+% Error Handling in Rust
 
 > The best-laid plans of mice and men  
 > Often go awry
@@ -60,12 +60,12 @@ fn probability(_: &Event) -> f64 {
 
 fn descriptive_probability(event: Event) -> &'static str {
     match probability(&event) {
-        1.00 => "certain",
-        0.00 => "impossible",
+        1.00          => "certain",
+        0.00          => "impossible",
         0.00 ... 0.25 => "very unlikely",
         0.25 ... 0.50 => "unlikely",
         0.50 ... 0.75 => "likely",
-        0.75 ... 1.00 => "very likely",
+        0.75 ... 1.00  => "very likely",
     }
 }
 
@@ -97,12 +97,12 @@ fn probability(_: &Event) -> f64 {
 
 fn descriptive_probability(event: Event) -> &'static str {
     match probability(&event) {
-        1.00 => "certain",
-        0.00 => "impossible",
+        1.00          => "certain",
+        0.00          => "impossible",
         0.00 ... 0.25 => "very unlikely",
         0.25 ... 0.50 => "unlikely",
         0.50 ... 0.75 => "likely",
-        0.75 ... 1.00 => "very likely",
+        0.75 ... 1.00  => "very likely",
         _ => unreachable!()
     }
 }