fixes

Author: pczarn

src/libstd/collections/hash/map.rs

@@ -1004,7 +1004,7 @@ impl<K, V, S, H> HashMap<K, V, S>
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn drain(&mut self) -> Drain<K, V> {
         Drain {
-            inner: Bucket::at_index(&mut self.table, 0).unwrap()
+            inner: Bucket::at_index(&mut self.table, 0)
         }
     }
 
@@ -1295,7 +1295,7 @@ impl<'a, K, V> Clone for Values<'a, K, V> {
 #[unstable(feature = "std_misc",
            reason = "matches collection reform specification, waiting for dust to settle")]
 pub struct Drain<'a, K: 'a, V: 'a> {
-    inner: table::Bucket<K, V, &'a mut RawTable<K, V>>,
+    inner: Option<table::Bucket<K, V, &'a mut RawTable<K, V>>>,
 }
 
 /// A view into a single occupied location in a HashMap.
@@ -1469,26 +1469,30 @@ impl<'a, K, V> Iterator for Drain<'a, K, V> {
     type Item = (K, V);
 
     fn next(&mut self) -> Option<(K, V)> {
-        let cap = self.inner.table().capacity();
-        while self.inner.index() < cap {
-            if let Some(kv_pair) = self.inner.peek_take() {
-                return Some(kv_pair);
+        if let Some(ref mut bucket) = self.inner {
+            let cap = bucket.table().capacity();
+            while bucket.index() < cap {
+                if let Some(kv_pair) = bucket.peek_take() {
+                    return Some(kv_pair);
+                }
+                bucket.next();
             }
-            self.inner.next();
         }
 
         None
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let size = self.inner.table().size();
-        (size, Some(size))
+        self.inner.as_ref().map(|bucket| {
+            let size = bucket.table().size();
+            (size, Some(size))
+        }).unwrap_or((0, Some(0)))
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> {
-    fn len(&self) -> usize { self.inner.table().size() }
+    fn len(&self) -> usize { self.inner.as_ref().map(|bucket| bucket.table().size()).unwrap_or(0) }
 }
 
 #[unsafe_destructor]
@@ -1879,14 +1883,14 @@ mod test_map {
     #[test]
     fn test_empty_entry() {
         let mut m: HashMap<int, bool> = HashMap::new();
-        assert!(m.entry(0).is_err());
+        assert!(m.entry(0).get().is_err());
         assert!(*m.entry(0).get().unwrap_or_else(|e| e.insert(true)));
         assert_eq!(m.len(), 1);
     }
 
     #[test]
     fn test_empty_iter() {
-        let m: HashMap<int, bool> = HashMap::new();
+        let mut m: HashMap<int, bool> = HashMap::new();
         assert_eq!(m.drain().next(), None);
         assert_eq!(m.keys().next(), None);
         assert_eq!(m.values().next(), None);

src/libstd/collections/hash/table.rs

@@ -462,11 +462,18 @@ impl<K, V> RawTable<K, V> {
 
     #[inline]
     fn first_bucket_raw<M>(&self) -> RawBucket<K, V, M> {
-        RawBucket {
-            hash: self.middle.0 as *mut Option<SafeHash>,
-            kval: unsafe {
-                self.middle.0.offset(-(self.capacity as isize))
-            },
+        if self.capacity() == 0 {
+            RawBucket {
+                hash: ptr::null_mut(),
+                kval: ptr::null_mut(),
+            }
+        } else {
+            RawBucket {
+                hash: self.middle.0 as *mut Option<SafeHash>,
+                kval: unsafe {
+                    self.middle.0.offset(-(self.capacity as isize))
+                },
+            }
         }
     }
 
@@ -567,6 +574,7 @@ fn test_rounding() {
     assert_eq!(round_up_to_next(3, 4), 4);
     assert_eq!(round_up_to_next(4, 4), 4);
     assert_eq!(round_up_to_next(5, 4), 8);
+    assert_eq!(round_up_to_next(5, 8), 8);
 }
 
 #[inline]