---

yaml
---
r: 36737
b: refs/heads/try2
c: 309cdfd
h: refs/heads/master
i:
  36735: 92d5526
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 2c21f348a45f593ed4452fab9d083283cd4e7ce0
+refs/heads/try2: 309cdfd835abb43294a4c5eadac1f5a8dfd134b5
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try2/src/libcore/vec.rs

@@ -29,6 +29,7 @@ extern mod rustrt {
 #[abi = "rust-intrinsic"]
 extern mod rusti {
     fn move_val_init<T>(dst: &mut T, -src: T);
+    fn init<T>() -> T;
 }
 
 
@@ -483,9 +484,15 @@ pub fn remove<T>(v: &mut ~[T], i: uint) -> T {
 pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) unsafe {
     let mut v = v; // FIXME(#3488)
 
-    do as_imm_buf(v) |p, ln| {
+    do as_mut_buf(v) |p, ln| {
         for uint::range(0, ln) |i| {
-            let x = move *ptr::offset(p, i);
+            // NB: This unsafe operation counts on init writing 0s to the
+            // holes we create in the vector. That ensures that, if the
+            // iterator fails then we won't try to clean up the consumed
+            // elements during unwinding
+            let mut x = rusti::init();
+            let p = ptr::mut_offset(p, i);
+            x <-> *p;
             f(i, x);
         }
     }
@@ -505,7 +512,9 @@ pub fn pop<T>(v: &mut ~[T]) -> T {
     }
     let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
     unsafe {
-        let val = move *valptr;
+        // XXX: Should be rusti::uninit() - we don't need this zeroed
+        let mut val = rusti::init();
+        val <-> *valptr;
         raw::set_len(v, ln - 1u);
         val
     }
@@ -574,9 +583,11 @@ pub fn push_all_move<T>(v: &mut ~[T], rhs: ~[T]) {
     let mut rhs = rhs; // FIXME(#3488)
     reserve(v, v.len() + rhs.len());
     unsafe {
-        do as_imm_buf(rhs) |p, len| {
+        do as_mut_buf(rhs) |p, len| {
             for uint::range(0, len) |i| {
-                let x = move *ptr::offset(p, i);
+                // XXX Should be rusti::uninit() - don't need to zero
+                let mut x = rusti::init();
+                x <-> *ptr::mut_offset(p, i);
                 push(v, x);
             }
         }
@@ -586,12 +597,14 @@ pub fn push_all_move<T>(v: &mut ~[T], rhs: ~[T]) {
 
 /// Shorten a vector, dropping excess elements.
 pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
-    do as_imm_buf(*v) |p, oldlen| {
+    do as_mut_buf(*v) |p, oldlen| {
         assert(newlen <= oldlen);
         unsafe {
             // This loop is optimized out for non-drop types.
             for uint::range(newlen, oldlen) |i| {
-                let _dropped = move *ptr::offset(p, i);
+                // XXX Should be rusti::uninit() - don't need to zero
+                let mut dropped = rusti::init();
+                dropped <-> *ptr::mut_offset(p, i);
             }
             raw::set_len(v, newlen);
         }
@@ -614,12 +627,14 @@ pub fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
             // last_written < next_to_read < ln
             if *ptr::mut_offset(p, next_to_read) ==
                 *ptr::mut_offset(p, last_written) {
-                let _dropped = move *ptr::mut_offset(p, next_to_read);
+                // XXX Should be rusti::uninit() - don't need to zero
+                let mut dropped = rusti::init();
+                dropped <-> *ptr::mut_offset(p, next_to_read);
             } else {
                 last_written += 1;
                 // last_written <= next_to_read < ln
                 if next_to_read != last_written {
-                    *ptr::mut_offset(p, last_written) = move
+                    *ptr::mut_offset(p, last_written) <->
                         *ptr::mut_offset(p, next_to_read);
                 }
             }