Implement non-internal ivecs

Vectors are now similar to our old, pre-internal vectors, except that
they are uniquely owned, not refcounted.

Their name should probably change too, then. I've renamed them to vec
in the runtime, will do so throughout the compiler later.

2 files changed, 13 insertions, 23 deletions

diff --git a/src/test/run-pass/interior-vec.rs b/src/test/run-pass/interior-vec.rs
index 4c722b3cc64..956c97f23ec 100644
--- a/src/test/run-pass/interior-vec.rs
+++ b/src/test/run-pass/interior-vec.rs
@@ -1,28 +1,28 @@
-import rusti::ivec_len;
+import rusti::vec_len;
 
 native "rust-intrinsic" mod rusti {
-    fn ivec_len<T>(v: &[T]) -> uint;
+    fn vec_len<T>(v: &[T]) -> uint;
 }
 
 fn main() {
     let v: [int] = [];
-    assert (ivec_len(v) == 0u); // zero-length
+    assert (vec_len(v) == 0u); // zero-length
     let x = [1, 2];
-    assert (ivec_len(x) == 2u); // on stack
+    assert (vec_len(x) == 2u); // on stack
     let y = [1, 2, 3, 4, 5];
-    assert (ivec_len(y) == 5u); // on heap
+    assert (vec_len(y) == 5u); // on heap
 
     v += [];
-    assert (ivec_len(v) == 0u); // zero-length append
+    assert (vec_len(v) == 0u); // zero-length append
     x += [3];
-    assert (ivec_len(x) == 3u); // on-stack append
+    assert (vec_len(x) == 3u); // on-stack append
     y += [6, 7, 8, 9];
-    assert (ivec_len(y) == 9u); // on-heap append
+    assert (vec_len(y) == 9u); // on-heap append
 
     let vv = v + v;
-    assert (ivec_len(vv) == 0u); // zero-length add
+    assert (vec_len(vv) == 0u); // zero-length add
     let xx = x + [4];
-    assert (ivec_len(xx) == 4u); // on-stack add
+    assert (vec_len(xx) == 4u); // on-stack add
     let yy = y + [10, 11];
-    assert (ivec_len(yy) == 11u); // on-heap add
+    assert (vec_len(yy) == 11u); // on-heap add
 }
diff --git a/src/test/stdtest/vec.rs b/src/test/stdtest/vec.rs
index f5c4af42681..2f9e691b62d 100644
--- a/src/test/stdtest/vec.rs
+++ b/src/test/stdtest/vec.rs
@@ -19,20 +19,11 @@ fn square_if_odd(n: &uint) -> option::t<uint> {
 fn add(x: &uint, y: &uint) -> uint { ret x + y; }
 
 #[test]
-fn test_reserve_and_on_heap() {
-    let v: [int] = [1, 2];
-    assert (!vec::on_heap(v));
-    vec::reserve(v, 8u);
-    assert (vec::on_heap(v));
-}
-
-#[test]
 fn test_unsafe_ptrs() {
     // Test on-stack copy-from-buf.
     let a = [1, 2, 3];
     let ptr = vec::to_ptr(a);
-    let b = [];
-    vec::unsafe::copy_from_buf(b, ptr, 3u);
+    let b = vec::unsafe::from_buf(ptr, 3u);
     assert (vec::len(b) == 3u);
     assert (b[0] == 1);
     assert (b[1] == 2);
@@ -41,8 +32,7 @@ fn test_unsafe_ptrs() {
     // Test on-heap copy-from-buf.
     let c = [1, 2, 3, 4, 5];
     ptr = vec::to_ptr(c);
-    let d = [];
-    vec::unsafe::copy_from_buf(d, ptr, 5u);
+    let d = vec::unsafe::from_buf(ptr, 5u);
     assert (vec::len(d) == 5u);
     assert (d[0] == 1);
     assert (d[1] == 2);