---

yaml
---
r: 54612
b: refs/heads/snap-stage3
c: 24eee52
h: refs/heads/master
v: v3

Author: Kimundi

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 3322595e896e95c3e19ca33c854ad529f2ef3c19
+refs/heads/snap-stage3: 24eee5296bd8ec29285f65ef180d9cc9a9a391bf
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

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

@@ -116,19 +116,6 @@ totalord_impl!(i64)
 totalord_impl!(int)
 totalord_impl!(uint)
 
-pub fn cmp2<A:TotalOrd,B:TotalOrd>(
-    a1: &A, b1: &B,
-    a2: &A, b2: &B) -> Ordering
-{
-    //! Compares (a1, b1) against (a2, b2), where the a values are more significant.
-
-    match a1.cmp(a2) {
-        Less => Less,
-        Greater => Greater,
-        Equal => b1.cmp(b2)
-    }
-}
-
 /**
 * Trait for values that can be compared for a sort-order.
 *
@@ -206,14 +193,6 @@ mod test {
         assert_eq!(12.cmp(-5), Greater);
     }
 
-    #[test]
-    fn test_cmp2() {
-        assert_eq!(cmp2(1, 2, 3, 4), Less);
-        assert_eq!(cmp2(3, 2, 3, 4), Less);
-        assert_eq!(cmp2(5, 2, 3, 4), Greater);
-        assert_eq!(cmp2(5, 5, 5, 4), Greater);
-    }
-
     #[test]
     fn test_int_totaleq() {
         assert!(5.equals(&5));

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

@@ -29,9 +29,6 @@ pub trait Map<K, V>: Mutable {
     /// Return true if the map contains a value for the specified key
     fn contains_key(&self, key: &K) -> bool;
 
-    // Visits all keys and values
-    fn each(&self, f: &fn(&K, &V) -> bool);
-
     /// Visit all keys
     fn each_key(&self, f: &fn(&K) -> bool);
 

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

@@ -279,6 +279,24 @@ priv impl<K:Hash + IterBytes + Eq,V> HashMap<K, V> {
     }
 }
 
+impl<'self,K:Hash + IterBytes + Eq,V>
+        BaseIter<(&'self K, &'self V)> for HashMap<K, V> {
+    /// Visit all key-value pairs
+    fn each(&self, blk: &fn(&(&'self K, &'self V)) -> bool) {
+        for uint::range(0, self.buckets.len()) |i| {
+            let mut broke = false;
+            do self.buckets[i].map |bucket| {
+                if !blk(&(&bucket.key, &bucket.value)) {
+                    broke = true; // FIXME(#3064) just write "break;"
+                }
+            };
+            if broke { break; }
+        }
+    }
+    fn size_hint(&self) -> Option<uint> { Some(self.len()) }
+}
+
+
 impl<K:Hash + IterBytes + Eq,V> Container for HashMap<K, V> {
     /// Return the number of elements in the map
     fn len(&const self) -> uint { self.size }
@@ -297,7 +315,7 @@ impl<K:Hash + IterBytes + Eq,V> Mutable for HashMap<K, V> {
     }
 }
 
-impl<K:Hash + IterBytes + Eq,V> Map<K, V> for HashMap<K, V> {
+impl<'self,K:Hash + IterBytes + Eq,V> Map<K, V> for HashMap<K, V> {
     /// Return true if the map contains a value for the specified key
     fn contains_key(&self, k: &K) -> bool {
         match self.bucket_for_key(k) {
@@ -306,25 +324,14 @@ impl<K:Hash + IterBytes + Eq,V> Map<K, V> for HashMap<K, V> {
         }
     }
 
-    /// Visit all key-value pairs
-    fn each(&self, blk: &fn(&'self K, &'self V) -> bool) {
-        for uint::range(0, self.buckets.len()) |i| {
-            for self.buckets[i].each |bucket| {
-                if !blk(&bucket.key, &bucket.value) {
-                    return;
-                }
-            }
-        }
-    }
-
     /// Visit all keys
     fn each_key(&self, blk: &fn(k: &K) -> bool) {
-        self.each(|k, _| blk(k))
+        self.each(|&(k, _)| blk(k))
     }
 
     /// Visit all values
     fn each_value(&self, blk: &fn(v: &V) -> bool) {
-        self.each(|_, v| blk(v))
+        self.each(|&(_, v)| blk(v))
     }
 
     /// Iterate over the map and mutate the contained values
@@ -538,7 +545,7 @@ impl<K:Hash + IterBytes + Eq,V:Eq> Eq for HashMap<K, V> {
     fn eq(&self, other: &HashMap<K, V>) -> bool {
         if self.len() != other.len() { return false; }
 
-        for self.each |key, value| {
+        for self.each |&(key, value)| {
             match other.find(key) {
                 None => return false,
                 Some(v) => if value != v { return false },
@@ -791,7 +798,7 @@ mod test_map {
             assert!(m.insert(i, i*2));
         }
         let mut observed = 0;
-        for m.each |k, v| {
+        for m.each |&(k, v)| {
             assert!(*v == *k * 2);
             observed |= (1 << *k);
         }

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

@@ -344,3 +344,29 @@ pub fn copy_seq<T:Copy,IT:BaseIter<T>,BT:Buildable<T>>(v: &IT) -> BT {
         for v.each |x| { push(*x); }
     }
 }
+
+/**
+ * Helper function to transform an internal iterator into an owned vector.
+ *
+ * # Example:
+ *
+ * ~~~
+ * let v = ~[1, 2, 3];
+ * let v2 = do iter_to_vec |f| { v.each(|e| f(*e)) };
+ * if v != v2 { fail!() }
+ * ~~~
+ */
+#[inline(always)]
+pub fn iter_to_vec<T>(pusher: &fn(it: &fn(T) -> bool)) -> ~[T] {
+    let mut v = ~[];
+    let pushf = |e| {v.push(e); true};
+    pusher(pushf);
+    v
+}
+
+#[test]
+fn test_iter_to_vec() {
+    let v = ~[1, 2, 3];
+    let v2 = do iter_to_vec |f| { v.each(|e| f(*e)) };
+    if v != v2 { fail!() }
+}

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

@@ -301,11 +301,7 @@ pub fn slice_shift_char<'a>(s: &'a str) -> (char, &'a str) {
 
 /// Prepend a char to a string
 pub fn unshift_char(s: &mut ~str, ch: char) {
-    // This could be more efficient.
-    let mut new_str = ~"";
-    new_str.push_char(ch);
-    new_str.push_str(*s);
-    *s = new_str;
+    *s = from_char(ch) + *s;
 }
 
 /**

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

@@ -28,6 +28,24 @@ pub struct TrieMap<T> {
     priv length: uint
 }
 
+impl<'self,T> BaseIter<(uint, &'self T)> for TrieMap<T> {
+    /// Visit all key-value pairs in order
+    #[inline(always)]
+    fn each(&self, f: &fn(&(uint, &'self T)) -> bool) {
+        self.root.each(f);
+    }
+    #[inline(always)]
+    fn size_hint(&self) -> Option<uint> { Some(self.len()) }
+}
+
+impl<'self,T> ReverseIter<(uint, &'self T)> for TrieMap<T> {
+    /// Visit all key-value pairs in reverse order
+    #[inline(always)]
+    fn each_reverse(&self, f: &fn(&(uint, &'self T)) -> bool) {
+        self.root.each_reverse(f);
+    }
+}
+
 impl<T> Container for TrieMap<T> {
     /// Return the number of elements in the map
     #[inline(always)]
@@ -54,22 +72,16 @@ impl<T> Map<uint, T> for TrieMap<T> {
         self.find(key).is_some()
     }
 
-    /// Visit all key-value pairs in order
-    #[inline(always)]
-    fn each(&self, f: &fn(&uint, &'self T) -> bool) {
-        self.root.each(f);
-    }
-
     /// Visit all keys in order
     #[inline(always)]
     fn each_key(&self, f: &fn(&uint) -> bool) {
-        self.each(|k, _| f(k))
+        self.each(|&(k, _)| f(&k))
     }
 
     /// Visit all values in order
     #[inline(always)]
     fn each_value(&self, f: &fn(&T) -> bool) {
-        self.each(|_, v| f(v))
+        self.each(|&(_, v)| f(v))
     }
 
     /// Iterate over the map and mutate the contained values
@@ -136,22 +148,16 @@ pub impl<T> TrieMap<T> {
         TrieMap{root: TrieNode::new(), length: 0}
     }
 
-    /// Visit all key-value pairs in reverse order
-    #[inline(always)]
-    fn each_reverse(&self, f: &fn(&uint, &'self T) -> bool) {
-        self.root.each_reverse(f);
-    }
-
     /// Visit all keys in reverse order
     #[inline(always)]
     fn each_key_reverse(&self, f: &fn(&uint) -> bool) {
-        self.each_reverse(|k, _| f(k))
+        self.each_reverse(|&(k, _)| f(&k))
     }
 
     /// Visit all values in reverse order
     #[inline(always)]
     fn each_value_reverse(&self, f: &fn(&T) -> bool) {
-        self.each_reverse(|_, v| f(v))
+        self.each_reverse(|&(_, v)| f(v))
     }
 }
 
@@ -233,22 +239,22 @@ impl<T> TrieNode<T> {
 }
 
 impl<T> TrieNode<T> {
-    fn each(&self, f: &fn(&uint, &'self T) -> bool) -> bool {
+    fn each(&self, f: &fn(&(uint, &'self T)) -> bool) -> bool {
         for uint::range(0, self.children.len()) |idx| {
             match self.children[idx] {
                 Internal(ref x) => if !x.each(f) { return false },
-                External(k, ref v) => if !f(&k, v) { return false },
+                External(k, ref v) => if !f(&(k, v)) { return false },
                 Nothing => ()
             }
         }
         true
     }
 
-    fn each_reverse(&self, f: &fn(&uint, &'self T) -> bool) -> bool {
+    fn each_reverse(&self, f: &fn(&(uint, &'self T)) -> bool) -> bool {
         for uint::range_rev(self.children.len(), 0) |idx| {
             match self.children[idx - 1] {
                 Internal(ref x) => if !x.each_reverse(f) { return false },
-                External(k, ref v) => if !f(&k, v) { return false },
+                External(k, ref v) => if !f(&(k, v)) { return false },
                 Nothing => ()
             }
         }
@@ -432,8 +438,8 @@ mod tests {
         assert!(m.insert(1, 2));
 
         let mut n = 0;
-        for m.each |k, v| {
-            assert!(*k == n);
+        for m.each |&(k, v)| {
+            assert!(k == n);
             assert!(*v == n * 2);
             n += 1;
         }
@@ -448,11 +454,11 @@ mod tests {
         }
 
         let mut n = uint::max_value - 9999;
-        for m.each |k, v| {
+        for m.each |&(k, v)| {
             if n == uint::max_value - 5000 { break }
             assert!(n < uint::max_value - 5000);
 
-            assert!(*k == n);
+            assert!(k == n);
             assert!(*v == n / 2);
             n += 1;
         }
@@ -469,8 +475,8 @@ mod tests {
         assert!(m.insert(1, 2));
 
         let mut n = 4;
-        for m.each_reverse |k, v| {
-            assert!(*k == n);
+        for m.each_reverse |&(k, v)| {
+            assert!(k == n);
             assert!(*v == n * 2);
             n -= 1;
         }
@@ -485,11 +491,11 @@ mod tests {
         }
 
         let mut n = uint::max_value;
-        for m.each_reverse |k, v| {
+        for m.each_reverse |&(k, v)| {
             if n == uint::max_value - 5000 { break }
             assert!(n > uint::max_value - 5000);
 
-            assert!(*k == n);
+            assert!(k == n);
             assert!(*v == n / 2);
             n -= 1;
         }

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

@@ -161,6 +161,7 @@ impl<A:Ord> Ord for (A,) {
     fn gt(&self, other: &(A,)) -> bool { other.lt(&(*self))  }
 }
 
+
 #[cfg(notest)]
 impl<A:Eq,B:Eq> Eq for (A, B) {
     #[inline(always)]

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

@@ -86,7 +86,7 @@ pub fn have_crate_data(cstore: &CStore, cnum: ast::crate_num) -> bool {
 
 pub fn iter_crate_data(cstore: &CStore,
                        i: &fn(ast::crate_num, @crate_metadata)) {
-    for cstore.metas.each |&k, &v| {
+    for cstore.metas.each |&(&k, &v)| {
         i(k, v);
     }
 }

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

@@ -239,8 +239,7 @@ fn parse_region(st: @mut PState) -> ty::Region {
         assert!(next(st) == '|');
         let br = parse_bound_region(st);
         assert!(next(st) == ']');
-        ty::re_free(ty::FreeRegion {scope_id: id,
-                                    bound_region: br})
+        ty::re_free(id, br)
       }
       's' => {
         let id = parse_int(st);

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

@@ -146,12 +146,12 @@ fn enc_region(w: @io::Writer, cx: @ctxt, r: ty::Region) {
         w.write_char('b');
         enc_bound_region(w, cx, br);
       }
-      ty::re_free(ref fr) => {
+      ty::re_free(id, br) => {
         w.write_char('f');
         w.write_char('[');
-        w.write_int(fr.scope_id);
+        w.write_int(id);
         w.write_char('|');
-        enc_bound_region(w, cx, fr.bound_region);
+        enc_bound_region(w, cx, br);
         w.write_char(']');
       }
       ty::re_scope(nid) => {

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

@@ -475,12 +475,9 @@ impl tr for ty::Region {
     fn tr(&self, xcx: @ExtendedDecodeContext) -> ty::Region {
         match *self {
             ty::re_bound(br) => ty::re_bound(br.tr(xcx)),
+            ty::re_free(id, br) => ty::re_free(xcx.tr_id(id), br.tr(xcx)),
             ty::re_scope(id) => ty::re_scope(xcx.tr_id(id)),
             ty::re_static | ty::re_infer(*) => *self,
-            ty::re_free(ref fr) => {
-                ty::re_free(ty::FreeRegion {scope_id: xcx.tr_id(fr.scope_id),
-                                            bound_region: fr.bound_region.tr(xcx)})
-            }
         }
     }
 }