---

yaml
---
r: 193631
b: refs/heads/beta
c: dbec033
h: refs/heads/master
i:
  193629: 498d54d
  193627: bcbaa21
  193623: ffedb7c
  193615: b064283
  193599: 12606cc
v: v3

Author: nikomatsakis

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: b83b26bacb6371173cdec6bf68c7ffa69f858c84
+refs/heads/beta: dbec033e29417ab01bae5749b58f8866b300f005
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

branches/beta/README.md

@@ -115,7 +115,7 @@ The Rust community congregates in a few places:
 
 ## Contributing
 
-To contribute to Rust, please see [CONTRIBUTING](CONTRIBUTING.md).
+To contribute to Rust, please see [CONTRIBUTING.md](CONTRIBUTING.md).
 
 Rust has an [IRC] culture and most real-time collaboration happens in a
 variety of channels on Mozilla's IRC network, irc.mozilla.org. The
@@ -131,4 +131,4 @@ Rust is primarily distributed under the terms of both the MIT license
 and the Apache License (Version 2.0), with portions covered by various
 BSD-like licenses.
 
-See [LICENSE-APACHE](LICENSE-APACHE), [LICENSE-MIT](LICENSE-MIT), and [COPYRIGHT](COPYRIGHT) for details.
+See LICENSE-APACHE, LICENSE-MIT, and COPYRIGHT for details.

branches/beta/configure

@@ -430,10 +430,6 @@ case $CFG_OSTYPE in
         CFG_CPUTYPE=x86_64
         ;;
 
-#   Win 8 # uname -s on 64-bit cygwin does not contain WOW64, so simply use uname -m to detect arch (works in my install)
-    CYGWIN_NT-6.3)
-    	CFG_OSTYPE=pc-windows-gnu
-    	;;
 # We do not detect other OS such as XP/2003 using 64 bit using uname.
 # If we want to in the future, we will need to use Cygwin - Chuck's csih helper in /usr/lib/csih/winProductName.exe or alternative.
     *)

branches/beta/mk/main.mk

@@ -18,7 +18,7 @@ CFG_RELEASE_NUM=1.0.0
 # An optional number to put after the label, e.g. '.2' -> '-beta.2'
 # NB Make sure it starts with a dot to conform to semver pre-release
 # versions (section 9)
-CFG_PRERELEASE_VERSION=
+CFG_PRERELEASE_VERSION=.2
 
 CFG_FILENAME_EXTRA=4e7c5e5c
 
@@ -30,8 +30,8 @@ CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),beta)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
+CFG_RELEASE=$(CFG_RELEASE_NUM)-alpha$(CFG_PRERELEASE_VERSION)
+CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-alpha$(CFG_PRERELEASE_VERSION)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),nightly)

branches/beta/mk/tests.mk

@@ -590,7 +590,7 @@ TEST_SREQ$(1)_T_$(2)_H_$(3) = \
 
 # The tests select when to use debug configuration on their own;
 # remove directive, if present, from CFG_RUSTC_FLAGS (issue #7898).
-CTEST_RUSTC_FLAGS := $$(subst -C debug-assertions,,$$(CFG_RUSTC_FLAGS))
+CTEST_RUSTC_FLAGS := $$(subst --cfg ndebug,,$$(CFG_RUSTC_FLAGS))
 
 # The tests cannot be optimized while the rest of the compiler is optimized, so
 # filter out the optimization (if any) from rustc and then figure out if we need

branches/beta/src/compiletest/compiletest.rs

@@ -22,9 +22,10 @@
 #![feature(unicode)]
 #![feature(core)]
 #![feature(path)]
+#![feature(os)]
 #![feature(io)]
+#![feature(fs)]
 #![feature(net)]
-#![feature(path_ext)]
 
 #![deny(warnings)]
 
@@ -332,7 +333,7 @@ pub fn make_test<F>(config: &Config, testfile: &Path, f: F) -> test::TestDescAnd
         desc: test::TestDesc {
             name: make_test_name(config, testfile),
             ignore: header::is_test_ignored(config, testfile),
-            should_panic: test::ShouldPanic::No,
+            should_fail: test::ShouldFail::No,
         },
         testfn: f(),
     }

branches/beta/src/compiletest/runtest.rs

@@ -20,6 +20,7 @@ use procsrv;
 use util::logv;
 
 use std::env;
+use std::ffi::OsStr;
 use std::fmt;
 use std::fs::{self, File};
 use std::io::BufReader;
@@ -1322,7 +1323,7 @@ fn make_exe_name(config: &Config, testfile: &Path) -> PathBuf {
     let mut f = output_base_name(config, testfile);
     if !env::consts::EXE_SUFFIX.is_empty() {
         let mut fname = f.file_name().unwrap().to_os_string();
-        fname.push(env::consts::EXE_SUFFIX);
+        fname.push_os_str(OsStr::from_str(env::consts::EXE_SUFFIX));
         f.set_file_name(&fname);
     }
     f
@@ -1432,7 +1433,7 @@ fn make_out_name(config: &Config, testfile: &Path, extension: &str) -> PathBuf {
 fn aux_output_dir_name(config: &Config, testfile: &Path) -> PathBuf {
     let f = output_base_name(config, testfile);
     let mut fname = f.file_name().unwrap().to_os_string();
-    fname.push("libaux");
+    fname.push_os_str(OsStr::from_str("libaux"));
     f.with_file_name(&fname)
 }
 
@@ -1646,8 +1647,8 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> PathBuf {
         p.to_path_buf()
     } else {
         let mut stem = p.file_stem().unwrap().to_os_string();
-        stem.push("-");
-        stem.push(suffix);
+        stem.push_os_str(OsStr::from_str("-"));
+        stem.push_os_str(OsStr::from_str(suffix));
         p.with_file_name(&stem)
     }
 }

branches/beta/src/doc/grammar.md

@@ -514,7 +514,7 @@ field_expr : expr '.' ident ;
 ### Array expressions
 
 ```antlr
-array_expr : '[' "mut" ? array_elems? ']' ;
+array_expr : '[' "mut" ? vec_elems? ']' ;
 
 array_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
 ```

branches/beta/src/doc/guide-tasks.md

@@ -1,4 +1,4 @@
 % The (old) Rust Threads and Communication Guide
 
 This content has moved into
-[the Rust Programming Language book](book/concurrency.html).
+[the Rust Programming Language book](book/tasks.html).

branches/beta/src/doc/intro.md

@@ -389,11 +389,11 @@ safe concurrent programs.
 Here's an example of a concurrent Rust program:
 
 ```{rust}
-use std::thread;
+use std::thread::Thread;
 
 fn main() {
     let guards: Vec<_> = (0..10).map(|_| {
-        thread::scoped(|| {
+        Thread::scoped(|| {
             println!("Hello, world!");
         })
     }).collect();
@@ -421,16 +421,16 @@ problem.
 Let's see an example. This Rust code will not compile:
 
 ```{rust,ignore}
-use std::thread;
+use std::thread::Thread;
 
 fn main() {
     let mut numbers = vec![1, 2, 3];
 
     let guards: Vec<_> = (0..3).map(|i| {
-        thread::scoped(move || {
+        Thread::scoped(move || {
             numbers[i] += 1;
             println!("numbers[{}] is {}", i, numbers[i]);
-        })
+        });
     }).collect();
 }
 ```
@@ -439,10 +439,10 @@ It gives us this error:
 
 ```text
 7:25: 10:6 error: cannot move out of captured outer variable in an `FnMut` closure
-7     thread::scoped(move || {
+7     Thread::scoped(move || {
 8       numbers[i] += 1;
 9       println!("numbers[{}] is {}", i, numbers[i]);
-10     })
+10     });
 error: aborting due to previous error
 ```
 
@@ -471,19 +471,19 @@ mutation doesn't cause a data race.
 Here's what using an Arc with a Mutex looks like:
 
 ```{rust}
-use std::thread;
+use std::thread::Thread;
 use std::sync::{Arc,Mutex};
 
 fn main() {
     let numbers = Arc::new(Mutex::new(vec![1, 2, 3]));
 
     let guards: Vec<_> = (0..3).map(|i| {
         let number = numbers.clone();
-        thread::scoped(move || {
+        Thread::scoped(move || {
             let mut array = number.lock().unwrap();
             array[i] += 1;
             println!("numbers[{}] is {}", i, array[i]);
-        })
+        });
     }).collect();
 }
 ```
@@ -535,15 +535,15 @@ As an example, Rust's ownership system is _entirely_ at compile time. The
 safety check that makes this an error about moved values:
 
 ```{rust,ignore}
-use std::thread;
+use std::thread::Thread;
 
 fn main() {
     let numbers = vec![1, 2, 3];
 
     let guards: Vec<_> = (0..3).map(|i| {
-        thread::scoped(move || {
+        Thread::scoped(move || {
             println!("{}", numbers[i]);
-        })
+        });
     }).collect();
 }
 ```

branches/beta/src/doc/reference.md

@@ -2429,10 +2429,6 @@ The currently implemented features of the reference compiler are:
                        so that new attributes can be added in a bacwards compatible
                        manner (RFC 572).
 
-* `custom_derive` - Allows the use of `#[derive(Foo,Bar)]` as sugar for
-                    `#[derive_Foo] #[derive_Bar]`, which can be user-defined syntax
-                    extensions.
-
 * `intrinsics` - Allows use of the "rust-intrinsics" ABI. Compiler intrinsics
                  are inherently unstable and no promise about them is made.
 
@@ -2847,7 +2843,7 @@ automatically dereferenced to make the field access possible.
 ### Array expressions
 
 ```{.ebnf .gram}
-array_expr : '[' "mut" ? array_elems? ']' ;
+array_expr : '[' "mut" ? vec_elems? ']' ;
 
 array_elems : [expr [',' expr]*] | [expr ';' expr] ;
 ```
@@ -3007,6 +3003,10 @@ A type cast expression is denoted with the binary operator `as`.
 Executing an `as` expression casts the value on the left-hand side to the type
 on the right-hand side.
 
+A numeric value can be cast to any numeric type. A raw pointer value can be
+cast to or from any integral type or raw pointer type. Any other cast is
+unsupported and will fail to compile.
+
 An example of an `as` expression:
 
 ```

branches/beta/src/doc/style/errors/ergonomics.md

@@ -22,9 +22,9 @@ fn write_info(info: &Info) -> Result<(), IoError> {
     let mut file = File::open_mode(&Path::new("my_best_friends.txt"),
                                    Open, Write);
     // Early return on error
-    try!(file.write_line(&format!("name: {}", info.name)));
-    try!(file.write_line(&format!("age: {}", info.age)));
-    try!(file.write_line(&format!("rating: {}", info.rating)));
+    try!(file.write_line(format!("name: {}", info.name).as_slice()));
+    try!(file.write_line(format!("age: {}", info.age).as_slice()));
+    try!(file.write_line(format!("rating: {}", info.rating).as_slice()));
     return Ok(());
 }
 ```
@@ -44,15 +44,15 @@ fn write_info(info: &Info) -> Result<(), IoError> {
     let mut file = File::open_mode(&Path::new("my_best_friends.txt"),
                                    Open, Write);
     // Early return on error
-    match file.write_line(&format!("name: {}", info.name)) {
+    match file.write_line(format!("name: {}", info.name).as_slice()) {
         Ok(_) => (),
         Err(e) => return Err(e)
     }
-    match file.write_line(&format!("age: {}", info.age)) {
+    match file.write_line(format!("age: {}", info.age).as_slice()) {
         Ok(_) => (),
         Err(e) => return Err(e)
     }
-    return file.write_line(&format!("rating: {}", info.rating));
+    return file.write_line(format!("rating: {}", info.rating).as_slice());
 }
 ```
 

branches/beta/src/doc/trpl/SUMMARY.md

@@ -16,11 +16,11 @@
     * [Standard Input](standard-input.md)
     * [Guessing Game](guessing-game.md)
 * [II: Intermediate Rust](intermediate.md)
+    * [More Strings](more-strings.md)
     * [Crates and Modules](crates-and-modules.md)
     * [Testing](testing.md)
     * [Pointers](pointers.md)
     * [Ownership](ownership.md)
-    * [More Strings](more-strings.md)
     * [Patterns](patterns.md)
     * [Method Syntax](method-syntax.md)
     * [Closures](closures.md)

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

@@ -60,12 +60,6 @@ let v = vec![1, 2, 3]; // v: Vec<i32>
 brackets `[]` with `vec!`. Rust allows you to use either in either situation,
 this is just convention.)
 
-There's an alternate form of `vec!` for repeating an initial value:
-
-```
-let v = vec![0; 10]; // ten zeroes
-```
-
 You can get the length of, iterate over, and subscript vectors just like
 arrays. In addition, (mutable) vectors can grow automatically:
 

branches/beta/src/doc/trpl/concurrency.md

@@ -223,8 +223,15 @@ method which has this signature:
 fn lock(&self) -> LockResult<MutexGuard<T>>
 ```
 
-Because `Send` is not implemented for `MutexGuard<T>`, we can't transfer the
-guard across thread boundaries, which gives us our error.
+If we [look at the code for MutexGuard](https://github.com/rust-lang/rust/blob/ca4b9674c26c1de07a2042cb68e6a062d7184cef/src/libstd/sync/mutex.rs#L172), we'll see
+this:
+
+```ignore
+__marker: marker::NoSend,
+```
+
+Because our guard is `NoSend`, it's not `Send`. Which means we can't actually
+transfer the guard across thread boundaries, which gives us our error.
 
 We can use `Arc<T>` to fix this. Here's the working version: