---

yaml
---
r: 159358
b: refs/heads/master
c: 43fd644
h: refs/heads/master
v: v3

Author: ricky26

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7e43f419cb98c9035d30e5cf0e0be7944dbc0371
+refs/heads/master: 43fd6446add0bcf237f3fe15b7d715eceee2a08c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2

trunk/src/doc/guide-lifetimes.md

@@ -51,7 +51,6 @@ 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,7 +225,6 @@ 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;
@@ -263,7 +262,6 @@ 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/po4a.conf

@@ -19,7 +19,7 @@
 [type: text] src/doc/guide-tasks.md $lang:doc/l10n/$lang/guide-tasks.md
 [type: text] src/doc/guide-testing.md $lang:doc/l10n/$lang/guide-testing.md
 [type: text] src/doc/guide-unsafe.md $lang:doc/l10n/$lang/guide-unsafe.md
-[type: text] src/doc/guide-crates.md $lang:doc/l10n/$lang/guide-crates.md
+[type: text] src/doc/guide-unsafe.md $lang:doc/l10n/$lang/guide-crates.md
 [type: text] src/doc/guide.md $lang:doc/l10n/$lang/guide.md
 [type: text] src/doc/index.md $lang:doc/l10n/$lang/index.md
 [type: text] src/doc/intro.md $lang:doc/l10n/$lang/intro.md

trunk/src/doc/reference.md

@@ -2653,10 +2653,9 @@ An expression may have two roles: it always produces a *value*, and it may have
 value, and has effects during *evaluation*. Many expressions contain
 sub-expressions (operands). The meaning of each kind of expression dictates
 several things:
-
-* Whether or not to evaluate the sub-expressions when evaluating the expression
-* The order in which to evaluate the sub-expressions
-* How to combine the sub-expressions' values to obtain the value of the expression
+  * Whether or not to evaluate the sub-expressions when evaluating the
+  * expression The order in which to evaluate the sub-expressions How to
+  * combine the sub-expressions' values to obtain the value of the expression.
 
 In this way, the structure of expressions dictates the structure of execution.
 Blocks are just another kind of expression, so blocks, statements, expressions,

trunk/src/etc/make-win-dist.py

@@ -62,6 +62,7 @@ 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,7 +97,8 @@ 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 NumCast Int SignedInt UnsignedInt Float
+syn keyword rustTrait Num NumCast CheckedAdd CheckedSub CheckedMul CheckedDiv
+syn keyword rustTrait Signed Unsigned Primitive Int Float
 syn keyword rustTrait FloatMath ToPrimitive FromPrimitive
 syn keyword rustTrait Box
 syn keyword rustTrait GenericPath Path PosixPath WindowsPath

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::{Int, UnsignedInt};
+use std::num;
 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((new_min_chunk_size + 1u).next_power_of_two(), true);
+            chunk(num::next_power_of_two(new_min_chunk_size + 1u), 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((new_min_chunk_size + 1u).next_power_of_two(), false);
+            chunk(num::next_power_of_two(new_min_chunk_size + 1u), 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,7 +22,6 @@
 //!
 //! ```
 //! use std::collections::{BitvSet, Bitv};
-//! use std::num::Float;
 //! use std::iter;
 //!
 //! let max_prime = 10000;
@@ -70,7 +69,6 @@ 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;
@@ -258,9 +256,9 @@ impl Bitv {
 
     /// Retrieves the value at index `i`.
     ///
-    /// # Panics
+    /// # Failure
     ///
-    /// Panics if `i` is out of bounds.
+    /// Fails if `i` is out of bounds.
     ///
     /// # Example
     ///
@@ -285,9 +283,9 @@ impl Bitv {
 
     /// Sets the value of a bit at a index `i`.
     ///
-    /// # Panics
+    /// # Failure
     ///
-    /// Panics if `i` is out of bounds.
+    /// Fails if `i` is out of bounds.
     ///
     /// # Example
     ///
@@ -353,9 +351,9 @@ impl Bitv {
     /// Sets `self` to the union of `self` and `other`. Both bitvectors must be
     /// the same length. Returns `true` if `self` changed.
     ///
-    /// # Panics
+    /// # Failure
     ///
-    /// Panics if the bitvectors are of different lengths.
+    /// Fails if the bitvectors are of different lengths.
     ///
     /// # Example
     ///
@@ -383,9 +381,9 @@ impl Bitv {
     /// Sets `self` to the intersection of `self` and `other`. Both bitvectors
     /// must be the same length. Returns `true` if `self` changed.
     ///
-    /// # Panics
+    /// # Failure
     ///
-    /// Panics if the bitvectors are of different lengths.
+    /// Fails if the bitvectors are of different lengths.
     ///
     /// # Example
     ///
@@ -413,9 +411,9 @@ impl Bitv {
     /// element of `other` at the same index. Both bitvectors must be the same
     /// length. Returns `true` if `self` changed.
     ///
-    /// # Panics
+    /// # Failure
     ///
-    /// Panics if the bitvectors are of different length.
+    /// Fails if the bitvectors are of different length.
     ///
     /// # Example
     ///
@@ -580,9 +578,9 @@ impl Bitv {
     /// Compares a `Bitv` to a slice of `bool`s.
     /// Both the `Bitv` and slice must have the same length.
     ///
-    /// # Panics
+    /// # Failure
     ///
-    /// Panics if the the `Bitv` and slice are of different length.
+    /// Fails if the the `Bitv` and slice are of different length.
     ///
     /// # Example
     ///
@@ -718,7 +716,7 @@ impl Bitv {
 
     /// Shortens by one element and returns the removed element.
     ///
-    /// # Panics
+    /// # Failure
     ///
     /// Assert if empty.
     ///

trunk/src/libcollections/enum_set.rs

@@ -15,7 +15,6 @@
 
 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,7 +69,6 @@ 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/string.rs

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

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::{Int, UnsignedInt};
+use core::num;
 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 }
@@ -587,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 = new_cap.next_power_of_two();
+                    let amort_cap = num::next_power_of_two(new_cap);
                     // next_power_of_two will overflow to exactly 0 for really big capacities
                     if amort_cap == 0 {
                         self.grow_capacity(new_cap);
@@ -624,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)
             }
@@ -941,9 +941,9 @@ impl<T> Vec<T> {
 
     /// Appends an element to the back of a collection.
     ///
-    /// # Panics
+    /// # Failure
     ///
-    /// Panics if the number of elements in the vector overflows a `uint`.
+    /// Fails if the number of elements in the vector overflows a `uint`.
     ///
     /// # Example
     ///
@@ -957,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
         }
@@ -1050,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);
@@ -1462,9 +1462,9 @@ impl<T> Vec<T> {
     /// Converts a `Vec<T>` to a `Vec<U>` where `T` and `U` have the same
     /// size and in case they are not zero-sized the same minimal alignment.
     ///
-    /// # Panics
+    /// # Failure
     ///
-    /// Panics if `T` and `U` have differing sizes or are not zero-sized and
+    /// Fails if `T` and `U` have differing sizes or are not zero-sized and
     /// have differing minimal alignments.
     ///
     /// # Example