---

yaml
---
r: 159602
b: refs/heads/auto
c: d91a015
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 7b28ba07781c0c769c393dbb002367ec1f972b4b
+refs/heads/auto: d91a015ab4c538f02fbbc03dfb08193a381c2e3b
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide-lifetimes.md

@@ -51,6 +51,7 @@ expensive. So we'd like to define a function that takes the points just as
 a reference.
 
 ~~~
+# use std::num::Float;
 # struct Point {x: f64, y: f64}
 # fn sqrt(f: f64) -> f64 { 0.0 }
 fn compute_distance(p1: &Point, p2: &Point) -> f64 {

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

@@ -225,6 +225,7 @@ Here is another example showing how futures allow you to background
 computations. The workload will be distributed on the available cores.
 
 ```{rust}
+# use std::num::Float;
 # use std::sync::Future;
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
@@ -262,6 +263,7 @@ several computations on a single large vector of floats. Each task needs the
 full vector to perform its duty.
 
 ```{rust}
+use std::num::Float;
 use std::rand;
 use std::sync::Arc;
 

branches/auto/src/etc/make-win-dist.py

@@ -62,7 +62,6 @@ def make_win_dist(dist_root, target_triple):
                     "libcomctl32.a",
                     "libcomdlg32.a",
                     "libcrypt32.a",
-                    "libctl3d32.a",
                     "libgdi32.a",
                     "libimagehlp.a",
                     "libiphlpapi.a",

branches/auto/src/etc/vim/syntax/rust.vim

@@ -97,8 +97,7 @@ syn keyword rustTrait FromIterator IntoIterator Extend ExactSize
 syn keyword rustTrait Iterator DoubleEndedIterator
 syn keyword rustTrait RandomAccessIterator CloneableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator
-syn keyword rustTrait Num NumCast CheckedAdd CheckedSub CheckedMul CheckedDiv
-syn keyword rustTrait Signed Unsigned Primitive Int Float
+syn keyword rustTrait NumCast Int SignedInt UnsignedInt Float
 syn keyword rustTrait FloatMath ToPrimitive FromPrimitive
 syn keyword rustTrait Box
 syn keyword rustTrait GenericPath Path PosixPath WindowsPath

branches/auto/src/liballoc/boxed.rs

@@ -65,50 +65,12 @@ impl<T: Clone> Clone for Box<T> {
     }
 }
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<T:PartialEq> PartialEq for Box<T> {
-    #[inline]
-    fn eq(&self, other: &Box<T>) -> bool { *(*self) == *(*other) }
-    #[inline]
-    fn ne(&self, other: &Box<T>) -> bool { *(*self) != *(*other) }
-}
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<T:PartialOrd> PartialOrd for Box<T> {
-    #[inline]
-    fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {
-        (**self).partial_cmp(&**other)
-    }
-    #[inline]
-    fn lt(&self, other: &Box<T>) -> bool { *(*self) < *(*other) }
-    #[inline]
-    fn le(&self, other: &Box<T>) -> bool { *(*self) <= *(*other) }
-    #[inline]
-    fn ge(&self, other: &Box<T>) -> bool { *(*self) >= *(*other) }
-    #[inline]
-    fn gt(&self, other: &Box<T>) -> bool { *(*self) > *(*other) }
-}
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<T: Ord> Ord for Box<T> {
-    #[inline]
-    fn cmp(&self, other: &Box<T>) -> Ordering {
-        (**self).cmp(&**other)
-    }
-}
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<T: Eq> Eq for Box<T> {}
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<Sized? T: PartialEq> PartialEq for Box<T> {
     #[inline]
     fn eq(&self, other: &Box<T>) -> bool { PartialEq::eq(&**self, &**other) }
     #[inline]
     fn ne(&self, other: &Box<T>) -> bool { PartialEq::ne(&**self, &**other) }
 }
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<Sized? T: PartialOrd> PartialOrd for Box<T> {
     #[inline]
     fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {
@@ -123,14 +85,12 @@ impl<Sized? T: PartialOrd> PartialOrd for Box<T> {
     #[inline]
     fn gt(&self, other: &Box<T>) -> bool { PartialOrd::gt(&**self, &**other) }
 }
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<Sized? T: Ord> Ord for Box<T> {
     #[inline]
     fn cmp(&self, other: &Box<T>) -> Ordering {
         Ord::cmp(&**self, &**other)
     }
 }
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<Sized? T: Eq> Eq for Box<T> {}
 
 /// Extension methods for an owning `Any` trait object.

branches/auto/src/libarena/lib.rs

@@ -38,7 +38,7 @@ use std::cmp;
 use std::intrinsics::{TyDesc, get_tydesc};
 use std::intrinsics;
 use std::mem;
-use std::num;
+use std::num::{Int, UnsignedInt};
 use std::ptr;
 use std::rc::Rc;
 use std::rt::heap::{allocate, deallocate};
@@ -132,7 +132,7 @@ impl Drop for Arena {
 
 #[inline]
 fn round_up(base: uint, align: uint) -> uint {
-    (base.checked_add(&(align - 1))).unwrap() & !(align - 1)
+    (base.checked_add(align - 1)).unwrap() & !(align - 1)
 }
 
 // Walk down a chunk, running the destructors for any objects stored
@@ -187,7 +187,7 @@ impl Arena {
         self.chunks.borrow_mut().push(self.copy_head.borrow().clone());
 
         *self.copy_head.borrow_mut() =
-            chunk(num::next_power_of_two(new_min_chunk_size + 1u), true);
+            chunk((new_min_chunk_size + 1u).next_power_of_two(), true);
 
         return self.alloc_copy_inner(n_bytes, align);
     }
@@ -228,7 +228,7 @@ impl Arena {
         self.chunks.borrow_mut().push(self.head.borrow().clone());
 
         *self.head.borrow_mut() =
-            chunk(num::next_power_of_two(new_min_chunk_size + 1u), false);
+            chunk((new_min_chunk_size + 1u).next_power_of_two(), false);
 
         return self.alloc_noncopy_inner(n_bytes, align);
     }
@@ -376,8 +376,8 @@ fn calculate_size<T>(capacity: uint) -> uint {
     let mut size = mem::size_of::<TypedArenaChunk<T>>();
     size = round_up(size, mem::min_align_of::<T>());
     let elem_size = mem::size_of::<T>();
-    let elems_size = elem_size.checked_mul(&capacity).unwrap();
-    size = size.checked_add(&elems_size).unwrap();
+    let elems_size = elem_size.checked_mul(capacity).unwrap();
+    size = size.checked_add(elems_size).unwrap();
     size
 }
 
@@ -432,7 +432,7 @@ impl<T> TypedArenaChunk<T> {
     #[inline]
     fn end(&self) -> *const u8 {
         unsafe {
-            let size = mem::size_of::<T>().checked_mul(&self.capacity).unwrap();
+            let size = mem::size_of::<T>().checked_mul(self.capacity).unwrap();
             self.start().offset(size as int)
         }
     }
@@ -481,7 +481,7 @@ impl<T> TypedArena<T> {
     fn grow(&self) {
         unsafe {
             let chunk = *self.first.borrow_mut();
-            let new_capacity = (*chunk).capacity.checked_mul(&2).unwrap();
+            let new_capacity = (*chunk).capacity.checked_mul(2).unwrap();
             let chunk = TypedArenaChunk::<T>::new(chunk, new_capacity);
             self.ptr.set((*chunk).start() as *const T);
             self.end.set((*chunk).end() as *const T);

branches/auto/src/libcollections/bit.rs

@@ -22,6 +22,7 @@
 //!
 //! ```
 //! use std::collections::{BitvSet, Bitv};
+//! use std::num::Float;
 //! use std::iter;
 //!
 //! let max_prime = 10000;
@@ -69,6 +70,7 @@ use core::default::Default;
 use core::fmt;
 use core::iter::{Chain, Enumerate, Repeat, Skip, Take};
 use core::iter;
+use core::num::Int;
 use core::slice;
 use core::u32;
 use std::hash;
@@ -256,9 +258,9 @@ impl Bitv {
 
     /// Retrieves the value at index `i`.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `i` is out of bounds.
+    /// Panics if `i` is out of bounds.
     ///
     /// # Example
     ///
@@ -283,9 +285,9 @@ impl Bitv {
 
     /// Sets the value of a bit at a index `i`.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `i` is out of bounds.
+    /// Panics if `i` is out of bounds.
     ///
     /// # Example
     ///
@@ -351,9 +353,9 @@ impl Bitv {
     /// Sets `self` to the union of `self` and `other`. Both bitvectors must be
     /// the same length. Returns `true` if `self` changed.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the bitvectors are of different lengths.
+    /// Panics if the bitvectors are of different lengths.
     ///
     /// # Example
     ///
@@ -381,9 +383,9 @@ impl Bitv {
     /// Sets `self` to the intersection of `self` and `other`. Both bitvectors
     /// must be the same length. Returns `true` if `self` changed.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the bitvectors are of different lengths.
+    /// Panics if the bitvectors are of different lengths.
     ///
     /// # Example
     ///
@@ -411,9 +413,9 @@ impl Bitv {
     /// element of `other` at the same index. Both bitvectors must be the same
     /// length. Returns `true` if `self` changed.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the bitvectors are of different length.
+    /// Panics if the bitvectors are of different length.
     ///
     /// # Example
     ///
@@ -578,9 +580,9 @@ impl Bitv {
     /// Compares a `Bitv` to a slice of `bool`s.
     /// Both the `Bitv` and slice must have the same length.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if the the `Bitv` and slice are of different length.
+    /// Panics if the the `Bitv` and slice are of different length.
     ///
     /// # Example
     ///
@@ -716,7 +718,7 @@ impl Bitv {
 
     /// Shortens by one element and returns the removed element.
     ///
-    /// # Failure
+    /// # Panics
     ///
     /// Assert if empty.
     ///

branches/auto/src/libcollections/enum_set.rs

@@ -15,6 +15,7 @@
 
 use core::prelude::*;
 use core::fmt;
+use core::num::Int;
 
 // FIXME(contentions): implement union family of methods? (general design may be wrong here)
 

branches/auto/src/libcollections/hash/mod.rs

@@ -69,6 +69,7 @@ use alloc::boxed::Box;
 use alloc::rc::Rc;
 use core::intrinsics::TypeId;
 use core::mem;
+use core::num::Int;
 
 use vec::Vec;
 

branches/auto/src/libcollections/str.rs

@@ -534,13 +534,6 @@ impl<'a> PartialOrd for MaybeOwned<'a> {
 }
 
 impl<'a> Ord for MaybeOwned<'a> {
-    // NOTE(stage0): remove method after a snapshot
-    #[cfg(stage0)]
-    #[inline]
-    fn cmp(&self, other: &MaybeOwned) -> Ordering {
-        self.as_slice().cmp(&other.as_slice())
-    }
-    #[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
     #[inline]
     fn cmp(&self, other: &MaybeOwned) -> Ordering {
         self.as_slice().cmp(other.as_slice())

branches/auto/src/libcollections/string.rs

@@ -498,9 +498,9 @@ impl String {
 
     /// Shortens a string to the specified length.
     ///
-    /// # Failure
+    /// # Panics
     ///
-    /// Fails if `new_len` > current length,
+    /// Panics if `new_len` > current length,
     /// or if `new_len` is not a character boundary.
     ///
     /// # Example