---

yaml
---
r: 113662
b: refs/heads/snap-stage3
c: e9018f9
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: abdacecdf86b4b5a4f432560445a24e1c5f4751b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: a211907f88a8ac7a7deb3bd4c028e5dd34be95a2
+refs/heads/snap-stage3: e9018f9c75f190aae6714b7f2e774fdd784eacc1
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/rust.md

@@ -2943,7 +2943,7 @@ See [Break expressions](#break-expressions) and [Continue expressions](#continue
 break_expr : "break" [ lifetime ];
 ~~~~
 
-A `break` expression has an optional `label`.
+A `break` expression has an optional _label_.
 If the label is absent, then executing a `break` expression immediately terminates the innermost loop enclosing it.
 It is only permitted in the body of a loop.
 If the label is present, then `break foo` terminates the loop with label `foo`,
@@ -2956,7 +2956,7 @@ but must enclose it.
 continue_expr : "continue" [ lifetime ];
 ~~~~
 
-A `continue` expression has an optional `label`.
+A `continue` expression has an optional _label_.
 If the label is absent,
 then executing a `continue` expression immediately terminates the current iteration of the innermost loop enclosing it,
 returning control to the loop *head*.
@@ -3115,7 +3115,7 @@ let x: List<int> = Cons(10, box Cons(11, box Nil));
 
 match x {
     Cons(a, box Cons(b, _)) => {
-        process_pair(a,b);
+        process_pair(a, b);
     }
     Cons(10, _) => {
         process_ten();
@@ -3329,8 +3329,8 @@ order specified by the tuple type.
 An example of a tuple type and its use:
 
 ~~~~
-type Pair<'a> = (int,&'a str);
-let p: Pair<'static> = (10,"hello");
+type Pair<'a> = (int, &'a str);
+let p: Pair<'static> = (10, "hello");
 let (a, b) = p;
 assert!(b != "world");
 ~~~~

branches/snap-stage3/src/doc/tutorial.md

@@ -2602,7 +2602,7 @@ fn main() {
 ~~~
 
 The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
-`TotalOrd`, `Encodable` `Decodable`, `Clone`,
+`TotalOrd`, `Encodable`, `Decodable`, `Clone`,
 `Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
 
 # Crates and the module system

branches/snap-stage3/src/libcore/bool.rs

@@ -15,11 +15,14 @@
 //! Implementations of the following traits:
 //!
 //! * `Not`
+//! * `BitAnd`
+//! * `BitOr`
+//! * `BitXor`
 //! * `Ord`
 //! * `TotalOrd`
 //! * `Eq`
+//! * `TotalEq`
 //! * `Default`
-//! * `Zero`
 //!
 //! A `to_bit` conversion function.
 

branches/snap-stage3/src/libcore/lib.rs

@@ -17,7 +17,7 @@
 //!
 //! * `memcpy`, `memcmp`, `memset` - These are core memory routines which are
 //!   often generated by LLVM. Additionally, this library can make explicit
-//!   calls to these funcitons. Their signatures are the same as found in C.
+//!   calls to these functions. Their signatures are the same as found in C.
 //!   These functions are often provided by the system libc, but can also be
 //!   provided by `librlibc` which is distributed with the standard rust
 //!   distribution.

branches/snap-stage3/src/libcore/num/mod.rs

@@ -11,7 +11,7 @@
 //! Numeric traits and functions for generic mathematics
 //!
 //! These are implemented for the primitive numeric types in `std::{u8, u16,
-//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64, float}`.
+//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64}`.
 
 #![allow(missing_doc)]
 
@@ -97,7 +97,7 @@ pub trait One: Mul<Self, Self> {
 pub trait Signed: Num + Neg<Self> {
     /// Computes the absolute value.
     ///
-    /// For float, f32, and f64, `NaN` will be returned if the number is `NaN`.
+    /// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`.
     fn abs(&self) -> Self;
 
     /// The positive difference of two numbers.
@@ -108,15 +108,17 @@ pub trait Signed: Num + Neg<Self> {
 
     /// Returns the sign of the number.
     ///
-    /// For `float`, `f32`, `f64`:
-    ///   * `1.0` if the number is positive, `+0.0` or `INFINITY`
-    ///   * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
-    ///   * `NaN` if the number is `NaN`
+    /// For `f32` and `f64`:
+    ///
+    /// * `1.0` if the number is positive, `+0.0` or `INFINITY`
+    /// * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
+    /// * `NaN` if the number is `NaN`
     ///
     /// For `int`:
-    ///   * `0` if the number is zero
-    ///   * `1` if the number is positive
-    ///   * `-1` if the number is negative
+    ///
+    /// * `0` if the number is zero
+    /// * `1` if the number is positive
+    /// * `-1` if the number is negative
     fn signum(&self) -> Self;
 
     /// Returns true if the number is positive and false if the number is zero or negative.
@@ -128,7 +130,7 @@ pub trait Signed: Num + Neg<Self> {
 
 /// Computes the absolute value.
 ///
-/// For float, f32, and f64, `NaN` will be returned if the number is `NaN`
+/// For `f32` and `f64`, `NaN` will be returned if the number is `NaN`
 #[inline(always)]
 pub fn abs<T: Signed>(value: T) -> T {
     value.abs()
@@ -145,15 +147,17 @@ pub fn abs_sub<T: Signed>(x: T, y: T) -> T {
 
 /// Returns the sign of the number.
 ///
-/// For float, f32, f64:
-/// - `1.0` if the number is positive, `+0.0` or `INFINITY`
-/// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
-/// - `NAN` if the number is `NAN`
+/// For `f32` and `f64`:
+///
+/// * `1.0` if the number is positive, `+0.0` or `INFINITY`
+/// * `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
+/// * `NaN` if the number is `NaN`
 ///
 /// For int:
-/// - `0` if the number is zero
-/// - `1` if the number is positive
-/// - `-1` if the number is negative
+///
+/// * `0` if the number is zero
+/// * `1` if the number is positive
+/// * `-1` if the number is negative
 #[inline(always)] pub fn signum<T: Signed>(value: T) -> T { value.signum() }
 
 /// A trait for values which cannot be negative

branches/snap-stage3/src/libcore/result.rs

@@ -508,12 +508,19 @@ impl<T, E> Result<T, E> {
     /// Unwraps a result, yielding the content of an `Ok`.
     /// If the value is an `Err` then it calls `op` with its value.
     #[inline]
-    pub fn unwrap_or_handle(self, op: |E| -> T) -> T {
+    pub fn unwrap_or_else(self, op: |E| -> T) -> T {
         match self {
             Ok(t) => t,
             Err(e) => op(e)
         }
     }
+
+    /// Deprecated name for `unwrap_or_else()`.
+    #[deprecated = "replaced by .unwrap_or_else()"]
+    #[inline]
+    pub fn unwrap_or_handle(self, op: |E| -> T) -> T {
+        self.unwrap_or_else(op)
+    }
 }
 
 impl<T, E: Show> Result<T, E> {
@@ -758,8 +765,8 @@ mod tests {
         let ok: Result<int, ~str> = Ok(100);
         let ok_err: Result<int, ~str> = Err("I got this.".to_owned());
 
-        assert_eq!(ok.unwrap_or_handle(handler), 100);
-        assert_eq!(ok_err.unwrap_or_handle(handler), 50);
+        assert_eq!(ok.unwrap_or_else(handler), 100);
+        assert_eq!(ok_err.unwrap_or_else(handler), 50);
     }
 
     #[test]
@@ -774,6 +781,6 @@ mod tests {
         }
 
         let bad_err: Result<int, ~str> = Err("Unrecoverable mess.".to_owned());
-        let _ : int = bad_err.unwrap_or_handle(handler);
+        let _ : int = bad_err.unwrap_or_else(handler);
     }
 }

branches/snap-stage3/src/libstd/num/mod.rs

@@ -11,7 +11,7 @@
 //! Numeric traits and functions for generic mathematics
 //!
 //! These are implemented for the primitive numeric types in `std::{u8, u16,
-//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64, float}`.
+//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64}`.
 
 #![allow(missing_doc)]
 

branches/snap-stage3/src/libtest/lib.rs

@@ -32,7 +32,7 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://static.rust-lang.org/doc/master")]
 
-#![feature(asm, macro_rules)]
+#![feature(asm, macro_rules, phase)]
 #![deny(deprecated_owned_vector)]
 
 extern crate collections;
@@ -83,7 +83,7 @@ pub mod stats;
 // colons. This way if some test runner wants to arrange the tests
 // hierarchically it may.
 
-#[deriving(Clone)]
+#[deriving(Clone, Eq, TotalEq, Hash)]
 pub enum TestName {
     StaticTestName(&'static str),
     DynTestName(StrBuf)
@@ -156,6 +156,19 @@ impl TestFn {
     }
 }
 
+impl fmt::Show for TestFn {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write(match *self {
+            StaticTestFn(..) => "StaticTestFn(..)",
+            StaticBenchFn(..) => "StaticBenchFn(..)",
+            StaticMetricFn(..) => "StaticMetricFn(..)",
+            DynTestFn(..) => "DynTestFn(..)",
+            DynMetricFn(..) => "DynMetricFn(..)",
+            DynBenchFn(..) => "DynBenchFn(..)"
+        }.as_bytes())
+    }
+}
+
 /// Manager of the benchmarking runs.
 ///
 /// This is feed into functions marked with `#[bench]` to allow for
@@ -170,13 +183,14 @@ pub struct Bencher {
 
 // The definition of a single test. A test runner will run a list of
 // these.
-#[deriving(Clone)]
+#[deriving(Clone, Show, Eq, TotalEq, Hash)]
 pub struct TestDesc {
     pub name: TestName,
     pub ignore: bool,
     pub should_fail: bool,
 }
 
+#[deriving(Show)]
 pub struct TestDescAndFn {
     pub desc: TestDesc,
     pub testfn: TestFn,
@@ -242,15 +256,9 @@ pub fn test_main(args: &[StrBuf], tests: Vec<TestDescAndFn> ) {
 pub fn test_main_static(args: &[StrBuf], tests: &[TestDescAndFn]) {
     let owned_tests = tests.iter().map(|t| {
         match t.testfn {
-            StaticTestFn(f) =>
-            TestDescAndFn { testfn: StaticTestFn(f), desc: t.desc.clone() },
-
-            StaticBenchFn(f) =>
-            TestDescAndFn { testfn: StaticBenchFn(f), desc: t.desc.clone() },
-
-            _ => {
-                fail!("non-static tests passed to test::test_main_static");
-            }
+            StaticTestFn(f) => TestDescAndFn { testfn: StaticTestFn(f), desc: t.desc.clone() },
+            StaticBenchFn(f) => TestDescAndFn { testfn: StaticBenchFn(f), desc: t.desc.clone() },
+            _ => fail!("non-static tests passed to test::test_main_static")
         }
     }).collect();
     test_main(args, owned_tests)
@@ -419,8 +427,15 @@ pub fn opt_shard(maybestr: Option<StrBuf>) -> Option<(uint,uint)> {
         None => None,
         Some(s) => {
             let mut it = s.as_slice().split('.');
-            match (it.next().and_then(from_str), it.next().and_then(from_str), it.next()) {
-                (Some(a), Some(b), None) => Some((a, b)),
+            match (it.next().and_then(from_str::<uint>), it.next().and_then(from_str::<uint>),
+                   it.next()) {
+                (Some(a), Some(b), None) => {
+                    if a <= 0 || a > b {
+                        fail!("tried to run shard {a}.{b}, but {a} is out of bounds \
+                              (should be between 1 and {b}", a=a, b=b)
+                    }
+                    Some((a, b))
+                }
                 _ => None,
             }
         }
@@ -739,10 +754,9 @@ pub fn fmt_bench_samples(bs: &BenchSamples) -> StrBuf {
 }
 
 // A simple console test runner
-pub fn run_tests_console(opts: &TestOpts,
-                         tests: Vec<TestDescAndFn> ) -> io::IoResult<bool> {
-    fn callback<T: Writer>(event: &TestEvent,
-                           st: &mut ConsoleTestState<T>) -> io::IoResult<()> {
+pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn> ) -> io::IoResult<bool> {
+
+    fn callback<T: Writer>(event: &TestEvent, st: &mut ConsoleTestState<T>) -> io::IoResult<()> {
         match (*event).clone() {
             TeFiltered(ref filtered_tests) => st.write_run_start(filtered_tests.len()),
             TeWait(ref test, padding) => st.write_test_start(test, padding),
@@ -778,6 +792,7 @@ pub fn run_tests_console(opts: &TestOpts,
             }
         }
     }
+
     let mut st = try!(ConsoleTestState::new(opts, None::<StdWriter>));
     fn len_if_padded(t: &TestDescAndFn) -> uint {
         match t.testfn.padding() {
@@ -933,9 +948,7 @@ fn get_concurrency() -> uint {
     }
 }
 
-pub fn filter_tests(
-    opts: &TestOpts,
-    tests: Vec<TestDescAndFn> ) -> Vec<TestDescAndFn> {
+pub fn filter_tests(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> Vec<TestDescAndFn> {
     let mut filtered = tests;
 
     // Remove tests that don't match the test filter
@@ -973,7 +986,9 @@ pub fn filter_tests(
         None => filtered,
         Some((a,b)) => {
             filtered.move_iter().enumerate()
-            .filter(|&(i,_)| i % b == a)
+            // note: using a - 1 so that the valid shards, for example, are
+            // 1.2 and 2.2 instead of 0.2 and 1.2
+            .filter(|&(i,_)| i % b == (a - 1))
             .map(|(_,t)| t)
             .collect()
         }

branches/snap-stage3/src/test/run-make/test-shard-completeness/Makefile

@@ -0,0 +1,7 @@
+-include ../tools.mk
+
+all:
+	# Running all the shards should hit every test
+	$(RUSTC) --test main.rs
+	$(call RUN,main) --test-shard 1.2 | grep "test_1 ... ok"
+	$(call RUN,main) --test-shard 2.2 | grep "test_2 ... ok"

branches/snap-stage3/src/test/run-make/test-shard-completeness/main.rs

@@ -0,0 +1,16 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_type = "lib"]
+
+#[test]
+fn test_1() { }
+#[test]
+fn test_2() { }