---

yaml
---
r: 223669
b: refs/heads/beta
c: df73abe
h: refs/heads/master
i:
  223667: 1d547e2
v: v3

Author: birkenfeld

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 19d8bfff154c830bbe471ddeedfcf197b7458576
+refs/heads/beta: df73abedd585a0f797eb393264fc01ff5a442c40
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 938f5d7af401e2d8238522fed4a612943b6e77fd
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/CONTRIBUTING.md

@@ -83,21 +83,6 @@ feature. We use the 'fork and pull' model described there.
 
 Please make pull requests against the `master` branch.
 
-Compiling all of `make check` can take a while. When testing your pull request,
-consider using one of the more specialized `make` targets to cut down on the
-amount of time you have to wait. You need to have built the compiler at least
-once before running these will work, but that’s only one full build rather than
-one each time.
-
-    $ make -j8 rustc-stage1 && make check-stage1
-
-is one such example, which builds just `rustc`, and then runs the tests. If
-you’re adding something to the standard library, try
-
-    $ make -j8 check-stage1-std NO_REBUILD=1
-
-This will not rebuild the compiler, but will run the tests.
-
 All pull requests are reviewed by another person. We have a bot,
 @rust-highfive, that will automatically assign a random person to review your
 request.
@@ -123,10 +108,6 @@ will run all the tests on every platform we support. If it all works out,
 
 [merge-queue]: http://buildbot.rust-lang.org/homu/queue/rust
 
-Speaking of tests, Rust has a comprehensive test suite. More information about
-it can be found
-[here](https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md).
-
 ## Writing Documentation
 
 Documentation improvements are very welcome. The source of `doc.rust-lang.org`

branches/beta/mk/main.mk

@@ -295,6 +295,7 @@ LLVM_BINDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --bindir)
 LLVM_INCDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --includedir)
 LLVM_LIBDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --libdir)
 LLVM_LIBDIR_RUSTFLAGS_$(1)=-L "$$(LLVM_LIBDIR_$(1))"
+LLVM_LIBS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --libs $$(LLVM_COMPONENTS))
 LLVM_LDFLAGS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --ldflags)
 ifeq ($$(findstring freebsd,$(1)),freebsd)
 # On FreeBSD, it may search wrong headers (that are for pre-installed LLVM),

branches/beta/mk/target.mk

@@ -249,9 +249,11 @@ endef
 
 $(foreach host,$(CFG_HOST), \
  $(foreach target,$(CFG_TARGET), \
-  $(foreach crate,$(CRATES), \
-   $(eval $(call SETUP_LIB_MSVC_ENV_VARS,0,$(target),$(host),$(crate))))))
+  $(foreach stage,$(STAGES), \
+   $(foreach crate,$(CRATES), \
+    $(eval $(call SETUP_LIB_MSVC_ENV_VARS,$(stage),$(target),$(host),$(crate)))))))
 $(foreach host,$(CFG_HOST), \
  $(foreach target,$(CFG_TARGET), \
-  $(foreach tool,$(TOOLS), \
-   $(eval $(call SETUP_TOOL_MSVC_ENV_VARS,0,$(target),$(host),$(tool))))))
+  $(foreach stage,$(STAGES), \
+   $(foreach tool,$(TOOLS), \
+    $(eval $(call SETUP_TOOL_MSVC_ENV_VARS,$(stage),$(target),$(host),$(tool)))))))

branches/beta/src/compiletest/runtest.rs

@@ -1126,10 +1126,16 @@ impl fmt::Display for Status {
 
 fn compile_test(config: &Config, props: &TestProps,
                 testfile: &Path) -> ProcRes {
+    compile_test_(config, props, testfile, &[])
+}
+
+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 link_args = vec!("-L".to_string(),
-                         aux_dir.to_str().unwrap().to_string());
+    let mut link_args = vec!("-L".to_string(),
+                             aux_dir.to_str().unwrap().to_string());
+    link_args.extend(extra_args.iter().cloned());
     let args = make_compile_args(config,
                                  props,
                                  link_args,
@@ -1138,7 +1144,7 @@ fn compile_test(config: &Config, props: &TestProps,
 }
 
 fn document(config: &Config, props: &TestProps,
-            testfile: &Path) -> (ProcRes, PathBuf) {
+            testfile: &Path, extra_args: &[String]) -> (ProcRes, PathBuf) {
     let aux_dir = aux_output_dir_name(config, testfile);
     let out_dir = output_base_name(config, testfile);
     let _ = fs::remove_dir_all(&out_dir);
@@ -1148,6 +1154,7 @@ fn document(config: &Config, props: &TestProps,
                         "-o".to_string(),
                         out_dir.to_str().unwrap().to_string(),
                         testfile.to_str().unwrap().to_string()];
+    args.extend(extra_args.iter().cloned());
     args.extend(split_maybe_args(&props.compile_flags));
     let args = ProcArgs {
         prog: config.rustdoc_path.to_str().unwrap().to_string(),
@@ -1710,7 +1717,7 @@ fn charset() -> &'static str {
 }
 
 fn run_rustdoc_test(config: &Config, props: &TestProps, testfile: &Path) {
-    let (proc_res, out_dir) = document(config, props, testfile);
+    let (proc_res, out_dir) = document(config, props, testfile, &[]);
     if !proc_res.status.success() {
         fatal_proc_rec("rustdoc failed!", &proc_res);
     }

branches/beta/src/doc/complement-design-faq.md

@@ -99,7 +99,7 @@ Second, it makes cost explicit. In general, the only safe way to have a
 non-exhaustive match would be to panic the thread if nothing is matched, though
 it could fall through if the type of the `match` expression is `()`. This sort
 of hidden cost and special casing is against the language's philosophy. It's
-easy to ignore all unspecified cases by using the `_` wildcard:
+easy to ignore certain cases by using the `_` wildcard:
 
 ```rust,ignore
 match val.do_something() {

branches/beta/src/doc/reference.md

@@ -338,16 +338,12 @@ type of the literal. The integer suffix must be the name of one of the
 integral types: `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64`,
 `isize`, or `usize`.
 
-The type of an _unsuffixed_ integer literal is determined by type inference:
-
-* If an integer type can be _uniquely_ determined from the surrounding
-  program context, the unsuffixed integer literal has that type.
-
-* If the program context underconstrains the type, it defaults to the
-  signed 32-bit integer `i32`.
-
-* If the program context overconstrains the type, it is considered a
-  static type error.
+The type of an _unsuffixed_ integer literal is determined by type inference.
+If an integer type can be _uniquely_ determined from the surrounding program
+context, the unsuffixed integer literal has that type. If the program context
+underconstrains the type, it defaults to the signed 32-bit integer `i32`; if
+the program context overconstrains the type, it is considered a static type
+error.
 
 Examples of integer literals of various forms:
 
@@ -375,17 +371,12 @@ The suffix forcibly sets the type of the literal. There are two valid
 _floating-point suffixes_, `f32` and `f64` (the 32-bit and 64-bit floating point
 types), which explicitly determine the type of the literal.
 
-The type of an _unsuffixed_ floating-point literal is determined by
-type inference:
-
-* If a floating-point type can be _uniquely_ determined from the
-  surrounding program context, the unsuffixed floating-point literal
-  has that type.
-
-* If the program context underconstrains the type, it defaults to `f64`.
-
-* If the program context overconstrains the type, it is considered a
-  static type error.
+The type of an _unsuffixed_ floating-point literal is determined by type
+inference. If a floating-point type can be _uniquely_ determined from the
+surrounding program context, the unsuffixed floating-point literal has that type.
+If the program context underconstrains the type, it defaults to double-precision `f64`;
+if the program context overconstrains the type, it is considered a static type
+error.
 
 Examples of floating-point literals of various forms:
 
@@ -2515,8 +2506,9 @@ Here are some examples:
 #### Moved and copied types
 
 When a [local variable](#variables) is used as an
-[rvalue](#lvalues,-rvalues-and-temporaries), the variable will be copied
-if its type implements `Copy`. All others are moved.
+[rvalue](#lvalues,-rvalues-and-temporaries) the variable will either be moved
+or copied, depending on its type. All values whose type implements `Copy` are
+copied, all others are moved.
 
 ### Literal expressions
 
@@ -2881,6 +2873,7 @@ operand.
 ```
 # let mut x = 0;
 # let y = 0;
+
 x = y;
 ```
 
@@ -2970,12 +2963,14 @@ move values (depending on their type) from the environment into the lambda
 expression's captured environment.
 
 In this example, we define a function `ten_times` that takes a higher-order
-function argument, and we then call it with a lambda expression as an argument:
+function argument, and call it with a lambda expression as an argument:
 
 ```
 fn ten_times<F>(f: F) where F: Fn(i32) {
-    for index in 0..10 {
-        f(index);
+    let mut i = 0i32;
+    while i < 10 {
+        f(i);
+        i += 1;
     }
 }
 
@@ -3324,13 +3319,10 @@ An example of a tuple type and its use:
 
 ```
 type Pair<'a> = (i32, &'a str);
-let p: Pair<'static> = (10, "ten");
+let p: Pair<'static> = (10, "hello");
 let (a, b) = p;
-
-assert_eq!(a, 10);
-assert_eq!(b, "ten");
-assert_eq!(p.0, 10);
-assert_eq!(p.1, "ten");
+assert!(b != "world");
+assert!(p.0 == 10);
 ```
 
 For historical reasons and convenience, the tuple type with no elements (`()`)
@@ -3340,32 +3332,27 @@ is often called ‘unit’ or ‘the unit type’.
 
 Rust has two different types for a list of items:
 
-* `[T; N]`, an 'array'
-* `&[T]`, a 'slice'
+* `[T; N]`, an 'array'.
+* `&[T]`, a 'slice'.
 
 An array has a fixed size, and can be allocated on either the stack or the
 heap.
 
 A slice is a 'view' into an array. It doesn't own the data it points
 to, it borrows it.
 
-Examples:
+An example of each kind:
 
 ```{rust}
-// A stack-allocated array
-let array: [i32; 3] = [1, 2, 3];
-
-// A heap-allocated array
-let vector: Vec<i32> = vec![1, 2, 3];
-
-// A slice into an array
-let slice: &[i32] = &vector[..];
+let vec: Vec<i32> = vec![1, 2, 3];
+let arr: [i32; 3] = [1, 2, 3];
+let s: &[i32] = &vec[..];
 ```
 
 As you can see, the `vec!` macro allows you to create a `Vec<T>` easily. The
 `vec!` macro is also part of the standard library, rather than the language.
 
-All in-bounds elements of arrays and slices are always initialized, and access
+All in-bounds elements of arrays, and slices are always initialized, and access
 to an array or slice is always bounds-checked.
 
 ### Structure types
@@ -3499,7 +3486,7 @@ x = bo(5,7);
 
 #### Function types for specific items
 
-Internal to the compiler, there are also function types that are specific to a particular
+Internally to the compiler, there are also function types that are specific to a particular
 function item. In the following snippet, for example, the internal types of the functions
 `foo` and `bar` are different, despite the fact that they have the same signature:
 
@@ -3527,14 +3514,13 @@ more of the closure traits:
 
 * `FnMut`
   : The closure can be called multiple times as mutable. A closure called as
-    `FnMut` can mutate values from its environment. `FnMut` inherits from
-    `FnOnce` (i.e. anything implementing `FnMut` also implements `FnOnce`).
+    `FnMut` can mutate values from its environment. `FnMut` implies
+    `FnOnce`.
 
 * `Fn`
   : The closure can be called multiple times through a shared reference.
     A closure called as `Fn` can neither move out from nor mutate values
-    from its environment. `Fn` inherits from `FnMut`, which itself
-    inherits from `FnOnce`.
+    from its environment. `Fn` implies `FnMut` and `FnOnce`.
 
 
 ### Trait objects
@@ -3657,7 +3643,7 @@ Coercions are defined in [RFC401]. A coercion is implicit and has no syntax.
 ### Coercion sites
 
 A coercion can only occur at certain coercion sites in a program; these are
-typically places where the desired type is explicit or can be derived by
+typically places where the desired type is explicit or can be dervied by
 propagation from explicit types (without type inference). Possible coercion
 sites are:
 

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

@@ -38,17 +38,6 @@ fn add_one(x: i32) -> i32 {
 }
 ```
 
-There is another style of doc comment, `//!`, to comment containing items (e.g.
-crates, modules or functions), instead of the items following it. Commonly used
-inside crates root (lib.rs) or modules root (mod.rs):
-
-```
-//! # The Rust Standard Library
-//!
-//! The Rust Standard Library provides the essential runtime
-//! functionality for building portable Rust software.
-```
-
 When writing doc comments, providing some examples of usage is very, very
 helpful. You’ll notice we’ve used a new macro here: `assert_eq!`. This compares
 two values, and `panic!`s if they’re not equal to each other. It’s very helpful

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

@@ -10,12 +10,11 @@ system is up to the task, and gives you powerful ways to reason about
 concurrent code at compile time.
 
 Before we talk about the concurrency features that come with Rust, it's important
-to understand something: Rust is low-level enough that the vast majority of
-this is provided by the standard library, not by the language. This means that
-if you don't like some aspect of the way Rust handles concurrency, you can
-implement an alternative way of doing things.
-[mio](https://github.com/carllerche/mio) is a real-world example of this
-principle in action.
+to understand something: Rust is low-level enough that all of this is provided
+by the standard library, not by the language. This means that if you don't like
+some aspect of the way Rust handles concurrency, you can implement an alternative
+way of doing things. [mio](https://github.com/carllerche/mio) is a real-world
+example of this principle in action.
 
 ## Background: `Send` and `Sync`
 

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

@@ -533,10 +533,19 @@ attribute turns off Rust's name mangling, so that it is easier to link to.
 
 # FFI and panics
 
-It’s important to be mindful of `panic!`s when working with FFI. A `panic!`
-across an FFI boundary is undefined behavior. If you’re writing code that may
-panic, you should run it in another thread, so that the panic doesn’t bubble up
-to C:
+It’s important to be mindful of `panic!`s when working with FFI. This code,
+when called from C, will `abort`:
+
+```rust
+#[no_mangle]
+pub extern fn oh_no() -> ! {
+    panic!("Oops!");
+}
+# fn main() {}
+```
+
+If you’re writing code that may panic, you should run it in another thread,
+so that the panic doesn’t bubble up to C:
 
 ```rust
 use std::thread;