---

yaml
---
r: 64103
b: refs/heads/snap-stage3
c: 2a8ae0e
h: refs/heads/master
i:
  64101: 36846c2
  64099: 9554e98
  64095: 845d771
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 59e6a4d44c329ddf37d9ff33df874e7800647ec2
+refs/heads/snap-stage3: 2a8ae0eb4ae91d8695ea7e95e024f51ec19ef56a
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/tests.mk

@@ -15,7 +15,7 @@
 
 # The names of crates that must be tested
 TEST_TARGET_CRATES = std extra
-TEST_HOST_CRATES = syntax rustc rustdoc rust rustpkg
+TEST_HOST_CRATES = syntax rustc rustdoc rust rustpkg rusti
 TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
 
 # Markdown files under doc/ that should have their code extracted and run
@@ -157,6 +157,7 @@ check-test: cleantestlibs cleantmptestlogs all check-stage2-rfail
 
 check-lite: cleantestlibs cleantmptestlogs \
 	check-stage2-std check-stage2-extra check-stage2-rpass \
+	check-stage2-rustpkg check-stage2-rusti \
 	check-stage2-rfail check-stage2-cfail
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 

branches/snap-stage3/src/libextra/arena.rs

@@ -40,7 +40,6 @@ use list::{MutList, MutCons, MutNil};
 use std::at_vec;
 use std::cast::{transmute, transmute_mut, transmute_mut_region};
 use std::cast;
-use std::num;
 use std::ptr;
 use std::sys;
 use std::uint;
@@ -176,7 +175,7 @@ impl Arena {
     fn alloc_pod_grow(&mut self, n_bytes: uint, align: uint) -> *u8 {
         // Allocate a new chunk.
         let chunk_size = at_vec::capacity(self.pod_head.data);
-        let new_min_chunk_size = num::max(n_bytes, chunk_size);
+        let new_min_chunk_size = uint::max(n_bytes, chunk_size);
         self.chunks = @mut MutCons(copy self.pod_head, self.chunks);
         self.pod_head =
             chunk(uint::next_power_of_two(new_min_chunk_size + 1u), true);
@@ -218,7 +217,7 @@ impl Arena {
                          -> (*u8, *u8) {
         // Allocate a new chunk.
         let chunk_size = at_vec::capacity(self.head.data);
-        let new_min_chunk_size = num::max(n_bytes, chunk_size);
+        let new_min_chunk_size = uint::max(n_bytes, chunk_size);
         self.chunks = @mut MutCons(copy self.head, self.chunks);
         self.head =
             chunk(uint::next_power_of_two(new_min_chunk_size + 1u), false);

branches/snap-stage3/src/libextra/bitv.rs

@@ -12,7 +12,6 @@
 
 
 use std::cmp;
-use std::num;
 use std::ops;
 use std::uint;
 use std::vec;
@@ -727,7 +726,7 @@ impl Set<uint> for BitvSet {
         }
         let nbits = self.capacity();
         if value >= nbits {
-            let newsize = num::max(value, nbits * 2) / uint::bits + 1;
+            let newsize = uint::max(value, nbits * 2) / uint::bits + 1;
             assert!(newsize > self.bitv.storage.len());
             self.bitv.storage.grow(newsize, &0);
         }
@@ -826,7 +825,7 @@ impl BitvSet {
     /// and w1/w2 are the words coming from the two vectors self, other.
     fn each_common(&self, other: &BitvSet,
                    f: &fn(uint, uint, uint) -> bool) -> bool {
-        let min = num::min(self.bitv.storage.len(),
+        let min = uint::min(self.bitv.storage.len(),
                             other.bitv.storage.len());
         self.bitv.storage.slice(0, min).iter().enumerate().advance(|(i, &w)| {
             f(i * uint::bits, w, other.bitv.storage[i])
@@ -844,7 +843,7 @@ impl BitvSet {
                     f: &fn(bool, uint, uint) -> bool) -> bool {
         let len1 = self.bitv.storage.len();
         let len2 = other.bitv.storage.len();
-        let min = num::min(len1, len2);
+        let min = uint::min(len1, len2);
 
         /* only one of these loops will execute and that's the point */
         for self.bitv.storage.slice(min, len1).iter().enumerate().advance |(i, &w)| {

branches/snap-stage3/src/libextra/deque.rs

@@ -10,7 +10,6 @@
 
 //! A double-ended queue implemented as a circular buffer
 
-use std::num;
 use std::uint;
 use std::vec;
 use std::iterator::FromIterator;
@@ -52,7 +51,7 @@ impl<T> Deque<T> {
     /// Create an empty Deque with space for at least `n` elements.
     pub fn with_capacity(n: uint) -> Deque<T> {
         Deque{nelts: 0, lo: 0,
-              elts: vec::from_fn(num::max(MINIMUM_CAPACITY, n), |_| None)}
+              elts: vec::from_fn(uint::max(MINIMUM_CAPACITY, n), |_| None)}
     }
 
     /// Return a reference to the first element in the deque

branches/snap-stage3/src/libextra/net/tcp.rs

@@ -28,7 +28,7 @@ use std::comm::{stream, Port, SharedChan};
 use std::ptr;
 use std::result::{Result};
 use std::result;
-use std::num;
+use std::uint;
 use std::vec;
 
 pub mod rustrt {
@@ -880,7 +880,7 @@ impl io::Reader for TcpSocketBuf {
           let needed = len - count;
             if nbuffered > 0 {
                 unsafe {
-                    let ncopy = num::min(nbuffered, needed);
+                    let ncopy = uint::min(nbuffered, needed);
                     let dst = ptr::mut_offset(
                         vec::raw::to_mut_ptr(buf), count);
                     let src = ptr::offset(

branches/snap-stage3/src/libextra/num/bigint.rs

@@ -21,7 +21,6 @@ A BigInt is a combination of BigUint and Sign.
 
 use std::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
 use std::int;
-use std::num;
 use std::num::{IntConvertible, Zero, One, ToStrRadix, FromStrRadix, Orderable};
 use std::str;
 use std::uint;
@@ -205,7 +204,7 @@ impl Unsigned for BigUint {}
 impl Add<BigUint, BigUint> for BigUint {
 
     fn add(&self, other: &BigUint) -> BigUint {
-        let new_len = num::max(self.data.len(), other.data.len());
+        let new_len = uint::max(self.data.len(), other.data.len());
 
         let mut carry = 0;
         let mut sum = do vec::from_fn(new_len) |i| {
@@ -225,7 +224,7 @@ impl Add<BigUint, BigUint> for BigUint {
 impl Sub<BigUint, BigUint> for BigUint {
 
     fn sub(&self, other: &BigUint) -> BigUint {
-        let new_len = num::max(self.data.len(), other.data.len());
+        let new_len = uint::max(self.data.len(), other.data.len());
 
         let mut borrow = 0;
         let diff = do vec::from_fn(new_len) |i| {
@@ -261,7 +260,7 @@ impl Mul<BigUint, BigUint> for BigUint {
         // = a1*b1 * base^2 +
         //   (a1*b1 + a0*b0 - (a1-b0)*(b1-a0)) * base +
         //   a0*b0
-        let half_len = num::max(s_len, o_len) / 2;
+        let half_len = uint::max(s_len, o_len) / 2;
         let (sHi, sLo) = cut_at(self,  half_len);
         let (oHi, oLo) = cut_at(other, half_len);
 
@@ -298,7 +297,7 @@ impl Mul<BigUint, BigUint> for BigUint {
 
 
         fn cut_at(a: &BigUint, n: uint) -> (BigUint, BigUint) {
-            let mid = num::min(a.data.len(), n);
+            let mid = uint::min(a.data.len(), n);
             return (BigUint::from_slice(a.data.slice(mid, a.data.len())),
                     BigUint::from_slice(a.data.slice(0, mid)));
         }
@@ -483,7 +482,7 @@ impl Integer for BigUint {
 impl IntConvertible for BigUint {
 
     fn to_int(&self) -> int {
-        num::min(self.to_uint(), int::max_value as uint) as int
+        uint::min(self.to_uint(), int::max_value as uint) as int
     }
 
 
@@ -581,7 +580,7 @@ impl BigUint {
         let mut n: BigUint      = Zero::zero();
         let mut power: BigUint  = One::one();
         loop {
-            let start = num::max(end, unit_len) - unit_len;
+            let start = uint::max(end, unit_len) - unit_len;
             match uint::parse_bytes(buf.slice(start, end), radix) {
                 // FIXME(#6102): Assignment operator for BigInt causes ICE
                 // Some(d) => n += BigUint::from_uint(d) * power,
@@ -1056,9 +1055,9 @@ impl IntConvertible for BigInt {
 
     fn to_int(&self) -> int {
         match self.sign {
-            Plus  => num::min(self.to_uint(), int::max_value as uint) as int,
+            Plus  => uint::min(self.to_uint(), int::max_value as uint) as int,
             Zero  => 0,
-            Minus => num::min((-self).to_uint(),
+            Minus => uint::min((-self).to_uint(),
                                (int::max_value as uint) + 1) as int
         }
     }

branches/snap-stage3/src/libextra/par.rs

@@ -10,9 +10,9 @@
 
 
 use std::cast;
-use std::num;
 use std::ptr;
 use std::sys;
+use std::uint;
 use std::vec;
 use future_spawn = future::spawn;
 
@@ -44,15 +44,15 @@ fn map_slices<A:Copy + Send,B:Copy + Send>(
         ~[f()(0u, xs)]
     }
     else {
-        let num_tasks = num::min(MAX_TASKS, len / MIN_GRANULARITY);
+        let num_tasks = uint::min(MAX_TASKS, len / MIN_GRANULARITY);
 
         let items_per_task = len / num_tasks;
 
         let mut futures = ~[];
         let mut base = 0u;
         info!("spawning tasks");
         while base < len {
-            let end = num::min(len, base + items_per_task);
+            let end = uint::min(len, base + items_per_task);
             do xs.as_imm_buf |p, _len| {
                 let f = f();
                 let base = base;

branches/snap-stage3/src/libextra/sort.rs

@@ -840,7 +840,7 @@ mod test_qsort {
 
         let expected = ~[1, 2, 3];
 
-        do quick_sort(names) |x, y| { *x < *y };
+        do quick_sort(names) |x, y| { int::le(*x, *y) };
 
         let immut_names = names;
 

branches/snap-stage3/src/libextra/stats.rs

@@ -12,6 +12,7 @@ use sort;
 use std::cmp;
 use std::io;
 use std::num;
+use std::f64;
 use std::vec;
 
 // NB: this can probably be rewritten in terms of num::Num
@@ -177,7 +178,7 @@ impl<'self> Stats for &'self [f64] {
     }
 
     fn std_dev(self) -> f64 {
-        self.var().sqrt()
+        f64::sqrt(self.var())
     }
 
     fn std_dev_pct(self) -> f64 {

branches/snap-stage3/src/libextra/time.rs

@@ -11,9 +11,9 @@
 #[allow(missing_doc)];
 
 
+use std::i32;
 use std::int;
 use std::io;
-use std::num;
 use std::str;
 
 static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
@@ -249,7 +249,7 @@ impl Tm {
         } else {
             let s = self.strftime("%Y-%m-%dT%H:%M:%S");
             let sign = if self.tm_gmtoff > 0_i32 { '+' } else { '-' };
-            let mut m = num::abs(self.tm_gmtoff) / 60_i32;
+            let mut m = i32::abs(self.tm_gmtoff) / 60_i32;
             let h = m / 60_i32;
             m -= h * 60_i32;
             s + fmt!("%c%02d:%02d", sign, h as int, m as int)
@@ -832,7 +832,7 @@ priv fn do_strftime(format: &str, tm: &Tm) -> ~str {
           'Z' => copy tm.tm_zone,
           'z' => {
             let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' };
-            let mut m = num::abs(tm.tm_gmtoff) / 60_i32;
+            let mut m = i32::abs(tm.tm_gmtoff) / 60_i32;
             let h = m / 60_i32;
             m -= h * 60_i32;
             fmt!("%c%02d%02d", sign, h as int, m as int)

branches/snap-stage3/src/libextra/treemap.rs

@@ -13,7 +13,7 @@
 //! `TotalOrd`.
 
 
-use std::num;
+use std::uint;
 use std::util::{swap, replace};
 
 // This is implemented as an AA tree, which is a simplified variation of
@@ -63,7 +63,7 @@ fn lt<K: Ord + TotalOrd, V: Ord>(a: &TreeMap<K, V>,
     let mut y = b.iter();
 
     let (a_len, b_len) = (a.len(), b.len());
-    for num::min(a_len, b_len).times {
+    for uint::min(a_len, b_len).times {
         let (key_a, value_a) = x.next().unwrap();
         let (key_b, value_b) = y.next().unwrap();
         if *key_a < *key_b { return true; }

branches/snap-stage3/src/librustc/back/rpath.rs

@@ -14,7 +14,6 @@ use metadata::cstore;
 use metadata::filesearch;
 
 use std::hashmap::HashSet;
-use std::num;
 use std::os;
 use std::uint;
 use std::util;
@@ -142,7 +141,7 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
     assert!(len1 > 0);
     assert!(len2 > 0);
 
-    let max_common_path = num::min(len1, len2) - 1;
+    let max_common_path = uint::min(len1, len2) - 1;
     let mut start_idx = 0;
     while start_idx < max_common_path
         && split1[start_idx] == split2[start_idx] {

branches/snap-stage3/src/librustc/metadata/loader.rs

@@ -25,11 +25,11 @@ use syntax::{ast, attr};
 
 use std::cast;
 use std::io;
-use std::num;
 use std::option;
 use std::os::consts::{macos, freebsd, linux, android, win32};
 use std::ptr;
 use std::str;
+use std::uint;
 use std::vec;
 use extra::flate;
 
@@ -211,7 +211,7 @@ fn get_metadata_section(os: os,
                 let vlen = encoder::metadata_encoding_version.len();
                 debug!("checking %u bytes of metadata-version stamp",
                        vlen);
-                let minsz = num::min(vlen, csz);
+                let minsz = uint::min(vlen, csz);
                 let mut version_ok = false;
                 do vec::raw::buf_as_slice(cvbuf, minsz) |buf0| {
                     version_ok = (buf0 ==

branches/snap-stage3/src/librustc/middle/check_match.rs

@@ -18,7 +18,6 @@ use middle::typeck::method_map;
 use middle::moves;
 use util::ppaux::ty_to_str;
 
-use std::num;
 use std::uint;
 use std::vec;
 use extra::sort;
@@ -245,7 +244,7 @@ pub fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@pat]) -> useful {
                 let max_len = do m.rev_iter().fold(0) |max_len, r| {
                   match r[0].node {
                     pat_vec(ref before, _, ref after) => {
-                      num::max(before.len() + after.len(), max_len)
+                      uint::max(before.len() + after.len(), max_len)
                     }
                     _ => max_len
                   }