---

yaml
---
r: 159603
b: refs/heads/auto
c: 607eb12
h: refs/heads/master
i:
  159601: f0b18b2
  159599: 333e763
v: v3

Author: steveklabnik

[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: d91a015ab4c538f02fbbc03dfb08193a381c2e3b
+refs/heads/auto: 607eb12ab7683c8d84460edd50971944f5994f92
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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 {

branches/auto/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;
 

branches/auto/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
-fail.
+panic.
 
 # Macros
 

branches/auto/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-unsafe.md $lang:doc/l10n/$lang/guide-crates.md
+[type: text] src/doc/guide-crates.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

branches/auto/src/etc/emacs/rust-mode.el

@@ -176,7 +176,7 @@
     "false" "fn" "for"
     "if" "impl" "in"
     "let" "loop"
-    "match" "mod" "move" "mut"
+    "match" "mod" "mut"
     "priv" "proc" "pub"
     "ref" "return"
     "self" "static" "struct" "super"

branches/auto/src/etc/kate/rust.xml

@@ -34,7 +34,6 @@
 		<item> loop </item>
 		<item> match </item>
 		<item> mod </item>
-		<item> move </item>
 		<item> mut </item>
 		<item> priv </item>
 		<item> pub </item>

branches/auto/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",

branches/auto/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

branches/auto/src/liballoc/boxed.rs

@@ -65,12 +65,50 @@ 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> {
@@ -85,12 +123,14 @@ 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::{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);

branches/auto/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.
     ///

branches/auto/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)
 

branches/auto/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;
 

branches/auto/src/libcollections/str.rs

@@ -534,6 +534,13 @@ 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.
     ///
-    /// # Panics
+    /// # Failure
     ///
-    /// Panics if `new_len` > current length,
+    /// Fails if `new_len` > current length,
     /// or if `new_len` is not a character boundary.
     ///
     /// # Example