---

yaml
---
r: 159615
b: refs/heads/auto
c: 93c4942
h: refs/heads/master
i:
  159613: 2e6885b
  159611: e148d97
  159607: 21e6699
  159599: 333e763
  159583: d91b5db
  159551: 8f2ef77
  159487: bf6e325
v: v3

Author: reem

[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: 0d97b95d43248c7bf0aa408fa39567245e9b794d
+refs/heads/auto: 93c4942690753e982cbb4bf6667940da71c5d286
 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-pointers.md

@@ -133,11 +133,11 @@ pass-by-reference. Basically, languages can make two choices (this is made
 up syntax, it's not Rust):
 
 ```{notrust,ignore}
-func foo(x) {
+fn foo(x) {
     x = 5
 }
 
-func main() {
+fn main() {
     i = 1
     foo(i)
     // what is the value of i here?
@@ -153,11 +153,11 @@ So what do pointers have to do with this? Well, since pointers point to a
 location in memory...
 
 ```{notrust,ignore}
-func foo(&int x) {
+fn foo(&int x) {
     *x = 5
 }
 
-func main() {
+fn main() {
     i = 1
     foo(&i)
     // what is the value of i here?
@@ -192,13 +192,13 @@ When you combine pointers and functions, it's easy to accidentally invalidate
 the memory the pointer is pointing to. For example:
 
 ```{notrust,ignore}
-func make_pointer(): &int {
+fn make_pointer(): &int {
     x = 5;
 
     return &x;
 }
 
-func main() {
+fn main() {
     &int i = make_pointer();
     *i = 5; // uh oh!
 }
@@ -214,11 +214,11 @@ issue. Two pointers are said to alias when they point at the same location
 in memory. Like this:
 
 ```{notrust,ignore}
-func mutate(&int i, int j) {
+fn mutate(&int i, int j) {
     *i = j;
 }
 
-func main() {
+fn main() {
   x = 5;
   y = &x;
   z = &x; //y and z are aliased

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

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

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/snapshot.py

@@ -75,11 +75,7 @@ def full_snapshot_name(date, rev, platform, hsh):
 
 
 def get_kernel(triple):
-    t = triple.split('-')
-    if len(t) == 2:
-      os_name = t[1]
-    else:
-      os_name = t[2]
+    os_name = triple.split('-')[2]
     if os_name == "windows":
         return "winnt"
     if os_name == "darwin":

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