---

yaml
---
r: 143906
b: refs/heads/try2
c: 88b89f8
h: refs/heads/master
v: v3

Author: alexcrichton

[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: 59da4e0bc971f3435f6e8b29ed9447a02f21487d
+refs/heads/try2: 88b89f84766930b1d6d7be1c558290c40e55d4ff
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -371,6 +371,7 @@ 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,7 +552,15 @@ 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))
+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_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
 		--compile-lib-path $$(HLIB$(1)_H_$(3))				\

branches/try2/src/etc/zsh/_rust

@@ -27,8 +27,7 @@ _rustc_opts_switches=(
     --sysroot'[Override the system root]'
     --test'[Build a test harness]'
     --target'[Target triple cpu-manufacturer-kernel\[-os\] to compile]'
-    --target-cpu'[Select target processor (llc -mcpu=help for details)]'
-    --target-feature'[Target specific attributes (llc -mattr=help for details)]'
+    --target-feature'[Target specific attributes (llc -mattr=help for detail)]'
     --android-cross-path'[The path to the Android NDK]'
     {-v,--version}'[Print version info and exit]'
 )

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/libextra/treemap.rs

@@ -14,8 +14,7 @@
 
 
 use std::util::{swap, replace};
-use std::iterator::{FromIterator, Extendable, Peekable};
-use std::cmp::Ordering;
+use std::iterator::{FromIterator, Extendable};
 
 // This is implemented as an AA tree, which is a simplified variation of
 // a red-black tree where red (horizontal) nodes can only be added
@@ -530,24 +529,24 @@ impl<T: TotalOrd> TreeSet<T> {
 
     /// Visit the values (in-order) representing the difference
     pub fn difference<'a>(&'a self, other: &'a TreeSet<T>) -> Difference<'a, T> {
-        Difference{a: self.iter().peekable(), b: other.iter().peekable()}
+        Difference{a: Focus::new(self.iter()), b: Focus::new(other.iter())}
     }
 
     /// Visit the values (in-order) representing the symmetric difference
     pub fn symmetric_difference<'a>(&'a self, other: &'a TreeSet<T>)
         -> SymDifference<'a, T> {
-        SymDifference{a: self.iter().peekable(), b: other.iter().peekable()}
+        SymDifference{a: Focus::new(self.iter()), b: Focus::new(other.iter())}
     }
 
     /// Visit the values (in-order) representing the intersection
     pub fn intersection<'a>(&'a self, other: &'a TreeSet<T>)
         -> Intersection<'a, T> {
-        Intersection{a: self.iter().peekable(), b: other.iter().peekable()}
+        Intersection{a: Focus::new(self.iter()), b: Focus::new(other.iter())}
     }
 
     /// Visit the values (in-order) representing the union
     pub fn union<'a>(&'a self, other: &'a TreeSet<T>) -> Union<'a, T> {
-        Union{a: self.iter().peekable(), b: other.iter().peekable()}
+        Union{a: Focus::new(self.iter()), b: Focus::new(other.iter())}
     }
 }
 
@@ -561,47 +560,61 @@ pub struct TreeSetRevIterator<'self, T> {
     priv iter: TreeMapRevIterator<'self, T, ()>
 }
 
+// Encapsulate an iterator and hold its latest value until stepped forward
+struct Focus<A, T> {
+    priv iter: T,
+    priv focus: Option<A>,
+}
+
+impl<A, T: Iterator<A>> Focus<A, T> {
+    fn new(mut it: T) -> Focus<A, T> {
+        Focus{focus: it.next(), iter: it}
+    }
+    fn step(&mut self) {
+        self.focus = self.iter.next()
+    }
+}
+
 /// Lazy iterator producing elements in the set difference (in-order)
 pub struct Difference<'self, T> {
-    priv a: Peekable<&'self T, TreeSetIterator<'self, T>>,
-    priv b: Peekable<&'self T, TreeSetIterator<'self, T>>,
+    priv a: Focus<&'self T, TreeSetIterator<'self, T>>,
+    priv b: Focus<&'self T, TreeSetIterator<'self, T>>,
 }
 
 /// Lazy iterator producing elements in the set symmetric difference (in-order)
 pub struct SymDifference<'self, T> {
-    priv a: Peekable<&'self T, TreeSetIterator<'self, T>>,
-    priv b: Peekable<&'self T, TreeSetIterator<'self, T>>,
+    priv a: Focus<&'self T, TreeSetIterator<'self, T>>,
+    priv b: Focus<&'self T, TreeSetIterator<'self, T>>,
 }
 
 /// Lazy iterator producing elements in the set intersection (in-order)
 pub struct Intersection<'self, T> {
-    priv a: Peekable<&'self T, TreeSetIterator<'self, T>>,
-    priv b: Peekable<&'self T, TreeSetIterator<'self, T>>,
+    priv a: Focus<&'self T, TreeSetIterator<'self, T>>,
+    priv b: Focus<&'self T, TreeSetIterator<'self, T>>,
 }
 
 /// Lazy iterator producing elements in the set intersection (in-order)
 pub struct Union<'self, T> {
-    priv a: Peekable<&'self T, TreeSetIterator<'self, T>>,
-    priv b: Peekable<&'self T, TreeSetIterator<'self, T>>,
-}
-
-/// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
-fn cmp_opt<T: TotalOrd>(x: Option<&T>, y: Option<&T>,
-                        short: Ordering, long: Ordering) -> Ordering {
-    match (x, y) {
-        (None    , _       ) => short,
-        (_       , None    ) => long,
-        (Some(x1), Some(y1)) => x1.cmp(y1),
-    }
+    priv a: Focus<&'self T, TreeSetIterator<'self, T>>,
+    priv b: Focus<&'self T, TreeSetIterator<'self, T>>,
 }
 
 impl<'self, T: TotalOrd> Iterator<&'self T> for Difference<'self, T> {
     fn next(&mut self) -> Option<&'self T> {
         loop {
-            match cmp_opt(self.a.peek(), self.b.peek(), Less, Less) {
-                Less    => return self.a.next(),
-                Equal   => { self.a.next(); self.b.next(); }
-                Greater => { self.b.next(); }
+            match (self.a.focus, self.b.focus) {
+                (None    , _       ) => return None,
+                (ret     , None    ) => { self.a.step(); return ret },
+                (Some(a1), Some(b1)) => {
+                    let cmp = a1.cmp(b1);
+                    if cmp == Less {
+                        self.a.step();
+                        return Some(a1);
+                    } else {
+                        if cmp == Equal { self.a.step() }
+                        self.b.step();
+                    }
+                }
             }
         }
     }
@@ -610,10 +623,23 @@ impl<'self, T: TotalOrd> Iterator<&'self T> for Difference<'self, T> {
 impl<'self, T: TotalOrd> Iterator<&'self T> for SymDifference<'self, T> {
     fn next(&mut self) -> Option<&'self T> {
         loop {
-            match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
-                Less    => return self.a.next(),
-                Equal   => { self.a.next(); self.b.next(); }
-                Greater => return self.b.next(),
+            match (self.a.focus, self.b.focus) {
+                (ret     , None    ) => { self.a.step(); return ret },
+                (None    , ret     ) => { self.b.step(); return ret },
+                (Some(a1), Some(b1)) => {
+                    let cmp = a1.cmp(b1);
+                    if cmp == Less {
+                        self.a.step();
+                        return Some(a1);
+                    } else {
+                        self.b.step();
+                        if cmp == Greater {
+                            return Some(b1);
+                        } else {
+                            self.a.step();
+                        }
+                    }
+                }
             }
         }
     }
@@ -622,16 +648,20 @@ impl<'self, T: TotalOrd> Iterator<&'self T> for SymDifference<'self, T> {
 impl<'self, T: TotalOrd> Iterator<&'self T> for Intersection<'self, T> {
     fn next(&mut self) -> Option<&'self T> {
         loop {
-            let o_cmp = match (self.a.peek(), self.b.peek()) {
-                (None    , _       ) => None,
-                (_       , None    ) => None,
-                (Some(a1), Some(b1)) => Some(a1.cmp(b1)),
-            };
-            match o_cmp {
-                None          => return None,
-                Some(Less)    => { self.a.next(); }
-                Some(Equal)   => { self.b.next(); return self.a.next() }
-                Some(Greater) => { self.b.next(); }
+            match (self.a.focus, self.b.focus) {
+                (None    , _       ) => return None,
+                (_       , None    ) => return None,
+                (Some(a1), Some(b1)) => {
+                    let cmp = a1.cmp(b1);
+                    if cmp == Less {
+                        self.a.step();
+                    } else {
+                        self.b.step();
+                        if cmp == Equal {
+                            return Some(a1);
+                        }
+                    }
+                },
             }
         }
     }
@@ -640,10 +670,22 @@ impl<'self, T: TotalOrd> Iterator<&'self T> for Intersection<'self, T> {
 impl<'self, T: TotalOrd> Iterator<&'self T> for Union<'self, T> {
     fn next(&mut self) -> Option<&'self T> {
         loop {
-            match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
-                Less    => return self.a.next(),
-                Equal   => { self.b.next(); return self.a.next() }
-                Greater => return self.b.next(),
+            match (self.a.focus, self.b.focus) {
+                (ret     , None) => { self.a.step(); return ret },
+                (None    , ret ) => { self.b.step(); return ret },
+                (Some(a1), Some(b1)) => {
+                    let cmp = a1.cmp(b1);
+                    if cmp == Greater {
+                        self.b.step();
+                        return Some(b1);
+                    } else {
+                        self.a.step();
+                        if cmp == Equal {
+                            self.b.step();
+                        }
+                        return Some(a1);
+                    }
+                }
             }
         }
     }

branches/try2/src/librustc/back/abi.rs

@@ -46,8 +46,7 @@ pub static tydesc_field_take_glue: uint = 2u;
 pub static tydesc_field_drop_glue: uint = 3u;
 pub static tydesc_field_free_glue: uint = 4u;
 pub static tydesc_field_visit_glue: uint = 5u;
-pub static tydesc_field_borrow_offset: uint = 6u;
-pub static n_tydesc_fields: uint = 7u;
+pub static n_tydesc_fields: uint = 6u;
 
 // The two halves of a closure: code and environment.
 pub static fn_field_code: uint = 0u;