(blocked on #5121) add stronger region annotations to the maps

src/libcore/container.rs

@@ -25,15 +25,15 @@ pub trait Mutable: Container {
     fn clear(&mut self);
 }
 
-pub trait Map<K, V>: Mutable {
+pub trait Map<'self, K, V>: Mutable {
     /// Return true if the map contains a value for the specified key
     fn contains_key(&self, key: &K) -> bool;
 
     /// Visit all keys
     fn each_key(&self, f: &fn(&K) -> bool);
 
     /// Visit all values
-    fn each_value(&self, f: &fn(&V) -> bool);
+    fn each_value(&self, f: &fn(&'self V) -> bool);
 
     /// Iterate over the map and mutate the contained values
     fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);

src/libcore/hashmap.rs

@@ -315,7 +315,7 @@ impl<K:Hash + IterBytes + Eq,V> Mutable for HashMap<K, V> {
     }
 }
 
-impl<'self,K:Hash + IterBytes + Eq,V> Map<K, V> for HashMap<K, V> {
+impl<'self,K:Hash + IterBytes + Eq,V> Map<'self, K, V> for HashMap<K, V> {
     /// Return true if the map contains a value for the specified key
     fn contains_key(&self, k: &K) -> bool {
         match self.bucket_for_key(k) {
@@ -325,12 +325,12 @@ impl<'self,K:Hash + IterBytes + Eq,V> Map<K, V> for HashMap<K, V> {
     }
 
     /// Visit all keys
-    fn each_key(&self, blk: &fn(k: &K) -> bool) {
+    fn each_key(&self, blk: &fn(k: &'self K) -> bool) {
         self.each(|&(k, _)| blk(k))
     }
 
     /// Visit all values
-    fn each_value(&self, blk: &fn(v: &V) -> bool) {
+    fn each_value(&self, blk: &fn(v: &'self V) -> bool) {
         self.each(|&(_, v)| blk(v))
     }
 
@@ -564,7 +564,7 @@ pub struct HashSet<T> {
 
 impl<T:Hash + IterBytes + Eq> BaseIter<T> for HashSet<T> {
     /// Visit all values in order
-    fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) }
+    fn each(&self, f: &fn(&'self T) -> bool) { self.map.each_key(f) }
     fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
 

src/libcore/trie.rs

@@ -65,7 +65,7 @@ impl<T> Mutable for TrieMap<T> {
     }
 }
 
-impl<T> Map<uint, T> for TrieMap<T> {
+impl<'self, T> Map<'self, uint, T> for TrieMap<T> {
     /// Return true if the map contains a value for the specified key
     #[inline(always)]
     fn contains_key(&self, key: &uint) -> bool {
@@ -80,7 +80,7 @@ impl<T> Map<uint, T> for TrieMap<T> {
 
     /// Visit all values in order
     #[inline(always)]
-    fn each_value(&self, f: &fn(&T) -> bool) {
+    fn each_value(&self, f: &fn(&'self T) -> bool) {
         self.each(|&(_, v)| f(v))
     }
 
@@ -156,7 +156,7 @@ pub impl<T> TrieMap<T> {
 
     /// Visit all values in reverse order
     #[inline(always)]
-    fn each_value_reverse(&self, f: &fn(&T) -> bool) {
+    fn each_value_reverse(&self, f: &fn(&'self T) -> bool) {
         self.each_reverse(|&(_, v)| f(v))
     }
 }

src/libstd/smallintmap.rs

@@ -70,7 +70,7 @@ impl<V> Mutable for SmallIntMap<V> {
     fn clear(&mut self) { self.v.clear() }
 }
 
-impl<V> Map<uint, V> for SmallIntMap<V> {
+impl<'self, V> Map<'self, uint, V> for SmallIntMap<V> {
     /// Return true if the map contains a value for the specified key
     fn contains_key(&self, key: &uint) -> bool {
         self.find(key).is_some()
@@ -82,7 +82,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
     }
 
     /// Visit all values in order
-    fn each_value(&self, blk: &fn(value: &V) -> bool) {
+    fn each_value(&self, blk: &fn(value: &'self V) -> bool) {
         self.each(|&(_, v)| blk(v))
     }
 

src/libstd/treemap.rs

@@ -116,17 +116,17 @@ impl<K: TotalOrd, V> Mutable for TreeMap<K, V> {
     }
 }
 
-impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
+impl<'self, K: TotalOrd, V> Map<'self, K, V> for TreeMap<K, V> {
     /// Return true if the map contains a value for the specified key
     fn contains_key(&self, key: &K) -> bool {
         self.find(key).is_some()
     }
 
     /// Visit all keys in order
-    fn each_key(&self, f: &fn(&K) -> bool) { self.each(|&(k, _)| f(k)) }
+    fn each_key(&self, f: &fn(&'self K) -> bool) { self.each(|&(k, _)| f(k)) }
 
     /// Visit all values in order
-    fn each_value(&self, f: &fn(&V) -> bool) {
+    fn each_value(&self, f: &fn(&'self V) -> bool) {
         self.each(|&(_, v)| f(v))
     }
 
@@ -181,12 +181,12 @@ pub impl<K: TotalOrd, V> TreeMap<K, V> {
     fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
 
     /// Visit all keys in reverse order
-    fn each_key_reverse(&self, f: &fn(&K) -> bool) {
+    fn each_key_reverse(&self, f: &fn(&'self K) -> bool) {
         self.each_reverse(|&(k, _)| f(k))
     }
 
     /// Visit all values in reverse order
-    fn each_value_reverse(&self, f: &fn(&V) -> bool) {
+    fn each_value_reverse(&self, f: &fn(&'self V) -> bool) {
         self.each_reverse(|&(_, v)| f(v))
     }
 
@@ -244,15 +244,15 @@ pub struct TreeSet<T> {
 impl<T: TotalOrd> BaseIter<T> for TreeSet<T> {
     /// Visit all values in order
     #[inline(always)]
-    fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) }
+    fn each(&self, f: &fn(&'self T) -> bool) { self.map.each_key(f) }
     #[inline(always)]
     fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
 
 impl<T: TotalOrd> ReverseIter<T> for TreeSet<T> {
     /// Visit all values in reverse order
     #[inline(always)]
-    fn each_reverse(&self, f: &fn(&T) -> bool) {
+    fn each_reverse(&self, f: &fn(&'self T) -> bool) {
         self.map.each_key_reverse(f)
     }
 }

src/test/bench/core-map.rs

@@ -23,7 +23,7 @@ fn timed(label: &str, f: &fn()) {
     io::println(fmt!("  %s: %f", label, end - start));
 }
 
-fn ascending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) {
+fn ascending<M: Map<'r, uint, uint>>(map: &mut M, n_keys: uint) {
     io::println(" Ascending integers:");
 
     do timed("insert") {
@@ -45,7 +45,7 @@ fn ascending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) {
     }
 }
 
-fn descending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) {
+fn descending<M: Map<'r, uint, uint>>(map: &mut M, n_keys: uint) {
     io::println(" Descending integers:");
 
     do timed("insert") {
@@ -67,7 +67,7 @@ fn descending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) {
     }
 }
 
-fn vector<M: Map<uint, uint>>(map: &mut M, n_keys: uint, dist: &[uint]) {
+fn vector<M: Map<'r, uint, uint>>(map: &mut M, n_keys: uint, dist: &[uint]) {
 
     do timed("insert") {
         for uint::range(0, n_keys) |i| {

src/test/compile-fail/map-types.rs

@@ -17,5 +17,5 @@ fn main() {
     let x: @Map<~str, ~str> = @HashMap::new::<~str, ~str>() as
         @Map<~str, ~str>;
     let y: @Map<uint, ~str> = @x;
-    //~^ ERROR mismatched types: expected `@core::container::Map<uint,~str>`
+    //~^ ERROR mismatched types: expected `@core::container::Map/&<uint,~str>`
 }

src/test/run-pass/class-impl-very-parameterized-trait.rs

@@ -70,15 +70,15 @@ impl<T> Mutable for cat<T> {
     fn clear(&mut self) {}
 }
 
-impl<T> Map<int, T> for cat<T> {
+impl<'self, T> Map<'self, int, T> for cat<T> {
     fn contains_key(&self, k: &int) -> bool { *k <= self.meows }
 
     fn each_key(&self, f: &fn(v: &int) -> bool) {
         for self.each |&(k, _)| { if !f(&k) { break; } loop;};
     }
 
-    fn each_value(&self, f: &fn(v: &T) -> bool) {
-        for self.each |&(_, v)| { if !f(v) { break; } loop;};
+    fn each_value(&self, f: &fn(v: &'self T) -> bool) {
+        fail!();
     }
 
     fn mutate_values(&mut self, f: &fn(&int, &mut T) -> bool) {