---

yaml
---
r: 50928
b: refs/heads/try
c: d774333
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: 89a7407c999449c56f9b00145cfbdfbb49fbde7c
+refs/heads/try: d77433386be3d5afa201cfd40dbaaa4d20dbbd80
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/container.rs

@@ -38,9 +38,12 @@ 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 the value corresponding to the key in the map
+    /// Return a reference to the value corresponding to the key
     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/try/src/libcore/hashmap.rs

@@ -24,6 +24,7 @@ pub mod linear {
     use rand;
     use uint;
     use vec;
+    use util::unreachable;
 
     static INITIAL_CAPACITY: uint = 32u; // 2^5
 
@@ -192,6 +193,14 @@ 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
@@ -338,7 +347,7 @@ pub mod linear {
             }
         }
 
-        /// Return the value corresponding to the key in the map
+        /// Return a reference to the value corresponding to the key
         fn find(&self, k: &K) -> Option<&'self V> {
             match self.bucket_for_key(k) {
                 FoundEntry(idx) => Some(self.value_for_bucket(idx)),
@@ -410,6 +419,17 @@ pub mod linear {
             old_value
         }
 
+        /// 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)))
+            }
+        }
+
         /// 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 {
@@ -655,6 +675,19 @@ 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/try/src/librustc/middle/trans/tvec.rs

@@ -27,7 +27,6 @@ use middle::ty;
 use util::common::indenter;
 use util::ppaux::ty_to_str;
 
-use core::option::None;
 use core::uint;
 use core::vec;
 use syntax::ast;
@@ -414,52 +413,30 @@ pub fn write_content(bcx: block,
                         return bcx;
                     }
 
-                    let elem = unpack_datum!(bcx, {
+                    let tmpdatum = unpack_datum!(bcx, {
                         expr::trans_to_datum(bcx, element)
                     });
 
-                    let next_bcx = sub_block(bcx, ~"expr_repeat: while next");
-                    let loop_bcx = loop_scope_block(bcx, next_bcx, None, ~"expr_repeat", None);
-                    let cond_bcx = scope_block(loop_bcx, None, ~"expr_repeat: loop cond");
-                    let set_bcx = scope_block(loop_bcx, None, ~"expr_repeat: body: set");
-                    let inc_bcx = scope_block(loop_bcx, None, ~"expr_repeat: body: inc");
-                    Br(bcx, loop_bcx.llbb);
-
-                    let loop_counter = {
-                        // i = 0
-                        let i = alloca(loop_bcx, bcx.ccx().int_type);
-                        Store(loop_bcx, C_uint(bcx.ccx(), 0), i);
-
-                        Br(loop_bcx, cond_bcx.llbb);
-                        i
-                    };
-
-                    { // i < count
-                        let lhs = Load(cond_bcx, loop_counter);
-                        let rhs = C_uint(bcx.ccx(), count);
-                        let cond_val = ICmp(cond_bcx, lib::llvm::IntULT, lhs, rhs);
-
-                        CondBr(cond_bcx, cond_val, set_bcx.llbb, next_bcx.llbb);
-                    }
-
-                    { // v[i] = elem
-                        let i = Load(set_bcx, loop_counter);
-                        let lleltptr = InBoundsGEP(set_bcx, lldest, [i]);
-                        let set_bcx = elem.copy_to(set_bcx, INIT, lleltptr);
+                    let mut temp_cleanups = ~[];
 
-                        Br(set_bcx, inc_bcx.llbb);
+                    for uint::range(0, count) |i| {
+                        let lleltptr = GEPi(bcx, lldest, [i]);
+                        if i < count - 1 {
+                            // Copy all but the last one in.
+                            bcx = tmpdatum.copy_to(bcx, INIT, lleltptr);
+                        } else {
+                            // Move the last one in.
+                            bcx = tmpdatum.move_to(bcx, INIT, lleltptr);
+                        }
+                        add_clean_temp_mem(bcx, lleltptr, vt.unit_ty);
+                        temp_cleanups.push(lleltptr);
                     }
 
-                    { // i += 1
-                        let i = Load(inc_bcx, loop_counter);
-                        let plusone = Add(inc_bcx, i, C_uint(bcx.ccx(), 1));
-                        Store(inc_bcx, plusone, loop_counter);
-
-                        Br(inc_bcx, cond_bcx.llbb);
+                    for vec::each(temp_cleanups) |cleanup| {
+                        revoke_clean(bcx, *cleanup);
                     }
 
-                    return next_bcx;
-
+                    return bcx;
                 }
             }
         }

branches/try/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 the value corresponding to the key in the map
+    /// Return a reference to the value corresponding to the key
     fn find(&self, key: &K) -> Option<&'self V> {
         let mut current: &'self Option<~TreeNode<K, V>> = &self.root;
         loop {
@@ -189,6 +189,12 @@ pub impl<K: TotalOrd, V> TreeMap<K, V> {
     fn iter(&self) -> TreeMapIterator<'self, K, V> {
         TreeMapIterator{stack: ~[], node: &self.root}
     }
+
+    /// 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)
+    }
 }
 
 /// Lazy forward iterator over a map
@@ -584,8 +590,20 @@ fn split<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
     }
 }
 
-fn insert<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>, key: K,
-                          value: V) -> bool {
+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 {
     match *node {
       Some(ref mut save) => {
         match key.cmp(&save.key) {
@@ -716,6 +734,19 @@ 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();