Rewrite everything to use [] instead of vec() in value position.

48 files changed, 177 insertions, 177 deletions

diff --git a/src/test/bench/shootout/fasta.rs b/src/test/bench/shootout/fasta.rs
index ec962e38a48..b7a890971e3 100644
--- a/src/test/bench/shootout/fasta.rs
+++ b/src/test/bench/shootout/fasta.rs
@@ -28,10 +28,10 @@ type aminoacids = tup(char, u32);
 
 fn make_cumulative(vec[aminoacids] aa) -> vec[aminoacids] {
   let u32 cp = 0u32;
-  let vec[aminoacids] ans = vec();
+  let vec[aminoacids] ans = [];
   for (aminoacids a in aa) {
     cp += a._1;
-    ans += vec(tup(a._0, cp));
+    ans += [tup(a._0, cp)];
   }
   ret ans;
 }
@@ -91,7 +91,7 @@ fn make_repeat_fasta(str id, str desc, str s, int n) {
 }
 
 fn main(vec[str] args) {
-  let vec[aminoacids] iub = make_cumulative(vec(tup( 'a', 27u32 ),
+  let vec[aminoacids] iub = make_cumulative([tup( 'a', 27u32 ),
                                                 tup( 'c', 12u32 ),
                                                 tup( 'g', 12u32 ),
                                                 tup( 't', 27u32 ),
@@ -106,12 +106,12 @@ fn main(vec[str] args) {
                                                 tup( 'S', 2u32 ),
                                                 tup( 'V', 2u32 ),
                                                 tup( 'W', 2u32 ),
-                                                tup( 'Y', 2u32 )));
+                                                tup( 'Y', 2u32 )]);
 
-  let vec[aminoacids] homosapiens = make_cumulative(vec(tup( 'a', 30u32 ),
+  let vec[aminoacids] homosapiens = make_cumulative([tup( 'a', 30u32 ),
                                                         tup( 'c', 20u32 ),
                                                         tup( 'g', 20u32 ),
-                                                        tup( 't', 30u32 )));
+                                                        tup( 't', 30u32 )]);
 
   let str alu =
     "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" +
diff --git a/src/test/bench/shootout/nbody.rs b/src/test/bench/shootout/nbody.rs
index 4b3e9044d92..152291c7145 100644
--- a/src/test/bench/shootout/nbody.rs
+++ b/src/test/bench/shootout/nbody.rs
@@ -7,7 +7,7 @@ native "llvm" mod llvm {
 
 fn main() {
 
-    let vec[int] inputs = vec(
+    let vec[int] inputs = [
                               50000,
                               500000
                               //
@@ -16,7 +16,7 @@ fn main() {
                               // during 'make check' under valgrind
                               // 5000000
                               // 50000000
-        );
+        ];
 
     let vec[Body::props] bodies = NBodySystem::MakeNBodySystem();
 
@@ -38,13 +38,13 @@ fn main() {
 mod NBodySystem {
 
     fn MakeNBodySystem() -> vec[Body::props] {
-        let vec[Body::props] bodies = vec(
+        let vec[Body::props] bodies = [
             // these each return a Body::props
             Body::sun(), 
             Body::jupiter(), 
             Body::saturn(), 
             Body::uranus(), 
-            Body::neptune());
+            Body::neptune()];
 
         let float px = 0.0;
         let float py = 0.0;
diff --git a/src/test/compile-fail/infinite-vec-type-recursion.rs b/src/test/compile-fail/infinite-vec-type-recursion.rs
index 5e26c855ed6..9a2cd3237ba 100644
--- a/src/test/compile-fail/infinite-vec-type-recursion.rs
+++ b/src/test/compile-fail/infinite-vec-type-recursion.rs
@@ -8,5 +8,5 @@
 type x = vec[x];
 
 fn main() {
-  let x b = vec();
+  let x b = [];
 }
diff --git a/src/test/compile-fail/writing-to-immutable-vec.rs b/src/test/compile-fail/writing-to-immutable-vec.rs
index cb4030eaed7..2872d11fc80 100644
--- a/src/test/compile-fail/writing-to-immutable-vec.rs
+++ b/src/test/compile-fail/writing-to-immutable-vec.rs
@@ -3,6 +3,6 @@
 // xfail-stage2
 // error-pattern: writing to immutable type
 fn main() {
-  let vec[int] v = vec(1, 2, 3);
+  let vec[int] v = [1, 2, 3];
   v.(1) = 4;
 }
\ No newline at end of file
diff --git a/src/test/run-fail/vec-overrun.rs b/src/test/run-fail/vec-overrun.rs
index 1eaedff9b4c..a6d782809c7 100644
--- a/src/test/run-fail/vec-overrun.rs
+++ b/src/test/run-fail/vec-overrun.rs
@@ -6,7 +6,7 @@
 // error-pattern:bounds check
 
 fn main() {
-  let vec[int] v = vec(10);
+  let vec[int] v = [10];
   let int x = 0;
   assert (v.(x) == 10);
   // Bounds-check failure.
diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs
index fab59869d8c..ac691bb85ae 100644
--- a/src/test/run-fail/vec-underrun.rs
+++ b/src/test/run-fail/vec-underrun.rs
@@ -6,7 +6,7 @@
 // error-pattern:bounds check
 
 fn main() {
-  let vec[int] v = vec(10, 20);
+  let vec[int] v = [10, 20];
   let int x = 0;
   assert (v.(x) == 10);
   // Bounds-check failure.
diff --git a/src/test/run-pass/alt-join.rs b/src/test/run-pass/alt-join.rs
index a785f91d3b4..3d6d6313085 100644
--- a/src/test/run-pass/alt-join.rs
+++ b/src/test/run-pass/alt-join.rs
@@ -7,7 +7,7 @@ import std::option::some;
 fn foo[T](&option::t[T] y) {
   let int x;
   
-  let vec[int] res = vec();
+  let vec[int] res = [];
   
   /* tests that x doesn't get put in the precondition for the 
      entire if expression */
@@ -22,7 +22,7 @@ fn foo[T](&option::t[T] y) {
         x = 42;
       }
     }
-    res += vec(x);
+    res += [x];
   }
 
   ret;
diff --git a/src/test/run-pass/argv.rs b/src/test/run-pass/argv.rs
index 92d5fcc6e66..a84d3192f7b 100644
--- a/src/test/run-pass/argv.rs
+++ b/src/test/run-pass/argv.rs
@@ -1,6 +1,6 @@
 fn main(vec[str] args) {
-  let vec[str] vs = vec("hi", "there", "this", "is", "a", "vec");
-  let vec[vec[str]] vvs = vec(args, vs);
+  let vec[str] vs = ["hi", "there", "this", "is", "a", "vec"];
+  let vec[vec[str]] vvs = [args, vs];
   for (vec[str] vs in vvs) {
     for (str s in vs) {
       log s;
diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs
index 3485977e132..65f0f57a14a 100644
--- a/src/test/run-pass/break.rs
+++ b/src/test/run-pass/break.rs
@@ -13,7 +13,7 @@ fn main() {
   } while (i < 30);
   assert (i == 20);
 
-  for (int x in vec(1, 2, 3, 4, 5, 6)) {
+  for (int x in [1, 2, 3, 4, 5, 6]) {
     if (x == 3) { break; }
     assert (x <= 3);
   }
@@ -32,7 +32,7 @@ fn main() {
     assert (i % 2 != 0);
   } while (i < 10);
 
-  for (int x in vec(1, 2, 3, 4, 5, 6)) {
+  for (int x in [1, 2, 3, 4, 5, 6]) {
     if (x % 2 == 0) { cont; }
     assert (x % 2 != 0);
   }
diff --git a/src/test/run-pass/empty-mutable-vec.rs b/src/test/run-pass/empty-mutable-vec.rs
index a972fda4e53..7faf162b889 100644
--- a/src/test/run-pass/empty-mutable-vec.rs
+++ b/src/test/run-pass/empty-mutable-vec.rs
@@ -1,4 +1,4 @@
 fn main() {
-    let vec[mutable int] v = vec(mutable);
+    let vec[mutable int] v = [mutable];
 }
 
diff --git a/src/test/run-pass/expr-alt-generic-box2.rs b/src/test/run-pass/expr-alt-generic-box2.rs
index 7398d0b030c..3b6cadc7202 100644
--- a/src/test/run-pass/expr-alt-generic-box2.rs
+++ b/src/test/run-pass/expr-alt-generic-box2.rs
@@ -16,7 +16,7 @@ fn test_vec() {
     ret v1 == v2;
   }
   auto eq = bind compare_vec(_, _);
-  test_generic[vec[int]](vec(1, 2, 3), eq);
+  test_generic[vec[int]]([1, 2, 3], eq);
 }
 
 fn main() {
diff --git a/src/test/run-pass/expr-block-generic-box2.rs b/src/test/run-pass/expr-block-generic-box2.rs
index d0e272a26cc..2c9d85d5d96 100644
--- a/src/test/run-pass/expr-block-generic-box2.rs
+++ b/src/test/run-pass/expr-block-generic-box2.rs
@@ -12,7 +12,7 @@ fn test_vec() {
     ret v1 == v2;
   }
   auto eq = bind compare_vec(_, _);
-  test_generic[vec[int]](vec(1, 2), eq);
+  test_generic[vec[int]]([1, 2], eq);
 }
 
 fn main() {
diff --git a/src/test/run-pass/expr-if-generic-box2.rs b/src/test/run-pass/expr-if-generic-box2.rs
index 572662431f6..c0224fffcd2 100644
--- a/src/test/run-pass/expr-if-generic-box2.rs
+++ b/src/test/run-pass/expr-if-generic-box2.rs
@@ -12,7 +12,7 @@ fn test_vec() {
     ret v1 == v2;
   }
   auto eq = bind compare_vec(_, _);
-  test_generic[vec[int]](vec(1, 2), vec(2, 3), eq);
+  test_generic[vec[int]]([1, 2], [2, 3], eq);
 }
 
 fn main() {
diff --git a/src/test/run-pass/foreach-nested-2.rs b/src/test/run-pass/foreach-nested-2.rs
index 33a376d529e..423821ab16c 100644
--- a/src/test/run-pass/foreach-nested-2.rs
+++ b/src/test/run-pass/foreach-nested-2.rs
@@ -15,7 +15,7 @@ iter range(int start, int stop) -> int {
 
 fn main() {
     let vec[mutable int] a =
-      vec(mutable -1, -1, -1, -1, -1, -1, -1, -1);
+      [mutable -1, -1, -1, -1, -1, -1, -1, -1];
     let int p = 0;
 
     for each (int i in two()) {
diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs
index 9ba304c1463..dd431a80890 100644
--- a/src/test/run-pass/foreach-nested.rs
+++ b/src/test/run-pass/foreach-nested.rs
@@ -6,7 +6,7 @@ iter two() -> int {
 }
 
 fn main() {
-    let vec[mutable int] a = vec(mutable -1, -1, -1, -1);
+    let vec[mutable int] a = [mutable -1, -1, -1, -1];
     let int p = 0;
 
     for each (int i in two()) {
diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs
index ee80786c18a..f7207295685 100644
--- a/src/test/run-pass/integral-indexing.rs
+++ b/src/test/run-pass/integral-indexing.rs
@@ -2,7 +2,7 @@
 
 fn main() {
 
-  let vec[int] v = vec(0, 1, 2, 3, 4, 5);
+  let vec[int] v = [0, 1, 2, 3, 4, 5];
   let str s = "abcdef";
   assert (v.(3u) == 3);
   assert (v.(3u8) == 3);
diff --git a/src/test/run-pass/lib-bitv.rs b/src/test/run-pass/lib-bitv.rs
index 506d5b2ad1d..706f3c22cd5 100644
--- a/src/test/run-pass/lib-bitv.rs
+++ b/src/test/run-pass/lib-bitv.rs
@@ -16,10 +16,10 @@ fn test_1_element() {
   auto act;
 
   act = bitv::create(1u, false);
-  assert (bitv::eq_vec(act, vec(0u)));
+  assert (bitv::eq_vec(act, [0u]));
 
   act = bitv::create(1u, true);
-  assert (bitv::eq_vec(act, vec(1u)));
+  assert (bitv::eq_vec(act, [1u]));
 }
 
 fn test_10_elements() {
@@ -27,11 +27,11 @@ fn test_10_elements() {
 
   // all 0
   act = bitv::create(10u, false);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
 
   // all 1
   act = bitv::create(10u, true);
-  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
+  assert (bitv::eq_vec(act, [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
 
   // mixed
   act = bitv::create(10u, false);
@@ -40,7 +40,7 @@ fn test_10_elements() {
   bitv::set(act, 2u, true);
   bitv::set(act, 3u, true);
   bitv::set(act, 4u, true);
-  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u)));
+  assert (bitv::eq_vec(act, [1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u]));
 
   // mixed
   act = bitv::create(10u, false);
@@ -49,7 +49,7 @@ fn test_10_elements() {
   bitv::set(act, 7u, true);
   bitv::set(act, 8u, true);
   bitv::set(act, 9u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u)));
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u]));
 
   // mixed
   act = bitv::create(10u, false);
@@ -57,7 +57,7 @@ fn test_10_elements() {
   bitv::set(act, 3u, true);
   bitv::set(act, 6u, true);
   bitv::set(act, 9u, true);
-  assert (bitv::eq_vec(act, vec(1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u)));
+  assert (bitv::eq_vec(act, [1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u]));
 }
 
 fn test_31_elements() {
@@ -65,17 +65,17 @@ fn test_31_elements() {
 
   // all 0
   act = bitv::create(31u, false);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+                             0u, 0u, 0u, 0u, 0u, 0u, 0u]));
 
   // all 1
   act = bitv::create(31u, true);
-  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  assert (bitv::eq_vec(act, [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
-                              1u, 1u, 1u, 1u, 1u, 1u, 1u)));
+                             1u, 1u, 1u, 1u, 1u, 1u, 1u]));
 
   // mixed
   act = bitv::create(31u, false);
@@ -87,10 +87,10 @@ fn test_31_elements() {
   bitv::set(act, 5u, true);
   bitv::set(act, 6u, true);
   bitv::set(act, 7u, true);
-  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  assert (bitv::eq_vec(act, [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+                             0u, 0u, 0u, 0u, 0u, 0u, 0u]));
 
   // mixed
   act = bitv::create(31u, false);
@@ -102,10 +102,10 @@ fn test_31_elements() {
   bitv::set(act, 21u, true);
   bitv::set(act, 22u, true);
   bitv::set(act, 23u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
-                              0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+                             0u, 0u, 0u, 0u, 0u, 0u, 0u]));
 
   // mixed
   act = bitv::create(31u, false);
@@ -116,20 +116,20 @@ fn test_31_elements() {
   bitv::set(act, 28u, true);
   bitv::set(act, 29u, true);
   bitv::set(act, 30u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              1u, 1u, 1u, 1u, 1u, 1u, 1u)));
+                             1u, 1u, 1u, 1u, 1u, 1u, 1u]));
 
   // mixed
   act = bitv::create(31u, false);
   bitv::set(act, 3u, true);
   bitv::set(act, 17u, true);
   bitv::set(act, 30u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              0u, 0u, 0u, 0u, 0u, 0u, 1u)));
+                             0u, 0u, 0u, 0u, 0u, 0u, 1u]));
 }
 
 fn test_32_elements() {
@@ -137,17 +137,17 @@ fn test_32_elements() {
 
   // all 0
   act = bitv::create(32u, false);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+                             0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
 
   // all 1
   act = bitv::create(32u, true);
-  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  assert (bitv::eq_vec(act, [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
-                              1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
+                             1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
 
   // mixed
   act = bitv::create(32u, false);
@@ -159,10 +159,10 @@ fn test_32_elements() {
   bitv::set(act, 5u, true);
   bitv::set(act, 6u, true);
   bitv::set(act, 7u, true);
-  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  assert (bitv::eq_vec(act, [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+                             0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
 
   // mixed
   act = bitv::create(32u, false);
@@ -174,10 +174,10 @@ fn test_32_elements() {
   bitv::set(act, 21u, true);
   bitv::set(act, 22u, true);
   bitv::set(act, 23u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
-                              0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+                             0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
 
   // mixed
   act = bitv::create(32u, false);
@@ -189,10 +189,10 @@ fn test_32_elements() {
   bitv::set(act, 29u, true);
   bitv::set(act, 30u, true);
   bitv::set(act, 31u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
+                             1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
 
   // mixed
   act = bitv::create(32u, false);
@@ -200,10 +200,10 @@ fn test_32_elements() {
   bitv::set(act, 17u, true);
   bitv::set(act, 30u, true);
   bitv::set(act, 31u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u)));
+                             0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u]));
 }
 
 fn test_33_elements() {
@@ -211,19 +211,19 @@ fn test_33_elements() {
 
   // all 0
   act = bitv::create(33u, false);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              0u)));
+                             0u]));
 
   // all 1
   act = bitv::create(33u, true);
-  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  assert (bitv::eq_vec(act, [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
-                              1u)));
+                             1u]));
 
   // mixed
   act = bitv::create(33u, false);
@@ -235,11 +235,11 @@ fn test_33_elements() {
   bitv::set(act, 5u, true);
   bitv::set(act, 6u, true);
   bitv::set(act, 7u, true);
-  assert (bitv::eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+  assert (bitv::eq_vec(act, [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              0u)));
+                             0u]));
 
   // mixed
   act = bitv::create(33u, false);
@@ -251,11 +251,11 @@ fn test_33_elements() {
   bitv::set(act, 21u, true);
   bitv::set(act, 22u, true);
   bitv::set(act, 23u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
-                              0u)));
+                              0u]));
 
   // mixed
   act = bitv::create(33u, false);
@@ -267,11 +267,11 @@ fn test_33_elements() {
   bitv::set(act, 29u, true);
   bitv::set(act, 30u, true);
   bitv::set(act, 31u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
-                              0u)));
+                             0u]));
 
   // mixed
   act = bitv::create(33u, false);
@@ -280,11 +280,11 @@ fn test_33_elements() {
   bitv::set(act, 30u, true);
   bitv::set(act, 31u, true);
   bitv::set(act, 32u, true);
-  assert (bitv::eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+  assert (bitv::eq_vec(act, [0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
                               0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
-                              1u)));
+                             1u]));
 }
 
 fn main() {
diff --git a/src/test/run-pass/lib-io.rs b/src/test/run-pass/lib-io.rs
index d9a33a6b120..3462e93f7c5 100644
--- a/src/test/run-pass/lib-io.rs
+++ b/src/test/run-pass/lib-io.rs
@@ -14,7 +14,7 @@ fn test_simple(str tmpfilebase) {
   log frood;
 
   {
-    let io::writer out = io::file_writer(tmpfile, vec(io::create));
+    let io::writer out = io::file_writer(tmpfile, [io::create]);
     out.write_str(frood);
   }
 
diff --git a/src/test/run-pass/lib-qsort.rs b/src/test/run-pass/lib-qsort.rs
index 2f086667686..473950cd864 100644
--- a/src/test/run-pass/lib-qsort.rs
+++ b/src/test/run-pass/lib-qsort.rs
@@ -19,32 +19,32 @@ fn check_sort(vec[mutable int] v1, vec[mutable int] v2) {
 
 fn main() {
   {
-    auto v1 = vec(mutable 3,7,4,5,2,9,5,8);
-    auto v2 = vec(mutable 2,3,4,5,5,7,8,9);
+    auto v1 = [mutable 3,7,4,5,2,9,5,8];
+    auto v2 = [mutable 2,3,4,5,5,7,8,9];
     check_sort(v1, v2);
   }
 
   {
-    auto v1 = vec(mutable 1,1,1);
-    auto v2 = vec(mutable 1,1,1);
+    auto v1 = [mutable 1,1,1];
+    auto v2 = [mutable 1,1,1];
     check_sort(v1, v2);
   }
 
   {
-    let vec[mutable int] v1 = vec(mutable);
-    let vec[mutable int] v2 = vec(mutable);
+    let vec[mutable int] v1 = [mutable];
+    let vec[mutable int] v2 = [mutable];
     check_sort(v1, v2);
   }
 
   {
-    auto v1 = vec(mutable 9);
-    auto v2 = vec(mutable 9);
+    auto v1 = [mutable 9];
+    auto v2 = [mutable 9];
     check_sort(v1, v2);
   }
 
   {
-    auto v1 = vec(mutable 9,3,3,3,9);
-    auto v2 = vec(mutable 3,3,3,9,9);
+    auto v1 = [mutable 9,3,3,3,9];
+    auto v2 = [mutable 3,3,3,9,9];
     check_sort(v1, v2);
   }
 
diff --git a/src/test/run-pass/lib-sha1.rs b/src/test/run-pass/lib-sha1.rs
index 882784796d5..7f137cb871c 100644
--- a/src/test/run-pass/lib-sha1.rs
+++ b/src/test/run-pass/lib-sha1.rs
@@ -24,44 +24,44 @@ fn main() {
 
     // Test messages from FIPS 180-1
     let vec[test] fips_180_1_tests =
-        vec(
+        [
             rec(input = "abc",
-                output = vec(0xA9u8, 0x99u8, 0x3Eu8, 0x36u8, 0x47u8,
+                output = [0xA9u8, 0x99u8, 0x3Eu8, 0x36u8, 0x47u8,
                              0x06u8, 0x81u8, 0x6Au8, 0xBAu8, 0x3Eu8,
                              0x25u8, 0x71u8, 0x78u8, 0x50u8, 0xC2u8,
-                             0x6Cu8, 0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8)
+                             0x6Cu8, 0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8]
                 ),
             rec(input = "abcdbcdecdefdefgefghfghighij"
                       + "hijkijkljklmklmnlmnomnopnopq",
-                output = vec(0x84u8, 0x98u8, 0x3Eu8, 0x44u8, 0x1Cu8,
+                output = [0x84u8, 0x98u8, 0x3Eu8, 0x44u8, 0x1Cu8,
                              0x3Bu8, 0xD2u8, 0x6Eu8, 0xBAu8, 0xAEu8,
                              0x4Au8, 0xA1u8, 0xF9u8, 0x51u8, 0x29u8,
-                             0xE5u8, 0xE5u8, 0x46u8, 0x70u8, 0xF1u8)
+                             0xE5u8, 0xE5u8, 0x46u8, 0x70u8, 0xF1u8]
                 ),
             rec(input = a_million_letter_a(),
-                output = vec(0x34u8, 0xAAu8, 0x97u8, 0x3Cu8, 0xD4u8,
+                output = [0x34u8, 0xAAu8, 0x97u8, 0x3Cu8, 0xD4u8,
                              0xC4u8, 0xDAu8, 0xA4u8, 0xF6u8, 0x1Eu8,
                              0xEBu8, 0x2Bu8, 0xDBu8, 0xADu8, 0x27u8,
-                             0x31u8, 0x65u8, 0x34u8, 0x01u8, 0x6Fu8)
+                             0x31u8, 0x65u8, 0x34u8, 0x01u8, 0x6Fu8]
                 )
-            );
+            ];
 
     // Examples from wikipedia
     let vec[test] wikipedia_tests =
-        vec(
+        [
             rec(input = "The quick brown fox jumps over the lazy dog",
-                output = vec(0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8, 0x7au8,
+                output = [0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8, 0x7au8,
                              0x2du8, 0x28u8, 0xfcu8, 0xedu8, 0x84u8,
                              0x9eu8, 0xe1u8, 0xbbu8, 0x76u8, 0xe7u8,
-                             0x39u8, 0x1bu8, 0x93u8, 0xebu8, 0x12u8)
+                             0x39u8, 0x1bu8, 0x93u8, 0xebu8, 0x12u8]
                 ),
             rec(input = "The quick brown fox jumps over the lazy cog",
-                output = vec(0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8, 0xd2u8,
+                output = [0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8, 0xd2u8,
                              0x5eu8, 0x1bu8, 0x3au8, 0xfau8, 0xd3u8,
                              0xe8u8, 0x5au8, 0x0bu8, 0xd1u8, 0x7du8,
-                             0x9bu8, 0x10u8, 0x0du8, 0xb4u8, 0xb3u8)
+                             0x9bu8, 0x10u8, 0x0du8, 0xb4u8, 0xb3u8]
                 )
-            );
+            ];
 
     auto tests = fips_180_1_tests + wikipedia_tests;
 
diff --git a/src/test/run-pass/lib-sort.rs b/src/test/run-pass/lib-sort.rs
index 6ec266fa210..fe0c9e9473f 100644
--- a/src/test/run-pass/lib-sort.rs
+++ b/src/test/run-pass/lib-sort.rs
@@ -17,32 +17,32 @@ fn check_sort(vec[int] v1, vec[int] v2) {
 
 fn main() {
   {
-    auto v1 = vec(3,7,4,5,2,9,5,8);
-    auto v2 = vec(2,3,4,5,5,7,8,9);
+    auto v1 = [3,7,4,5,2,9,5,8];
+    auto v2 = [2,3,4,5,5,7,8,9];
     check_sort(v1, v2);
   }
 
   {
-    auto v1 = vec(1,1,1);
-    auto v2 = vec(1,1,1);
+    auto v1 = [1,1,1];
+    auto v2 = [1,1,1];
     check_sort(v1, v2);
   }
 
   {
-    let vec[int] v1 = vec();
-    let vec[int] v2 = vec();
+    let vec[int] v1 = [];
+    let vec[int] v2 = [];
     check_sort(v1, v2);
   }
 
   {
-    auto v1 = vec(9);
-    auto v2 = vec(9);
+    auto v1 = [9];
+    auto v2 = [9];
     check_sort(v1, v2);
   }
 
   {
-    auto v1 = vec(9,3,3,3,9);
-    auto v2 = vec(3,3,3,9,9);
+    auto v1 = [9,3,3,3,9];
+    auto v2 = [3,3,3,9,9];
     check_sort(v1, v2);
   }
 
diff --git a/src/test/run-pass/lib-str.rs b/src/test/run-pass/lib-str.rs
index eaa31012b11..185694a25a1 100644
--- a/src/test/run-pass/lib-str.rs
+++ b/src/test/run-pass/lib-str.rs
@@ -73,10 +73,10 @@ fn test_concat() {
     assert (_str::eq(_str::concat(v), s));
   }
 
-  t(vec("you", "know", "I'm", "no", "good"), "youknowI'mnogood");
-  let vec[str] v = vec();
+  t(["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
+  let vec[str] v = [];
   t(v, "");
-  t(vec("hi"), "hi");
+  t(["hi"], "hi");
 }
 
 fn test_connect() {
@@ -84,10 +84,10 @@ fn test_connect() {
     assert (_str::eq(_str::connect(v, sep), s));
   }
 
-  t(vec("you", "know", "I'm", "no", "good"), " ", "you know I'm no good");
-  let vec[str] v = vec();
+  t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good");
+  let vec[str] v = [];
   t(v, " ", "");
-  t(vec("hi"), " ", "hi");
+  t(["hi"], " ", "hi");
 }
 
 fn test_to_upper() {
diff --git a/src/test/run-pass/lib-vec.rs b/src/test/run-pass/lib-vec.rs
index f7e6157a14d..63e903d2d8e 100644
--- a/src/test/run-pass/lib-vec.rs
+++ b/src/test/run-pass/lib-vec.rs
@@ -23,7 +23,7 @@ fn test_init_fn() {
 }
 
 fn test_slice() {
-  let vec[int] v = vec(1,2,3,4,5);
+  let vec[int] v = [1,2,3,4,5];
   auto v2 = std::_vec::slice[int](v, 2u, 4u);
   assert (std::_vec::len[int](v2) == 2u);
   assert (v2.(0) == 3);
@@ -33,7 +33,7 @@ fn test_slice() {
 fn test_map() {
   fn square(&int x) -> int { ret x * x; }
   let std::option::operator[int, int] op = square;
-  let vec[int] v = vec(1, 2, 3, 4, 5);
+  let vec[int] v = [1, 2, 3, 4, 5];
   let vec[int] s = std::_vec::map[int, int](op, v);
   let int i = 0;
   while (i < 5) {
@@ -45,8 +45,8 @@ fn test_map() {
 fn test_map2() {
   fn times(&int x, &int y) -> int { ret x * y; }
   auto f = times;
-  auto v0 = vec(1, 2, 3, 4, 5);
-  auto v1 = vec(5, 4, 3, 2, 1);
+  auto v0 = [1, 2, 3, 4, 5];
+  auto v1 = [5, 4, 3, 2, 1];
   auto u = std::_vec::map2[int,int,int](f, v0, v1);
 
   auto i = 0;
diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
index c816f817225..6345e43acf5 100644
--- a/src/test/run-pass/linear-for-loop.rs
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -1,5 +1,5 @@
 fn main() {
-  auto x = vec(1,2,3);
+  auto x = [1,2,3];
   auto y = 0;
   for (int i in x) {
     log i;
diff --git a/src/test/run-pass/maybe-mutable.rs b/src/test/run-pass/maybe-mutable.rs
index c0af0867faa..7b8781d2f81 100644
--- a/src/test/run-pass/maybe-mutable.rs
+++ b/src/test/run-pass/maybe-mutable.rs
@@ -9,9 +9,9 @@ fn len(vec[mutable? int] v) -> uint {
 }
 
 fn main() {
-    auto v0 = vec(1, 2, 3, 4, 5);
+    auto v0 = [1, 2, 3, 4, 5];
     log len(v0);
-    auto v1 = vec(mutable 1, 2, 3, 4, 5);
+    auto v1 = [mutable 1, 2, 3, 4, 5];
     log len(v1);
 }
 
diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index c63220dfbfa..a09d8dc4ab8 100644
--- a/src/test/run-pass/mutable-alias-vec.rs
+++ b/src/test/run-pass/mutable-alias-vec.rs
@@ -3,11 +3,11 @@
 use std;
 
 fn grow(&mutable vec[int] v) {
-  v += vec(1);
+  v += [1];
 }
 
 fn main() {
-  let vec[int] v = vec();
+  let vec[int] v = [];
   grow(v);
   grow(v);
   grow(v);
diff --git a/src/test/run-pass/mutable-vec-drop.rs b/src/test/run-pass/mutable-vec-drop.rs
index ebfb8c6c53f..15c36f46b68 100644
--- a/src/test/run-pass/mutable-vec-drop.rs
+++ b/src/test/run-pass/mutable-vec-drop.rs
@@ -2,5 +2,5 @@ fn main() {
   // This just tests whether the vec leaks its members.
 
   let vec[mutable @tup(int,int)] pvec =
-    vec(mutable @tup(1,2), @tup(3,4), @tup(5,6));
+    [mutable @tup(1,2), @tup(3,4), @tup(5,6)];
 }
diff --git a/src/test/run-pass/obj-with-vec.rs b/src/test/run-pass/obj-with-vec.rs
index b298f75f969..7b807b9a76f 100644
--- a/src/test/run-pass/obj-with-vec.rs
+++ b/src/test/run-pass/obj-with-vec.rs
@@ -5,7 +5,7 @@ fn main() {
       ret data.(i);
     }
   }
-  auto b = buf(vec(1 as u8, 2 as u8, 3 as u8));
+  auto b = buf([1 as u8, 2 as u8, 3 as u8]);
   log b.get(1);
   assert (b.get(1) == (2 as u8));
 }
diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs
index ba7e623908d..9a8eca74af4 100644
--- a/src/test/run-pass/seq-compare.rs
+++ b/src/test/run-pass/seq-compare.rs
@@ -3,13 +3,13 @@ fn main() {
   assert ("hello " > "hello");
   assert ("hello" != "there");
 
-  assert (vec(1,2,3,4) > vec(1,2,3));
-  assert (vec(1,2,3) < vec(1,2,3,4));
-  assert (vec(1,2,4,4) > vec(1,2,3,4));
-  assert (vec(1,2,3,4) < vec(1,2,4,4));
-  assert (vec(1,2,3) <= vec(1,2,3));
-  assert (vec(1,2,3) <= vec(1,2,3,3));
-  assert (vec(1,2,3,4) > vec(1,2,3));
-  assert (vec(1,2,3) == vec(1,2,3));
-  assert (vec(1,2,3) != vec(1,1,3));
+  assert ([1,2,3,4] > [1,2,3]);
+  assert ([1,2,3] < [1,2,3,4]);
+  assert ([1,2,4,4] > [1,2,3,4]);
+  assert ([1,2,3,4] < [1,2,4,4]);
+  assert ([1,2,3] <= [1,2,3]);
+  assert ([1,2,3] <= [1,2,3,3]);
+  assert ([1,2,3,4] > [1,2,3]);
+  assert ([1,2,3] == [1,2,3]);
+  assert ([1,2,3] != [1,1,3]);
 }
diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs
index 58d529e8374..8412d51d8c7 100644
--- a/src/test/run-pass/size-and-align.rs
+++ b/src/test/run-pass/size-and-align.rs
@@ -13,6 +13,6 @@ fn uhoh[T](vec[clam[T]] v) {
 }
 
 fn main() {
-  let vec[clam[int]] v = vec(b[int], b[int], a[int](42, 17));
+  let vec[clam[int]] v = [b[int], b[int], a[int](42, 17)];
   uhoh[int](v);
 }
diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs
index 9438f50ef4d..9a533bca036 100644
--- a/src/test/run-pass/task-comm-16.rs
+++ b/src/test/run-pass/task-comm-16.rs
@@ -22,7 +22,7 @@ fn test_rec() {
 fn test_vec() {
   let port[vec[int]] po = port();
   let chan[vec[int]] ch = chan(po);
-  let vec[int] v0 = vec(0, 1, 2);
+  let vec[int] v0 = [0, 1, 2];
 
   ch <| v0;
 
diff --git a/src/test/run-pass/task-comm-2.rs b/src/test/run-pass/task-comm-2.rs
index f2aa250c881..e856f0bbef2 100644
--- a/src/test/run-pass/task-comm-2.rs
+++ b/src/test/run-pass/task-comm-2.rs
@@ -21,13 +21,13 @@ fn test00(bool create_threads) {
     let int number_of_tasks = 8;
     
     let int i = 0;
-    let vec[task] tasks = vec();
+    let vec[task] tasks = [];
     while (i < number_of_tasks) {
         i = i + 1;
         if (create_threads) {
-            tasks += vec(spawn thread start(i));
+            tasks += [spawn thread start(i)];
         } else {
-            tasks += vec(spawn start(i));
+            tasks += [spawn start(i)];
         }
     }
     
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index 0cdbe5ac0ba..907a7f28035 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -31,13 +31,13 @@ fn test00(bool is_multithreaded) {
     let int i = 0;
     
     // Create and spawn tasks...
-    let vec[task] tasks = vec();
+    let vec[task] tasks = [];
     while (i < number_of_tasks) {
         if (is_multithreaded) {
-            tasks += vec(
-                spawn thread test00_start(ch, i, number_of_messages));
+            tasks += [
+                spawn thread test00_start(ch, i, number_of_messages)];
         } else {
-            tasks += vec(spawn test00_start(ch, i, number_of_messages));
+            tasks += [spawn test00_start(ch, i, number_of_messages)];
         }
         i = i + 1;
     }
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index 16fc6452382..826743d0937 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -33,14 +33,14 @@ fn test00(bool is_multithreaded) {
     
     let int i = 0;
     
-    let vec[task] tasks = vec();
+    let vec[task] tasks = [];
     while (i < number_of_tasks) {
         i = i + 1;
         if (is_multithreaded) {
-            tasks += vec(
-                spawn thread test00_start(ch, i, number_of_messages));
+            tasks += [
+                spawn thread test00_start(ch, i, number_of_messages)];
         } else {
-            tasks += vec(spawn test00_start(ch, i, number_of_messages));
+            tasks += [spawn test00_start(ch, i, number_of_messages)];
         }
     }
     
@@ -147,11 +147,11 @@ fn test06() {
     
     let int i = 0;
     
-    let vec[task] tasks = vec();
+    let vec[task] tasks = [];
     while (i < number_of_tasks) {
         i = i + 1;
-        tasks += vec(spawn thread test06_start(i));
-        // tasks += vec(spawn test06_start(i));
+        tasks += [spawn thread test06_start(i)];
+        // tasks += [spawn test06_start(i)];
     }
     
     for (task t in tasks) {
diff --git a/src/test/run-pass/type-params-in-for-each.rs b/src/test/run-pass/type-params-in-for-each.rs
index 49fe099b625..1394643929e 100644
--- a/src/test/run-pass/type-params-in-for-each.rs
+++ b/src/test/run-pass/type-params-in-for-each.rs
@@ -9,7 +9,7 @@ iter range(uint lo, uint hi) -> uint {
 
 fn create_index[T](vec[tup(T, uint)] index, fn(&T) -> uint hash_fn) {
     for each (uint i in range(0u, 256u)) {
-        let vec[T] bucket = vec();
+        let vec[T] bucket = [];
     }
 }
 
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index a79294ec572..22a97ed7002 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -8,7 +8,7 @@ import std::io;
 
 fn main() {
   // Chars of 1, 2, 3, and 4 bytes
-  let vec[char] chs = vec('e', 'é', '€', 0x10000 as char);
+  let vec[char] chs = ['e', 'é', '€', 0x10000 as char];
   let str s = _str::from_chars(chs);
 
   assert (_str::byte_len(s) == 10u);
@@ -19,9 +19,9 @@ fn main() {
   assert (_str::char_at(s, 1u) == 'é');
 
   assert (_str::is_utf8(_str::bytes(s)));
-  assert (!_str::is_utf8(vec(0x80_u8)));
-  assert (!_str::is_utf8(vec(0xc0_u8)));
-  assert (!_str::is_utf8(vec(0xc0_u8, 0x10_u8)));
+  assert (!_str::is_utf8([0x80_u8]));
+  assert (!_str::is_utf8([0xc0_u8]));
+  assert (!_str::is_utf8([0xc0_u8, 0x10_u8]));
 
   auto stack = "a×c€";
   assert (_str::pop_char(stack) == '€');
diff --git a/src/test/run-pass/vec-alloc-append.rs b/src/test/run-pass/vec-alloc-append.rs
index d0ca6ab9c8c..c61d4cc967b 100644
--- a/src/test/run-pass/vec-alloc-append.rs
+++ b/src/test/run-pass/vec-alloc-append.rs
@@ -13,5 +13,5 @@ fn slice[T](vec[T] e) {
 }
 
 fn main() {
-  slice[str](vec("a"));
+  slice[str](["a"]);
 }
diff --git a/src/test/run-pass/vec-append.rs b/src/test/run-pass/vec-append.rs
index dc36799bce4..1d0d2509570 100644
--- a/src/test/run-pass/vec-append.rs
+++ b/src/test/run-pass/vec-append.rs
@@ -13,8 +13,8 @@ import std::_vec;
 const uint const_refcount = 0x7bad_face_u;
 
 fn fast_growth() {
-  let vec[int] v = vec(1,2,3,4,5);
-  v += vec(6,7,8,9,0);
+  let vec[int] v = [1,2,3,4,5];
+  v += [6,7,8,9,0];
 
   log v.(9);
   assert (v.(0) == 1);
@@ -23,9 +23,9 @@ fn fast_growth() {
 }
 
 fn slow_growth() {
-  let vec[int] v = vec();
+  let vec[int] v = [];
   let vec[int] u = v;
-  v += vec(17);
+  v += [17];
 
   log v.(0);
   assert (v.(0) == 17);
@@ -34,7 +34,7 @@ fn slow_growth() {
 fn slow_growth2_helper(str s) {   // ref up: s
 
   obj acc(vec[str] v) {
-    fn add(&str s) { v += vec(s); }
+    fn add(&str s) { v += [s]; }
   }
 
   let str ss = s;                 // ref up: s
@@ -50,7 +50,7 @@ fn slow_growth2_helper(str s) {   // ref up: s
      * copy of existing elements should increment the ref count of
      * mumble, the existing str in the originally- shared vec.
      */
-    let vec[str] v = vec(mumble); // ref up: v, mumble
+    let vec[str] v = [mumble]; // ref up: v, mumble
     let acc a = acc(v);           // ref up: a, v
 
     log _vec::refcount[str](v);
diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs
index 09a95402e65..3ef6b1dec56 100644
--- a/src/test/run-pass/vec-concat.rs
+++ b/src/test/run-pass/vec-concat.rs
@@ -1,8 +1,8 @@
 // -*- rust -*-
 
 fn main() {
-  let vec[int] a = vec(1,2,3,4,5);
-  let vec[int] b = vec(6,7,8,9,0);
+  let vec[int] a = [1,2,3,4,5];
+  let vec[int] b = [6,7,8,9,0];
   let vec[int] v = a + b;
   log v.(9);
   assert (v.(0) == 1);
diff --git a/src/test/run-pass/vec-drop.rs b/src/test/run-pass/vec-drop.rs
index fff9a1ee64b..6b46102faf4 100644
--- a/src/test/run-pass/vec-drop.rs
+++ b/src/test/run-pass/vec-drop.rs
@@ -1,4 +1,4 @@
 fn main() {
   // This just tests whether the vec leaks its members.
-  let vec[@tup(int,int)] pvec = vec(@tup(1,2),@tup(3,4),@tup(5,6));
+  let vec[@tup(int,int)] pvec = [@tup(1,2),@tup(3,4),@tup(5,6)];
 }
diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs
index b6976abd3a9..3c010e19e91 100644
--- a/src/test/run-pass/vec-growth.rs
+++ b/src/test/run-pass/vec-growth.rs
@@ -1,9 +1,9 @@
 fn main() {
-    auto v = vec(1);
-    v += vec(2);
-    v += vec(3);
-    v += vec(4);
-    v += vec(5);
+    auto v = [1];
+    v += [2];
+    v += [3];
+    v += [4];
+    v += [5];
     assert (v.(0) == 1);
     assert (v.(1) == 2);
     assert (v.(2) == 3);
diff --git a/src/test/run-pass/vec-in-tup.rs b/src/test/run-pass/vec-in-tup.rs
index 415554dd374..e1c0a78bd9a 100644
--- a/src/test/run-pass/vec-in-tup.rs
+++ b/src/test/run-pass/vec-in-tup.rs
@@ -1,4 +1,4 @@
 fn main() {
-  let tup(mutable vec[int]) i = tup(mutable vec(1,2,3));
-  i._0 = vec(4,5,6);
+  let tup(mutable vec[int]) i = tup(mutable [1,2,3]);
+  i._0 = [4,5,6];
 }
diff --git a/src/test/run-pass/vec-late-init.rs b/src/test/run-pass/vec-late-init.rs
index 39a0b6e89bc..48e91dcd213 100644
--- a/src/test/run-pass/vec-late-init.rs
+++ b/src/test/run-pass/vec-late-init.rs
@@ -1,9 +1,9 @@
 fn main() {
   let vec[int] later;
   if (true) {
-    later = vec(1);
+    later = [1];
   } else {
-    later = vec(2);
+    later = [2];
   }
   log later.(0);
 }
\ No newline at end of file
diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs
index fc4f19eae33..09416d67fef 100644
--- a/src/test/run-pass/vec-push.rs
+++ b/src/test/run-pass/vec-push.rs
@@ -1,9 +1,9 @@
 fn push[T](&mutable vec[mutable? T] v, &T t) {
-    v += vec(t);
+    v += [t];
 }
 
 fn main() {
-    auto v = @vec(1, 2, 3);
+    auto v = @[1, 2, 3];
     push[int](*v, 1);
 }
 
diff --git a/src/test/run-pass/vec-ref-count.rs b/src/test/run-pass/vec-ref-count.rs
index 86ba642b61f..cb26e4845d5 100644
--- a/src/test/run-pass/vec-ref-count.rs
+++ b/src/test/run-pass/vec-ref-count.rs
@@ -2,7 +2,7 @@ use std;
 import std::_vec;
 
 fn main() {
-    auto v = vec(1, 2, 3);
+    auto v = [1, 2, 3];
     log_err _vec::refcount[int](v);
     log_err _vec::refcount[int](v);
     log_err _vec::refcount[int](v);
diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs
index dc15060bafe..fb60210fbfc 100644
--- a/src/test/run-pass/vec-slice.rs
+++ b/src/test/run-pass/vec-slice.rs
@@ -2,7 +2,7 @@
 // xfail-stage1
 // xfail-stage2
 fn main() {
-  let vec[int] v = vec(1,2,3,4,5);
+  let vec[int] v = [1,2,3,4,5];
   auto v2 = v.(1,2);
   assert (v2.(0) == 2);
   assert (v2.(1) == 3);
diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs
index 138d0ff2880..5e97fa81465 100644
--- a/src/test/run-pass/vec.rs
+++ b/src/test/run-pass/vec.rs
@@ -1,7 +1,7 @@
 // -*- rust -*-
 
 fn main() {
-  let vec[int] v = vec(10, 20);
+  let vec[int] v = [10, 20];
   assert (v.(0) == 10);
   assert (v.(1) == 20);
   let int x = 0;
diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs
index 2adaf24bbc3..64dc59af3d6 100644
--- a/src/test/run-pass/while-with-break.rs
+++ b/src/test/run-pass/while-with-break.rs
@@ -6,7 +6,7 @@ fn main() {
     log i;
     i = i + 1;
     if (i == 95) { 
-      let vec[int] v = vec(1,2,3,4,5); // we check that it is freed by break
+      let vec[int] v = [1,2,3,4,5]; // we check that it is freed by break
       log "breaking"; 
       break; 
     }