---

yaml
---
r: 218233
b: refs/heads/master
c: 9f4d5b4
h: refs/heads/master
i:
  218231: 7d974d2
v: v3

Author: dotdash

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: afe25a2d6aaa308cce861fab50014f6a9f57a269
+refs/heads/master: 9f4d5b4be10ce9683569a0bd55f555d30f70b5a5
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

trunk/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`

trunk/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),

trunk/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)))))))

trunk/src/compiletest/runtest.rs

@@ -1702,11 +1702,8 @@ fn run_codegen_test(config: &Config, props: &TestProps, testfile: &Path) {
 }
 
 fn charset() -> &'static str {
-    // FreeBSD 10.1 defaults to GDB 6.1.1 which doesn't support "auto" charset
-    if cfg!(target_os = "bitrig") {
+    if cfg!(any(target_os = "bitrig", target_os = "freebsd")) {
         "auto"
-    } else if cfg!(target_os = "freebsd") {
-        "ISO-8859-1"
     } else {
         "UTF-8"
     }

trunk/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() {

trunk/src/doc/reference.md

@@ -2515,8 +2515,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 +2882,7 @@ operand.
 ```
 # let mut x = 0;
 # let y = 0;
+
 x = y;
 ```
 

trunk/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`
 

trunk/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;

trunk/src/doc/trpl/guessing-game.md

@@ -360,12 +360,10 @@ rand="0.3.0"
 The `[dependencies]` section of `Cargo.toml` is like the `[package]` section:
 everything that follows it is part of it, until the next section starts.
 Cargo uses the dependencies section to know what dependencies on external
-crates you have, and what versions you require. In this case, we’ve specified version `0.3.0`,
-which Cargo understands to be any release that’s compatible with this specific version.
+crates you have, and what versions you require. In this case, we’ve used version `0.3.0`.
 Cargo understands [Semantic Versioning][semver], which is a standard for writing version
-numbers. If we wanted to use only `0.3.0` exactly, we could use `=0.3.0`. If we
-wanted to use the latest version we could use `*`; We could use a range of
-versions. [Cargo’s documentation][cargodoc] contains more details.
+numbers. If we wanted to use the latest version we could use `*` or we could use a range
+of versions. [Cargo’s documentation][cargodoc] contains more details.
 
 [semver]: http://semver.org
 [cargodoc]: http://doc.crates.io/crates-io.html

trunk/src/doc/trpl/lifetimes.md

@@ -101,8 +101,6 @@ the lifetime `'a` has snuck in between the `&` and the `mut i32`. We read `&mut
 i32` as ‘a mutable reference to an i32’ and `&'a mut i32` as ‘a mutable
 reference to an `i32` with the lifetime `'a`’.
 
-# In `struct`s
-
 You’ll also need explicit lifetimes when working with [`struct`][structs]s:
 
 ```rust
@@ -139,33 +137,6 @@ x: &'a i32,
 uses it. So why do we need a lifetime here? We need to ensure that any reference
 to a `Foo` cannot outlive the reference to an `i32` it contains.
 
-## `impl` blocks
-
-Let’s implement a method on `Foo`:
-
-```rust
-struct Foo<'a> {
-    x: &'a i32,
-}
-
-impl<'a> Foo<'a> {
-    fn x(&self) -> &'a i32 { self.x }
-}
-
-fn main() {
-    let y = &5; // this is the same as `let _y = 5; let y = &_y;`
-    let f = Foo { x: y };
-
-    println!("x is: {}", f.x());
-}
-```
-
-As you can see, we need to declare a lifetime for `Foo` in the `impl` line. We repeat
-`'a` twice, just like on functions: `impl<'a>` defines a lifetime `'a`, and `Foo<'a>`
-uses it.
-
-## Multiple lifetimes
-
 If you have multiple references, you can use the same lifetime multiple times:
 
 ```rust

trunk/src/doc/trpl/patterns.md

@@ -282,38 +282,6 @@ This ‘destructuring’ behavior works on any compound data type, like
 [tuples]: primitive-types.html#tuples
 [enums]: enums.html
 
-# Ignoring bindings
-
-You can use `_` in a pattern to disregard the value. For example, here’s a
-`match` against a `Result<T, E>`:
-
-```rust
-# let some_value: Result<i32, &'static str> = Err("There was an error");
-match some_value {
-    Ok(value) => println!("got a value: {}", value),
-    Err(_) => println!("an error occurred"),
-}
-```
-
-In the first arm, we bind the value inside the `Ok` variant to `value`. But
-in the `Err` arm, we use `_` to disregard the specific error, and just print
-a general error message.
-
-`_` is valid in any pattern that creates a binding. This can be useful to
-ignore parts of a larger structure:
-
-```rust
-fn coordinate() -> (i32, i32, i32) {
-    // generate and return some sort of triple tuple
-# (1, 2, 3)
-}
-
-let (x, _, z) = coordinate();
-```
-
-Here, we bind the first and last element of the tuple to `x` and `z`, but
-ignore the middle element.
-
 # Mix and Match
 
 Whew! That’s a lot of different ways to match things, and they can all be

trunk/src/doc/trpl/unsafe.md

@@ -8,7 +8,7 @@ this, Rust has a keyword, `unsafe`. Code using `unsafe` has less restrictions
 than normal code does.
 
 Let’s go over the syntax, and then we’ll talk semantics. `unsafe` is used in
-four contexts. The first one is to mark a function as unsafe:
+two contexts. The first one is to mark a function as unsafe:
 
 ```rust
 unsafe fn danger_will_robinson() {
@@ -27,40 +27,15 @@ unsafe {
 }
 ```
 
-The third is for unsafe traits:
-
-```rust
-unsafe trait Scary { }
-```
-
-And the fourth is for `impl`ementing one of those traits:
-
-```rust
-# unsafe trait Scary { }
-unsafe impl Scary for i32 {}
-```
-
 It’s important to be able to explicitly delineate code that may have bugs that
 cause big problems. If a Rust program segfaults, you can be sure it’s somewhere
 in the sections marked `unsafe`.
 
 # What does ‘safe’ mean?
 
-Safe, in the context of Rust, means ‘doesn’t do anything unsafe’. It’s also
-important to know that there are certain behaviors that are probably not
-desirable in your code, but are expressly _not_ unsafe:
+Safe, in the context of Rust, means “doesn’t do anything unsafe.” Easy!
 
-* Deadlocks
-* Leaks of memory or other resources
-* Exiting without calling destructors
-* Integer overflow
-
-Rust cannot prevent all kinds of software problems. Buggy code can and will be
-written in Rust. These things aren’t great, but they don’t qualify as `unsafe`
-specifically.
-
-In addition, the following are all undefined behaviors in Rust, and must be
-avoided, even when writing `unsafe` code:
+Okay, let’s try again: what is not safe to do? Here’s a list:
 
 * Data races
 * Dereferencing a null/dangling raw pointer
@@ -89,6 +64,18 @@ avoided, even when writing `unsafe` code:
 [undef]: http://llvm.org/docs/LangRef.html#undefined-values
 [aliasing]: http://llvm.org/docs/LangRef.html#pointer-aliasing-rules
 
+Whew! That’s a bunch of stuff. It’s also important to notice all kinds of
+behaviors that are certainly bad, but are expressly _not_ unsafe:
+
+* Deadlocks
+* Leaks of memory or other resources
+* Exiting without calling destructors
+* Integer overflow
+
+Rust cannot prevent all kinds of software problems. Buggy code can and will be
+written in Rust. These things aren’t great, but they don’t qualify as `unsafe`
+specifically.
+
 # Unsafe Superpowers
 
 In both unsafe functions and unsafe blocks, Rust will let you do three things

trunk/src/etc/mklldeps.py

@@ -14,9 +14,10 @@
 
 f = open(sys.argv[1], 'wb')
 
-components = sys.argv[2].split() # splits on whitespace
+components = sys.argv[2].split(' ')
+components = [i for i in components if i]  # ignore extra whitespaces
 enable_static = sys.argv[3]
-llvm_config = sys.argv[4]
+llconfig = sys.argv[4]
 
 f.write("""// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
@@ -38,15 +39,15 @@ def run(args):
     out, err = proc.communicate()
 
     if err:
-        print("failed to run llvm_config: args = `{}`".format(args))
+        print("failed to run llconfig: args = `{}`".format(args))
         print(err)
         sys.exit(1)
     return out
 
 f.write("\n")
 
 # LLVM libs
-args = [llvm_config, '--libs', '--system-libs']
+args = [llconfig, '--libs', '--system-libs']
 
 args.extend(components)
 out = run(args)
@@ -68,13 +69,13 @@ def run(args):
     f.write(")]\n")
 
 # LLVM ldflags
-out = run([llvm_config, '--ldflags'])
+out = run([llconfig, '--ldflags'])
 for lib in out.strip().split(' '):
     if lib[:2] == "-l":
         f.write("#[link(name = \"" + lib[2:] + "\")]\n")
 
 # C++ runtime library
-out = run([llvm_config, '--cxxflags'])
+out = run([llconfig, '--cxxflags'])
 if enable_static == '1':
     assert('stdlib=libc++' not in out)
     f.write("#[link(name = \"stdc++\", kind = \"static\")]\n")

trunk/src/liballoc/lib.rs

@@ -148,5 +148,4 @@ pub fn oom() -> ! {
 //                optimize it out).
 #[doc(hidden)]
 #[unstable(feature = "issue_14344_fixme")]
-#[cfg(stage0)]
 pub fn fixme_14344_be_sure_to_link_to_collections() {}

trunk/src/libcollections/lib.rs

@@ -138,7 +138,6 @@ pub mod btree_set {
 // FIXME(#14344) this shouldn't be necessary
 #[doc(hidden)]
 #[unstable(feature = "issue_14344_fixme")]
-#[cfg(stage0)]
 pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
 #[cfg(not(test))]