---

yaml
---
r: 218156
b: refs/heads/tmp
c: f2fc920
h: refs/heads/master
v: v3

Author: emberian

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: 18adf6230e2e229d4d73391cebff060afc5e5aaa
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 539cc55018da6505b532dbdfb9f60e04f50a9250
+refs/heads/tmp: f2fc9209d05f4e6f59c289635af2d107e40a51f5
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: e6596d0052e79e6393bbee3538bb122930d89887
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/README.md

@@ -4,7 +4,7 @@ Rust is a fast systems programming language that guarantees
 memory safety and offers painless concurrency ([no data races]).
 It does not employ a garbage collector and has minimal runtime overhead.
 
-This repo contains the code for the compiler (`rustc`), as well
+This repo contains the code for `rustc`, the Rust compiler, as well
 as standard libraries, tools and documentation for Rust.
 
 [no data races]: http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html
@@ -73,7 +73,7 @@ Read ["Installing Rust"] from [The Book].
    ```
 
 3. Run `mingw32_shell.bat` or `mingw64_shell.bat` from wherever you installed
-   MSYS2 (i.e. `C:\msys`), depending on whether you want 32-bit or 64-bit Rust.
+   MYSY2 (i.e. `C:\msys`), depending on whether you want 32-bit or 64-bit Rust.
 
 4. Navigate to Rust's source code, configure and build it:
 

branches/tmp/configure

@@ -405,10 +405,6 @@ case $CFG_OSTYPE in
         CFG_OSTYPE=unknown-openbsd
        ;;
 
-    NetBSD)
-	    CFG_OSTYPE=unknown-netbsd
-	    ;;
-
     Darwin)
         CFG_OSTYPE=apple-darwin
         ;;

branches/tmp/mk/cfg/x86_64-unknown-netbsd.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/tmp/mk/main.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/tmp/mk/target.mk

@@ -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/tmp/src/compiletest/runtest.rs

@@ -21,7 +21,6 @@ const OS_TABLE: &'static [(&'static str, &'static str)] = &[
     ("ios", "ios"),
     ("linux", "linux"),
     ("mingw32", "windows"),
-    ("netbsd", "netbsd"),
     ("openbsd", "openbsd"),
     ("win32", "windows"),
     ("windows", "windows"),

branches/tmp/src/compiletest/util.rs

@@ -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:
 
@@ -2032,7 +2023,7 @@ The following configurations must be defined by the implementation:
   as a configuration itself, like `unix` or `windows`.
 * `target_os = "..."`. Operating system of the target, examples include
   `"windows"`, `"macos"`, `"ios"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"`,
-  `"bitrig"` , `"openbsd"` or `"netbsd"`.
+  `"bitrig"` or `"openbsd"`.
 * `target_pointer_width = "..."`. Target pointer width in bits. This is set
   to `"32"` for targets with 32-bit pointers, and likewise set to `"64"` for
   64-bit pointers.
@@ -2972,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;
     }
 }
 
@@ -3326,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 (`()`)
@@ -3342,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
@@ -3501,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:
 
@@ -3529,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
@@ -3659,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/tmp/src/doc/reference.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/tmp/src/doc/trpl/comments.md

@@ -33,10 +33,8 @@ pub fn new(value: T) -> Rc<T> {
 ```
 
 This code generates documentation that looks [like this][rc-new]. I've left the
-implementation out, with a regular comment in its place.
-
-The first thing to notice about this annotation is that it uses
-`///` instead of `//`. The triple slash
+implementation out, with a regular comment in its place. That's the first thing
+to notice about this annotation: it uses `///`, instead of `//`. The triple slash
 indicates a documentation comment.
 
 Documentation comments are written in Markdown.
@@ -377,7 +375,7 @@ $ rustdoc --test path/to/my/crate/root.rs
 $ cargo test
 ```
 
-That's right, `cargo test` tests embedded documentation too. However,
+That's right, `cargo test` tests embedded documentation too. However, 
 `cargo test` will not test binary crates, only library ones. This is
 due to the way `rustdoc` works: it links against the library to be tested,
 but with a binary, there’s nothing to link to.

branches/tmp/src/doc/trpl/documentation.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;

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

@@ -17,7 +17,7 @@ Note that this feature is currently hidden behind the `feature(link_args)` gate
 because this is not a sanctioned way of performing linking. Right now rustc
 shells out to the system linker, so it makes sense to provide extra command line
 arguments, but this will not always be the case. In the future rustc may use
-LLVM directly to link native libraries, in which case `link_args` will have no
+LLVM directly to link native libraries in which case `link_args` will have no
 meaning.
 
 It is highly recommended to *not* use this attribute, and rather use the more