---

yaml
---
r: 194234
b: refs/heads/beta
c: eefb8e2
h: refs/heads/master
v: v3

Author: semarie

[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: 4283b2ab5053eec3c7f95682e82aee9006c58eef
+refs/heads/beta: eefb8e206504e01054fdd4843c31270a3945e49c
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

branches/beta/src/libcollections/binary_heap.rs

@@ -563,8 +563,6 @@ impl<T: Ord> BinaryHeap<T> {
     pub fn is_empty(&self) -> bool { self.len() == 0 }
 
     /// Clears the binary heap, returning an iterator over the removed elements.
-    ///
-    /// The elements are removed in arbitrary order.
     #[inline]
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]

branches/beta/src/libcollections/slice.rs

@@ -13,23 +13,25 @@
 //! The `slice` module contains useful code to help work with slice values.
 //! Slices are a view into a block of memory represented as a pointer and a length.
 //!
-//! ```
+//! ```rust
+//! # #![feature(core)]
 //! // slicing a Vec
-//! let vec = vec![1, 2, 3];
-//! let int_slice = &vec[..];
+//! let vec = vec!(1, 2, 3);
+//! let int_slice = vec.as_slice();
 //! // coercing an array to a slice
 //! let str_slice: &[&str] = &["one", "two", "three"];
 //! ```
 //!
 //! Slices are either mutable or shared. The shared slice type is `&[T]`,
-//! while the mutable slice type is `&mut [T]`, where `T` represents the element
-//! type. For example, you can mutate the block of memory that a mutable slice
-//! points to:
+//! while the mutable slice type is `&mut[T]`. For example, you can mutate the
+//! block of memory that a mutable slice points to:
 //!
-//! ```
-//! let x = &mut [1, 2, 3];
+//! ```rust
+//! let x: &mut[i32] = &mut [1, 2, 3];
 //! x[1] = 7;
-//! assert_eq!(x, &[1, 7, 3]);
+//! assert_eq!(x[0], 1);
+//! assert_eq!(x[1], 7);
+//! assert_eq!(x[2], 3);
 //! ```
 //!
 //! Here are some of the things this module contains:
@@ -39,43 +41,49 @@
 //! There are several structs that are useful for slices, such as `Iter`, which
 //! represents iteration over a slice.
 //!
-//! ## Trait Implementations
+//! ## Traits
+//!
+//! A number of traits add methods that allow you to accomplish tasks
+//! with slices, the most important being `SliceExt`. Other traits
+//! apply only to slices of elements satisfying certain bounds (like
+//! `Ord`).
+//!
+//! An example is the `slice` method which enables slicing syntax `[a..b]` that
+//! returns an immutable "view" into a `Vec` or another slice from the index
+//! interval `[a, b)`:
+//!
+//! ```rust
+//! fn main() {
+//!     let numbers = [0, 1, 2];
+//!     let last_numbers = &numbers[1..3];
+//!     // last_numbers is now &[1, 2]
+//! }
+//! ```
+//!
+//! ## Implementations of other traits
 //!
 //! There are several implementations of common traits for slices. Some examples
 //! include:
 //!
 //! * `Clone`
-//! * `Eq`, `Ord` - for slices whose element type are `Eq` or `Ord`.
+//! * `Eq`, `Ord` - for immutable slices whose element type are `Eq` or `Ord`.
 //! * `Hash` - for slices whose element type is `Hash`
 //!
 //! ## Iteration
 //!
-//! The slices implement `IntoIterator`. The iterators of yield references
-//! to the slice elements.
+//! The method `iter()` returns an iteration value for a slice. The iterator
+//! yields references to the slice's elements, so if the element
+//! type of the slice is `isize`, the element type of the iterator is `&isize`.
 //!
-//! ```
-//! let numbers = &[0, 1, 2];
-//! for n in numbers {
-//!     println!("{} is a number!", n);
+//! ```rust
+//! let numbers = [0, 1, 2];
+//! for &x in numbers.iter() {
+//!     println!("{} is a number!", x);
 //! }
 //! ```
 //!
-//! The mutable slice yields mutable references to the elements:
-//!
-//! ```
-//! let mut scores = [7, 8, 9];
-//! for score in &mut scores[..] {
-//!     *score += 1;
-//! }
-//! ```
-//!
-//! This iterator yields mutable references to the slice's elements, so while the element
-//! type of the slice is `i32`, the element type of the iterator is `&mut i32`.
-//!
-//! * `.iter()` and `.iter_mut()` are the explicit methods to return the default
-//!   iterators.
-//! * Further methods that return iterators are `.split()`, `.splitn()`,
-//!   `.chunks()`, `.windows()` and more.
+//! * `.iter_mut()` returns an iterator that allows modifying each value.
+//! * Further iterators exist that split, chunk or permute the slice.
 
 #![doc(primitive = "slice")]
 #![stable(feature = "rust1", since = "1.0.0")]

branches/beta/src/libcollections/str.rs

@@ -19,7 +19,7 @@
 //! are owned elsewhere.
 //!
 //! Basic operations are implemented directly by the compiler, but more advanced
-//! operations are defined as methods on the `str` type.
+//! operations are defined on the [`StrExt`](trait.StrExt.html) trait.
 //!
 //! # Examples
 //!

branches/beta/src/libcollections/vec.rs

@@ -646,30 +646,23 @@ impl<T> Vec<T> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn push(&mut self, value: T) {
-        #[cold]
-        #[inline(never)]
-        fn resize<T>(vec: &mut Vec<T>) {
-            let old_size = vec.cap * mem::size_of::<T>();
-            let size = max(old_size, 2 * mem::size_of::<T>()) * 2;
-            if old_size > size { panic!("capacity overflow") }
-            unsafe {
-                let ptr = alloc_or_realloc(*vec.ptr, old_size, size);
-                if ptr.is_null() { ::alloc::oom() }
-                vec.ptr = Unique::new(ptr);
-            }
-            vec.cap = max(vec.cap, 2) * 2;
-        }
-
         if mem::size_of::<T>() == 0 {
             // zero-size types consume no memory, so we can't rely on the
             // address space running out
             self.len = self.len.checked_add(1).expect("length overflow");
             unsafe { mem::forget(value); }
             return
         }
-
         if self.len == self.cap {
-            resize(self);
+            let old_size = self.cap * mem::size_of::<T>();
+            let size = max(old_size, 2 * mem::size_of::<T>()) * 2;
+            if old_size > size { panic!("capacity overflow") }
+            unsafe {
+                let ptr = alloc_or_realloc(*self.ptr, old_size, size);
+                if ptr.is_null() { ::alloc::oom() }
+                self.ptr = Unique::new(ptr);
+            }
+            self.cap = max(self.cap, 2) * 2;
         }
 
         unsafe {

branches/beta/src/libcore/str/mod.rs

@@ -165,7 +165,8 @@ impl FromStr for bool {
     /// assert!(<bool as FromStr>::from_str("not even a boolean").is_err());
     /// ```
     ///
-    /// Note, in many cases, the `.parse()` method on `str` is more proper.
+    /// Note, in many cases, the StrExt::parse() which is based on
+    /// this FromStr::from_str() is more proper.
     ///
     /// ```
     /// assert_eq!("true".parse(), Ok(true));
@@ -530,7 +531,7 @@ impl<'a> DoubleEndedIterator for CharIndices<'a> {
 /// External iterator for a string's bytes.
 /// Use with the `std::iter` module.
 ///
-/// Created with `str::bytes`
+/// Created with `StrExt::bytes`
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Clone)]
 pub struct Bytes<'a>(Map<slice::Iter<'a, u8>, BytesDeref>);
@@ -1488,27 +1489,27 @@ impl<'a, S: ?Sized> Str for &'a S where S: Str {
     fn as_slice(&self) -> &str { Str::as_slice(*self) }
 }
 
-/// Return type of `str::split`
+/// Return type of `StrExt::split`
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Split<'a, P: Pattern<'a>>(CharSplits<'a, P>);
 delegate_iter!{pattern &'a str : Split<'a, P>}
 
-/// Return type of `str::split_terminator`
+/// Return type of `StrExt::split_terminator`
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct SplitTerminator<'a, P: Pattern<'a>>(CharSplits<'a, P>);
 delegate_iter!{pattern &'a str : SplitTerminator<'a, P>}
 
-/// Return type of `str::splitn`
+/// Return type of `StrExt::splitn`
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct SplitN<'a, P: Pattern<'a>>(CharSplitsN<'a, P>);
 delegate_iter!{pattern forward &'a str : SplitN<'a, P>}
 
-/// Return type of `str::rsplit`
+/// Return type of `StrExt::rsplit`
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RSplit<'a, P: Pattern<'a>>(RCharSplits<'a, P>);
 delegate_iter!{pattern reverse &'a str : RSplit<'a, P>}
 
-/// Return type of `str::rsplitn`
+/// Return type of `StrExt::rsplitn`
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RSplitN<'a, P: Pattern<'a>>(RCharSplitsN<'a, P>);
 delegate_iter!{pattern reverse &'a str : RSplitN<'a, P>}

branches/beta/src/librustc_trans/trans/expr.rs

@@ -1766,8 +1766,6 @@ fn trans_eager_binop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
       ast::BiAdd => {
         if is_float {
             FAdd(bcx, lhs, rhs, binop_debug_loc)
-        } else if is_simd {
-            Add(bcx, lhs, rhs, binop_debug_loc)
         } else {
             let (newbcx, res) = with_overflow_check(
                 bcx, OverflowOp::Add, info, lhs_t, lhs, rhs, binop_debug_loc);
@@ -1778,8 +1776,6 @@ fn trans_eager_binop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
       ast::BiSub => {
         if is_float {
             FSub(bcx, lhs, rhs, binop_debug_loc)
-        } else if is_simd {
-            Sub(bcx, lhs, rhs, binop_debug_loc)
         } else {
             let (newbcx, res) = with_overflow_check(
                 bcx, OverflowOp::Sub, info, lhs_t, lhs, rhs, binop_debug_loc);
@@ -1790,8 +1786,6 @@ fn trans_eager_binop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
       ast::BiMul => {
         if is_float {
             FMul(bcx, lhs, rhs, binop_debug_loc)
-        } else if is_simd {
-            Mul(bcx, lhs, rhs, binop_debug_loc)
         } else {
             let (newbcx, res) = with_overflow_check(
                 bcx, OverflowOp::Mul, info, lhs_t, lhs, rhs, binop_debug_loc);

branches/beta/src/libstd/io/mod.rs

@@ -631,14 +631,14 @@ pub trait BufRead: Read {
 
 /// A `Write` adaptor which will write data to multiple locations.
 ///
-/// For more information, see `Write::broadcast`.
-#[unstable(feature = "io", reason = "awaiting stability of Write::broadcast")]
+/// For more information, see `WriteExt::broadcast`.
+#[unstable(feature = "io", reason = "awaiting stability of WriteExt::broadcast")]
 pub struct Broadcast<T, U> {
     first: T,
     second: U,
 }
 
-#[unstable(feature = "io", reason = "awaiting stability of Write::broadcast")]
+#[unstable(feature = "io", reason = "awaiting stability of WriteExt::broadcast")]
 impl<T: Write, U: Write> Write for Broadcast<T, U> {
     fn write(&mut self, data: &[u8]) -> Result<usize> {
         let n = try!(self.first.write(data));
@@ -654,7 +654,7 @@ impl<T: Write, U: Write> Write for Broadcast<T, U> {
 
 /// Adaptor to chain together two instances of `Read`.
 ///
-/// For more information, see `Read::chain`.
+/// For more information, see `ReadExt::chain`.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Chain<T, U> {
     first: T,
@@ -677,7 +677,7 @@ impl<T: Read, U: Read> Read for Chain<T, U> {
 
 /// Reader adaptor which limits the bytes read from an underlying reader.
 ///
-/// For more information, see `Read::take`.
+/// For more information, see `ReadExt::take`.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Take<T> {
     inner: T,
@@ -730,14 +730,14 @@ impl<T: BufRead> BufRead for Take<T> {
 
 /// An adaptor which will emit all read data to a specified writer as well.
 ///
-/// For more information see `Read::tee`
-#[unstable(feature = "io", reason = "awaiting stability of Read::tee")]
+/// For more information see `ReadExt::tee`
+#[unstable(feature = "io", reason = "awaiting stability of ReadExt::tee")]
 pub struct Tee<R, W> {
     reader: R,
     writer: W,
 }
 
-#[unstable(feature = "io", reason = "awaiting stability of Read::tee")]
+#[unstable(feature = "io", reason = "awaiting stability of ReadExt::tee")]
 impl<R: Read, W: Write> Read for Tee<R, W> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         let n = try!(self.reader.read(buf));
@@ -749,7 +749,7 @@ impl<R: Read, W: Write> Read for Tee<R, W> {
 
 /// A bridge from implementations of `Read` to an `Iterator` of `u8`.
 ///
-/// See `Read::bytes` for more information.
+/// See `ReadExt::bytes` for more information.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Bytes<R> {
     inner: R,
@@ -771,16 +771,16 @@ impl<R: Read> Iterator for Bytes<R> {
 
 /// A bridge from implementations of `Read` to an `Iterator` of `char`.
 ///
-/// See `Read::chars` for more information.
-#[unstable(feature = "io", reason = "awaiting stability of Read::chars")]
+/// See `ReadExt::chars` for more information.
+#[unstable(feature = "io", reason = "awaiting stability of ReadExt::chars")]
 pub struct Chars<R> {
     inner: R,
 }
 
 /// An enumeration of possible errors that can be generated from the `Chars`
 /// adapter.
 #[derive(PartialEq, Clone, Debug)]
-#[unstable(feature = "io", reason = "awaiting stability of Read::chars")]
+#[unstable(feature = "io", reason = "awaiting stability of ReadExt::chars")]
 pub enum CharsError {
     /// Variant representing that the underlying stream was read successfully
     /// but it did not contain valid utf8 data.
@@ -790,7 +790,7 @@ pub enum CharsError {
     Other(Error),
 }
 
-#[unstable(feature = "io", reason = "awaiting stability of Read::chars")]
+#[unstable(feature = "io", reason = "awaiting stability of ReadExt::chars")]
 impl<R: Read> Iterator for Chars<R> {
     type Item = result::Result<char, CharsError>;
 
@@ -822,7 +822,7 @@ impl<R: Read> Iterator for Chars<R> {
     }
 }
 
-#[unstable(feature = "io", reason = "awaiting stability of Read::chars")]
+#[unstable(feature = "io", reason = "awaiting stability of ReadExt::chars")]
 impl std_error::Error for CharsError {
     fn description(&self) -> &str {
         match *self {
@@ -838,7 +838,7 @@ impl std_error::Error for CharsError {
     }
 }
 
-#[unstable(feature = "io", reason = "awaiting stability of Read::chars")]
+#[unstable(feature = "io", reason = "awaiting stability of ReadExt::chars")]
 impl fmt::Display for CharsError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {

branches/beta/src/libstd/io/prelude.rs

@@ -18,7 +18,7 @@
 //! ```
 //!
 //! This module contains reexports of many core I/O traits such as `Read`,
-//! `Write` and `BufRead`. Structures and functions are not
+//! `Write`, `ReadExt`, and `WriteExt`. Structures and functions are not
 //! contained in this module.
 
 #![stable(feature = "rust1", since = "1.0.0")]