Remove last uses of vec::len

src/fuzzer/fuzzer.rs

@@ -8,7 +8,6 @@ import std::getopts::opt_present;
 import std::getopts::opt_str;
 import std::io;
 import std::io::stdout;
-import std::vec;
 import std::ivec;
 import std::str;
 import std::uint;
@@ -347,12 +346,13 @@ fn check_variants(files: &[str]) {
 }
 
 fn main(args: vec[str]) {
-    if vec::len(args) != 2u {
+    let iargs = ivec::from_vec(args);
-        log_err #fmt("usage: %s <testdir>", args.(0));
+    if ivec::len(iargs) != 2u {
+        log_err #fmt("usage: %s <testdir>", iargs.(0));
         ret;
     }
     let files = ~[];
-    let root = args.(1);
+    let root = iargs.(1);
 
     find_rust_files(files, root);
     check_convergence(files);

src/lib/vec.rs

@@ -5,7 +5,6 @@ import util::orb;
 
 export vbuf;
 export buf;
-export len;
 
 type vbuf = rustrt::vbuf;
 
@@ -37,8 +36,6 @@ native "rust" mod rustrt {
 
 fn buf[T](v: array[T]) -> vbuf { ret rustrt::vec_buf[T](v, 0u); }
 
-fn len[T](v: array[T]) -> uint { ret rustrt::vec_len[T](v); }
-
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/test/compile-fail/bad-module.rs

@@ -1,4 +1,4 @@
-// error-pattern: unresolved import: vec
+// error-pattern: unresolved import: ivec
-import vec;
+import ivec;
 
-fn main() { let foo = vec::len([]); }
+fn main() { let foo = ivec::len([]); }

src/test/run-pass/hashmap-memory.rs

@@ -10,7 +10,7 @@ import option = std::option::t;
 import std::option::some;
 import std::option::none;
 import std::str;
-import std::vec;
+import std::ivec;
 import std::map;
 
 fn map(filename: str, emit: map_reduce::putter) { emit(filename, "1"); }
@@ -26,7 +26,7 @@ mod map_reduce {
 
     tag ctrl_proto { find_reducer(str, chan[int]); mapper_done; }
 
-    fn start_mappers(ctrl: chan[ctrl_proto], inputs: vec[str]) {
+    fn start_mappers(ctrl: chan[ctrl_proto], inputs: &[str]) {
         for i: str  in inputs { spawn map_task(ctrl, i); }
     }
 
@@ -55,7 +55,7 @@ mod map_reduce {
         ctrl <| mapper_done;
     }
 
-    fn map_reduce(inputs: vec[str]) {
+    fn map_reduce(inputs: &[str]) {
         let ctrl = port[ctrl_proto]();
 
         // This task becomes the master control task. It spawns others
@@ -67,7 +67,7 @@ mod map_reduce {
 
         start_mappers(chan(ctrl), inputs);
 
-        let num_mappers = vec::len(inputs) as int;
+        let num_mappers = ivec::len(inputs) as int;
 
 
         while num_mappers > 0 {
@@ -88,5 +88,5 @@ mod map_reduce {
 }
 
 fn main() {
-    map_reduce::map_reduce(["../src/test/run-pass/hashmap-memory.rs"]);
+    map_reduce::map_reduce(~["../src/test/run-pass/hashmap-memory.rs"]);
 }

src/test/run-pass/mutable-alias-vec.rs

@@ -3,14 +3,14 @@
 // -*- rust -*-
 use std;
 
-fn grow(v: &mutable vec[int]) { v += [1]; }
+fn grow(v: &mutable [int]) { v += ~[1]; }
 
 fn main() {
-    let v: vec[int] = [];
+    let v: [int] = ~[];
     grow(v);
     grow(v);
     grow(v);
-    let len = std::vec::len[int](v);
+    let len = std::ivec::len[int](v);
     log len;
     assert (len == 3 as uint);
 }

src/test/run-pass/vec-self-append.rs

@@ -1,14 +1,14 @@
 use std;
-import std::vec;
+import std::ivec;
 
 fn main() {
     // Make sure we properly handle repeated self-appends.
-    let a: vec[int] = [0];
+    let a: [int] = ~[0];
     let i = 20;
     let expected_len = 1u;
     while i > 0 {
-        log_err vec::len(a);
+        log_err ivec::len(a);
-        assert (vec::len(a) == expected_len);
+        assert (ivec::len(a) == expected_len);
         a += a;
         i -= 1;
         expected_len *= 2u;

src/test/stdtest/sha1.rs

@@ -4,12 +4,12 @@
 
 use std;
 import std::sha1;
-import std::vec;
+import std::ivec;
 import std::str;
 
 #[test]
 fn test() {
-    type test = {input: str, output: vec[u8]};
+    type test = {input: str, output: [u8]};
 
     fn a_million_letter_a() -> str {
         let i = 0;
@@ -19,40 +19,50 @@ fn test() {
     }
     // Test messages from FIPS 180-1
 
-    let fips_180_1_tests: vec[test] =
+    let fips_180_1_tests: [test] =
-        [{input: "abc",
+        ~[{input: "abc",
           output:
-              [0xA9u8, 0x99u8, 0x3Eu8, 0x36u8, 0x47u8, 0x06u8, 0x81u8, 0x6Au8,
+              ~[0xA9u8, 0x99u8, 0x3Eu8, 0x36u8,
-               0xBAu8, 0x3Eu8, 0x25u8, 0x71u8, 0x78u8, 0x50u8, 0xC2u8, 0x6Cu8,
+                0x47u8, 0x06u8, 0x81u8, 0x6Au8,
-               0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8]},
+                0xBAu8, 0x3Eu8, 0x25u8, 0x71u8,
+                0x78u8, 0x50u8, 0xC2u8, 0x6Cu8,
+                0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8]},
          {input:
               "abcdbcdecdefdefgefghfghighij" + "hijkijkljklmklmnlmnomnopnopq",
           output:
-              [0x84u8, 0x98u8, 0x3Eu8, 0x44u8, 0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,
+              ~[0x84u8, 0x98u8, 0x3Eu8, 0x44u8,
-               0xBAu8, 0xAEu8, 0x4Au8, 0xA1u8, 0xF9u8, 0x51u8, 0x29u8, 0xE5u8,
+                0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,
-               0xE5u8, 0x46u8, 0x70u8, 0xF1u8]},
+                0xBAu8, 0xAEu8, 0x4Au8, 0xA1u8,
+                0xF9u8, 0x51u8, 0x29u8, 0xE5u8,
+                0xE5u8, 0x46u8, 0x70u8, 0xF1u8]},
          {input: a_million_letter_a(),
           output:
-              [0x34u8, 0xAAu8, 0x97u8, 0x3Cu8, 0xD4u8, 0xC4u8, 0xDAu8, 0xA4u8,
+              ~[0x34u8, 0xAAu8, 0x97u8, 0x3Cu8,
-               0xF6u8, 0x1Eu8, 0xEBu8, 0x2Bu8, 0xDBu8, 0xADu8, 0x27u8, 0x31u8,
+                0xD4u8, 0xC4u8, 0xDAu8, 0xA4u8,
-               0x65u8, 0x34u8, 0x01u8, 0x6Fu8]}];
+                0xF6u8, 0x1Eu8, 0xEBu8, 0x2Bu8,
+                0xDBu8, 0xADu8, 0x27u8, 0x31u8,
+                0x65u8, 0x34u8, 0x01u8, 0x6Fu8]}];
     // Examples from wikipedia
 
-    let wikipedia_tests: vec[test] =
+    let wikipedia_tests: [test] =
-        [{input: "The quick brown fox jumps over the lazy dog",
+        ~[{input: "The quick brown fox jumps over the lazy dog",
           output:
-              [0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8, 0x7au8, 0x2du8, 0x28u8, 0xfcu8,
+              ~[0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8,
-               0xedu8, 0x84u8, 0x9eu8, 0xe1u8, 0xbbu8, 0x76u8, 0xe7u8, 0x39u8,
+                0x7au8, 0x2du8, 0x28u8, 0xfcu8,
-               0x1bu8, 0x93u8, 0xebu8, 0x12u8]},
+                0xedu8, 0x84u8, 0x9eu8, 0xe1u8,
+                0xbbu8, 0x76u8, 0xe7u8, 0x39u8,
+                0x1bu8, 0x93u8, 0xebu8, 0x12u8]},
          {input: "The quick brown fox jumps over the lazy cog",
           output:
-              [0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8, 0xd2u8, 0x5eu8, 0x1bu8, 0x3au8,
+              ~[0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8,
-               0xfau8, 0xd3u8, 0xe8u8, 0x5au8, 0x0bu8, 0xd1u8, 0x7du8, 0x9bu8,
+                0xd2u8, 0x5eu8, 0x1bu8, 0x3au8,
-               0x10u8, 0x0du8, 0xb4u8, 0xb3u8]}];
+                0xfau8, 0xd3u8, 0xe8u8, 0x5au8,
+                0x0bu8, 0xd1u8, 0x7du8, 0x9bu8,
+                0x10u8, 0x0du8, 0xb4u8, 0xb3u8]}];
     let tests = fips_180_1_tests + wikipedia_tests;
-    fn check_vec_eq(v0: vec[u8], v1: vec[u8]) {
+    fn check_vec_eq(v0: &[u8], v1: &[u8]) {
-        assert (vec::len[u8](v0) == vec::len[u8](v1));
+        assert (ivec::len[u8](v0) == ivec::len[u8](v1));
-        let len = vec::len[u8](v0);
+        let len = ivec::len[u8](v0);
         let i = 0u;
         while i < len {
             let a = v0.(i);
@@ -66,7 +76,7 @@ fn test() {
     let sh = sha1::mk_sha1();
     for t: test  in tests {
         sh.input_str(t.input);
-        let out = sh.result();
+        let out = sh.result_ivec();
         check_vec_eq(t.output, out);
         sh.reset();
     }
@@ -81,7 +91,7 @@ fn test() {
             sh.input_str(str::substr(t.input, len - left, take));
             left = left - take;
         }
-        let out = sh.result();
+        let out = sh.result_ivec();
         check_vec_eq(t.output, out);
         sh.reset();
     }