---

yaml
---
r: 272991
b: refs/heads/beta
c: d961323
h: refs/heads/master
i:
  272989: f6a0ce2
  272987: c2c999e
  272983: 86d4d92
  272975: e528058
  272959: 9df4812

Author: SimonSapin

[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: 6d6ae1ffe665610ae235dd95e849248a6741ff0f
+refs/heads/beta: d9613237fd1736fa8e9ce95686d85463a38dc976
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/mk/crates.mk

@@ -49,17 +49,16 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := libc std term \
-                 getopts collections test rand \
-                 core alloc \
+TARGET_CRATES := libc std flate arena term \
+                 serialize getopts collections test rand \
+                 log graphviz core rbml alloc \
                  rustc_unicode rustc_bitflags \
 		 alloc_system alloc_jemalloc
 RUSTC_CRATES := rustc rustc_typeck rustc_mir rustc_borrowck rustc_resolve rustc_driver \
                 rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
                 rustc_data_structures rustc_front rustc_platform_intrinsics \
                 rustc_plugin rustc_metadata rustc_passes
-HOST_CRATES := syntax syntax_ext $(RUSTC_CRATES) rustdoc fmt_macros \
-		flate arena graphviz rbml log serialize
+HOST_CRATES := syntax syntax_ext $(RUSTC_CRATES) rustdoc fmt_macros
 TOOLS := compiletest rustdoc rustc rustbook error_index_generator
 
 DEPS_core :=
@@ -85,10 +84,10 @@ DEPS_log := std
 DEPS_num := std
 DEPS_rbml := std log serialize
 DEPS_serialize := std log
-DEPS_term := std
-DEPS_test := std getopts term native:rust_test_helpers
+DEPS_term := std log
+DEPS_test := std getopts serialize rbml term native:rust_test_helpers
 
-DEPS_syntax := std term serialize log arena libc rustc_bitflags rustc_unicode
+DEPS_syntax := std term serialize log arena libc rustc_bitflags
 DEPS_syntax_ext := syntax fmt_macros
 
 DEPS_rustc := syntax fmt_macros flate arena serialize getopts rbml rustc_front\

branches/beta/mk/tests.mk

@@ -299,6 +299,9 @@ check-stage$(1)-T-$(2)-H-$(3)-exec: \
 	check-stage$(1)-T-$(2)-H-$(3)-cfail-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-pfail-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-rpass-valgrind-exec \
+	check-stage$(1)-T-$(2)-H-$(3)-rpass-full-exec \
+	check-stage$(1)-T-$(2)-H-$(3)-rfail-full-exec \
+	check-stage$(1)-T-$(2)-H-$(3)-cfail-full-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-rmake-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-rustdocck-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-crates-exec \
@@ -314,15 +317,6 @@ check-stage$(1)-T-$(2)-H-$(3)-exec: \
 # able to build a compiler (when the target triple is in the set of host triples)
 ifneq ($$(findstring $(2),$$(CFG_HOST)),)
 
-check-stage$(1)-T-$(2)-H-$(3)-exec: \
-	check-stage$(1)-T-$(2)-H-$(3)-rpass-full-exec \
-	check-stage$(1)-T-$(2)-H-$(3)-rfail-full-exec \
-	check-stage$(1)-T-$(2)-H-$(3)-cfail-full-exec
-
-check-stage$(1)-T-$(2)-H-$(3)-pretty-exec: \
-	check-stage$(1)-T-$(2)-H-$(3)-pretty-rpass-full-exec \
-	check-stage$(1)-T-$(2)-H-$(3)-pretty-rfail-full-exec
-
 check-stage$(1)-T-$(2)-H-$(3)-crates-exec: \
 	$$(foreach crate,$$(TEST_CRATES), \
            check-stage$(1)-T-$(2)-H-$(3)-$$(crate)-exec)
@@ -346,7 +340,9 @@ check-stage$(1)-T-$(2)-H-$(3)-doc-exec: \
 check-stage$(1)-T-$(2)-H-$(3)-pretty-exec: \
 	check-stage$(1)-T-$(2)-H-$(3)-pretty-rpass-exec \
     check-stage$(1)-T-$(2)-H-$(3)-pretty-rpass-valgrind-exec \
+	check-stage$(1)-T-$(2)-H-$(3)-pretty-rpass-full-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-pretty-rfail-exec \
+	check-stage$(1)-T-$(2)-H-$(3)-pretty-rfail-full-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-pretty-pretty-exec
 
 endef

branches/beta/src/bootstrap/bootstrap.py

@@ -73,8 +73,7 @@ def download_rust_nightly(self):
 
         if self.rustc().startswith(self.bin_root()) and \
            (not os.path.exists(self.rustc()) or self.rustc_out_of_date()):
-            if os.path.exists(self.bin_root()):
-                shutil.rmtree(self.bin_root())
+            shutil.rmtree(self.bin_root())
             filename = "rust-std-nightly-" + self.build + ".tar.gz"
             url = "https://static.rust-lang.org/dist/" + self.snap_rustc_date()
             tarball = os.path.join(rustc_cache, filename)

branches/beta/src/bootstrap/build/compile.rs

@@ -83,19 +83,6 @@ pub fn std_link(build: &Build,
                          libdir.join(staticlib("compiler-rt", target))));
     }
     add_to_sysroot(&out_dir, &libdir);
-
-    if target.contains("musl") && (target.contains("x86_64") || target.contains("i686")) {
-        copy_third_party_objects(build, target, &libdir);
-    }
-}
-
-/// Copies the crt(1,i,n).o startup objects
-///
-/// Only required for musl targets that statically link to libc
-fn copy_third_party_objects(build: &Build, target: &str, into: &Path) {
-    for &obj in &["crt1.o", "crti.o", "crtn.o"] {
-        t!(fs::copy(compiler_file(build.cc(target), obj), into.join(obj)));
-    }
 }
 
 /// Build and prepare startup objects like rsbegin.o and rsend.o

branches/beta/src/bootstrap/build/sanity.rs

@@ -79,7 +79,7 @@ pub fn check(build: &mut Build) {
         }
 
         // Make sure musl-root is valid if specified
-        if target.contains("musl") && (target.contains("x86_64") || target.contains("i686")) {
+        if target.contains("musl") && target.contains("x86_64") {
             match build.config.musl_root {
                 Some(ref root) => {
                     if fs::metadata(root.join("lib/libc.a")).is_err() {

branches/beta/src/doc/book/guessing-game.md

@@ -295,7 +295,7 @@ Rust warns us that we haven’t used the `Result` value. This warning comes from
 a special annotation that `io::Result` has. Rust is trying to tell you that
 you haven’t handled a possible error. The right way to suppress the error is
 to actually write error handling. Luckily, if we want to crash if there’s
-a problem, we can use `expect()`. If we can recover from the
+a problem, we can use these two little methods. If we can recover from the
 error somehow, we’d do something else, but we’ll save that for a future
 project.
 

branches/beta/src/doc/book/inline-assembly.md

@@ -2,7 +2,8 @@
 
 For extremely low-level manipulations and performance reasons, one
 might wish to control the CPU directly. Rust supports using inline
-assembly to do this via the `asm!` macro.
+assembly to do this via the `asm!` macro. The syntax roughly matches
+that of GCC & Clang:
 
 ```ignore
 asm!(assembly template

branches/beta/src/doc/book/ownership.md

@@ -51,7 +51,7 @@ fn foo() {
 }
 ```
 
-When `v` comes into scope, a new [vector][vectors] is created on [the stack][stack],
+When `v` comes into scope, a new [vector] is created on [the stack][stack],
 and it allocates space on [the heap][heap] for its elements. When `v` goes out
 of scope at the end of `foo()`, Rust will clean up everything related to the
 vector, even the heap-allocated memory. This happens deterministically, at the

branches/beta/src/doc/book/references-and-borrowing.md

@@ -23,7 +23,7 @@ Before we get to the details, two important notes about the ownership system.
 Rust has a focus on safety and speed. It accomplishes these goals through many
 ‘zero-cost abstractions’, which means that in Rust, abstractions cost as little
 as possible in order to make them work. The ownership system is a prime example
-of a zero-cost abstraction. All of the analysis we’ll talk about in this guide
+of a zero cost abstraction. All of the analysis we’ll talk about in this guide
 is _done at compile time_. You do not pay any run-time cost for any of these
 features.
 

branches/beta/src/doc/book/syntax-index.md

@@ -43,23 +43,23 @@
 * `!` (`!expr`): bitwise or logical complement.  Overloadable (`Not`).
 * `!=` (`var != expr`): nonequality comparison.  Overloadable (`PartialEq`).
 * `%` (`expr % expr`): arithmetic remainder.  Overloadable (`Rem`).
-* `%=` (`var %= expr`): arithmetic remainder & assignment. Overloadable (`RemAssign`).
+* `%=` (`var %= expr`): arithmetic remainder & assignment.
 * `&` (`expr & expr`): bitwise and.  Overloadable (`BitAnd`).
 * `&` (`&expr`): borrow.  See [References and Borrowing].
 * `&` (`&type`, `&mut type`, `&'a type`, `&'a mut type`): borrowed pointer type.  See [References and Borrowing].
-* `&=` (`var &= expr`): bitwise and & assignment. Overloadable (`BitAndAssign`).
+* `&=` (`var &= expr`): bitwise and & assignment.
 * `&&` (`expr && expr`): logical and.
 * `*` (`expr * expr`): arithmetic multiplication.  Overloadable (`Mul`).
 * `*` (`*expr`): dereference.
 * `*` (`*const type`, `*mut type`): raw pointer.  See [Raw Pointers].
-* `*=` (`var *= expr`): arithmetic multiplication & assignment. Overloadable (`MulAssign`).
+* `*=` (`var *= expr`): arithmetic multiplication & assignment.
 * `+` (`expr + expr`): arithmetic addition.  Overloadable (`Add`).
 * `+` (`trait + trait`, `'a + trait`): compound type constraint.  See [Traits (Multiple Trait Bounds)].
-* `+=` (`var += expr`): arithmetic addition & assignment. Overloadable (`AddAssign`).
+* `+=` (`var += expr`): arithmetic addition & assignment.
 * `,`: argument and element separator.  See [Attributes], [Functions], [Structs], [Generics], [Match], [Closures], [Crates and Modules (Importing Modules with `use`)].
 * `-` (`expr - expr`): arithmetic subtraction.  Overloadable (`Sub`).
 * `-` (`- expr`): arithmetic negation.  Overloadable (`Neg`).
-* `-=` (`var -= expr`): arithmetic subtraction & assignment. Overloadable (`SubAssign`).
+* `-=` (`var -= expr`): arithmetic subtraction & assignment.
 * `->` (`fn(…) -> type`, `|…| -> type`): function and closure return type.  See [Functions], [Closures].
 * `-> !` (`fn(…) -> !`, `|…| -> !`): diverging function or closure. See [Diverging Functions].
 * `.` (`expr.ident`): member access.  See [Structs], [Method Syntax].
@@ -69,14 +69,14 @@
 * `...` (`...expr`, `expr...expr`) *in an expression*: inclusive range expression. See [Iterators].
 * `...` (`expr...expr`) *in a pattern*: inclusive range pattern.  See [Patterns (Ranges)].
 * `/` (`expr / expr`): arithmetic division.  Overloadable (`Div`).
-* `/=` (`var /= expr`): arithmetic division & assignment. Overloadable (`DivAssign`).
+* `/=` (`var /= expr`): arithmetic division & assignment.
 * `:` (`pat: type`, `ident: type`): constraints.  See [Variable Bindings], [Functions], [Structs], [Traits].
 * `:` (`ident: expr`): struct field initializer.  See [Structs].
 * `:` (`'a: loop {…}`): loop label.  See [Loops (Loops Labels)].
 * `;`: statement and item terminator.
 * `;` (`[…; len]`): part of fixed-size array syntax.  See [Primitive Types (Arrays)].
 * `<<` (`expr << expr`): left-shift.  Overloadable (`Shl`).
-* `<<=` (`var <<= expr`): left-shift & assignment. Overloadable (`ShlAssign`).
+* `<<=` (`var <<= expr`): left-shift & assignment.
 * `<` (`expr < expr`): less-than comparison.  Overloadable (`PartialOrd`).
 * `<=` (`var <= expr`): less-than or equal-to comparison.  Overloadable (`PartialOrd`).
 * `=` (`var = expr`, `ident = type`): assignment/equivalence.  See [Variable Bindings], [`type` Aliases], generic parameter defaults.
@@ -85,14 +85,14 @@
 * `>` (`expr > expr`): greater-than comparison.  Overloadable (`PartialOrd`).
 * `>=` (`var >= expr`): greater-than or equal-to comparison.  Overloadable (`PartialOrd`).
 * `>>` (`expr >> expr`): right-shift.  Overloadable (`Shr`).
-* `>>=` (`var >>= expr`): right-shift & assignment. Overloadable (`ShrAssign`).
+* `>>=` (`var >>= expr`): right-shift & assignment.
 * `@` (`ident @ pat`): pattern binding.  See [Patterns (Bindings)].
 * `^` (`expr ^ expr`): bitwise exclusive or.  Overloadable (`BitXor`).
-* `^=` (`var ^= expr`): bitwise exclusive or & assignment. Overloadable (`BitXorAssign`).
+* `^=` (`var ^= expr`): bitwise exclusive or & assignment.
 * `|` (`expr | expr`): bitwise or.  Overloadable (`BitOr`).
 * `|` (`pat | pat`): pattern alternatives.  See [Patterns (Multiple patterns)].
 * `|` (`|…| expr`): closures.  See [Closures].
-* `|=` (`var |= expr`): bitwise or & assignment. Overloadable (`BitOrAssign`).
+* `|=` (`var |= expr`): bitwise or & assignment.
 * `||` (`expr || expr`): logical or.
 * `_`: "ignored" pattern binding.  See [Patterns (Ignoring bindings)].
 

branches/beta/src/doc/book/testing.md

@@ -515,3 +515,7 @@ you add more examples.
 
 We haven’t covered all of the details with writing documentation tests. For more,
 please see the [Documentation chapter](documentation.html).
+
+One final note: documentation tests *cannot* be run on binary crates.
+To see more on file arrangement see the [Crates and
+Modules](crates-and-modules.html) section.

branches/beta/src/doc/reference.md

@@ -1118,16 +1118,6 @@ type Point = (u8, u8);
 let p: Point = (41, 68);
 ```
 
-Currently a type alias to an enum type cannot be used to qualify the
-constructors:
-
-```
-enum E { A }
-type F = E;
-let _: F = E::A;  // OK
-// let _: F = F::A;  // Doesn't work
-```
-
 ### Structs
 
 A _struct_ is a nominal [struct type](#struct-types) defined with the
@@ -1205,24 +1195,18 @@ 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.
 
-Each enum value has a _discriminant_ which is an integer associated to it. You
-can specify it explicitly:
+Enums have a discriminant. You can assign them explicitly:
 
 ```
 enum Foo {
     Bar = 123,
 }
 ```
 
-The right hand side of the specification is interpreted as an `isize` value,
-but the compiler is allowed to use a smaller type in the actual memory layout.
-The [`repr` attribute](#ffi-attributes) can be added in order to change
-the type of the right hand side and specify the memory layout.
-
-If a discriminant isn't specified, they start at zero, and add one for each
+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 its discriminant:
+You can cast an enum to get this value:
 
 ```
 # enum Foo { Bar = 123 }
@@ -3328,10 +3312,6 @@ The primitive types are the following:
 * The boolean type `bool` with values `true` and `false`.
 * The machine types (integer and floating-point).
 * The machine-dependent integer types.
-* Arrays
-* Tuples
-* Slices
-* Function pointers
 
 #### Machine types
 

branches/beta/src/etc/unicode.py

@@ -398,7 +398,7 @@ def emit_norm_module(f, canon, compat, combine, norm_props):
         derived = load_properties("DerivedCoreProperties.txt", want_derived)
         scripts = load_properties("Scripts.txt", [])
         props = load_properties("PropList.txt",
-                ["White_Space", "Join_Control", "Noncharacter_Code_Point", "Pattern_White_Space"])
+                ["White_Space", "Join_Control", "Noncharacter_Code_Point"])
         norm_props = load_properties("DerivedNormalizationProps.txt",
                      ["Full_Composition_Exclusion"])
 
@@ -408,7 +408,7 @@ def emit_norm_module(f, canon, compat, combine, norm_props):
         # category tables
         for (name, cat, pfuns) in ("general_category", gencats, ["N", "Cc"]), \
                                   ("derived_property", derived, want_derived), \
-                                  ("property", props, ["White_Space", "Pattern_White_Space"]):
+                                  ("property", props, ["White_Space"]):
             emit_property_module(rf, name, cat, pfuns)
 
         # normalizations and conversions module

branches/beta/src/liballoc/arc.rs

@@ -201,12 +201,11 @@ impl<T> Arc<T> {
         Arc { _ptr: unsafe { Shared::new(Box::into_raw(x)) } }
     }
 
-    /// Unwraps the contained value if the `Arc<T>` has exactly one strong reference.
+    /// Unwraps the contained value if the `Arc<T>` has only one strong reference.
+    /// This will succeed even if there are outstanding weak references.
     ///
     /// Otherwise, an `Err` is returned with the same `Arc<T>`.
     ///
-    /// This will succeed even if there are outstanding weak references.
-    ///
     /// # Examples
     ///
     /// ```

branches/beta/src/liballoc/lib.rs

@@ -92,13 +92,16 @@
 #![feature(unsize)]
 
 #![cfg_attr(not(test), feature(raw, fn_traits, placement_new_protocol))]
-#![cfg_attr(test, feature(test, box_heap))]
+#![cfg_attr(test, feature(test, rustc_private, box_heap))]
 
 // Allow testing this library
 
 #[cfg(test)]
 #[macro_use]
 extern crate std;
+#[cfg(test)]
+#[macro_use]
+extern crate log;
 
 // Heaps provided for low-level allocation strategies
 

branches/beta/src/liballoc/rc.rs

@@ -224,12 +224,11 @@ impl<T> Rc<T> {
         }
     }
 
-    /// Unwraps the contained value if the `Rc<T>` has exactly one strong reference.
+    /// Unwraps the contained value if the `Rc<T>` has only one strong reference.
+    /// This will succeed even if there are outstanding weak references.
     ///
     /// Otherwise, an `Err` is returned with the same `Rc<T>`.
     ///
-    /// This will succeed even if there are outstanding weak references.
-    ///
     /// # Examples
     ///
     /// ```

branches/beta/src/liballoc_jemalloc/build.rs

@@ -111,7 +111,7 @@ fn main() {
     println!("cargo:rustc-link-search=native={}/lib", build_dir.display());
     if target.contains("android") {
         println!("cargo:rustc-link-lib=gcc");
-    } else if !target.contains("windows") && !target.contains("musl") {
+    } else if !target.contains("windows") {
         println!("cargo:rustc-link-lib=pthread");
     }
 }