---

yaml
---
r: 66174
b: refs/heads/master
c: 8cadca4
h: refs/heads/master
v: v3

Author: artagnon

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: cb58b19f023f95614e4a2bc3c812614d0938a9f2
+refs/heads/master: 8cadca4e41f2aad72391b834f295ae01f9c29551
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/libextra/time.rs

@@ -1142,9 +1142,6 @@ mod tests {
         assert!(result::unwrap(strptime("-0800", "%z")).tm_gmtoff ==
             0);
         assert!(test("%", "%%"));
-
-        // Test for #7256
-        assert_eq!(strptime("360", "%Y-%m-%d"), Err(~"Invalid year"))
     }
 
     fn test_ctime() {

trunk/src/librustc/back/abi.rs

@@ -74,11 +74,3 @@ pub static slice_elt_len: uint = 1u;
 pub static worst_case_glue_call_args: uint = 7u;
 
 pub static abi_version: uint = 1u;
-
-pub fn memcpy_glue_name() -> ~str { return ~"rust_memcpy_glue"; }
-
-pub fn bzero_glue_name() -> ~str { return ~"rust_bzero_glue"; }
-
-pub fn yield_glue_name() -> ~str { return ~"rust_yield_glue"; }
-
-pub fn no_op_type_glue_name() -> ~str { return ~"rust_no_op_type_glue"; }

trunk/src/librustc/middle/resolve.rs

@@ -1415,26 +1415,24 @@ impl Resolver {
                                            (ReducedGraphParent,
                                             vt<ReducedGraphParent>)) {
         let ident = variant.node.name;
-
-        let privacy =
-            match variant.node.vis {
-                public    => Public,
-                private   => Private,
-                inherited => parent_privacy
-            };
+        let (child, _) = self.add_child(ident, parent, ForbidDuplicateValues,
+                                        variant.span);
+
+        let privacy;
+        match variant.node.vis {
+            public => privacy = Public,
+            private => privacy = Private,
+            inherited => privacy = parent_privacy
+        }
 
         match variant.node.kind {
             tuple_variant_kind(_) => {
-                let (child, _) = self.add_child(ident, parent, ForbidDuplicateValues,
-                                                variant.span);
                 child.define_value(privacy,
                                    def_variant(item_id,
                                                local_def(variant.node.id)),
                                    variant.span);
             }
             struct_variant_kind(_) => {
-                let (child, _) = self.add_child(ident, parent, ForbidDuplicateTypesAndValues,
-                                                variant.span);
                 child.define_type(privacy,
                                   def_variant(item_id,
                                               local_def(variant.node.id)),

trunk/src/libstd/hashmap.rs

@@ -18,13 +18,15 @@
 use container::{Container, Mutable, Map, Set};
 use cmp::{Eq, Equiv};
 use hash::Hash;
-use iterator::{Iterator, IteratorUtil};
+use old_iter::BaseIter;
+use old_iter;
+use iterator::IteratorUtil;
 use option::{None, Option, Some};
 use rand::RngUtil;
 use rand;
 use uint;
 use vec;
-use vec::{ImmutableVector, MutableVector};
+use vec::ImmutableVector;
 use kinds::Copy;
 use util::{replace, unreachable};
 
@@ -309,17 +311,24 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
 
     /// Visit all key-value pairs
     fn each<'a>(&'a self, blk: &fn(&K, &'a V) -> bool) -> bool {
-        self.iter().advance(|(k, v)| blk(k, v))
+        for self.buckets.iter().advance |bucket| {
+            for bucket.iter().advance |pair| {
+                if !blk(&pair.key, &pair.value) {
+                    return false;
+                }
+            }
+        }
+        return true;
     }
 
     /// Visit all keys
     fn each_key(&self, blk: &fn(k: &K) -> bool) -> bool {
-        self.iter().advance(|(k, _)| blk(k))
+        self.each(|k, _| blk(k))
     }
 
     /// Visit all values
     fn each_value<'a>(&'a self, blk: &fn(v: &'a V) -> bool) -> bool {
-        self.iter().advance(|(_, v)| blk(v))
+        self.each(|_, v| blk(v))
     }
 
     /// Iterate over the map and mutate the contained values
@@ -515,19 +524,6 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
             TableFull | FoundHole(_) => None,
         }
     }
-
-    /// An iterator visiting all key-value pairs in arbitrary order.
-    /// Iterator element type is (&'a K, &'a V).
-    pub fn iter<'a>(&'a self) -> HashMapIterator<'a, K, V> {
-        HashMapIterator { iter: self.buckets.iter() }
-    }
-
-    /// An iterator visiting all key-value pairs in arbitrary order,
-    /// with mutable references to the values.
-    /// Iterator element type is (&'a K, &'a mut V).
-    pub fn mut_iter<'a>(&'a mut self) -> HashMapMutIterator<'a, K, V> {
-        HashMapMutIterator { iter: self.buckets.mut_iter() }
-    }
 }
 
 impl<K: Hash + Eq, V: Copy> HashMap<K, V> {
@@ -546,7 +542,7 @@ impl<K:Hash + 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.iter().advance |(key, value)| {
+        for self.each |key, value| {
             match other.find(key) {
                 None => return false,
                 Some(v) => if value != v { return false },
@@ -559,68 +555,19 @@ impl<K:Hash + Eq,V:Eq> Eq for HashMap<K, V> {
     fn ne(&self, other: &HashMap<K, V>) -> bool { !self.eq(other) }
 }
 
-/// HashMap iterator
-pub struct HashMapIterator<'self, K, V> {
-    priv iter: vec::VecIterator<'self, Option<Bucket<K, V>>>,
-}
-
-/// HashMap mutable values iterator
-pub struct HashMapMutIterator<'self, K, V> {
-    priv iter: vec::VecMutIterator<'self, Option<Bucket<K, V>>>,
-}
-
-/// HashSet iterator
-pub struct HashSetIterator<'self, K> {
-    priv iter: vec::VecIterator<'self, Option<Bucket<K, ()>>>,
-}
-
-impl<'self, K, V> Iterator<(&'self K, &'self V)> for HashMapIterator<'self, K, V> {
-    #[inline]
-    fn next(&mut self) -> Option<(&'self K, &'self V)> {
-        for self.iter.advance |elt| {
-            match elt {
-                &Some(ref bucket) => return Some((&bucket.key, &bucket.value)),
-                &None => {},
-            }
-        }
-        None
-    }
-}
-
-impl<'self, K, V> Iterator<(&'self K, &'self mut V)> for HashMapMutIterator<'self, K, V> {
-    #[inline]
-    fn next(&mut self) -> Option<(&'self K, &'self mut V)> {
-        for self.iter.advance |elt| {
-            match elt {
-                &Some(ref mut bucket) => return Some((&bucket.key, &mut bucket.value)),
-                &None => {},
-            }
-        }
-        None
-    }
-}
-
-impl<'self, K> Iterator<&'self K> for HashSetIterator<'self, K> {
-    #[inline]
-    fn next(&mut self) -> Option<&'self K> {
-        for self.iter.advance |elt| {
-            match elt {
-                &Some(ref bucket) => return Some(&bucket.key),
-                &None => {},
-            }
-        }
-        None
-    }
-}
-
-
 /// An implementation of a hash set using the underlying representation of a
 /// HashMap where the value is (). As with the `HashMap` type, a `HashSet`
 /// requires that the elements implement the `Eq` and `Hash` traits.
 pub struct HashSet<T> {
     priv map: HashMap<T, ()>
 }
 
+impl<T:Hash + Eq> BaseIter<T> for HashSet<T> {
+    /// Visit all values in order
+    fn each(&self, f: &fn(&T) -> bool) -> bool { self.map.each_key(f) }
+    fn size_hint(&self) -> Option<uint> { Some(self.len()) }
+}
+
 impl<T:Hash + Eq> Eq for HashSet<T> {
     fn eq(&self, other: &HashSet<T>) -> bool { self.map == other.map }
     fn ne(&self, other: &HashSet<T>) -> bool { self.map != other.map }
@@ -654,12 +601,12 @@ impl<T:Hash + Eq> Set<T> for HashSet<T> {
     /// Return true if the set has no elements in common with `other`.
     /// This is equivalent to checking for an empty intersection.
     fn is_disjoint(&self, other: &HashSet<T>) -> bool {
-        self.iter().all(|v| !other.contains(v))
+        old_iter::all(self, |v| !other.contains(v))
     }
 
     /// Return true if the set is a subset of another
     fn is_subset(&self, other: &HashSet<T>) -> bool {
-        self.iter().all(|v| other.contains(v))
+        old_iter::all(self, |v| other.contains(v))
     }
 
     /// Return true if the set is a superset of another
@@ -669,7 +616,7 @@ impl<T:Hash + Eq> Set<T> for HashSet<T> {
 
     /// Visit the values representing the difference
     fn difference(&self, other: &HashSet<T>, f: &fn(&T) -> bool) -> bool {
-        self.iter().advance(|v| other.contains(v) || f(v))
+        self.each(|v| other.contains(v) || f(v))
     }
 
     /// Visit the values representing the symmetric difference
@@ -681,12 +628,12 @@ impl<T:Hash + Eq> Set<T> for HashSet<T> {
 
     /// Visit the values representing the intersection
     fn intersection(&self, other: &HashSet<T>, f: &fn(&T) -> bool) -> bool {
-        self.iter().advance(|v| !other.contains(v) || f(v))
+        self.each(|v| !other.contains(v) || f(v))
     }
 
     /// Visit the values representing the union
     fn union(&self, other: &HashSet<T>, f: &fn(&T) -> bool) -> bool {
-        self.iter().advance(f) && other.iter().advance(|v| self.contains(v) || f(v))
+        self.each(f) && other.each(|v| self.contains(v) || f(v))
     }
 }
 
@@ -717,18 +664,6 @@ impl<T:Hash + Eq> HashSet<T> {
     pub fn contains_equiv<Q:Hash + Equiv<T>>(&self, value: &Q) -> bool {
       self.map.contains_key_equiv(value)
     }
-
-    /// Visit all elements in arbitrary order
-    /// FIXME: #6978: Remove when all callers are converted
-    pub fn each(&self, f: &fn(&T) -> bool) -> bool {
-        self.iter().advance(f)
-    }
-
-    /// An iterator visiting all elements in arbitrary order.
-    /// Iterator element type is &'a T.
-    pub fn iter<'a>(&'a self) -> HashSetIterator<'a, T> {
-        HashSetIterator { iter: self.map.buckets.iter() }
-    }
 }
 
 #[cfg(test)]
@@ -873,7 +808,7 @@ mod test_map {
             assert!(m.insert(i, i*2));
         }
         let mut observed = 0;
-        for m.iter().advance |(k, v)| {
+        for m.each |k, v| {
             assert_eq!(*v, *k * 2);
             observed |= (1 << *k);
         }
@@ -950,7 +885,6 @@ mod test_set {
     use super::*;
     use container::{Container, Map, Set};
     use vec;
-    use uint;
 
     #[test]
     fn test_disjoint() {
@@ -1003,19 +937,6 @@ mod test_set {
         assert!(b.is_superset(&a));
     }
 
-    #[test]
-    fn test_iterate() {
-        let mut a = HashSet::new();
-        for uint::range(0, 32) |i| {
-            assert!(a.insert(i));
-        }
-        let mut observed = 0;
-        for a.iter().advance |k| {
-            observed |= (1 << *k);
-        }
-        assert_eq!(observed, 0xFFFF_FFFF);
-    }
-
     #[test]
     fn test_intersection() {
         let mut a = HashSet::new();

trunk/src/libstd/to_str.rs

@@ -23,7 +23,6 @@ use hash::Hash;
 use cmp::Eq;
 use old_iter::BaseIter;
 use vec::ImmutableVector;
-use iterator::IteratorUtil;
 
 /// A generic trait for converting a value to a string
 pub trait ToStr {
@@ -57,7 +56,7 @@ impl<A:ToStr+Hash+Eq, B:ToStr+Hash+Eq> ToStr for HashMap<A, B> {
     #[inline]
     fn to_str(&self) -> ~str {
         let mut (acc, first) = (~"{", true);
-        for self.iter().advance |(key, value)| {
+        for self.each |key, value| {
             if first {
                 first = false;
             }
@@ -77,7 +76,7 @@ impl<A:ToStr+Hash+Eq> ToStr for HashSet<A> {
     #[inline]
     fn to_str(&self) -> ~str {
         let mut (acc, first) = (~"{", true);
-        for self.iter().advance |element| {
+        for self.each |element| {
             if first {
                 first = false;
             }