use BorrowFrom

pczarn · pczarn · commit 92c2f4c227d7 · 2015-02-07T18:46:21.000+01:00
diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
@@ -13,7 +13,7 @@
 use self::Entry::*;
 use self::VacantEntryState::*;
 
-use borrow::BorrowFrom;
+use borrow::{BorrowFrom, BorrowFromMut};
 use clone::Clone;
 use cmp::{max, Eq, PartialEq};
 use default::Default;
@@ -36,7 +36,8 @@ use super::table::{
     FullBucketImm,
     FullBucketMut,
     RawTable,
-    SafeHash
+    SafeHash,
+    TableRef,
 };
 use super::table::BucketState::{
     Empty,
@@ -321,12 +322,13 @@ fn search_hashed<K, V, M, F>(table: M,
                              hash: SafeHash,
                              mut is_match: F)
                              -> InternalEntry<K, V, M> where
-    M: Deref<Target=RawTable<K, V>>,
+    RawTable<K, V>: BorrowFrom<M>,
     F: FnMut(&K) -> bool,
 {
     // Worst case, we'll find one empty bucket among `size + 1` buckets.
+    let table = TableRef(table);
     let size = table.size();
-    let mut probe = match Bucket::new(table, hash) {
+    let mut probe = match Bucket::new(table.0, hash) {
         Some(probe) => probe,
         None => return InternalEntry::TableIsEmpty,
     };
@@ -418,7 +420,8 @@ fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>,
                     let b = bucket.put(old_hash, old_key, old_val);
                     // Now that it's stolen, just read the value's pointer
                     // right out of the table!
-                    let starting_bucket = Bucket::at_index(b.into_table(), starting_index).unwrap()
+                    let starting_bucket = Bucket::at_index(b.into_table(), starting_index).ok()
+                                                                                          .unwrap()
                                                                                           .peek();
                     if let Full(starting_bucket) = starting_bucket {
                         return starting_bucket.into_mut_refs().1;
@@ -448,10 +451,11 @@ fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>,
 // Performs insertion with relaxed requirements.
 // The caller should ensure that invariants of Robin Hood linear probing hold.
 fn insert_hashed_ordered<M, K, V>(arg: M, h: SafeHash, k: K, v: V) -> M
-    where M: Deref<Target=RawTable<K, V>> + DerefMut
+    where RawTable<K, V>: BorrowFromMut<M>
 {
-    let cap = arg.capacity();
-    let mut buckets = Bucket::new(arg, h).unwrap();
+    let table = TableRef(arg);
+    let cap = table.capacity();
+    let mut buckets = Bucket::new(table.0, h).unwrap();
     let ib = buckets.index();
 
     while buckets.index() != ib + cap {
@@ -670,7 +674,7 @@ impl<K, V, S, H> HashMap<K, V, S>
         // Iterate over `old_capacity` buckets, which constitute half of
         // the table which was resized in-place, or the entire
         // `old_table`.
-        let mut bucket = Bucket::at_index(&mut self.table, 0).unwrap().iter_to(old_capacity);
+        let mut bucket = Bucket::at_index(&mut self.table, 0).ok().unwrap().iter_to(old_capacity);
 
         // "So a few of the first shall be last: for many be called,
         // but few chosen."
@@ -1004,7 +1008,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)
+            inner: Bucket::at_index(&mut self.table, 0).ok()
         }
     }
 
@@ -1516,7 +1520,7 @@ impl<'a, K, V> Entry<'a, K, V> {
 
 #[unstable(feature = "std_misc",
            reason = "matches collection reform v2 specification, waiting for dust to settle")]
-impl<K, V, M: Deref<Target=RawTable<K, V>>> OccupiedEntryState<K, V, M> {
+impl<K, V, M> OccupiedEntryState<K, V, M> where RawTable<K, V>: BorrowFrom<M> {
     /// Gets a reference to the value in the entry.
     pub fn get(&self) -> &V {
         self.elem.read().2
@@ -1525,7 +1529,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> OccupiedEntryState<K, V, M> {
 
 #[unstable(feature = "std_misc",
            reason = "matches collection reform v2 specification, waiting for dust to settle")]
-impl<K, V, M: DerefMut<Target=RawTable<K, V>>> OccupiedEntryState<K, V, M> {
+impl<K, V, M> OccupiedEntryState<K, V, M> where RawTable<K, V>: BorrowFromMut<M> {
     /// Gets a mutable reference to the value in the entry.
     pub fn get_mut(&mut self) -> &mut V {
         self.elem.read_mut().2
diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
@@ -12,6 +12,7 @@
 
 use self::BucketState::*;
 
+use borrow::{BorrowFrom, BorrowFromMut};
 use clone::Clone;
 use cmp;
 use hash::{Hash, Hasher};
@@ -78,11 +79,16 @@ struct RawBucket<K, V, M> {
 
 impl<K,V,M> Copy for RawBucket<K,V,M> {}
 
+#[derive(Clone)]
+pub struct TableRef<M>(M);
+
+impl<M: Copy> Copy for TableRef<M> {}
+
 struct BareBucket<K, V, M> {
     raw: RawBucket<K, V, M>,
     idx: usize,
     capacity: usize,
-    table: M,
+    table: TableRef<M>,
 }
 
 impl<K,V,M:Copy> Copy for BareBucket<K,V,M> {}
@@ -151,11 +157,19 @@ fn can_alias_safehash_as_option() {
     assert_eq!(size_of::<SafeHash>(), size_of::<Option<SafeHash>>())
 }
 
-impl<K, V> Deref for RawTable<K, V> {
+#[old_impl_check]
+impl<K, V, M> Deref for TableRef<M> where RawTable<K, V>: BorrowFrom<M> {
     type Target = RawTable<K, V>;
 
     fn deref(&self) -> &RawTable<K, V> {
-        self
+        BorrowFrom::borrow_from(&mut self.0)
+    }
+}
+
+#[old_impl_check]
+impl<K, V, M> DerefMut for TableRef<M> where RawTable<K, V>: BorrowFromMut<M> {
+    fn deref_mut(&mut self) -> &mut RawTable<K, V> {
+        BorrowFromMut::borrow_from_mut(&mut self.0)
     }
 }
 
@@ -168,7 +182,7 @@ impl<K, V, M> RawBucket<K, V, M> {
     }
 }
 
-impl<'t, K, V, M: Deref<Target=RawTable<K, V>> + 't> RawBucket<K, V, M> {
+impl<'t, K, V, M: 't> RawBucket<K, V, M> where RawTable<K, V>: BorrowFrom<M> {
     pub fn into_refs(self) -> (&'t K, &'t V) {
         let &(ref k, ref v) = unsafe {
             &*self.kval
@@ -178,7 +192,7 @@ impl<'t, K, V, M: Deref<Target=RawTable<K, V>> + 't> RawBucket<K, V, M> {
 }
 
 impl<'t, K, V, M> RawBucket<K, V, M>
-    where M: Deref<Target=RawTable<K, V>> + DerefMut + 't
+    where RawTable<K, V>: BorrowFromMut<M>, M: 't
 {
     pub fn into_mut_refs(self) -> (&'t mut K, &'t mut V) {
         let &mut (ref mut k, ref mut v) = unsafe {
@@ -190,29 +204,31 @@ impl<'t, K, V, M> RawBucket<K, V, M>
 
 // Chain buckets! This is perfectly safe as long as operations on one
 // `Bucket` can't invalidate other `Bucket`s.
-impl<K, V, M: Deref<Target=RawTable<K, V>>> Deref for Bucket<K, V, M> {
-    type Target = RawTable<K, V>;
-
-    fn deref(&self) -> &RawTable<K, V> {
-        &*self.0.table
+impl<K, V, M> BorrowFrom<Bucket<K, V, M>> for RawTable<K, V>
+    where RawTable<K, V>: BorrowFrom<M>
+{
+    fn borrow_from(bucket: &Bucket<K, V, M>) -> &RawTable<K, V> {
+        BorrowFrom::borrow_from(&bucket.0.table.0)
     }
 }
 
-impl<K, V, M: DerefMut<Target=RawTable<K, V>>> DerefMut for Bucket<K, V, M> {
-    fn deref_mut(&mut self) -> &mut RawTable<K, V> {
-        &mut *self.0.table
+impl<K, V, M> BorrowFromMut<Bucket<K, V, M>> for RawTable<K, V>
+    where RawTable<K, V>: BorrowFromMut<M>
+{
+    fn borrow_from_mut(bucket: &mut Bucket<K, V, M>) -> &mut RawTable<K, V> {
+        BorrowFromMut::borrow_from_mut(&mut bucket.0.table.0)
     }
 }
 
 // Buckets hold references to the table.
 impl<K, V, M, S> Bucket<K, V, M, S> {
     /// Borrow a reference to the table.
     pub fn table(&self) -> &M {
-        &self.0.table
+        &self.0.table.0
     }
     /// Move out the reference to the table.
     pub fn into_table(self) -> M {
-        self.0.table
+        self.0.table.0
     }
     /// Get the raw index.
     pub fn index(&self) -> uint {
@@ -221,23 +237,24 @@ impl<K, V, M, S> Bucket<K, V, M, S> {
     /// Turn the bucket into an iterator over full buckets.
     pub fn into_iter(self) -> RawFullBuckets<K, V, M> {
         RawFullBuckets {
-            raw: self.raw,
+            raw: self.0.raw,
             hashes_end: unsafe {
-                self.raw.hash.offset(self.0.capacity as int - self.index() as int)
+                self.0.raw.hash.offset(self.0.capacity as int - self.index() as int)
             },
-            table: self.table,
+            table: self.0.table,
         }
     }
 }
 
-impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> {
+impl<K, V, M> Bucket<K, V, M> where RawTable<K, V>: BorrowFrom<M> {
     pub fn new(table: M, hash: SafeHash) -> Option<Bucket<K, V, M>> {
         Bucket::at_index(table, *hash as usize).ok()
     }
 
     pub fn at_index(table: M, ib_index: uint)
                    -> Result<Bucket<K, V, M>, Bucket<K, V, M, bucket::TableIsEmpty>>
     {
+        let table = TableRef(table);
         let ib_index = ib_index & (table.capacity() - 1);
         let bb = BareBucket {
             raw: unsafe {
@@ -261,7 +278,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> {
 
     /// Narrows down the range of iteration, which must be a power of 2.
     pub fn iter_to(mut self, limit: usize) -> Bucket<K, V, M> {
-        assert!(limit <= self.capacity);
+        assert!(limit <= TableRef(&self.table).capacity());
         assert!(limit.is_power_of_two());
         self.0.capacity = limit;
         self
@@ -294,7 +311,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> {
     }
 }
 
-impl<K, V, M: Deref<Target=RawTable<K, V>> + DerefMut> Bucket<K, V, M> {
+impl<K, V, M> Bucket<K, V, M> where RawTable<K, V>: BorrowFromMut<M> {
     /// A combination of `peek` and `take` which doesn't consume the bucket.
     pub fn peek_take(&mut self) -> Option<(K, V)> {
         unsafe {
@@ -310,7 +327,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>> + DerefMut> Bucket<K, V, M> {
     }
 }
 
-impl<K, V, M: Deref<Target=RawTable<K, V>>, S> Bucket<K, V, M, S> {
+impl<K, V, M, S> Bucket<K, V, M, S> where RawTable<K, V>: BorrowFrom<M> {
     #[inline]
     pub fn into_next(self) -> Bucket<K, V, M> {
         let mut bucket = self.into_bucket();
@@ -324,10 +341,10 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>, S> Bucket<K, V, M, S> {
     }
 }
 
-impl<K, V, M: Deref<Target=RawTable<K, V>>> EmptyBucket<K, V, M> {
+impl<K, V, M> EmptyBucket<K, V, M> where RawTable<K, V>: BorrowFrom<M> {
     pub fn gap_peek(self) -> Option<GapThenFull<K, V, M>> {
         let gap = Bucket(BareBucket {
-            table: (),
+            table: TableRef(()),
             idx: self.0.idx,
             capacity: self.0.capacity,
             raw: RawBucket {
@@ -348,7 +365,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> EmptyBucket<K, V, M> {
     }
 }
 
-impl<K, V, M: Deref<Target=RawTable<K, V>> + DerefMut> EmptyBucket<K, V, M> {
+impl<K, V, M> EmptyBucket<K, V, M> where RawTable<K, V>: BorrowFromMut<M> {
     /// Puts given key and value pair, along with the key's hash,
     /// into this bucket in the hashtable. Note how `self` is 'moved' into
     /// this function, because this slot will no longer be empty when
@@ -369,7 +386,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>> + DerefMut> EmptyBucket<K, V, M> {
     }
 }
 
-impl<K, V, M: Deref<Target=RawTable<K, V>>> FullBucket<K, V, M> {
+impl<K, V, M> FullBucket<K, V, M> where RawTable<K, V>: BorrowFrom<M> {
     /// Get the distance between this bucket and the 'ideal' location
     /// as determined by the key's hash stored in it.
     ///
@@ -391,7 +408,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> FullBucket<K, V, M> {
     }
 }
 
-impl<K, V, M: Deref<Target=RawTable<K, V>> + DerefMut> FullBucket<K, V, M> {
+impl<K, V, M> FullBucket<K, V, M> where RawTable<K, V>: BorrowFromMut<M> {
     /// Removes this bucket's key and value from the hashtable.
     ///
     /// This works similarly to `put`, building an `EmptyBucket` out of the
@@ -415,7 +432,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>> + DerefMut> FullBucket<K, V, M> {
     }
 }
 
-impl<'t, K, V, M: Deref<Target=RawTable<K, V>> + 't> FullBucket<K, V, M> {
+impl<'t, K, V, M: 't> FullBucket<K, V, M> where RawTable<K, V>: BorrowFrom<M> {
     /// Exchange a bucket state for immutable references into the table.
     /// Because the underlying reference to the table is also consumed,
     /// no further changes to the structure of the table are possible;
@@ -426,15 +443,15 @@ impl<'t, K, V, M: Deref<Target=RawTable<K, V>> + 't> FullBucket<K, V, M> {
     }
 }
 
-impl<'t, K, V, M: Deref<Target=RawTable<K, V>> + DerefMut + 't> FullBucket<K, V, M> {
+impl<'t, K, V, M: 't> FullBucket<K, V, M> where RawTable<K, V>: BorrowFromMut<M> {
     /// This works similarly to `into_refs`, exchanging a bucket state
     /// for mutable references into the table.
     pub fn into_mut_refs(self) -> (&'t mut K, &'t mut V) {
         self.0.raw.into_mut_refs()
     }
 }
 
-impl<K, V, M: Deref<Target=RawTable<K, V>>> GapThenFull<K, V, M> {
+impl<K, V, M> GapThenFull<K, V, M> where RawTable<K, V>: BorrowFrom<M> {
     #[inline]
     pub fn full(&self) -> &FullBucket<K, V, M> {
         &self.full
@@ -636,7 +653,7 @@ impl<K, V, M> DerefMut for RawFullBucket<K, V, M> {
 pub struct RawFullBuckets<K, V, M> {
     raw: RawBucket<K, V, M>,
     hashes_end: *mut Option<SafeHash>,
-    table: M,
+    table: TableRef<M>,
 }
 
 // FIXME(#19839) Remove in favor of `#[derive(Clone)]`
@@ -710,12 +727,12 @@ impl<K: Clone, V: Clone> Clone for RawTable<K, V> {
 
             {
                 let cap = self.capacity();
-                let mut buckets = if let Some(buckets) = Bucket::at_index(self, 0) {
+                let mut buckets = if let Ok(buckets) = Bucket::at_index(self, 0) {
                     buckets
                 } else {
                     return new_ht;
                 };
-                let mut new_buckets = Bucket::at_index(&mut new_ht, 0).unwrap();
+                let mut new_buckets = Bucket::at_index(&mut new_ht, 0).ok().unwrap();
                 while buckets.index() != cap {
                     match buckets.peek() {
                         Full(full) => {
