---

yaml
---
r: 143908
b: refs/heads/try2
c: 8b502d6
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: d9492d72baa73082be91edf8acd6bb97747db3c9
+refs/heads/try2: 8b502d60abf582e799aa7390cb9b8ab2b4465e65
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -371,7 +371,6 @@ opt docs     1 "build documentation"
 opt optimize 1 "build optimized rust code"
 opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"
-opt optimize-tests 1 "build tests with optimizations"
 opt llvm-assertions 1 "build LLVM with assertions"
 opt debug 0 "build with extra debug fun"
 opt ratchet-bench 0 "ratchet benchmarks"

branches/try2/doc/rustpkg.md

@@ -103,11 +103,6 @@ When building a package that is in a `git` repository,
 When building a package that is not under version control,
 or that has no tags, `rustpkg` assumes the intended version is 0.1.
 
-> **Note:** A future version of rustpkg will support semantic versions.
-> Also, a future version will add the option to specify a version with a metadata
-> attribute like `#[link(vers = "3.1415")]` inside the crate module,
-> though this attribute will never be mandatory.
-
 # Dependencies
 
 rustpkg infers dependencies from `extern mod` directives.

branches/try2/mk/tests.mk

@@ -552,15 +552,7 @@ TEST_SREQ$(1)_T_$(2)_H_$(3) = \
 
 # The tests select when to use debug configuration on their own;
 # remove directive, if present, from CFG_RUSTC_FLAGS (issue #7898).
-CTEST_RUSTC_FLAGS := $$(subst --cfg debug,,$$(CFG_RUSTC_FLAGS))
-
-# The tests can not be optimized while the rest of the compiler is optimized, so
-# filter out the optimization (if any) from rustc and then figure out if we need
-# to be optimized
-CTEST_RUSTC_FLAGS := $$(subst -O,,$$(CTEST_RUSTC_FLAGS))
-ifndef CFG_DISABLE_OPTIMIZE_TESTS
-CTEST_RUSTC_FLAGS += -O
-endif
+CTEST_RUSTC_FLAGS = $$(subst --cfg debug,,$$(CFG_RUSTC_FLAGS))
 
 CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
 		--compile-lib-path $$(HLIB$(1)_H_$(3))				\

branches/try2/src/libextra/dlist.rs

@@ -26,7 +26,6 @@ use std::cast;
 use std::ptr;
 use std::util;
 use std::iterator::{FromIterator, Extendable, Invert};
-use std::iterator;
 
 use container::Deque;
 
@@ -590,27 +589,12 @@ impl<A, T: Iterator<A>> Extendable<A, T> for DList<A> {
 impl<A: Eq> Eq for DList<A> {
     fn eq(&self, other: &DList<A>) -> bool {
         self.len() == other.len() &&
-            iterator::order::eq(self.iter(), other.iter())
+            self.iter().zip(other.iter()).all(|(a, b)| a.eq(b))
     }
 
+    #[inline]
     fn ne(&self, other: &DList<A>) -> bool {
-        self.len() != other.len() &&
-            iterator::order::ne(self.iter(), other.iter())
-    }
-}
-
-impl<A: Eq + Ord> Ord for DList<A> {
-    fn lt(&self, other: &DList<A>) -> bool {
-        iterator::order::lt(self.iter(), other.iter())
-    }
-    fn le(&self, other: &DList<A>) -> bool {
-        iterator::order::le(self.iter(), other.iter())
-    }
-    fn gt(&self, other: &DList<A>) -> bool {
-        iterator::order::gt(self.iter(), other.iter())
-    }
-    fn ge(&self, other: &DList<A>) -> bool {
-        iterator::order::ge(self.iter(), other.iter())
+        !self.eq(other)
     }
 }
 
@@ -980,48 +964,6 @@ mod tests {
         assert_eq!(&n, &m);
     }
 
-    #[test]
-    fn test_ord() {
-        let n: DList<int> = list_from([]);
-        let m = list_from([1,2,3]);
-        assert!(n < m);
-        assert!(m > n);
-        assert!(n <= n);
-        assert!(n >= n);
-    }
-
-    #[test]
-    fn test_ord_nan() {
-        let nan = 0.0/0.0;
-        let n = list_from([nan]);
-        let m = list_from([nan]);
-        assert!(!(n < m));
-        assert!(!(n > m));
-        assert!(!(n <= m));
-        assert!(!(n >= m));
-
-        let n = list_from([nan]);
-        let one = list_from([1.0]);
-        assert!(!(n < one));
-        assert!(!(n > one));
-        assert!(!(n <= one));
-        assert!(!(n >= one));
-
-        let u = list_from([1.0,2.0,nan]);
-        let v = list_from([1.0,2.0,3.0]);
-        assert!(!(u < v));
-        assert!(!(u > v));
-        assert!(!(u <= v));
-        assert!(!(u >= v));
-
-        let s = list_from([1.0,2.0,4.0,2.0]);
-        let t = list_from([1.0,2.0,3.0,2.0]);
-        assert!(!(s < t));
-        assert!(s > one);
-        assert!(!(s <= one));
-        assert!(s >= one);
-    }
-
     #[test]
     fn test_fuzz() {
         do 25.times {

branches/try2/src/libstd/iterator.rs

@@ -1568,163 +1568,6 @@ impl<A: Clone> RandomAccessIterator<A> for Repeat<A> {
     fn idx(&self, _: uint) -> Option<A> { Some(self.element.clone()) }
 }
 
-/// Functions for lexicographical ordering of sequences.
-///
-/// Lexicographical ordering through `<`, `<=`, `>=`, `>` requires
-/// that the elements implement both `Eq` and `Ord`.
-///
-/// If two sequences are equal up until the point where one ends,
-/// the shorter sequence compares less.
-pub mod order {
-    use cmp;
-    use cmp::{TotalEq, TotalOrd, Ord, Eq};
-    use option::{Some, None};
-    use super::Iterator;
-
-    /// Compare `a` and `b` for equality using `TotalOrd`
-    pub fn equals<A: TotalEq, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
-        loop {
-            match (a.next(), b.next()) {
-                (None, None) => return true,
-                (None, _) | (_, None) => return false,
-                (Some(x), Some(y)) => if !x.equals(&y) { return false },
-            }
-        }
-    }
-
-    /// Order `a` and `b` lexicographically using `TotalOrd`
-    pub fn cmp<A: TotalOrd, T: Iterator<A>>(mut a: T, mut b: T) -> cmp::Ordering {
-        loop {
-            match (a.next(), b.next()) {
-                (None, None) => return cmp::Equal,
-                (None, _   ) => return cmp::Less,
-                (_   , None) => return cmp::Greater,
-                (Some(x), Some(y)) => match x.cmp(&y) {
-                    cmp::Equal => (),
-                    non_eq => return non_eq,
-                },
-            }
-        }
-    }
-
-    /// Compare `a` and `b` for equality (Using partial equality, `Eq`)
-    pub fn eq<A: Eq, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
-        loop {
-            match (a.next(), b.next()) {
-                (None, None) => return true,
-                (None, _) | (_, None) => return false,
-                (Some(x), Some(y)) => if !x.eq(&y) { return false },
-            }
-        }
-    }
-
-    /// Compare `a` and `b` for nonequality (Using partial equality, `Eq`)
-    pub fn ne<A: Eq, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
-        loop {
-            match (a.next(), b.next()) {
-                (None, None) => return false,
-                (None, _) | (_, None) => return true,
-                (Some(x), Some(y)) => if x.ne(&y) { return true },
-            }
-        }
-    }
-
-    /// Return `a` < `b` lexicographically (Using partial order, `Ord`)
-    pub fn lt<A: Eq + Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
-        loop {
-            match (a.next(), b.next()) {
-                (None, None) => return false,
-                (None, _   ) => return true,
-                (_   , None) => return false,
-                (Some(x), Some(y)) => if x.ne(&y) { return x.lt(&y) },
-            }
-        }
-    }
-
-    /// Return `a` <= `b` lexicographically (Using partial order, `Ord`)
-    pub fn le<A: Eq + Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
-        loop {
-            match (a.next(), b.next()) {
-                (None, None) => return true,
-                (None, _   ) => return true,
-                (_   , None) => return false,
-                (Some(x), Some(y)) => if x.ne(&y) { return x.le(&y) },
-            }
-        }
-    }
-
-    /// Return `a` > `b` lexicographically (Using partial order, `Ord`)
-    pub fn gt<A: Eq + Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
-        loop {
-            match (a.next(), b.next()) {
-                (None, None) => return false,
-                (None, _   ) => return false,
-                (_   , None) => return true,
-                (Some(x), Some(y)) => if x.ne(&y) { return x.gt(&y) },
-            }
-        }
-    }
-
-    /// Return `a` >= `b` lexicographically (Using partial order, `Ord`)
-    pub fn ge<A: Eq + Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool {
-        loop {
-            match (a.next(), b.next()) {
-                (None, None) => return true,
-                (None, _   ) => return false,
-                (_   , None) => return true,
-                (Some(x), Some(y)) => if x.ne(&y) { return x.ge(&y) },
-            }
-        }
-    }
-
-    #[test]
-    fn test_lt() {
-        use vec::ImmutableVector;
-
-        let empty: [int, ..0] = [];
-        let xs = [1,2,3];
-        let ys = [1,2,0];
-
-        assert!(!lt(xs.iter(), ys.iter()));
-        assert!(!le(xs.iter(), ys.iter()));
-        assert!( gt(xs.iter(), ys.iter()));
-        assert!( ge(xs.iter(), ys.iter()));
-
-        assert!( lt(ys.iter(), xs.iter()));
-        assert!( le(ys.iter(), xs.iter()));
-        assert!(!gt(ys.iter(), xs.iter()));
-        assert!(!ge(ys.iter(), xs.iter()));
-
-        assert!( lt(empty.iter(), xs.iter()));
-        assert!( le(empty.iter(), xs.iter()));
-        assert!(!gt(empty.iter(), xs.iter()));
-        assert!(!ge(empty.iter(), xs.iter()));
-
-        // Sequence with NaN
-        let u = [1.0, 2.0];
-        let v = [0.0/0.0, 3.0];
-
-        assert!(!lt(u.iter(), v.iter()));
-        assert!(!le(u.iter(), v.iter()));
-        assert!(!gt(u.iter(), v.iter()));
-        assert!(!ge(u.iter(), v.iter()));
-
-        let a = [0.0/0.0];
-        let b = [1.0];
-        let c = [2.0];
-
-        assert!(lt(a.iter(), b.iter()) == (a[0] <  b[0]));
-        assert!(le(a.iter(), b.iter()) == (a[0] <= b[0]));
-        assert!(gt(a.iter(), b.iter()) == (a[0] >  b[0]));
-        assert!(ge(a.iter(), b.iter()) == (a[0] >= b[0]));
-
-        assert!(lt(c.iter(), b.iter()) == (c[0] <  b[0]));
-        assert!(le(c.iter(), b.iter()) == (c[0] <= b[0]));
-        assert!(gt(c.iter(), b.iter()) == (c[0] >  b[0]));
-        assert!(ge(c.iter(), b.iter()) == (c[0] >= b[0]));
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

branches/try2/src/libstd/macros.rs

@@ -16,12 +16,20 @@ macro_rules! rterrln (
     } )
 )
 
-// Some basic logging. Enabled by passing `--cfg rtdebug` to the libstd build.
+// Some basic logging
+macro_rules! rtdebug_ (
+    ($( $arg:expr),+) => ( {
+        rterrln!( $($arg),+ )
+    } )
+)
+
+// An alternate version with no output, for turning off logging. An
+// earlier attempt that did not call the fmt! macro was insufficient,
+// as a case of the "let bind each variable" approach eventually
+// failed without an error message describing the invocation site.
 macro_rules! rtdebug (
     ($( $arg:expr),+) => ( {
-        if cfg!(rtdebug) {
-            rterrln!( $($arg),+ )
-        }
+        let _x = fmt!( $($arg),+ );
     })
 )
 

branches/try2/src/libstd/option.rs

@@ -47,7 +47,6 @@ use ops::Add;
 use util;
 use num::Zero;
 use iterator::Iterator;
-use iterator;
 use str::{StrSlice, OwnedStr};
 use to_str::ToStr;
 use clone::DeepClone;
@@ -59,21 +58,31 @@ pub enum Option<T> {
     Some(T),
 }
 
-impl<T: Eq + Ord> Ord for Option<T> {
+impl<T:Ord> Ord for Option<T> {
     fn lt(&self, other: &Option<T>) -> bool {
-        iterator::order::lt(self.iter(), other.iter())
+        match (self, other) {
+            (&None, &None) => false,
+            (&None, &Some(_)) => true,
+            (&Some(_), &None) => false,
+            (&Some(ref a), &Some(ref b)) => *a < *b
+        }
     }
 
     fn le(&self, other: &Option<T>) -> bool {
-        iterator::order::le(self.iter(), other.iter())
+        match (self, other) {
+            (&None, &None) => true,
+            (&None, &Some(_)) => true,
+            (&Some(_), &None) => false,
+            (&Some(ref a), &Some(ref b)) => *a <= *b
+        }
     }
 
     fn ge(&self, other: &Option<T>) -> bool {
-        iterator::order::ge(self.iter(), other.iter())
+        !(self < other)
     }
 
     fn gt(&self, other: &Option<T>) -> bool {
-        iterator::order::gt(self.iter(), other.iter())
+        !(self <= other)
     }
 }
 
@@ -544,18 +553,6 @@ mod tests {
         assert!(it.next().is_none());
     }
 
-    #[test]
-    fn test_ord() {
-        let small = Some(1.0);
-        let big = Some(5.0);
-        let nan = Some(0.0/0.0);
-        assert!(!(nan < big));
-        assert!(!(nan > big));
-        assert!(small < big);
-        assert!(None < big);
-        assert!(big > None);
-    }
-
     #[test]
     fn test_mutate() {
         let mut x = Some(3i);

branches/try2/src/libstd/prelude.rs

@@ -70,7 +70,6 @@ pub use from_str::FromStr;
 pub use to_bytes::IterBytes;
 pub use to_str::{ToStr, ToStrConsume};
 pub use tuple::{CopyableTuple, ImmutableTuple, ExtendedTupleOps};
-pub use tuple::{CloneableTuple1, ImmutableTuple1};
 pub use tuple::{CloneableTuple2, CloneableTuple3, CloneableTuple4, CloneableTuple5};
 pub use tuple::{CloneableTuple6, CloneableTuple7, CloneableTuple8, CloneableTuple9};
 pub use tuple::{CloneableTuple10, CloneableTuple11, CloneableTuple12};