---

yaml
---
r: 272980
b: refs/heads/beta
c: 99eee83
h: refs/heads/master

Author: nathankleyn

[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: 3820d38e90127c9542d11a5677a2a0ec7804aacb
+refs/heads/beta: 99eee832e035895e62d0ac52608e63199d80a35a
 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,8 +84,8 @@ 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_ext := syntax fmt_macros

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/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 }

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