---

yaml
---
r: 47615
b: refs/heads/incoming
c: 5e6d787
h: refs/heads/master
i:
  47613: 631bb81
  47611: 6c0425f
  47607: d86a405
  47599: 0b6e396
  47583: c1c716a
  47551: 8a19adf
  47487: 89cdea9
  47359: a67f4f0
  47103: f0d6e8a
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: 2c198561dd878dcfa4fca3b7785215fd3490ca84
+refs/heads/incoming: 5e6d7871c656145a5530b653882a3ce26f40c163
 refs/heads/dist-snap: 8b98e5a296d95c5e832db0756828e5bec31c6f50
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/compiletest/compiletest.rc

@@ -33,7 +33,7 @@ mod errors;
 use std::getopts;
 use std::test;
 
-use core::result;
+use core::{result, either};
 use result::{Ok, Err};
 
 use common::config;
@@ -158,7 +158,11 @@ pub fn test_opts(config: config) -> test::TestOpts {
     test::TestOpts {
         filter: config.filter,
         run_ignored: config.run_ignored,
-        logfile: config.logfile.map(|s| s.to_str()),
+        logfile: copy config.logfile,
+        run_tests: true,
+        run_benchmarks: false,
+        save_results: option::None,
+        compare_results: option::None
     }
 }
 
@@ -210,13 +214,15 @@ pub fn make_test(config: config, testfile: &Path) -> test::TestDescAndFn {
     }
 }
 
-pub fn make_test_name(config: config, testfile: &Path) -> ~str {
-    fmt!("[%s] %s", mode_str(config.mode), testfile.to_str())
+pub fn make_test_name(config: config, testfile: &Path) -> test::TestName {
+    test::DynTestName(fmt!("[%s] %s",
+                           mode_str(config.mode),
+                           testfile.to_str()))
 }
 
 pub fn make_test_closure(config: config, testfile: &Path) -> test::TestFn {
     let testfile = testfile.to_str();
-    fn~() { runtest::run(config, testfile) }
+    test::DynTestFn(fn~() { runtest::run(config, testfile) })
 }
 
 // Local Variables:

branches/incoming/src/libcore/cmp.rs

@@ -85,3 +85,12 @@ pub pure fn gt<T: Ord>(v1: &T, v2: &T) -> bool {
     (*v1).gt(v2)
 }
 
+#[inline(always)]
+pub pure fn min<T: Ord>(v1: T, v2: T) -> T {
+    if v1 < v2 { v1 } else { v2 }
+}
+
+#[inline(always)]
+pub pure fn max<T: Ord>(v1: T, v2: T) -> T {
+    if v1 > v2 { v1 } else { v2 }
+}

branches/incoming/src/libcore/either.rs

@@ -145,7 +145,7 @@ pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
     }
 }
 
-impl<T, U> Either<T, U> {
+pub impl<T, U> Either<T, U> {
     #[inline(always)]
     fn either<V>(&self, f_left: fn(&T) -> V, f_right: fn(&U) -> V) -> V {
         either(f_left, f_right, self)

branches/incoming/src/libcore/num/f64.rs

@@ -21,6 +21,7 @@ use to_str;
 use from_str;
 
 pub use cmath::c_double_targ_consts::*;
+pub use cmp::{min, max};
 
 macro_rules! delegate(
     (

branches/incoming/src/libcore/num/int-template.rs

@@ -24,18 +24,14 @@ use vec;
 use i8;
 use i16;
 use i32;
+pub use cmp::{min, max};
 
 pub const bits : uint = inst::bits;
 pub const bytes : uint = (inst::bits / 8);
 
 pub const min_value: T = (-1 as T) << (bits - 1);
 pub const max_value: T = min_value - 1 as T;
 
-#[inline(always)]
-pub pure fn min(x: T, y: T) -> T { if x < y { x } else { y } }
-#[inline(always)]
-pub pure fn max(x: T, y: T) -> T { if x > y { x } else { y } }
-
 #[inline(always)]
 pub pure fn add(x: T, y: T) -> T { x + y }
 #[inline(always)]

branches/incoming/src/libcore/num/num.rs

@@ -39,6 +39,10 @@ pub trait One {
     static pure fn one() -> Self;
 }
 
+pub pure fn abs<T: Ord Num Zero>(v: T) -> T {
+    if v < Zero::zero() { v.neg() } else { v }
+}
+
 pub trait Round {
     pure fn round(&self, mode: RoundMode) -> Self;
 

branches/incoming/src/libcore/num/uint-template.rs

@@ -27,17 +27,14 @@ use u8;
 use u16;
 use u32;
 
+pub use cmp::{min, max};
+
 pub const bits : uint = inst::bits;
 pub const bytes : uint = (inst::bits / 8);
 
 pub const min_value: T = 0 as T;
 pub const max_value: T = 0 as T - 1 as T;
 
-#[inline(always)]
-pub pure fn min(x: T, y: T) -> T { if x < y { x } else { y } }
-#[inline(always)]
-pub pure fn max(x: T, y: T) -> T { if x > y { x } else { y } }
-
 #[inline(always)]
 pub pure fn add(x: T, y: T) -> T { x + y }
 #[inline(always)]