---

yaml
---
r: 83953
b: refs/heads/dist-snap
c: 58eb70a
h: refs/heads/master
i:
  83951: 629746c
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 20016b92c8c03e33ad9b965fba32ac851fe9f6bf
+refs/heads/dist-snap: 58eb70a5e2ce6602e5685f5cc18ab2fe0c327020
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libextra/treemap.rs

@@ -57,23 +57,25 @@ impl<K: Eq + TotalOrd, V: Eq> Eq for TreeMap<K, V> {
 }
 
 // Lexicographical comparison
-fn lt<K: Ord + TotalOrd, V>(a: &TreeMap<K, V>,
+fn lt<K: Ord + TotalOrd, V: Ord>(a: &TreeMap<K, V>,
                                  b: &TreeMap<K, V>) -> bool {
     let mut x = a.iter();
     let mut y = b.iter();
 
     let (a_len, b_len) = (a.len(), b.len());
     for uint::min(a_len, b_len).times {
-        let (key_a,_) = x.next().unwrap();
-        let (key_b,_) = y.next().unwrap();
+        let (key_a, value_a) = x.next().unwrap();
+        let (key_b, value_b) = y.next().unwrap();
         if *key_a < *key_b { return true; }
         if *key_a > *key_b { return false; }
-    };
+        if *value_a < *value_b { return true; }
+        if *value_a > *value_b { return false; }
+    }
 
     a_len < b_len
 }
 
-impl<K: Ord + TotalOrd, V> Ord for TreeMap<K, V> {
+impl<K: Ord + TotalOrd, V: Ord> Ord for TreeMap<K, V> {
     #[inline]
     fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) }
     #[inline]
@@ -935,7 +937,7 @@ mod test_treemap {
         assert!(b.insert(0, 5));
         assert!(a < b);
         assert!(a.insert(0, 7));
-        assert!(!(a < b) && !(b < a));
+        assert!(!(a < b) && b < a);
         assert!(b.insert(-2, 0));
         assert!(b < a);
         assert!(a.insert(-5, 2));

branches/dist-snap/src/librustc/middle/trans/machine.rs

@@ -14,9 +14,6 @@ use lib::llvm::{ValueRef};
 use lib::llvm::False;
 use lib::llvm::llvm;
 use middle::trans::common::*;
-use middle::trans::type_of;
-use middle::ty;
-use util::ppaux::ty_to_str;
 
 use middle::trans::type_::Type;
 
@@ -116,42 +113,3 @@ pub fn llalign_of(cx: &CrateContext, ty: Type) -> ValueRef {
             llvm::LLVMAlignOf(ty.to_ref()), cx.int_type.to_ref(), False);
     }
 }
-
-// Computes the size of the data part of an enum.
-pub fn static_size_of_enum(cx: &mut CrateContext, t: ty::t) -> uint {
-    if cx.enum_sizes.contains_key(&t) {
-        return cx.enum_sizes.get_copy(&t);
-    }
-
-    debug!("static_size_of_enum %s", ty_to_str(cx.tcx, t));
-
-    match ty::get(t).sty {
-        ty::ty_enum(tid, ref substs) => {
-            // Compute max(variant sizes).
-            let mut max_size = 0;
-            let variants = ty::enum_variants(cx.tcx, tid);
-            for variants.iter().advance |variant| {
-                if variant.args.len() == 0 {
-                    loop;
-                }
-
-                let lltypes = variant.args.map(|&variant_arg| {
-                    let substituted = ty::subst(cx.tcx, substs, variant_arg);
-                    type_of::sizing_type_of(cx, substituted)
-                });
-
-                debug!("static_size_of_enum: variant %s type %s",
-                       cx.tcx.sess.str_of(variant.name),
-                       cx.tn.type_to_str(Type::struct_(lltypes, false)));
-
-                let this_size = llsize_of_real(cx, Type::struct_(lltypes, false));
-                if max_size < this_size {
-                    max_size = this_size;
-                }
-            }
-            cx.enum_sizes.insert(t, max_size);
-            return max_size;
-        }
-        _ => cx.sess.bug("static_size_of_enum called on non-enum")
-    }
-}

branches/dist-snap/src/librustc/middle/trans/type_of.rs

@@ -104,8 +104,7 @@ pub fn type_of_non_gc_box(cx: &mut CrateContext, t: ty::t) -> Type {
 //
 // (2) It won't make any recursive calls to determine the structure of the
 //     type behind pointers. This can help prevent infinite loops for
-//     recursive types. For example, `static_size_of_enum()` relies on this
-//     behavior.
+//     recursive types. For example, enum types rely on this behavior.
 
 pub fn sizing_type_of(cx: &mut CrateContext, t: ty::t) -> Type {
     match cx.llsizingtypes.find_copy(&t) {

branches/dist-snap/src/librustc/util/enum_set.rs

@@ -125,9 +125,9 @@ impl<E:CLike> Iterator<E> for EnumSetIterator<E> {
         Some(elem)
     }
 
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let exact = self.bits.population_count();
-        (exact, Some(exact))
+    fn size_hint(&self) -> (Option<uint>, Option<uint>) {
+        let exact = Some(self.bits.population_count());
+        (exact, exact)
     }
 }
 

branches/dist-snap/src/libstd/iterator.rs

@@ -26,7 +26,6 @@ use option::{Option, Some, None};
 use ops::{Add, Mul};
 use cmp::Ord;
 use clone::Clone;
-use uint;
 
 /// Conversion from an `Iterator`
 pub trait FromIterator<A, T: Iterator<A>> {
@@ -44,7 +43,7 @@ pub trait Iterator<A> {
     /// Return a lower bound and upper bound on the remaining length of the iterator.
     ///
     /// The common use case for the estimate is pre-allocating space to store the results.
-    fn size_hint(&self) -> (uint, Option<uint>) { (0, None) }
+    fn size_hint(&self) -> (Option<uint>, Option<uint>) { (None, None) }
 }
 
 /// Iterator adaptors provided for every `Iterator` implementation. The adaptor objects are also
@@ -685,18 +684,18 @@ impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for ChainIterator<A, T, U> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (Option<uint>, Option<uint>) {
         let (a_lower, a_upper) = self.a.size_hint();
         let (b_lower, b_upper) = self.b.size_hint();
 
-        let lower = if uint::max_value - a_lower < b_lower {
-            uint::max_value
-        } else {
-            a_lower + b_lower
+        let lower = match (a_lower, b_lower) {
+            (Some(x), Some(y)) => Some(x + y),
+            (Some(x), None) => Some(x),
+            (None, Some(y)) => Some(y),
+            (None, None) => None
         };
 
         let upper = match (a_upper, b_upper) {
-            (Some(x), Some(y)) if uint::max_value - x < y => Some(uint::max_value),
             (Some(x), Some(y)) => Some(x + y),
             _ => None
         };
@@ -720,23 +719,6 @@ impl<A, B, T: Iterator<A>, U: Iterator<B>> Iterator<(A, B)> for ZipIterator<A, T
             _ => None
         }
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let (a_lower, a_upper) = self.a.size_hint();
-        let (b_lower, b_upper) = self.b.size_hint();
-
-        let lower = cmp::min(a_lower, b_lower);
-
-        let upper = match (a_upper, b_upper) {
-            (Some(x), Some(y)) => Some(cmp::min(x,y)),
-            (Some(x), None) => Some(x),
-            (None, Some(y)) => Some(y),
-            (None, None) => None
-        };
-
-        (lower, upper)
-    }
 }
 
 /// An iterator which maps the values of `iter` with `f`
@@ -755,7 +737,7 @@ impl<'self, A, B, T: Iterator<A>> Iterator<B> for MapIterator<'self, A, B, T> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (Option<uint>, Option<uint>) {
         self.iter.size_hint()
     }
 }
@@ -780,9 +762,9 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for FilterIterator<'self, A, T> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (Option<uint>, Option<uint>) {
         let (_, upper) = self.iter.size_hint();
-        (0, upper) // can't know a lower bound, due to the predicate
+        (None, upper) // can't know a lower bound, due to the predicate
     }
 }
 
@@ -805,9 +787,9 @@ impl<'self, A, B, T: Iterator<A>> Iterator<B> for FilterMapIterator<'self, A, B,
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (Option<uint>, Option<uint>) {
         let (_, upper) = self.iter.size_hint();
-        (0, upper) // can't know a lower bound, due to the predicate
+        (None, upper) // can't know a lower bound, due to the predicate
     }
 }
 
@@ -830,11 +812,6 @@ impl<A, T: Iterator<A>> Iterator<(uint, A)> for EnumerateIterator<A, T> {
             _ => None
         }
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        self.iter.size_hint()
-    }
 }
 
 /// An iterator which rejects elements while `predicate` is true
@@ -867,12 +844,6 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for SkipWhileIterator<'self, A, T> {
             }
         }
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let (_, upper) = self.iter.size_hint();
-        (0, upper) // can't know a lower bound, due to the predicate
-    }
 }
 
 /// An iterator which only accepts elements while `predicate` is true
@@ -901,12 +872,6 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for TakeWhileIterator<'self, A, T> {
             }
         }
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let (_, upper) = self.iter.size_hint();
-        (0, upper) // can't know a lower bound, due to the predicate
-    }
 }
 
 /// An iterator which skips over `n` elements of `iter`.
@@ -940,21 +905,6 @@ impl<A, T: Iterator<A>> Iterator<A> for SkipIterator<A, T> {
             next
         }
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let (lower, upper) = self.iter.size_hint();
-
-        let lower = if lower >= self.n { lower - self.n } else { 0 };
-
-        let upper = match upper {
-            Some(x) if x >= self.n => Some(x - self.n),
-            Some(_) => Some(0),
-            None => None
-        };
-
-        (lower, upper)
-    }
 }
 
 /// An iterator which only iterates over the first `n` iterations of `iter`.
@@ -975,20 +925,6 @@ impl<A, T: Iterator<A>> Iterator<A> for TakeIterator<A, T> {
             None
         }
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let (lower, upper) = self.iter.size_hint();
-
-        let lower = cmp::min(lower, self.n);
-
-        let upper = match upper {
-            Some(x) if x < self.n => Some(x),
-            _ => Some(self.n)
-        };
-
-        (lower, upper)
-    }
 }
 
 /// An iterator to maintain state while iterating another iterator
@@ -1005,12 +941,6 @@ impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B,
     fn next(&mut self) -> Option<B> {
         self.iter.next().chain(|a| (self.f)(&mut self.state, a))
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let (_, upper) = self.iter.size_hint();
-        (0, upper) // can't know a lower bound, due to the scan function
-    }
 }
 
 /// An iterator that maps each element to an iterator,
@@ -1092,11 +1022,6 @@ impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
         self.state = self.state.add(&self.step); // FIXME: #6050
         Some(result)
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        (uint::max_value, None) // Too bad we can't specify an infinite lower bound
-    }
 }
 
 #[cfg(test)]
@@ -1312,43 +1237,6 @@ mod tests {
         assert_eq!(v.slice(0, 0).iter().transform(|&x| x).min(), None);
     }
 
-    #[test]
-    fn test_iterator_size_hint() {
-        let c = Counter::new(0, 1);
-        let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        let v2 = &[10, 11, 12];
-        let vi = v.iter();
-
-        assert_eq!(c.size_hint(), (uint::max_value, None));
-        assert_eq!(vi.size_hint(), (10, Some(10)));
-
-        assert_eq!(c.take_(5).size_hint(), (5, Some(5)));
-        assert_eq!(c.skip(5).size_hint().second(), None);
-        assert_eq!(c.take_while(|_| false).size_hint(), (0, None));
-        assert_eq!(c.skip_while(|_| false).size_hint(), (0, None));
-        assert_eq!(c.enumerate().size_hint(), (uint::max_value, None));
-        assert_eq!(c.chain_(vi.transform(|&i| i)).size_hint(), (uint::max_value, None));
-        assert_eq!(c.zip(vi).size_hint(), (10, Some(10)));
-        assert_eq!(c.scan(0, |_,_| Some(0)).size_hint(), (0, None));
-        assert_eq!(c.filter(|_| false).size_hint(), (0, None));
-        assert_eq!(c.transform(|_| 0).size_hint(), (uint::max_value, None));
-        assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None));
-
-        assert_eq!(vi.take_(5).size_hint(), (5, Some(5)));
-        assert_eq!(vi.take_(12).size_hint(), (10, Some(10)));
-        assert_eq!(vi.skip(3).size_hint(), (7, Some(7)));
-        assert_eq!(vi.skip(12).size_hint(), (0, Some(0)));
-        assert_eq!(vi.take_while(|_| false).size_hint(), (0, Some(10)));
-        assert_eq!(vi.skip_while(|_| false).size_hint(), (0, Some(10)));
-        assert_eq!(vi.enumerate().size_hint(), (10, Some(10)));
-        assert_eq!(vi.chain_(v2.iter()).size_hint(), (13, Some(13)));
-        assert_eq!(vi.zip(v2.iter()).size_hint(), (3, Some(3)));
-        assert_eq!(vi.scan(0, |_,_| Some(0)).size_hint(), (0, Some(10)));
-        assert_eq!(vi.filter(|_| false).size_hint(), (0, Some(10)));
-        assert_eq!(vi.transform(|i| i+1).size_hint(), (10, Some(10)));
-        assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10)));
-    }
-
     #[test]
     fn test_collect() {
         let a = ~[1, 2, 3, 4, 5];