---

yaml
---
r: 54109
b: refs/heads/dist-snap
c: 585c572
h: refs/heads/master
i:
  54107: ab048d5
v: v3

Author: sanxiyn

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: e8bf0a4a49405cfde21910af889d626fbdd5bd52
+refs/heads/dist-snap: 585c57234f6f2dbab7d56ec1351e5aeb052d3edb
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/container.rs

@@ -38,12 +38,9 @@ pub trait Map<K, V>: Mutable {
     /// Iterate over the map and mutate the contained values
     fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
 
-    /// Return a reference to the value corresponding to the key
+    /// Return the value corresponding to the key in the map
     fn find(&self, key: &K) -> Option<&'self V>;
 
-    /// Return a mutable reference to the value corresponding to the key
-    fn find_mut(&mut self, key: &K) -> Option<&'self mut V>;
-
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.

branches/dist-snap/src/libcore/hashmap.rs

@@ -24,7 +24,6 @@ pub mod linear {
     use rand;
     use uint;
     use vec;
-    use util::unreachable;
 
     static INITIAL_CAPACITY: uint = 32u; // 2^5
 
@@ -193,14 +192,6 @@ pub mod linear {
             }
         }
 
-        #[inline(always)]
-        fn mut_value_for_bucket(&mut self, idx: uint) -> &'self mut V {
-            match self.buckets[idx] {
-                Some(ref mut bkt) => &mut bkt.value,
-                None => unreachable()
-            }
-        }
-
         /// 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
@@ -347,25 +338,14 @@ pub mod linear {
             }
         }
 
-        /// Return a reference to the value corresponding to the key
+        /// Return the value corresponding to the key in the map
         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,
             }
         }
 
-        /// Return a mutable reference to the value corresponding to the key
-        fn find_mut(&mut self, k: &K) -> Option<&'self mut V> {
-            let idx = match self.bucket_for_key(k) {
-                FoundEntry(idx) => idx,
-                TableFull | FoundHole(_) => return None
-            };
-            unsafe {  // FIXME(#4903)---requires flow-sensitive borrow checker
-                Some(::cast::transmute_mut_region(self.mut_value_for_bucket(idx)))
-            }
-        }
-
         /// Insert a key-value pair into the map. An existing value for a
         /// key is replaced by the new value. Return true if the key did
         /// not already exist in the map.
@@ -675,19 +655,6 @@ pub mod linear {
             fail_unless!(*m.get(&2) == 4);
         }
 
-        #[test]
-        fn test_find_mut() {
-            let mut m = LinearMap::new();
-            fail_unless!(m.insert(1, 12));
-            fail_unless!(m.insert(2, 8));
-            fail_unless!(m.insert(5, 14));
-            let new = 100;
-            match m.find_mut(&5) {
-                None => fail!(), Some(x) => *x = new
-            }
-            assert_eq!(m.find(&5), Some(&new));
-        }
-
         #[test]
         pub fn test_insert_overwrite() {
             let mut m = LinearMap::new();

branches/dist-snap/src/libcore/trie.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! An ordered map and set for integer keys implemented as a radix trie
+//! A radix trie for storing integers in sorted order
 
 use prelude::*;
 
@@ -90,7 +90,7 @@ impl<T> Map<uint, T> for TrieMap<T> {
         self.root.mutate_values(f);
     }
 
-    /// Return a reference to the value corresponding to the key
+    /// Return the value corresponding to the key in the map
     #[inline(hint)]
     fn find(&self, key: &uint) -> Option<&'self T> {
         let mut node: &'self TrieNode<T> = &self.root;
@@ -111,12 +111,6 @@ impl<T> Map<uint, T> for TrieMap<T> {
         }
     }
 
-    /// Return a mutable reference to the value corresponding to the key
-    #[inline(always)]
-    fn find_mut(&mut self, key: &uint) -> Option<&'self mut T> {
-        find_mut(&mut self.root.children[chunk(*key, 0)], *key, 1)
-    }
-
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.
@@ -282,17 +276,6 @@ fn chunk(n: uint, idx: uint) -> uint {
     (n >> sh) & MASK
 }
 
-fn find_mut<T>(child: &'r mut Child<T>, key: uint, idx: uint) -> Option<&'r mut T> {
-    unsafe { // FIXME(#4903)---requires flow-sensitive borrow checker
-        (match *child {
-            External(_, ref value) => Some(cast::transmute_mut(value)),
-            Internal(ref x) => find_mut(cast::transmute_mut(&x.children[chunk(key, idx)]),
-                                        key, idx + 1),
-            Nothing => None
-        }).map_consume(|x| cast::transmute_mut_region(x))
-    }
-}
-
 fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint, value: T,
              idx: uint) -> bool {
     let mut tmp = Nothing;
@@ -374,22 +357,8 @@ pub fn check_integrity<T>(trie: &TrieNode<T>) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use core::option::{Some, None};
     use uint;
 
-    #[test]
-    fn test_find_mut() {
-        let mut m = TrieMap::new();
-        fail_unless!(m.insert(1, 12));
-        fail_unless!(m.insert(2, 8));
-        fail_unless!(m.insert(5, 14));
-        let new = 100;
-        match m.find_mut(&5) {
-            None => fail!(), Some(x) => *x = new
-        }
-        assert_eq!(m.find(&5), Some(&new));
-    }
-
     #[test]
     fn test_step() {
         let mut trie = TrieMap::new();

branches/dist-snap/src/librustdoc/tystr_pass.rs

@@ -69,13 +69,13 @@ fn get_fn_sig(srv: astsrv::Srv, fn_id: doc::AstId) -> Option<~str> {
         match ctxt.ast_map.get(&fn_id) {
           ast_map::node_item(@ast::item {
             ident: ident,
-            node: ast::item_fn(ref decl, _, ref tys, _), _
+            node: ast::item_fn(ref decl, purity, ref tys, _), _
           }, _) |
           ast_map::node_foreign_item(@ast::foreign_item {
             ident: ident,
-            node: ast::foreign_item_fn(ref decl, _, ref tys), _
+            node: ast::foreign_item_fn(ref decl, purity, ref tys), _
           }, _, _, _) => {
-            Some(pprust::fun_to_str(decl, ident, None, tys,
+            Some(pprust::fun_to_str(decl, purity, ident, None, tys,
                                     extract::interner()))
           }
           _ => fail!(~"get_fn_sig: fn_id not bound to a fn item")
@@ -214,6 +214,7 @@ fn get_method_sig(
                     ast::required(ty_m) => {
                       Some(pprust::fun_to_str(
                           &ty_m.decl,
+                          ty_m.purity,
                           ty_m.ident,
                           Some(ty_m.self_ty.node),
                           &ty_m.generics,
@@ -223,6 +224,7 @@ fn get_method_sig(
                     ast::provided(m) => {
                       Some(pprust::fun_to_str(
                           &m.decl,
+                          m.purity,
                           m.ident,
                           Some(m.self_ty.node),
                           &m.generics,
@@ -243,6 +245,7 @@ fn get_method_sig(
                 Some(method) => {
                     Some(pprust::fun_to_str(
                         &method.decl,
+                        method.purity,
                         method.ident,
                         Some(method.self_ty.node),
                         &method.generics,

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

@@ -86,7 +86,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
         self.each(|&(_, v)| blk(v))
     }
 
-    /// Iterate over the map and mutate the contained values
+    /// Visit all key-value pairs in order
     fn mutate_values(&mut self, it: &fn(&uint, &'self mut V) -> bool) {
         for uint::range(0, self.v.len()) |i| {
             match self.v[i] {
@@ -96,7 +96,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
         }
     }
 
-    /// Return a reference to the value corresponding to the key
+    /// Iterate over the map and mutate the contained values
     fn find(&self, key: &uint) -> Option<&'self V> {
         if *key < self.v.len() {
             match self.v[*key] {
@@ -108,18 +108,6 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
         }
     }
 
-    /// Return a mutable reference to the value corresponding to the key
-    fn find_mut(&mut self, key: &uint) -> Option<&'self mut V> {
-        if *key < self.v.len() {
-            match self.v[*key] {
-              Some(ref mut value) => Some(value),
-              None => None
-            }
-        } else {
-            None
-        }
-    }
-
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.
@@ -172,20 +160,6 @@ pub impl<V:Copy> SmallIntMap<V> {
 #[cfg(test)]
 mod tests {
     use super::SmallIntMap;
-    use core::prelude::*;
-
-    #[test]
-    fn test_find_mut() {
-        let mut m = SmallIntMap::new();
-        fail_unless!(m.insert(1, 12));
-        fail_unless!(m.insert(2, 8));
-        fail_unless!(m.insert(5, 14));
-        let new = 100;
-        match m.find_mut(&5) {
-            None => fail!(), Some(x) => *x = new
-        }
-        assert_eq!(m.find(&5), Some(&new));
-    }
 
     #[test]
     fn test_len() {

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

@@ -135,7 +135,7 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
         mutate_values(&mut self.root, f);
     }
 
-    /// Return a reference to the value corresponding to the key
+    /// Return the value corresponding to the key in the map
     fn find(&self, key: &K) -> Option<&'self V> {
         let mut current: &'self Option<~TreeNode<K, V>> = &self.root;
         loop {
@@ -152,12 +152,6 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
         }
     }
 
-    /// Return a mutable reference to the value corresponding to the key
-    #[inline(always)]
-    fn find_mut(&mut self, key: &K) -> Option<&'self mut V> {
-        find_mut(&mut self.root, key)
-    }
-
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.
@@ -590,20 +584,8 @@ fn split<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
     }
 }
 
-fn find_mut<K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>, key: &K) -> Option<&'r mut V> {
-    match *node {
-      Some(ref mut x) => {
-        match key.cmp(&x.key) {
-          Less => find_mut(&mut x.left, key),
-          Greater => find_mut(&mut x.right, key),
-          Equal => Some(&mut x.value),
-        }
-      }
-      None => None
-    }
-}
-
-fn insert<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>, key: K, value: V) -> bool {
+fn insert<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>, key: K,
+                          value: V) -> bool {
     match *node {
       Some(ref mut save) => {
         match key.cmp(&save.key) {
@@ -734,19 +716,6 @@ mod test_treemap {
         fail_unless!(m.find(&2) == None);
     }
 
-    #[test]
-    fn test_find_mut() {
-        let mut m = TreeMap::new();
-        fail_unless!(m.insert(1, 12));
-        fail_unless!(m.insert(2, 8));
-        fail_unless!(m.insert(5, 14));
-        let new = 100;
-        match m.find_mut(&5) {
-          None => fail!(), Some(x) => *x = new
-        }
-        assert_eq!(m.find(&5), Some(&new));
-    }
-
     #[test]
     fn insert_replace() {
         let mut m = TreeMap::new();