---

yaml
---
r: 159343
b: refs/heads/master
c: 4963afd
h: refs/heads/master
i:
  159341: 9088ff4
  159339: 60ad6f9
  159335: 64b3355
  159327: 1a80f50
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 0ab861aa2dc972e13d98c24db603f125688d5e43
+refs/heads/master: 4963afdc7b6adeee74abd306d3933a58bbec522b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2

trunk/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 {

trunk/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;
 

trunk/src/doc/guide.md

@@ -5274,7 +5274,7 @@ let result = task::try(proc() {
 
 This task will randomly panic or succeed. `task::try` returns a `Result`
 type, so we can handle the response like any other computation that may
-panic.
+fail.
 
 # Macros
 

trunk/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",

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

trunk/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.

trunk/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);

trunk/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;

trunk/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)
 

trunk/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;
 

trunk/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())

trunk/src/libcollections/vec.rs

@@ -21,7 +21,7 @@ use core::default::Default;
 use core::fmt;
 use core::kinds::marker::{ContravariantLifetime, InvariantType};
 use core::mem;
-use core::num;
+use core::num::{Int, UnsignedInt};
 use core::ops;
 use core::ptr;
 use core::raw::Slice as RawSlice;
@@ -161,7 +161,7 @@ impl<T> Vec<T> {
         } else if capacity == 0 {
             Vec::new()
         } else {
-            let size = capacity.checked_mul(&mem::size_of::<T>())
+            let size = capacity.checked_mul(mem::size_of::<T>())
                                .expect("capacity overflow");
             let ptr = unsafe { allocate(size, mem::min_align_of::<T>()) };
             Vec { ptr: ptr as *mut T, len: 0, cap: capacity }
@@ -506,13 +506,6 @@ impl<T: PartialEq> PartialEq for Vec<T> {
 
 #[unstable = "waiting on PartialOrd stability"]
 impl<T: PartialOrd> PartialOrd for Vec<T> {
-    // NOTE(stage0): remove method after a snapshot
-    #[cfg(stage0)]
-    #[inline]
-    fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering> {
-        self.as_slice().partial_cmp(&other.as_slice())
-    }
-    #[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
     #[inline]
     fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering> {
         self.as_slice().partial_cmp(other.as_slice())
@@ -530,13 +523,6 @@ impl<T: PartialEq, V: AsSlice<T>> Equiv<V> for Vec<T> {
 
 #[unstable = "waiting on Ord stability"]
 impl<T: Ord> Ord for Vec<T> {
-    // NOTE(stage0): remove method after a snapshot
-    #[cfg(stage0)]
-    #[inline]
-    fn cmp(&self, other: &Vec<T>) -> Ordering {
-        self.as_slice().cmp(&other.as_slice())
-    }
-    #[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
     #[inline]
     fn cmp(&self, other: &Vec<T>) -> Ordering {
         self.as_slice().cmp(other.as_slice())
@@ -601,11 +587,11 @@ impl<T> Vec<T> {
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn reserve(&mut self, additional: uint) {
         if self.cap - self.len < additional {
-            match self.len.checked_add(&additional) {
+            match self.len.checked_add(additional) {
                 None => panic!("Vec::reserve: `uint` overflow"),
                 // if the checked_add
                 Some(new_cap) => {
-                    let amort_cap = num::next_power_of_two(new_cap);
+                    let amort_cap = new_cap.next_power_of_two();
                     // next_power_of_two will overflow to exactly 0 for really big capacities
                     if amort_cap == 0 {
                         self.grow_capacity(new_cap);
@@ -638,7 +624,7 @@ impl<T> Vec<T> {
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn reserve_exact(&mut self, additional: uint) {
         if self.cap - self.len < additional {
-            match self.len.checked_add(&additional) {
+            match self.len.checked_add(additional) {
                 None => panic!("Vec::reserve: `uint` overflow"),
                 Some(new_cap) => self.grow_capacity(new_cap)
             }
@@ -971,7 +957,7 @@ impl<T> Vec<T> {
     pub fn push(&mut self, value: T) {
         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");
+            self.len = self.len.checked_add(1).expect("length overflow");
             unsafe { mem::forget(value); }
             return
         }
@@ -1064,7 +1050,7 @@ impl<T> Vec<T> {
         if mem::size_of::<T>() == 0 { return }
 
         if capacity > self.cap {
-            let size = capacity.checked_mul(&mem::size_of::<T>())
+            let size = capacity.checked_mul(mem::size_of::<T>())
                                .expect("capacity overflow");
             unsafe {
                 self.ptr = alloc_or_realloc(self.ptr, self.cap * mem::size_of::<T>(), size);