---

yaml
---
r: 193530
b: refs/heads/beta
c: 96b1f0c
h: refs/heads/master
v: v3

Author: wesleywiser

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: ae16afb9e3ea783e50d810cfac8035ad03e628a4
+refs/heads/beta: 96b1f0c0be849d785cb4597ea9a8d088c3a2adf4
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

branches/beta/mk/main.mk

@@ -18,7 +18,7 @@ CFG_RELEASE_NUM=1.0.0
 # An optional number to put after the label, e.g. '.2' -> '-beta.2'
 # NB Make sure it starts with a dot to conform to semver pre-release
 # versions (section 9)
-CFG_PRERELEASE_VERSION=
+CFG_PRERELEASE_VERSION=.2
 
 CFG_FILENAME_EXTRA=4e7c5e5c
 
@@ -30,8 +30,8 @@ CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),beta)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
+CFG_RELEASE=$(CFG_RELEASE_NUM)-alpha$(CFG_PRERELEASE_VERSION)
+CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-alpha$(CFG_PRERELEASE_VERSION)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),nightly)

branches/beta/mk/tests.mk

@@ -590,7 +590,7 @@ TEST_SREQ$(1)_T_$(2)_H_$(3) = \
 
 # The tests select when to use debug configuration on their own;
 # remove directive, if present, from CFG_RUSTC_FLAGS (issue #7898).
-CTEST_RUSTC_FLAGS := $$(subst -C debug-assertions,,$$(CFG_RUSTC_FLAGS))
+CTEST_RUSTC_FLAGS := $$(subst --cfg ndebug,,$$(CFG_RUSTC_FLAGS))
 
 # The tests cannot be optimized while the rest of the compiler is optimized, so
 # filter out the optimization (if any) from rustc and then figure out if we need

branches/beta/src/compiletest/compiletest.rs

@@ -24,8 +24,8 @@
 #![feature(path)]
 #![feature(os)]
 #![feature(io)]
+#![feature(fs)]
 #![feature(net)]
-#![feature(path_ext)]
 
 #![deny(warnings)]
 

branches/beta/src/doc/guide-tasks.md

@@ -1,4 +1,4 @@
 % The (old) Rust Threads and Communication Guide
 
 This content has moved into
-[the Rust Programming Language book](book/concurrency.html).
+[the Rust Programming Language book](book/tasks.html).

branches/beta/src/doc/reference.md

@@ -2555,14 +2555,6 @@ The currently implemented features of the reference compiler are:
                             types, e.g. as the return type of a public function.
                             This capability may be removed in the future.
 
-* `allow_internal_unstable` - Allows `macro_rules!` macros to be tagged with the
-                              `#[allow_internal_unstable]` attribute, designed
-                              to allow `std` macros to call
-                              `#[unstable]`/feature-gated functionality
-                              internally without imposing on callers
-                              (i.e. making them behave like function calls in
-                              terms of encapsulation).
-
 If a feature is promoted to a language feature, then all existing programs will
 start to receive compilation warnings about #[feature] directives which enabled
 the new feature (because the directive is no longer necessary). However, if a

branches/beta/src/doc/trpl/arrays-vectors-and-slices.md

@@ -60,12 +60,6 @@ let v = vec![1, 2, 3]; // v: Vec<i32>
 brackets `[]` with `vec!`. Rust allows you to use either in either situation,
 this is just convention.)
 
-There's an alternate form of `vec!` for repeating an initial value:
-
-```
-let v = vec![0; 10]; // ten zeroes
-```
-
 You can get the length of, iterate over, and subscript vectors just like
 arrays. In addition, (mutable) vectors can grow automatically:
 

branches/beta/src/liballoc/lib.rs

@@ -56,8 +56,6 @@
 //! The [`heap`](heap/index.html) module defines the low-level interface to the
 //! default global allocator. It is not compatible with the libc allocator API.
 
-// Do not remove on snapshot creation. Needed for bootstrap. (Issue #22364)
-#![cfg_attr(stage0, feature(custom_attribute))]
 #![crate_name = "alloc"]
 #![unstable(feature = "alloc")]
 #![feature(staged_api)]

branches/beta/src/libarena/lib.rs

@@ -19,8 +19,6 @@
 //! arena but can only hold objects of a single type, and `Arena`, which is a
 //! more complex, slower arena which can hold objects of any type.
 
-// Do not remove on snapshot creation. Needed for bootstrap. (Issue #22364)
-#![cfg_attr(stage0, feature(custom_attribute))]
 #![crate_name = "arena"]
 #![unstable(feature = "rustc_private")]
 #![staged_api]

branches/beta/src/libcollections/lib.rs

@@ -12,8 +12,7 @@
 //!
 //! See [std::collections](../std/collections) for a detailed discussion of collections in Rust.
 
-// Do not remove on snapshot creation. Needed for bootstrap. (Issue #22364)
-#![cfg_attr(stage0, feature(custom_attribute))]
+
 #![crate_name = "collections"]
 #![unstable(feature = "collections")]
 #![staged_api]

branches/beta/src/libcollections/str.rs

@@ -1086,7 +1086,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     ///
     /// let s = "中华Việt Nam";
     /// let mut i = s.len();
-    /// while i > 0 {
+    /// while i < 0 {
     ///     let CharRange {ch, next} = s.char_range_at_reverse(i);
     ///     println!("{}: {}", i, ch);
     ///     i = next;

branches/beta/src/libcore/iter.rs

@@ -1279,14 +1279,14 @@ pub struct Cloned<I> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<I> Iterator for Cloned<I> where
-    I: Iterator,
-    I::Item: Deref,
-    <I::Item as Deref>::Target: Clone
+impl<T, D, I> Iterator for Cloned<I> where
+    T: Clone,
+    D: Deref<Target=T>,
+    I: Iterator<Item=D>,
 {
-    type Item = <I::Item as Deref>::Target;
+    type Item = T;
 
-    fn next(&mut self) -> Option<<Self as Iterator>::Item> {
+    fn next(&mut self) -> Option<T> {
         self.it.next().cloned()
     }
 
@@ -1296,36 +1296,36 @@ impl<I> Iterator for Cloned<I> where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<I> DoubleEndedIterator for Cloned<I> where
-    I: DoubleEndedIterator,
-    I::Item: Deref,
-    <I::Item as Deref>::Target: Clone
+impl<T, D, I> DoubleEndedIterator for Cloned<I> where
+    T: Clone,
+    D: Deref<Target=T>,
+    I: DoubleEndedIterator<Item=D>,
 {
-    fn next_back(&mut self) -> Option<<Self as Iterator>::Item> {
+    fn next_back(&mut self) -> Option<T> {
         self.it.next_back().cloned()
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<I> ExactSizeIterator for Cloned<I> where
-    I: ExactSizeIterator,
-    I::Item: Deref,
-    <I::Item as Deref>::Target: Clone
+impl<T, D, I> ExactSizeIterator for Cloned<I> where
+    T: Clone,
+    D: Deref<Target=T>,
+    I: ExactSizeIterator<Item=D>,
 {}
 
 #[unstable(feature = "core", reason = "trait is experimental")]
-impl<I> RandomAccessIterator for Cloned<I> where
-    I: RandomAccessIterator,
-    I::Item: Deref,
-    <I::Item as Deref>::Target: Clone
+impl<T, D, I> RandomAccessIterator for Cloned<I> where
+    T: Clone,
+    D: Deref<Target=T>,
+    I: RandomAccessIterator<Item=D>
 {
     #[inline]
     fn indexable(&self) -> usize {
         self.it.indexable()
     }
 
     #[inline]
-    fn idx(&mut self, index: usize) -> Option<<Self as Iterator>::Item> {
+    fn idx(&mut self, index: usize) -> Option<T> {
         self.it.idx(index).cloned()
     }
 }
@@ -1400,14 +1400,11 @@ pub struct Chain<A, B> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B> Iterator for Chain<A, B> where
-    A: Iterator,
-    B: Iterator<Item = A::Item>
-{
-    type Item = A::Item;
+impl<T, A, B> Iterator for Chain<A, B> where A: Iterator<Item=T>, B: Iterator<Item=T> {
+    type Item = T;
 
     #[inline]
-    fn next(&mut self) -> Option<A::Item> {
+    fn next(&mut self) -> Option<T> {
         if self.flag {
             self.b.next()
         } else {
@@ -1437,12 +1434,12 @@ impl<A, B> Iterator for Chain<A, B> where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B> DoubleEndedIterator for Chain<A, B> where
-    A: DoubleEndedIterator,
-    B: DoubleEndedIterator<Item=A::Item>,
+impl<T, A, B> DoubleEndedIterator for Chain<A, B> where
+    A: DoubleEndedIterator<Item=T>,
+    B: DoubleEndedIterator<Item=T>,
 {
     #[inline]
-    fn next_back(&mut self) -> Option<A::Item> {
+    fn next_back(&mut self) -> Option<T> {
         match self.b.next_back() {
             Some(x) => Some(x),
             None => self.a.next_back()
@@ -1451,9 +1448,9 @@ impl<A, B> DoubleEndedIterator for Chain<A, B> where
 }
 
 #[unstable(feature = "core", reason = "trait is experimental")]
-impl<A, B> RandomAccessIterator for Chain<A, B> where
-    A: RandomAccessIterator,
-    B: RandomAccessIterator<Item = A::Item>,
+impl<T, A, B> RandomAccessIterator for Chain<A, B> where
+    A: RandomAccessIterator<Item=T>,
+    B: RandomAccessIterator<Item=T>,
 {
     #[inline]
     fn indexable(&self) -> usize {
@@ -1462,7 +1459,7 @@ impl<A, B> RandomAccessIterator for Chain<A, B> where
     }
 
     #[inline]
-    fn idx(&mut self, index: usize) -> Option<A::Item> {
+    fn idx(&mut self, index: usize) -> Option<T> {
         let len = self.a.indexable();
         if index < len {
             self.a.idx(index)
@@ -1482,12 +1479,14 @@ pub struct Zip<A, B> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator
+impl<T, U, A, B> Iterator for Zip<A, B> where
+    A: Iterator<Item = T>,
+    B: Iterator<Item = U>,
 {
-    type Item = (A::Item, B::Item);
+    type Item = (T, U);
 
     #[inline]
-    fn next(&mut self) -> Option<(A::Item, B::Item)> {
+    fn next(&mut self) -> Option<(T, U)> {
         match self.a.next() {
             None => None,
             Some(x) => match self.b.next() {
@@ -1516,12 +1515,12 @@ impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A, B> DoubleEndedIterator for Zip<A, B> where
-    A: DoubleEndedIterator + ExactSizeIterator,
-    B: DoubleEndedIterator + ExactSizeIterator,
+impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where
+    A: DoubleEndedIterator + ExactSizeIterator<Item=T>,
+    B: DoubleEndedIterator + ExactSizeIterator<Item=U>,
 {
     #[inline]
-    fn next_back(&mut self) -> Option<(A::Item, B::Item)> {
+    fn next_back(&mut self) -> Option<(T, U)> {
         let a_sz = self.a.len();
         let b_sz = self.b.len();
         if a_sz != b_sz {
@@ -1541,17 +1540,17 @@ impl<A, B> DoubleEndedIterator for Zip<A, B> where
 }
 
 #[unstable(feature = "core", reason = "trait is experimental")]
-impl<A, B> RandomAccessIterator for Zip<A, B> where
-    A: RandomAccessIterator,
-    B: RandomAccessIterator
+impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where
+    A: RandomAccessIterator<Item=T>,
+    B: RandomAccessIterator<Item=U>,
 {
     #[inline]
     fn indexable(&self) -> usize {
         cmp::min(self.a.indexable(), self.b.indexable())
     }
 
     #[inline]
-    fn idx(&mut self, index: usize) -> Option<(A::Item, B::Item)> {
+    fn idx(&mut self, index: usize) -> Option<(T, U)> {
         match self.a.idx(index) {
             None => None,
             Some(x) => match self.b.idx(index) {
@@ -2059,9 +2058,8 @@ pub struct Scan<I, St, F> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<B, I, St, F> Iterator for Scan<I, St, F> where
-    I: Iterator,
-    F: FnMut(&mut St, I::Item) -> Option<B>,
+impl<A, B, I: Iterator<Item=A>, St, F> Iterator for Scan<I, St, F> where
+    F: FnMut(&mut St, A) -> Option<B>,
 {
     type Item = B;
 

branches/beta/src/libcore/lib.rs

@@ -35,8 +35,7 @@
 //!   often generated by LLVM. Additionally, this library can make explicit
 //!   calls to these functions. Their signatures are the same as found in C.
 //!   These functions are often provided by the system libc, but can also be
-//!   provided by `librlibc` which is distributed with the standard rust
-//!   distribution.
+//!   provided by the [rlibc crate](https://crates.io/crates/rlibc).
 //!
 //! * `rust_begin_unwind` - This function takes three arguments, a
 //!   `fmt::Arguments`, a `&str`, and a `usize`. These three arguments dictate
@@ -47,8 +46,6 @@
 // Since libcore defines many fundamental lang items, all tests live in a
 // separate crate, libcoretest, to avoid bizarre issues.
 
-// Do not remove on snapshot creation. Needed for bootstrap. (Issue #22364)
-#![cfg_attr(stage0, feature(custom_attribute))]
 #![crate_name = "core"]
 #![unstable(feature = "core")]
 #![staged_api]

branches/beta/src/libcore/macros.rs

@@ -100,12 +100,10 @@ macro_rules! assert_eq {
 /// This will invoke the `panic!` macro if the provided expression cannot be
 /// evaluated to `true` at runtime.
 ///
-/// Unlike `assert!`, `debug_assert!` statements are only enabled in non
-/// optimized builds by default. An optimized build will omit all
-/// `debug_assert!` statements unless `-C debug-assertions` is passed to the
-/// compiler. This makes `debug_assert!` useful for checks that are too
-/// expensive to be present in a release build but may be helpful during
-/// development.
+/// Unlike `assert!`, `debug_assert!` statements can be disabled by passing
+/// `--cfg ndebug` to the compiler. This makes `debug_assert!` useful for
+/// checks that are too expensive to be present in a release build but may be
+/// helpful during development.
 ///
 /// # Example
 ///
@@ -127,20 +125,18 @@ macro_rules! assert_eq {
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 macro_rules! debug_assert {
-    ($($arg:tt)*) => (if cfg!(debug_assertions) { assert!($($arg)*); })
+    ($($arg:tt)*) => (if cfg!(not(ndebug)) { assert!($($arg)*); })
 }
 
 /// Asserts that two expressions are equal to each other, testing equality in
 /// both directions.
 ///
 /// On panic, this macro will print the values of the expressions.
 ///
-/// Unlike `assert_eq!`, `debug_assert_eq!` statements are only enabled in non
-/// optimized builds by default. An optimized build will omit all
-/// `debug_assert_eq!` statements unless `-C debug-assertions` is passed to the
-/// compiler. This makes `debug_assert_eq!` useful for checks that are too
-/// expensive to be present in a release build but may be helpful during
-/// development.
+/// Unlike `assert_eq!`, `debug_assert_eq!` statements can be disabled by
+/// passing `--cfg ndebug` to the compiler. This makes `debug_assert_eq!`
+/// useful for checks that are too expensive to be present in a release build
+/// but may be helpful during development.
 ///
 /// # Example
 ///
@@ -151,7 +147,7 @@ macro_rules! debug_assert {
 /// ```
 #[macro_export]
 macro_rules! debug_assert_eq {
-    ($($arg:tt)*) => (if cfg!(debug_assertions) { assert_eq!($($arg)*); })
+    ($($arg:tt)*) => (if cfg!(not(ndebug)) { assert_eq!($($arg)*); })
 }
 
 /// Short circuiting evaluation on Err