---

yaml
---
r: 46900
b: refs/heads/try
c: a165f88
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
-refs/heads/try: 91c59f5c9a6d1fe72a18768b074fcb16542e0ca1
+refs/heads/try: a165f882726d86ad4c65a5b72daa5b457af12e6c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/hashmap.rs

@@ -108,17 +108,19 @@ pub mod linear {
         }
 
         #[inline(always)]
-        pure fn bucket_for_key(&self, k: &K) -> SearchResult {
+        pure fn bucket_for_key(&self, buckets: &[Option<Bucket<K, V>>],
+                               k: &K) -> SearchResult {
             let hash = k.hash_keyed(self.k0, self.k1) as uint;
-            self.bucket_for_key_with_hash(hash, k)
+            self.bucket_for_key_with_hash(buckets, hash, k)
         }
 
         #[inline(always)]
         pure fn bucket_for_key_with_hash(&self,
+                                         buckets: &[Option<Bucket<K, V>>],
                                          hash: uint,
                                          k: &K) -> SearchResult {
             let _ = for self.bucket_sequence(hash) |i| {
-                match self.buckets[i] {
+                match buckets[i] {
                     Some(ref bkt) => if bkt.hash == hash && *k == bkt.key {
                         return FoundEntry(i);
                     },
@@ -155,19 +157,11 @@ pub mod linear {
             }
         }
 
-        #[inline(always)]
-        pure fn value_for_bucket(&self, idx: uint) -> &self/V {
-            match self.buckets[idx] {
-                Some(ref bkt) => &bkt.value,
-                None => die!(~"LinearMap::find: internal logic error"),
-            }
-        }
-
         /// Inserts the key value pair into the buckets.
         /// Assumes that there will be a bucket.
         /// True if there was no previous entry with that key
         fn insert_internal(&mut self, hash: uint, k: K, v: V) -> bool {
-            match self.bucket_for_key_with_hash(hash, &k) {
+            match self.bucket_for_key_with_hash(self.buckets, hash, &k) {
                 TableFull => { die!(~"Internal logic error"); }
                 FoundHole(idx) => {
                     debug!("insert fresh (%?->%?) at idx %?, hash %?",
@@ -202,7 +196,8 @@ pub mod linear {
             //
             // I found this explanation elucidating:
             // http://www.maths.lse.ac.uk/Courses/MA407/del-hash.pdf
-            let mut idx = match self.bucket_for_key_with_hash(hash, k) {
+            let mut idx = match self.bucket_for_key_with_hash(self.buckets,
+                                                              hash, k) {
                 TableFull | FoundHole(_) => return None,
                 FoundEntry(idx) => idx
             };
@@ -278,7 +273,7 @@ pub mod linear {
     impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: Map<K, V> {
         /// Return true if the map contains a value for the specified key
         pure fn contains_key(&self, k: &K) -> bool {
-            match self.bucket_for_key(k) {
+            match self.bucket_for_key(self.buckets, k) {
                 FoundEntry(_) => {true}
                 TableFull | FoundHole(_) => {false}
             }
@@ -296,9 +291,20 @@ pub mod linear {
 
         /// Return the value corresponding to the key in the map
         pure fn find(&self, k: &K) -> Option<&self/V> {
-            match self.bucket_for_key(k) {
-                FoundEntry(idx) => Some(self.value_for_bucket(idx)),
-                TableFull | FoundHole(_) => None,
+            match self.bucket_for_key(self.buckets, k) {
+                FoundEntry(idx) => {
+                    match self.buckets[idx] {
+                        Some(ref bkt) => {
+                            Some(&bkt.value)
+                        }
+                        None => {
+                            die!(~"LinearMap::find: internal logic error")
+                        }
+                    }
+                }
+                TableFull | FoundHole(_) => {
+                    None
+                }
             }
         }
 
@@ -358,63 +364,6 @@ pub mod linear {
             old_value
         }
 
-        /// Return the value corresponding to the key in the map, or insert
-        /// and return the value if it doesn't exist.
-        fn find_or_insert(&mut self, k: K, v: V) -> &self/V {
-            if self.size >= self.resize_at {
-                // n.b.: We could also do this after searching, so
-                // that we do not resize if this call to insert is
-                // simply going to update a key in place.  My sense
-                // though is that it's worse to have to search through
-                // buckets to find the right spot twice than to just
-                // resize in this corner case.
-                self.expand();
-            }
-
-            let hash = k.hash_keyed(self.k0, self.k1) as uint;
-            let idx = match self.bucket_for_key_with_hash(hash, &k) {
-                TableFull => die!(~"Internal logic error"),
-                FoundEntry(idx) => idx,
-                FoundHole(idx) => {
-                    self.buckets[idx] = Some(Bucket{hash: hash, key: k,
-                                         value: v});
-                    self.size += 1;
-                    idx
-                },
-            };
-
-            self.value_for_bucket(idx)
-        }
-
-        /// Return the value corresponding to the key in the map, or create,
-        /// insert, and return a new value if it doesn't exist.
-        fn find_or_insert_with(&mut self, k: K, f: fn(&K) -> V) -> &self/V {
-            if self.size >= self.resize_at {
-                // n.b.: We could also do this after searching, so
-                // that we do not resize if this call to insert is
-                // simply going to update a key in place.  My sense
-                // though is that it's worse to have to search through
-                // buckets to find the right spot twice than to just
-                // resize in this corner case.
-                self.expand();
-            }
-
-            let hash = k.hash_keyed(self.k0, self.k1) as uint;
-            let idx = match self.bucket_for_key_with_hash(hash, &k) {
-                TableFull => die!(~"Internal logic error"),
-                FoundEntry(idx) => idx,
-                FoundHole(idx) => {
-                    let v = f(&k);
-                    self.buckets[idx] = Some(Bucket{hash: hash, key: k,
-                                         value: v});
-                    self.size += 1;
-                    idx
-                },
-            };
-
-            self.value_for_bucket(idx)
-        }
-
         fn consume(&mut self, f: fn(K, V)) {
             let mut buckets = ~[];
             self.buckets <-> buckets;
@@ -572,7 +521,7 @@ mod test_map {
     use uint;
 
     #[test]
-    pub fn test_insert() {
+    pub fn inserts() {
         let mut m = LinearMap::new();
         assert m.insert(1, 2);
         assert m.insert(2, 4);
@@ -581,7 +530,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_insert_overwrite() {
+    pub fn overwrite() {
         let mut m = LinearMap::new();
         assert m.insert(1, 2);
         assert *m.get(&1) == 2;
@@ -590,7 +539,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_insert_conflicts() {
+    pub fn conflicts() {
         let mut m = linear::linear_map_with_capacity(4);
         assert m.insert(1, 2);
         assert m.insert(5, 3);
@@ -601,7 +550,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_conflict_remove() {
+    pub fn conflict_remove() {
         let mut m = linear::linear_map_with_capacity(4);
         assert m.insert(1, 2);
         assert m.insert(5, 3);
@@ -612,7 +561,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_is_empty() {
+    pub fn empty() {
         let mut m = linear::linear_map_with_capacity(4);
         assert m.insert(1, 2);
         assert !m.is_empty();
@@ -621,37 +570,23 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_pop() {
+    pub fn pops() {
         let mut m = LinearMap::new();
         m.insert(1, 2);
         assert m.pop(&1) == Some(2);
         assert m.pop(&1) == None;
     }
 
     #[test]
-    pub fn test_swap() {
+    pub fn swaps() {
         let mut m = LinearMap::new();
         assert m.swap(1, 2) == None;
         assert m.swap(1, 3) == Some(2);
         assert m.swap(1, 4) == Some(3);
     }
 
     #[test]
-    pub fn test_find_or_insert() {
-        let mut m = LinearMap::new::<int, int>();
-        assert m.find_or_insert(1, 2) == &2;
-        assert m.find_or_insert(1, 3) == &2;
-    }
-
-    #[test]
-    pub fn test_find_or_insert_with() {
-        let mut m = LinearMap::new::<int, int>();
-        assert m.find_or_insert_with(1, |_| 2) == &2;
-        assert m.find_or_insert_with(1, |_| 3) == &2;
-    }
-
-    #[test]
-    pub fn test_consume() {
+    pub fn consumes() {
         let mut m = LinearMap::new();
         assert m.insert(1, 2);
         assert m.insert(2, 3);
@@ -666,7 +601,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_iterate() {
+    pub fn iterate() {
         let mut m = linear::linear_map_with_capacity(4);
         for uint::range(0, 32) |i| {
             assert m.insert(i, i*2);
@@ -680,7 +615,7 @@ mod test_map {
     }
 
     #[test]
-    pub fn test_find() {
+    pub fn find() {
         let mut m = LinearMap::new();
         assert m.find(&1).is_none();
         m.insert(1, 2);

branches/try/src/librustc/middle/ty.rs

@@ -1932,6 +1932,10 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
             Some(tc) => { return *tc; }
             None => {}
         }
+        match cx.tc_cache.find(&ty_id) {    // Must check both caches!
+            Some(tc) => { return *tc; }
+            None => {}
+        }
         cache.insert(ty_id, TC_NONE);
 
         debug!("computing contents of %s", ty_to_str(cx, ty));