---

yaml
---
r: 196198
b: refs/heads/tmp
c: b9ab5fe
h: refs/heads/master
v: v3

Author: aturon

[refs]

@@ -32,7 +32,7 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 9854143cba679834bc4ef932858cd5303f015a0e
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: a37311d486d5e71b2f2d1290c9f9228c4f6ead79
+refs/heads/tmp: b9ab5fe7c29d0675ae03c87f1454fb52b36c18b4
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 53a183f0274316596bf9405944d4f0468d8c93e4
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/mk/tests.mk

@@ -166,7 +166,7 @@ $(foreach file,$(wildcard $(S)src/doc/trpl/*.md), \
 ######################################################################
 
 # The main testing target. Tests lots of stuff.
-check: check-sanitycheck cleantmptestlogs cleantestlibs all check-stage2 tidy
+check: cleantmptestlogs cleantestlibs all check-stage2 tidy
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 # As above but don't bother running tidy.
@@ -193,11 +193,6 @@ check-docs: cleantestlibs cleantmptestlogs check-stage2-docs
 # Not run as part of the normal test suite, but tested by bors on checkin.
 check-secondary: check-build-compiletest check-build-lexer-verifier check-lexer check-pretty
 
-.PHONY: check-sanitycheck
-
-check-sanitycheck:
-	$(Q)$(CFG_PYTHON) $(S)src/etc/check-sanitycheck.py
-
 # check + check-secondary.
 #
 # Issue #17883: build check-secondary first so hidden dependencies in

branches/tmp/src/compiletest/compiletest.rs

@@ -18,6 +18,7 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(path_ext)]
+#![feature(convert)]
 #![feature(str_char)]
 
 #![deny(warnings)]

branches/tmp/src/doc/reference.md

@@ -977,13 +977,17 @@ An example of `use` declarations:
 
 ```
 # #![feature(core)]
+use std::iter::range_step;
 use std::option::Option::{Some, None};
 use std::collections::hash_map::{self, HashMap};
 
 fn foo<T>(_: T){}
 fn bar(map1: HashMap<String, usize>, map2: hash_map::HashMap<String, usize>){}
 
 fn main() {
+    // Equivalent to 'std::iter::range_step(0, 10, 2);'
+    range_step(0, 10, 2);
+
     // Equivalent to 'foo(vec![std::option::Option::Some(1.0f64),
     // std::option::Option::None]);'
     foo(vec![Some(1.0f64), None]);

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

@@ -280,15 +280,13 @@ it returns an `Result<T, E>`, and because this is just an example, we `unwrap()`
 it to get a reference to the data. Real code would have more robust error handling
 here. We're then free to mutate it, since we have the lock.
 
-Lastly, while the threads are running, we wait on a short timer. But
-this is not ideal: we may have picked a reasonable amount of time to
-wait but it's more likely we'll either be waiting longer than
-necessary or not long enough, depending on just how much time the
-threads actually take to finish computing when the program runs.
-
-A more precise alternative to the timer would be to use one of the
-mechanisms provided by the Rust standard library for synchronizing
-threads with each other. Let's talk about one of them: channels.
+This timer bit is a bit awkward, however. We have picked a reasonable amount of
+time to wait, but it's entirely possible that we've picked too high, and that
+we could be taking less time. It's also possible that we've picked too low,
+and that we aren't actually finishing this computation.
+
+Rust's standard library provides a few more mechanisms for two threads to
+synchronize with each other. Let's talk about one: channels.
 
 ## Channels
 

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

@@ -243,12 +243,11 @@ for num in nums.iter() {
 ```
 
 These two basic iterators should serve you well. There are some more
-advanced iterators, including ones that are infinite. Like using range syntax
-and `step_by`:
+advanced iterators, including ones that are infinite. Like `count`:
 
 ```rust
-# #![feature(step_by)]
-(1..).step_by(5);
+# #![feature(core)]
+std::iter::count(1, 5);
 ```
 
 This iterator counts up from one, adding five each time. It will give
@@ -293,11 +292,11 @@ just use `for` instead.
 There are tons of interesting iterator adapters. `take(n)` will return an
 iterator over the next `n` elements of the original iterator, note that this
 has no side effect on the original iterator. Let's try it out with our infinite
-iterator from before:
+iterator from before, `count()`:
 
 ```rust
-# #![feature(step_by)]
-for i in (1..).step_by(5).take(5) {
+# #![feature(core)]
+for i in std::iter::count(1, 5).take(5) {
     println!("{}", i);
 }
 ```

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

@@ -477,7 +477,7 @@ forbidden in item signatures to allow reasoning about the types just based in
 the item signature alone. However, for ergonomic reasons a very restricted
 secondary inference algorithm called “lifetime elision” applies in function
 signatures. It infers only based on the signature components themselves and not
-based on the body of the function, only infers lifetime parameters, and does
+based on the body of the function, only infers lifetime paramters, and does
 this with only three easily memorizable and unambiguous rules. This makes
 lifetime elision a shorthand for writing an item signature, while not hiding
 away the actual types involved as full local inference would if applied to it.

branches/tmp/src/etc/check-sanitycheck.py

@@ -110,7 +110,7 @@ use heap::deallocate;
 ///         let child_numbers = shared_numbers.clone();
 ///
 ///         thread::spawn(move || {
-///             let local_numbers = &child_numbers[..];
+///             let local_numbers = child_numbers.as_slice();
 ///
 ///             // Work with the local numbers
 ///         });

branches/tmp/src/liballoc/arc.rs

@@ -51,7 +51,7 @@ use core::prelude::*;
 use core::any::Any;
 use core::cmp::Ordering;
 use core::default::Default;
-use core::error::Error;
+use core::error::{Error, FromError};
 use core::fmt;
 use core::hash::{self, Hash};
 use core::mem;
@@ -233,10 +233,24 @@ impl<T: ?Sized + Hash> Hash for Box<T> {
     }
 }
 
-impl Box<Any> {
-    #[inline]
+/// Extension methods for an owning `Any` trait object.
+#[unstable(feature = "alloc",
+           reason = "this trait will likely disappear once compiler bugs blocking \
+                     a direct impl on `Box<Any>` have been fixed ")]
+// FIXME(#18737): this should be a direct impl on `Box<Any>`. If you're
+//                removing this please make sure that you can downcase on
+//                `Box<Any + Send>` as well as `Box<Any>`
+pub trait BoxAny {
+    /// Returns the boxed value if it is of type `T`, or
+    /// `Err(Self)` if it isn't.
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
+    fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>>;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl BoxAny for Box<Any> {
+    #[inline]
+    fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object
@@ -253,10 +267,10 @@ impl Box<Any> {
     }
 }
 
-impl Box<Any+Send> {
+#[stable(feature = "rust1", since = "1.0.0")]
+impl BoxAny for Box<Any+Send> {
     #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
+    fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
         <Box<Any>>::downcast(self)
     }
 }
@@ -308,8 +322,8 @@ impl<I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for Box<I> {
 impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Box<I> {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, E: Error + 'a> From<E> for Box<Error + 'a> {
-    fn from(err: E) -> Box<Error + 'a> {
+impl<'a, E: Error + 'a> FromError<E> for Box<Error + 'a> {
+    fn from_error(err: E) -> Box<Error + 'a> {
         Box::new(err)
     }
 }

branches/tmp/src/liballoc/boxed.rs

@@ -17,6 +17,7 @@ use core::clone::Clone;
 
 use std::boxed;
 use std::boxed::Box;
+use std::boxed::BoxAny;
 
 #[test]
 fn test_owned_clone() {

branches/tmp/src/liballoc/boxed_test.rs

@@ -38,7 +38,7 @@
 //! [sieve]: http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
 //!
 //! ```
-//! # #![feature(collections, core, step_by)]
+//! # #![feature(collections, core)]
 //! use std::collections::{BitSet, BitVec};
 //! use std::num::Float;
 //! use std::iter;
@@ -60,7 +60,7 @@
 //!         if bv[i] {
 //!             // Mark all multiples of i as non-prime (any multiples below i * i
 //!             // will have been marked as non-prime previously)
-//!             for j in (i * i..max_prime).step_by(i) { bv.set(j, false) }
+//!             for j in iter::range_step(i * i, max_prime, i) { bv.set(j, false) }
 //!         }
 //!     }
 //!     BitSet::from_bit_vec(bv)
@@ -1264,6 +1264,14 @@ impl BitSet {
         BitSet { bit_vec: bit_vec }
     }
 
+    /// Deprecated: use `from_bit_vec`.
+    #[inline]
+    #[deprecated(since = "1.0.0", reason = "renamed to from_bit_vec")]
+    #[unstable(feature = "collections")]
+    pub fn from_bitv(bit_vec: BitVec) -> BitSet {
+        BitSet { bit_vec: bit_vec }
+    }
+
     /// Returns the capacity in bits for this bit vector. Inserting any
     /// element less than this amount will not trigger a resizing.
     ///

branches/tmp/src/libcollections/bit.rs

@@ -40,24 +40,6 @@ use self::Cow::*;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Borrow<Borrowed: ?Sized> {
     /// Immutably borrow from an owned value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::borrow::Borrow;
-    ///
-    /// fn check<T: Borrow<str>>(s: T) {
-    ///     assert_eq!("Hello", s.borrow());
-    /// }
-    ///
-    /// let s = "Hello".to_string();
-    ///
-    /// check(s);
-    ///
-    /// let s = "Hello";
-    ///
-    /// check(s);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     fn borrow(&self) -> &Borrowed;
 }
@@ -68,20 +50,6 @@ pub trait Borrow<Borrowed: ?Sized> {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait BorrowMut<Borrowed: ?Sized> : Borrow<Borrowed> {
     /// Mutably borrow from an owned value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::borrow::BorrowMut;
-    ///
-    /// fn check<T: BorrowMut<[i32]>>(mut v: T) {
-    ///     assert_eq!(&mut [1, 2, 3], v.borrow_mut());
-    /// }
-    ///
-    /// let v = vec![1, 2, 3];
-    ///
-    /// check(v);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     fn borrow_mut(&mut self) -> &mut Borrowed;
 }
@@ -203,18 +171,6 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned {
     /// Acquire a mutable reference to the owned form of the data.
     ///
     /// Copies the data if it is not already owned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::borrow::Cow;
-    ///
-    /// let mut cow: Cow<[_]> = Cow::Owned(vec![1, 2, 3]);
-    ///
-    /// let hello = cow.to_mut();
-    ///
-    /// assert_eq!(hello, &[1, 2, 3]);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned {
         match *self {
@@ -229,25 +185,33 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned {
     /// Extract the owned data.
     ///
     /// Copies the data if it is not already owned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::borrow::Cow;
-    ///
-    /// let cow: Cow<[_]> = Cow::Owned(vec![1, 2, 3]);
-    ///
-    /// let hello = cow.into_owned();
-    ///
-    /// assert_eq!(vec![1, 2, 3], hello);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn into_owned(self) -> <B as ToOwned>::Owned {
         match self {
             Borrowed(borrowed) => borrowed.to_owned(),
             Owned(owned) => owned
         }
     }
+
+    /// Returns true if this `Cow` wraps a borrowed value
+    #[deprecated(since = "1.0.0", reason = "match on the enum instead")]
+    #[unstable(feature = "std_misc")]
+    pub fn is_borrowed(&self) -> bool {
+        match *self {
+            Borrowed(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if this `Cow` wraps an owned value
+    #[deprecated(since = "1.0.0", reason = "match on the enum instead")]
+    #[unstable(feature = "std_misc")]
+    pub fn is_owned(&self) -> bool {
+        match *self {
+            Owned(_) => true,
+            _ => false,
+        }
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]