Reformat

This changes the indexing syntax from .() to [], the vector syntax from ~[] to
[] and the extension syntax from #fmt() to #fmt[]

24 files changed, 439 insertions, 457 deletions

diff --git a/src/test/stdtest/bitv.rs b/src/test/stdtest/bitv.rs
index 7666063239d..249a43be13b 100644
--- a/src/test/stdtest/bitv.rs
+++ b/src/test/stdtest/bitv.rs
@@ -18,9 +18,9 @@ fn test_0_elements() {
 fn test_1_element() {
     let act;
     act = bitv::create(1u, false);
-    assert (bitv::eq_vec(act, ~[0u]));
+    assert (bitv::eq_vec(act, [0u]));
     act = bitv::create(1u, true);
-    assert (bitv::eq_vec(act, ~[1u]));
+    assert (bitv::eq_vec(act, [1u]));
 }
 
 #[test]
@@ -29,11 +29,11 @@ fn test_10_elements() {
     // all 0
 
     act = bitv::create(10u, false);
-    assert (bitv::eq_vec(act, ~[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, ~[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);
@@ -42,7 +42,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, ~[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);
@@ -51,7 +51,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, ~[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);
@@ -59,7 +59,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, ~[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]));
 }
 
 #[test]
@@ -69,16 +69,16 @@ fn test_31_elements() {
 
     act = bitv::create(31u, false);
     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, 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,
-                         ~[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, 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);
@@ -91,9 +91,9 @@ fn test_31_elements() {
     bitv::set(act, 6u, true);
     bitv::set(act, 7u, true);
     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]));
+                         [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]));
     // mixed
 
     act = bitv::create(31u, false);
@@ -106,9 +106,9 @@ fn test_31_elements() {
     bitv::set(act, 22u, true);
     bitv::set(act, 23u, true);
     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, 0u, 0u, 0u, 0u,
+                          0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
+                          0u, 0u, 0u, 0u, 0u]));
     // mixed
 
     act = bitv::create(31u, false);
@@ -120,9 +120,9 @@ fn test_31_elements() {
     bitv::set(act, 29u, true);
     bitv::set(act, 30u, true);
     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]));
+                         [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]));
     // mixed
 
     act = bitv::create(31u, false);
@@ -130,9 +130,9 @@ fn test_31_elements() {
     bitv::set(act, 17u, true);
     bitv::set(act, 30u, true);
     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, 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]));
 }
 
 #[test]
@@ -142,16 +142,16 @@ fn test_32_elements() {
 
     act = bitv::create(32u, false);
     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, 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,
-                         ~[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, 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);
@@ -164,9 +164,9 @@ fn test_32_elements() {
     bitv::set(act, 6u, true);
     bitv::set(act, 7u, true);
     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]));
+                         [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]));
     // mixed
 
     act = bitv::create(32u, false);
@@ -179,9 +179,9 @@ fn test_32_elements() {
     bitv::set(act, 22u, true);
     bitv::set(act, 23u, true);
     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, 0u, 0u, 0u, 0u, 0u,
+                          0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
+                          0u, 0u, 0u, 0u, 0u, 0u]));
     // mixed
 
     act = bitv::create(32u, false);
@@ -194,9 +194,9 @@ fn test_32_elements() {
     bitv::set(act, 30u, true);
     bitv::set(act, 31u, true);
     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, 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]));
     // mixed
 
     act = bitv::create(32u, false);
@@ -205,9 +205,9 @@ fn test_32_elements() {
     bitv::set(act, 30u, true);
     bitv::set(act, 31u, true);
     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, 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]));
 }
 
 #[test]
@@ -217,16 +217,16 @@ fn test_33_elements() {
 
     act = bitv::create(33u, false);
     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, 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,
-                         ~[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, 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);
@@ -239,9 +239,9 @@ fn test_33_elements() {
     bitv::set(act, 6u, true);
     bitv::set(act, 7u, true);
     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]));
+                         [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]));
     // mixed
 
     act = bitv::create(33u, false);
@@ -254,9 +254,9 @@ fn test_33_elements() {
     bitv::set(act, 22u, true);
     bitv::set(act, 23u, true);
     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, 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]));
     // mixed
 
     act = bitv::create(33u, false);
@@ -269,9 +269,9 @@ fn test_33_elements() {
     bitv::set(act, 30u, true);
     bitv::set(act, 31u, true);
     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, 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]));
     // mixed
 
     act = bitv::create(33u, false);
@@ -281,8 +281,8 @@ fn test_33_elements() {
     bitv::set(act, 31u, true);
     bitv::set(act, 32u, true);
     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]));
+                         [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]));
 }
 
diff --git a/src/test/stdtest/comm.rs b/src/test/stdtest/comm.rs
index 7d20042e866..6b67acc51ea 100644
--- a/src/test/stdtest/comm.rs
+++ b/src/test/stdtest/comm.rs
@@ -15,7 +15,7 @@ fn send_recv() {
     comm::send(c, 42);
     let v = p.recv();
     log_err v;
-    assert(42 == v);
+    assert (42 == v);
 }
 
 #[test]
@@ -23,7 +23,7 @@ fn send_recv_fn() {
     let p = comm::port::<int>();
     let c = comm::chan::<int>(p);
     comm::send(c, 42);
-    assert(comm::recv(p) == 42);
+    assert (comm::recv(p) == 42);
 }
 
 #[test]
@@ -31,7 +31,7 @@ fn send_recv_fn_infer() {
     let p = comm::port();
     let c = comm::chan(p);
     comm::send(c, 42);
-    assert(comm::recv(p) == 42);
+    assert (comm::recv(p) == 42);
 }
 
 #[test]
diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs
index d751bd5c45d..acdde57b86e 100644
--- a/src/test/stdtest/deque.rs
+++ b/src/test/stdtest/deque.rs
@@ -79,7 +79,7 @@ fn test_boxes(a: @int, b: @int, c: @int, d: @int) {
     assert (deq.get(3) == d);
 }
 
-type eqfn<T> = fn(&T, &T) -> bool ;
+type eqfn<T> = fn(&T, &T) -> bool;
 
 fn test_parameterized<@T>(e: eqfn<T>, a: &T, b: &T, c: &T, d: &T) {
     let deq: deque::t<T> = deque::create::<T>();
@@ -175,15 +175,14 @@ fn test() {
     log "test parameterized: taggy";
     let eq3: eqfn<taggy> = taggyeq;
     test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3),
-                              two(17, 42));
+                                two(17, 42));
 
     log "*** test parameterized: taggypar<int>";
     let eq4: eqfn<taggypar<int>> = taggypareq::<int>;
-    test_parameterized::<taggypar<int>>(eq4,
-                                      onepar::<int>(1),
-                                      twopar::<int>(1, 2),
-                                      threepar::<int>(1, 2, 3),
-                                      twopar::<int>(17, 42));
+    test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1),
+                                        twopar::<int>(1, 2),
+                                        threepar::<int>(1, 2, 3),
+                                        twopar::<int>(17, 42));
     log "*** end test parameterized: taggypar::<int>";
 
     log "*** test parameterized: reccy";
diff --git a/src/test/stdtest/either.rs b/src/test/stdtest/either.rs
index 21b8184f496..82724b1c09a 100644
--- a/src/test/stdtest/either.rs
+++ b/src/test/stdtest/either.rs
@@ -20,60 +20,60 @@ fn test_either_right() {
 
 #[test]
 fn test_lefts() {
-    let input = ~[left(10), right(11), left(12), right(13), left(14)];
+    let input = [left(10), right(11), left(12), right(13), left(14)];
     let result = lefts(input);
-    assert (result == ~[10, 12, 14]);
+    assert (result == [10, 12, 14]);
 }
 
 #[test]
 fn test_lefts_none() {
-    let input: [t<int, int>] = ~[right(10), right(10)];
+    let input: [t<int, int>] = [right(10), right(10)];
     let result = lefts(input);
     assert (len(result) == 0u);
 }
 
 #[test]
 fn test_lefts_empty() {
-    let input: [t<int, int>] = ~[];
+    let input: [t<int, int>] = [];
     let result = lefts(input);
     assert (len(result) == 0u);
 }
 
 #[test]
 fn test_rights() {
-    let input = ~[left(10), right(11), left(12), right(13), left(14)];
+    let input = [left(10), right(11), left(12), right(13), left(14)];
     let result = rights(input);
-    assert (result == ~[11, 13]);
+    assert (result == [11, 13]);
 }
 
 #[test]
 fn test_rights_none() {
-    let input: [t<int, int>] = ~[left(10), left(10)];
+    let input: [t<int, int>] = [left(10), left(10)];
     let result = rights(input);
     assert (len(result) == 0u);
 }
 
 #[test]
 fn test_rights_empty() {
-    let input: [t<int, int>] = ~[];
+    let input: [t<int, int>] = [];
     let result = rights(input);
     assert (len(result) == 0u);
 }
 
 #[test]
 fn test_partition() {
-    let input = ~[left(10), right(11), left(12), right(13), left(14)];
+    let input = [left(10), right(11), left(12), right(13), left(14)];
     let result = partition(input);
-    assert (result.lefts.(0) == 10);
-    assert (result.lefts.(1) == 12);
-    assert (result.lefts.(2) == 14);
-    assert (result.rights.(0) == 11);
-    assert (result.rights.(1) == 13);
+    assert (result.lefts[0] == 10);
+    assert (result.lefts[1] == 12);
+    assert (result.lefts[2] == 14);
+    assert (result.rights[0] == 11);
+    assert (result.rights[1] == 13);
 }
 
 #[test]
 fn test_partition_no_lefts() {
-    let input: [t<int, int>] = ~[right(10), right(11)];
+    let input: [t<int, int>] = [right(10), right(11)];
     let result = partition(input);
     assert (len(result.lefts) == 0u);
     assert (len(result.rights) == 2u);
@@ -81,7 +81,7 @@ fn test_partition_no_lefts() {
 
 #[test]
 fn test_partition_no_rights() {
-    let input: [t<int, int>] = ~[left(10), left(11)];
+    let input: [t<int, int>] = [left(10), left(11)];
     let result = partition(input);
     assert (len(result.lefts) == 2u);
     assert (len(result.rights) == 0u);
@@ -89,7 +89,7 @@ fn test_partition_no_rights() {
 
 #[test]
 fn test_partition_empty() {
-    let input: [t<int, int>] = ~[];
+    let input: [t<int, int>] = [];
     let result = partition(input);
     assert (len(result.lefts) == 0u);
     assert (len(result.rights) == 0u);
diff --git a/src/test/stdtest/getopts.rs b/src/test/stdtest/getopts.rs
index 10acbafcb12..55d67729129 100644
--- a/src/test/stdtest/getopts.rs
+++ b/src/test/stdtest/getopts.rs
@@ -27,8 +27,8 @@ fn check_fail_type(f: opt::fail_, ft: fail_type) {
 // Tests for reqopt
 #[test]
 fn test_reqopt_long() {
-    let args = ~["--test=20"];
-    let opts = ~[opt::reqopt("test")];
+    let args = ["--test=20"];
+    let opts = [opt::reqopt("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
@@ -41,8 +41,8 @@ fn test_reqopt_long() {
 
 #[test]
 fn test_reqopt_long_missing() {
-    let args = ~["blah"];
-    let opts = ~[opt::reqopt("test")];
+    let args = ["blah"];
+    let opts = [opt::reqopt("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, option_missing); }
@@ -52,8 +52,8 @@ fn test_reqopt_long_missing() {
 
 #[test]
 fn test_reqopt_long_no_arg() {
-    let args = ~["--test"];
-    let opts = ~[opt::reqopt("test")];
+    let args = ["--test"];
+    let opts = [opt::reqopt("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, argument_missing); }
@@ -63,8 +63,8 @@ fn test_reqopt_long_no_arg() {
 
 #[test]
 fn test_reqopt_long_multi() {
-    let args = ~["--test=20", "--test=30"];
-    let opts = ~[opt::reqopt("test")];
+    let args = ["--test=20", "--test=30"];
+    let opts = [opt::reqopt("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, option_duplicated); }
@@ -74,8 +74,8 @@ fn test_reqopt_long_multi() {
 
 #[test]
 fn test_reqopt_short() {
-    let args = ~["-t", "20"];
-    let opts = ~[opt::reqopt("t")];
+    let args = ["-t", "20"];
+    let opts = [opt::reqopt("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
@@ -88,8 +88,8 @@ fn test_reqopt_short() {
 
 #[test]
 fn test_reqopt_short_missing() {
-    let args = ~["blah"];
-    let opts = ~[opt::reqopt("t")];
+    let args = ["blah"];
+    let opts = [opt::reqopt("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, option_missing); }
@@ -99,8 +99,8 @@ fn test_reqopt_short_missing() {
 
 #[test]
 fn test_reqopt_short_no_arg() {
-    let args = ~["-t"];
-    let opts = ~[opt::reqopt("t")];
+    let args = ["-t"];
+    let opts = [opt::reqopt("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, argument_missing); }
@@ -110,8 +110,8 @@ fn test_reqopt_short_no_arg() {
 
 #[test]
 fn test_reqopt_short_multi() {
-    let args = ~["-t", "20", "-t", "30"];
-    let opts = ~[opt::reqopt("t")];
+    let args = ["-t", "20", "-t", "30"];
+    let opts = [opt::reqopt("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, option_duplicated); }
@@ -123,8 +123,8 @@ fn test_reqopt_short_multi() {
 // Tests for optopt
 #[test]
 fn test_optopt_long() {
-    let args = ~["--test=20"];
-    let opts = ~[opt::optopt("test")];
+    let args = ["--test=20"];
+    let opts = [opt::optopt("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
@@ -137,8 +137,8 @@ fn test_optopt_long() {
 
 #[test]
 fn test_optopt_long_missing() {
-    let args = ~["blah"];
-    let opts = ~[opt::optopt("test")];
+    let args = ["blah"];
+    let opts = [opt::optopt("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) { assert (!opt::opt_present(m, "test")); }
@@ -148,8 +148,8 @@ fn test_optopt_long_missing() {
 
 #[test]
 fn test_optopt_long_no_arg() {
-    let args = ~["--test"];
-    let opts = ~[opt::optopt("test")];
+    let args = ["--test"];
+    let opts = [opt::optopt("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, argument_missing); }
@@ -159,8 +159,8 @@ fn test_optopt_long_no_arg() {
 
 #[test]
 fn test_optopt_long_multi() {
-    let args = ~["--test=20", "--test=30"];
-    let opts = ~[opt::optopt("test")];
+    let args = ["--test=20", "--test=30"];
+    let opts = [opt::optopt("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, option_duplicated); }
@@ -170,8 +170,8 @@ fn test_optopt_long_multi() {
 
 #[test]
 fn test_optopt_short() {
-    let args = ~["-t", "20"];
-    let opts = ~[opt::optopt("t")];
+    let args = ["-t", "20"];
+    let opts = [opt::optopt("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
@@ -184,8 +184,8 @@ fn test_optopt_short() {
 
 #[test]
 fn test_optopt_short_missing() {
-    let args = ~["blah"];
-    let opts = ~[opt::optopt("t")];
+    let args = ["blah"];
+    let opts = [opt::optopt("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) { assert (!opt::opt_present(m, "t")); }
@@ -195,8 +195,8 @@ fn test_optopt_short_missing() {
 
 #[test]
 fn test_optopt_short_no_arg() {
-    let args = ~["-t"];
-    let opts = ~[opt::optopt("t")];
+    let args = ["-t"];
+    let opts = [opt::optopt("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, argument_missing); }
@@ -206,8 +206,8 @@ fn test_optopt_short_no_arg() {
 
 #[test]
 fn test_optopt_short_multi() {
-    let args = ~["-t", "20", "-t", "30"];
-    let opts = ~[opt::optopt("t")];
+    let args = ["-t", "20", "-t", "30"];
+    let opts = [opt::optopt("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, option_duplicated); }
@@ -219,8 +219,8 @@ fn test_optopt_short_multi() {
 // Tests for optflag
 #[test]
 fn test_optflag_long() {
-    let args = ~["--test"];
-    let opts = ~[opt::optflag("test")];
+    let args = ["--test"];
+    let opts = [opt::optflag("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) { assert (opt::opt_present(m, "test")); }
@@ -230,8 +230,8 @@ fn test_optflag_long() {
 
 #[test]
 fn test_optflag_long_missing() {
-    let args = ~["blah"];
-    let opts = ~[opt::optflag("test")];
+    let args = ["blah"];
+    let opts = [opt::optflag("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) { assert (!opt::opt_present(m, "test")); }
@@ -241,8 +241,8 @@ fn test_optflag_long_missing() {
 
 #[test]
 fn test_optflag_long_arg() {
-    let args = ~["--test=20"];
-    let opts = ~[opt::optflag("test")];
+    let args = ["--test=20"];
+    let opts = [opt::optflag("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) {
@@ -255,8 +255,8 @@ fn test_optflag_long_arg() {
 
 #[test]
 fn test_optflag_long_multi() {
-    let args = ~["--test", "--test"];
-    let opts = ~[opt::optflag("test")];
+    let args = ["--test", "--test"];
+    let opts = [opt::optflag("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, option_duplicated); }
@@ -266,8 +266,8 @@ fn test_optflag_long_multi() {
 
 #[test]
 fn test_optflag_short() {
-    let args = ~["-t"];
-    let opts = ~[opt::optflag("t")];
+    let args = ["-t"];
+    let opts = [opt::optflag("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) { assert (opt::opt_present(m, "t")); }
@@ -277,8 +277,8 @@ fn test_optflag_short() {
 
 #[test]
 fn test_optflag_short_missing() {
-    let args = ~["blah"];
-    let opts = ~[opt::optflag("t")];
+    let args = ["blah"];
+    let opts = [opt::optflag("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) { assert (!opt::opt_present(m, "t")); }
@@ -288,14 +288,14 @@ fn test_optflag_short_missing() {
 
 #[test]
 fn test_optflag_short_arg() {
-    let args = ~["-t", "20"];
-    let opts = ~[opt::optflag("t")];
+    let args = ["-t", "20"];
+    let opts = [opt::optflag("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
         // The next variable after the flag is just a free argument
 
-        assert (m.free.(0) == "20");
+        assert (m.free[0] == "20");
       }
       _ { fail; }
     }
@@ -303,8 +303,8 @@ fn test_optflag_short_arg() {
 
 #[test]
 fn test_optflag_short_multi() {
-    let args = ~["-t", "-t"];
-    let opts = ~[opt::optflag("t")];
+    let args = ["-t", "-t"];
+    let opts = [opt::optflag("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, option_duplicated); }
@@ -316,8 +316,8 @@ fn test_optflag_short_multi() {
 // Tests for optmulti
 #[test]
 fn test_optmulti_long() {
-    let args = ~["--test=20"];
-    let opts = ~[opt::optmulti("test")];
+    let args = ["--test=20"];
+    let opts = [opt::optmulti("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
@@ -330,8 +330,8 @@ fn test_optmulti_long() {
 
 #[test]
 fn test_optmulti_long_missing() {
-    let args = ~["blah"];
-    let opts = ~[opt::optmulti("test")];
+    let args = ["blah"];
+    let opts = [opt::optmulti("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) { assert (!opt::opt_present(m, "test")); }
@@ -341,8 +341,8 @@ fn test_optmulti_long_missing() {
 
 #[test]
 fn test_optmulti_long_no_arg() {
-    let args = ~["--test"];
-    let opts = ~[opt::optmulti("test")];
+    let args = ["--test"];
+    let opts = [opt::optmulti("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, argument_missing); }
@@ -352,15 +352,15 @@ fn test_optmulti_long_no_arg() {
 
 #[test]
 fn test_optmulti_long_multi() {
-    let args = ~["--test=20", "--test=30"];
-    let opts = ~[opt::optmulti("test")];
+    let args = ["--test=20", "--test=30"];
+    let opts = [opt::optmulti("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
         assert (opt::opt_present(m, "test"));
         assert (opt::opt_str(m, "test") == "20");
-        assert (opt::opt_strs(m, "test").(0) == "20");
-        assert (opt::opt_strs(m, "test").(1) == "30");
+        assert (opt::opt_strs(m, "test")[0] == "20");
+        assert (opt::opt_strs(m, "test")[1] == "30");
       }
       _ { fail; }
     }
@@ -368,8 +368,8 @@ fn test_optmulti_long_multi() {
 
 #[test]
 fn test_optmulti_short() {
-    let args = ~["-t", "20"];
-    let opts = ~[opt::optmulti("t")];
+    let args = ["-t", "20"];
+    let opts = [opt::optmulti("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
@@ -382,8 +382,8 @@ fn test_optmulti_short() {
 
 #[test]
 fn test_optmulti_short_missing() {
-    let args = ~["blah"];
-    let opts = ~[opt::optmulti("t")];
+    let args = ["blah"];
+    let opts = [opt::optmulti("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) { assert (!opt::opt_present(m, "t")); }
@@ -393,8 +393,8 @@ fn test_optmulti_short_missing() {
 
 #[test]
 fn test_optmulti_short_no_arg() {
-    let args = ~["-t"];
-    let opts = ~[opt::optmulti("t")];
+    let args = ["-t"];
+    let opts = [opt::optmulti("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, argument_missing); }
@@ -404,15 +404,15 @@ fn test_optmulti_short_no_arg() {
 
 #[test]
 fn test_optmulti_short_multi() {
-    let args = ~["-t", "20", "-t", "30"];
-    let opts = ~[opt::optmulti("t")];
+    let args = ["-t", "20", "-t", "30"];
+    let opts = [opt::optmulti("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
         assert (opt::opt_present(m, "t"));
         assert (opt::opt_str(m, "t") == "20");
-        assert (opt::opt_strs(m, "t").(0) == "20");
-        assert (opt::opt_strs(m, "t").(1) == "30");
+        assert (opt::opt_strs(m, "t")[0] == "20");
+        assert (opt::opt_strs(m, "t")[1] == "30");
       }
       _ { fail; }
     }
@@ -420,8 +420,8 @@ fn test_optmulti_short_multi() {
 
 #[test]
 fn test_unrecognized_option_long() {
-    let args = ~["--untest"];
-    let opts = ~[opt::optmulti("t")];
+    let args = ["--untest"];
+    let opts = [opt::optmulti("t")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, unrecognized_option); }
@@ -431,8 +431,8 @@ fn test_unrecognized_option_long() {
 
 #[test]
 fn test_unrecognized_option_short() {
-    let args = ~["-t"];
-    let opts = ~[opt::optmulti("test")];
+    let args = ["-t"];
+    let opts = [opt::optmulti("test")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::failure(f) { check_fail_type(f, unrecognized_option); }
@@ -443,23 +443,23 @@ fn test_unrecognized_option_short() {
 #[test]
 fn test_combined() {
     let args =
-        ~["prog", "free1", "-s", "20", "free2", "--flag", "--long=30", "-f",
+        ["prog", "free1", "-s", "20", "free2", "--flag", "--long=30", "-f",
          "-m", "40", "-m", "50"];
     let opts =
-        ~[opt::optopt("s"), opt::optflag("flag"), opt::reqopt("long"),
+        [opt::optopt("s"), opt::optflag("flag"), opt::reqopt("long"),
          opt::optflag("f"), opt::optmulti("m"), opt::optopt("notpresent")];
     let rs = opt::getopts(args, opts);
     alt rs {
       opt::success(m) {
-        assert (m.free.(0) == "prog");
-        assert (m.free.(1) == "free1");
+        assert (m.free[0] == "prog");
+        assert (m.free[1] == "free1");
         assert (opt::opt_str(m, "s") == "20");
-        assert (m.free.(2) == "free2");
+        assert (m.free[2] == "free2");
         assert (opt::opt_present(m, "flag"));
         assert (opt::opt_str(m, "long") == "30");
         assert (opt::opt_present(m, "f"));
-        assert (opt::opt_strs(m, "m").(0) == "40");
-        assert (opt::opt_strs(m, "m").(1) == "50");
+        assert (opt::opt_strs(m, "m")[0] == "40");
+        assert (opt::opt_strs(m, "m")[1] == "50");
         assert (!opt::opt_present(m, "notpresent"));
       }
       _ { fail; }
diff --git a/src/test/stdtest/int.rs b/src/test/stdtest/int.rs
index 936b1fa91d3..61d3448a175 100644
--- a/src/test/stdtest/int.rs
+++ b/src/test/stdtest/int.rs
@@ -22,4 +22,4 @@ fn test_pow() {
     assert (int::pow(-3, 2u) == 9);
     assert (int::pow(-3, 3u) == -27);
     assert (int::pow(4, 9u) == 262144);
-}
\ No newline at end of file
+}
diff --git a/src/test/stdtest/io.rs b/src/test/stdtest/io.rs
index 002592d9020..08330c619fc 100644
--- a/src/test/stdtest/io.rs
+++ b/src/test/stdtest/io.rs
@@ -13,7 +13,7 @@ fn test_simple() {
     log frood;
     {
         let out: io::writer =
-            io::file_writer(tmpfile, ~[io::create, io::truncate]);
+            io::file_writer(tmpfile, [io::create, io::truncate]);
         out.write_str(frood);
     }
     let inp: io::reader = io::file_reader(tmpfile);
diff --git a/src/test/stdtest/list.rs b/src/test/stdtest/list.rs
index 4a44508efc4..9e05115a4f8 100644
--- a/src/test/stdtest/list.rs
+++ b/src/test/stdtest/list.rs
@@ -8,7 +8,7 @@ import std::option;
 
 #[test]
 fn test_from_vec() {
-    let l = from_vec(~[0, 1, 2]);
+    let l = from_vec([0, 1, 2]);
     assert (car(l) == 0);
     assert (car(cdr(l)) == 1);
     assert (car(cdr(cdr(l))) == 2);
@@ -16,7 +16,7 @@ fn test_from_vec() {
 
 #[test]
 fn test_foldl() {
-    let l = from_vec(~[0, 1, 2, 3, 4]);
+    let l = from_vec([0, 1, 2, 3, 4]);
     fn add(a: &int, b: &uint) -> uint { ret (a as uint) + b; }
     let rs = list::foldl(l, 0u, add);
     assert (rs == 10u);
@@ -24,7 +24,7 @@ fn test_foldl() {
 
 #[test]
 fn test_find_success() {
-    let l = from_vec(~[0, 1, 2]);
+    let l = from_vec([0, 1, 2]);
     fn match(i: &int) -> option::t<int> {
         ret if i == 2 { option::some(i) } else { option::none::<int> };
     }
@@ -34,7 +34,7 @@ fn test_find_success() {
 
 #[test]
 fn test_find_fail() {
-    let l = from_vec(~[0, 1, 2]);
+    let l = from_vec([0, 1, 2]);
     fn match(i: &int) -> option::t<int> { ret option::none::<int>; }
     let rs = list::find(l, match);
     assert (rs == option::none::<int>);
@@ -42,7 +42,7 @@ fn test_find_fail() {
 
 #[test]
 fn test_has() {
-    let l = from_vec(~[5, 8, 6]);
+    let l = from_vec([5, 8, 6]);
     let empty = list::nil::<int>;
     assert (list::has(l, 5));
     assert (!list::has(l, 7));
@@ -52,7 +52,7 @@ fn test_has() {
 
 #[test]
 fn test_length() {
-    let l = from_vec(~[0, 1, 2]);
+    let l = from_vec([0, 1, 2]);
     assert (list::length(l) == 3u);
 }
 
diff --git a/src/test/stdtest/net.rs b/src/test/stdtest/net.rs
index c1a26cb747d..9da7a12a060 100644
--- a/src/test/stdtest/net.rs
+++ b/src/test/stdtest/net.rs
@@ -3,10 +3,10 @@ import std::net;
 
 #[test]
 fn test_format_ip() {
-    assert(net::format_addr(net::ipv4(127u8,0u8,0u8,1u8)) == "127.0.0.1")
+    assert (net::format_addr(net::ipv4(127u8, 0u8, 0u8, 1u8)) == "127.0.0.1")
 }
 
 #[test]
 fn test_parse_ip() {
-    assert(net::parse_addr("127.0.0.1") == net::ipv4(127u8,0u8,0u8,1u8));
+    assert (net::parse_addr("127.0.0.1") == net::ipv4(127u8, 0u8, 0u8, 1u8));
 }
diff --git a/src/test/stdtest/path.rs b/src/test/stdtest/path.rs
index 5f7c34c5e05..911bc6b0dd9 100644
--- a/src/test/stdtest/path.rs
+++ b/src/test/stdtest/path.rs
@@ -14,4 +14,4 @@ fn test() {
 
     log fs::make_absolute("test-path");
     log fs::make_absolute("/usr/bin");
-}
\ No newline at end of file
+}
diff --git a/src/test/stdtest/ptr.rs b/src/test/stdtest/ptr.rs
index 269febfc6b7..ef0ffa54a04 100644
--- a/src/test/stdtest/ptr.rs
+++ b/src/test/stdtest/ptr.rs
@@ -9,10 +9,10 @@ fn test() {
     let p = {mutable fst: 10, mutable snd: 20};
     let pptr: *mutable pair = ptr::addr_of(p);
     let iptr: *mutable int = unsafe::reinterpret_cast(pptr);
-    assert (*iptr == 10);
+    assert (*iptr == 10);;
     *iptr = 30;
     assert (*iptr == 30);
-    assert (p.fst == 30);
+    assert (p.fst == 30);;
 
     *pptr = {mutable fst: 50, mutable snd: 60};
     assert (*iptr == 50);
diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs
index 4e557b533a4..250d77a4593 100644
--- a/src/test/stdtest/qsort.rs
+++ b/src/test/stdtest/qsort.rs
@@ -11,30 +11,30 @@ fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
     let f = ltequal;
     std::sort::quick_sort::<int>(f, v1);
     let i = 0u;
-    while i < len { log v2.(i); assert (v2.(i) == v1.(i)); i += 1u; }
+    while i < len { log v2[i]; assert (v2[i] == v1[i]); i += 1u; }
 }
 
 #[test]
 fn test() {
     {
-        let v1 = ~[mutable 3, 7, 4, 5, 2, 9, 5, 8];
-        let v2 = ~[mutable 2, 3, 4, 5, 5, 7, 8, 9];
+        let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8];
+        let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9];
         check_sort(v1, v2);
     }
     {
-        let v1 = ~[mutable 1, 1, 1];
-        let v2 = ~[mutable 1, 1, 1];
+        let v1 = [mutable 1, 1, 1];
+        let v2 = [mutable 1, 1, 1];
         check_sort(v1, v2);
     }
     {
-        let v1: [mutable int] = ~[mutable ];
-        let v2: [mutable int] = ~[mutable ];
+        let v1: [mutable int] = [mutable];
+        let v2: [mutable int] = [mutable];
         check_sort(v1, v2);
     }
-    { let v1 = ~[mutable 9]; let v2 = ~[mutable 9]; check_sort(v1, v2); }
+    { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); }
     {
-        let v1 = ~[mutable 9, 3, 3, 3, 9];
-        let v2 = ~[mutable 3, 3, 3, 9, 9];
+        let v1 = [mutable 9, 3, 3, 3, 9];
+        let v2 = [mutable 3, 3, 3, 9, 9];
         check_sort(v1, v2);
     }
 }
@@ -42,18 +42,15 @@ fn test() {
 // Regression test for #705
 #[test]
 fn test_simple() {
-    let names = ~[mutable 2, 1, 3];
+    let names = [mutable 2, 1, 3];
 
-    let expected = ~[1, 2, 3];
+    let expected = [1, 2, 3];
 
     fn lteq(a: &int, b: &int) -> bool { int::le(a, b) }
     sort::quick_sort(lteq, names);
 
     let pairs = vec::zip(expected, vec::from_mut(names));
-    for (a, b) in pairs {
-        log #fmt("%d %d", a, b);
-        assert (a == b);
-    }
+    for (a, b) in pairs { log #fmt["%d %d", a, b]; assert (a == b); }
 }
 
 // Local Variables:
diff --git a/src/test/stdtest/qsort3.rs b/src/test/stdtest/qsort3.rs
index 21f43218806..6c8df212218 100644
--- a/src/test/stdtest/qsort3.rs
+++ b/src/test/stdtest/qsort3.rs
@@ -9,30 +9,30 @@ fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
     let f2 = equal;
     std::sort::quick_sort3::<int>(f1, f2, v1);
     let i = 0u;
-    while i < len { log v2.(i); assert (v2.(i) == v1.(i)); i += 1u; }
+    while i < len { log v2[i]; assert (v2[i] == v1[i]); i += 1u; }
 }
 
 #[test]
 fn test() {
     {
-        let v1 = ~[mutable 3, 7, 4, 5, 2, 9, 5, 8];
-        let v2 = ~[mutable 2, 3, 4, 5, 5, 7, 8, 9];
+        let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8];
+        let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9];
         check_sort(v1, v2);
     }
     {
-        let v1 = ~[mutable 1, 1, 1];
-        let v2 = ~[mutable 1, 1, 1];
+        let v1 = [mutable 1, 1, 1];
+        let v2 = [mutable 1, 1, 1];
         check_sort(v1, v2);
     }
     {
-        let v1: [mutable int] = ~[mutable ];
-        let v2: [mutable int] = ~[mutable ];
+        let v1: [mutable int] = [mutable];
+        let v2: [mutable int] = [mutable];
         check_sort(v1, v2);
     }
-    { let v1 = ~[mutable 9]; let v2 = ~[mutable 9]; check_sort(v1, v2); }
+    { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); }
     {
-        let v1 = ~[mutable 9, 3, 3, 3, 9];
-        let v2 = ~[mutable 3, 3, 3, 9, 9];
+        let v1 = [mutable 9, 3, 3, 3, 9];
+        let v2 = [mutable 3, 3, 3, 9, 9];
         check_sort(v1, v2);
     }
 }
diff --git a/src/test/stdtest/rand.rs b/src/test/stdtest/rand.rs
index bf394602fab..a8f13ed6704 100644
--- a/src/test/stdtest/rand.rs
+++ b/src/test/stdtest/rand.rs
@@ -26,4 +26,4 @@ fn test() {
     }
     log r1.next();
     log r1.next();
-}
\ No newline at end of file
+}
diff --git a/src/test/stdtest/run.rs b/src/test/stdtest/run.rs
index 7476cb6621b..b60a3935500 100644
--- a/src/test/stdtest/run.rs
+++ b/src/test/stdtest/run.rs
@@ -11,9 +11,9 @@ import std::vec;
 #[cfg(target_os = "macos")]
 #[test]
 fn test_leaks() {
-    run::run_program("echo", ~[]);
-    run::start_program("echo", ~[]);
-    run::program_output("echo", ~[]);
+    run::run_program("echo", []);
+    run::start_program("echo", []);
+    run::program_output("echo", []);
 }
 
 // FIXME
@@ -28,8 +28,8 @@ fn test_pipes() {
     let pipe_out = os::pipe();
     let pipe_err = os::pipe();
 
-    let pid = run::spawn_process("cat", ~[],
-       pipe_in.in, pipe_out.out, pipe_err.out);
+    let pid =
+        run::spawn_process("cat", [], pipe_in.in, pipe_out.out, pipe_err.out);
     os::libc::close(pipe_in.in);
     os::libc::close(pipe_out.out);
     os::libc::close(pipe_err.out);
@@ -43,11 +43,10 @@ fn test_pipes() {
 
     log expected;
     log actual;
-    assert expected == actual;
+    assert (expected == actual);
 
     fn writeclose(fd: int, s: &str) {
-        let writer = io::new_writer(
-            io::fd_buf_writer(fd, option::none));
+        let writer = io::new_writer(io::fd_buf_writer(fd, option::none));
         writer.write_str(s);
 
         os::libc::close(fd);
@@ -56,8 +55,7 @@ fn test_pipes() {
     fn readclose(fd: int) -> str {
         // Copied from run::program_output
         let file = os::fd_FILE(fd);
-        let reader = io::new_reader(
-            io::FILE_buf_reader(file, option::none));
+        let reader = io::new_reader(io::FILE_buf_reader(file, option::none));
         let buf = "";
         while !reader.eof() {
             let bytes = reader.read_bytes(4096u);
@@ -66,4 +64,4 @@ fn test_pipes() {
         os::libc::fclose(file);
         ret buf;
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/stdtest/sha1.rs b/src/test/stdtest/sha1.rs
index 74729fa52ae..6b72be20dd5 100644
--- a/src/test/stdtest/sha1.rs
+++ b/src/test/stdtest/sha1.rs
@@ -20,53 +20,43 @@ fn test() {
     // Test messages from FIPS 180-1
 
     let fips_180_1_tests: [test] =
-        ~[{input: "abc",
+        [{input: "abc",
           output:
-              ~[0xA9u8, 0x99u8, 0x3Eu8, 0x36u8,
-                0x47u8, 0x06u8, 0x81u8, 0x6Au8,
-                0xBAu8, 0x3Eu8, 0x25u8, 0x71u8,
-                0x78u8, 0x50u8, 0xC2u8, 0x6Cu8,
-                0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8]},
+              [0xA9u8, 0x99u8, 0x3Eu8, 0x36u8, 0x47u8, 0x06u8, 0x81u8, 0x6Au8,
+               0xBAu8, 0x3Eu8, 0x25u8, 0x71u8, 0x78u8, 0x50u8, 0xC2u8, 0x6Cu8,
+               0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8]},
          {input:
               "abcdbcdecdefdefgefghfghighij" + "hijkijkljklmklmnlmnomnopnopq",
           output:
-              ~[0x84u8, 0x98u8, 0x3Eu8, 0x44u8,
-                0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,
-                0xBAu8, 0xAEu8, 0x4Au8, 0xA1u8,
-                0xF9u8, 0x51u8, 0x29u8, 0xE5u8,
-                0xE5u8, 0x46u8, 0x70u8, 0xF1u8]},
+              [0x84u8, 0x98u8, 0x3Eu8, 0x44u8, 0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,
+               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,
-                0xF6u8, 0x1Eu8, 0xEBu8, 0x2Bu8,
-                0xDBu8, 0xADu8, 0x27u8, 0x31u8,
-                0x65u8, 0x34u8, 0x01u8, 0x6Fu8]}];
+              [0x34u8, 0xAAu8, 0x97u8, 0x3Cu8, 0xD4u8, 0xC4u8, 0xDAu8, 0xA4u8,
+               0xF6u8, 0x1Eu8, 0xEBu8, 0x2Bu8, 0xDBu8, 0xADu8, 0x27u8, 0x31u8,
+               0x65u8, 0x34u8, 0x01u8, 0x6Fu8]}];
     // Examples from wikipedia
 
     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,
-                0xedu8, 0x84u8, 0x9eu8, 0xe1u8,
-                0xbbu8, 0x76u8, 0xe7u8, 0x39u8,
-                0x1bu8, 0x93u8, 0xebu8, 0x12u8]},
+              [0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8, 0x7au8, 0x2du8, 0x28u8, 0xfcu8,
+               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,
-                0xfau8, 0xd3u8, 0xe8u8, 0x5au8,
-                0x0bu8, 0xd1u8, 0x7du8, 0x9bu8,
-                0x10u8, 0x0du8, 0xb4u8, 0xb3u8]}];
+              [0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8, 0xd2u8, 0x5eu8, 0x1bu8, 0x3au8,
+               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: &[u8], v1: &[u8]) {
         assert (vec::len::<u8>(v0) == vec::len::<u8>(v1));
         let len = vec::len::<u8>(v0);
         let i = 0u;
         while i < len {
-            let a = v0.(i);
-            let b = v1.(i);
+            let a = v0[i];
+            let b = v1[i];
             assert (a == b);
             i += 1u;
         }
diff --git a/src/test/stdtest/sort.rs b/src/test/stdtest/sort.rs
index be15881e65a..c42f950ce6b 100644
--- a/src/test/stdtest/sort.rs
+++ b/src/test/stdtest/sort.rs
@@ -7,22 +7,22 @@ fn check_sort(v1: &[int], v2: &[int]) {
     let f = lteq;
     let v3 = std::sort::merge_sort::<int>(f, v1);
     let i = 0u;
-    while i < len { log v3.(i); assert (v3.(i) == v2.(i)); i += 1u; }
+    while i < len { log v3[i]; assert (v3[i] == v2[i]); i += 1u; }
 }
 
 #[test]
 fn test() {
     {
-        let v1 = ~[3, 7, 4, 5, 2, 9, 5, 8];
-        let v2 = ~[2, 3, 4, 5, 5, 7, 8, 9];
+        let v1 = [3, 7, 4, 5, 2, 9, 5, 8];
+        let v2 = [2, 3, 4, 5, 5, 7, 8, 9];
         check_sort(v1, v2);
     }
-    { let v1 = ~[1, 1, 1]; let v2 = ~[1, 1, 1]; check_sort(v1, v2); }
-    { let v1: [int] = ~[]; let v2: [int] = ~[]; check_sort(v1, v2); }
-    { let v1 = ~[9]; let v2 = ~[9]; check_sort(v1, v2); }
+    { let v1 = [1, 1, 1]; let v2 = [1, 1, 1]; check_sort(v1, v2); }
+    { let v1: [int] = []; let v2: [int] = []; check_sort(v1, v2); }
+    { let v1 = [9]; let v2 = [9]; check_sort(v1, v2); }
     {
-        let v1 = ~[9, 3, 3, 3, 9];
-        let v2 = ~[3, 3, 3, 9, 9];
+        let v1 = [9, 3, 3, 3, 9];
+        let v2 = [3, 3, 3, 9, 9];
         check_sort(v1, v2);
     }
 }
diff --git a/src/test/stdtest/str.rs b/src/test/stdtest/str.rs
index 8124e565f6a..ef225c82fd8 100644
--- a/src/test/stdtest/str.rs
+++ b/src/test/stdtest/str.rs
@@ -30,8 +30,8 @@ fn test_split() {
         let v = str::split(s, c as u8);
         log "split to: ";
         for z: str in v { log z; }
-        log "comparing: " + v.(i) + " vs. " + k;
-        assert (str::eq(v.(i), k));
+        log "comparing: " + v[i] + " vs. " + k;
+        assert (str::eq(v[i], k));
     }
     t("abc.hello.there", '.', 0, "abc");
     t("abc.hello.there", '.', 1, "hello");
@@ -70,10 +70,10 @@ fn test_substr() {
 #[test]
 fn test_concat() {
     fn t(v: &[str], s: &str) { assert (str::eq(str::concat(v), s)); }
-    t(~["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
-    let v: [str] = ~[];
+    t(["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
+    let v: [str] = [];
     t(v, "");
-    t(~["hi"], "hi");
+    t(["hi"], "hi");
 }
 
 #[test]
@@ -81,10 +81,10 @@ fn test_connect() {
     fn t(v: &[str], sep: &str, s: &str) {
         assert (str::eq(str::connect(v, sep), s));
     }
-    t(~["you", "know", "I'm", "no", "good"], " ", "you know I'm no good");
-    let v: [str] = ~[];
+    t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good");
+    let v: [str] = [];
     t(v, " ", "");
-    t(~["hi"], " ", "hi");
+    t(["hi"], " ", "hi");
 }
 
 #[test]
@@ -164,41 +164,41 @@ fn test_char_slice() {
 
 #[test]
 fn trim_left() {
-    assert str::trim_left("") == "";
-    assert str::trim_left("a") == "a";
-    assert str::trim_left("    ") == "";
-    assert str::trim_left("     blah") == "blah";
-    assert str::trim_left("   \u3000  wut") == "wut";
-    assert str::trim_left("hey ") == "hey ";
+    assert (str::trim_left("") == "");
+    assert (str::trim_left("a") == "a");
+    assert (str::trim_left("    ") == "");
+    assert (str::trim_left("     blah") == "blah");
+    assert (str::trim_left("   \u3000  wut") == "wut");
+    assert (str::trim_left("hey ") == "hey ");
 }
 
 #[test]
 fn trim_right() {
-    assert str::trim_right("") == "";
-    assert str::trim_right("a") == "a";
-    assert str::trim_right("    ") == "";
-    assert str::trim_right("blah     ") == "blah";
-    assert str::trim_right("wut   \u3000  ") == "wut";
-    assert str::trim_right(" hey") == " hey";
+    assert (str::trim_right("") == "");
+    assert (str::trim_right("a") == "a");
+    assert (str::trim_right("    ") == "");
+    assert (str::trim_right("blah     ") == "blah");
+    assert (str::trim_right("wut   \u3000  ") == "wut");
+    assert (str::trim_right(" hey") == " hey");
 }
 
 #[test]
 fn trim() {
-    assert str::trim("") == "";
-    assert str::trim("a") == "a";
-    assert str::trim("    ") == "";
-    assert str::trim("    blah     ") == "blah";
-    assert str::trim("\nwut   \u3000  ") == "wut";
-    assert str::trim(" hey dude ") == "hey dude";
+    assert (str::trim("") == "");
+    assert (str::trim("a") == "a");
+    assert (str::trim("    ") == "");
+    assert (str::trim("    blah     ") == "blah");
+    assert (str::trim("\nwut   \u3000  ") == "wut");
+    assert (str::trim(" hey dude ") == "hey dude");
 }
 
 #[test]
 fn is_whitespace() {
-    assert str::is_whitespace("");
-    assert str::is_whitespace(" ");
-    assert str::is_whitespace("\u2009"); // Thin space
-    assert str::is_whitespace("  \n\t   ");
-    assert !str::is_whitespace("   _   ");
+    assert (str::is_whitespace(""));
+    assert (str::is_whitespace(" "));
+    assert (str::is_whitespace("\u2009")); // Thin space
+    assert (str::is_whitespace("  \n\t   "));
+    assert (!str::is_whitespace("   _   "));
 }
 
 // Local Variables:
diff --git a/src/test/stdtest/str_buf.rs b/src/test/stdtest/str_buf.rs
index 6b013ed8db2..8bb040dde9c 100644
--- a/src/test/stdtest/str_buf.rs
+++ b/src/test/stdtest/str_buf.rs
@@ -12,4 +12,4 @@ fn test() {
     assert (str::eq(s_cstr, s));
     let s_buf = str::str_from_buf(sb, 5u);
     assert (str::eq(s_buf, s));
-}
\ No newline at end of file
+}
diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs
index 517210b9c56..d30d6addd0b 100644
--- a/src/test/stdtest/task.rs
+++ b/src/test/stdtest/task.rs
@@ -37,7 +37,7 @@ fn test_lib_spawn() {
 
 #[test]
 fn test_lib_spawn2() {
-    fn foo(x : int) { assert(x == 42); }
+    fn foo(x: int) { assert (x == 42); }
     task::_spawn(bind foo(42));
 }
 
@@ -52,7 +52,7 @@ fn test_join_chan() {
     log_err "received task status message";
     log_err s;
     alt s {
-      task::exit(_, task::tr_success.) { /* yay! */ }
+      task::exit(_, task::tr_success.) {/* yay! */ }
       _ { fail "invalid task status received" }
     }
 }
@@ -68,7 +68,7 @@ fn test_join_chan_fail() {
     log_err "received task status message";
     log_err s;
     alt s {
-      task::exit(_, task::tr_failure.) { /* yay! */ }
+      task::exit(_, task::tr_failure.) {/* yay! */ }
       _ { fail "invalid task status received" }
     }
 }
@@ -78,5 +78,5 @@ fn test_join_convenient() {
     fn winner() { }
     let f = winner;
     let handle = task::spawn_joinable(f);
-    assert(task::tr_success == task::join(handle));
+    assert (task::tr_success == task::join(handle));
 }
diff --git a/src/test/stdtest/test.rs b/src/test/stdtest/test.rs
index e85829b4477..e32105c2f0a 100644
--- a/src/test/stdtest/test.rs
+++ b/src/test/stdtest/test.rs
@@ -26,7 +26,7 @@ fn ignored_tests_result_in_ignored() {
 
 #[test]
 fn first_free_arg_should_be_a_filter() {
-    let args = ~["progname", "filter"];
+    let args = ["progname", "filter"];
     check (vec::is_not_empty(args));
     let opts = alt test::parse_opts(args) { either::left(o) { o } };
     assert (str::eq("filter", option::get(opts.filter)));
@@ -34,7 +34,7 @@ fn first_free_arg_should_be_a_filter() {
 
 #[test]
 fn parse_ignored_flag() {
-    let args = ~["progname", "filter", "--ignored"];
+    let args = ["progname", "filter", "--ignored"];
     check (vec::is_not_empty(args));
     let opts = alt test::parse_opts(args) { either::left(o) { o } };
     assert (opts.run_ignored);
@@ -47,13 +47,13 @@ fn filter_for_ignored_option() {
 
     let opts = {filter: option::none, run_ignored: true};
     let tests =
-        ~[{name: "1", fn: fn () { }, ignore: true},
-          {name: "2", fn: fn () { }, ignore: false}];
+        [{name: "1", fn: fn () { }, ignore: true},
+         {name: "2", fn: fn () { }, ignore: false}];
     let filtered = test::filter_tests(opts, tests);
 
     assert (vec::len(filtered) == 1u);
-    assert (filtered.(0).name == "1");
-    assert (filtered.(0).ignore == false);
+    assert (filtered[0].name == "1");
+    assert (filtered[0].ignore == false);
 }
 
 #[test]
@@ -61,37 +61,35 @@ fn sort_tests() {
     let opts = {filter: option::none, run_ignored: false};
 
     let names =
-        ~["sha1::test", "int::test_to_str", "int::test_pow",
-          "test::do_not_run_ignored_tests",
-          "test::ignored_tests_result_in_ignored",
-          "test::first_free_arg_should_be_a_filter",
-          "test::parse_ignored_flag", "test::filter_for_ignored_option",
-          "test::sort_tests"];
+        ["sha1::test", "int::test_to_str", "int::test_pow",
+         "test::do_not_run_ignored_tests",
+         "test::ignored_tests_result_in_ignored",
+         "test::first_free_arg_should_be_a_filter",
+         "test::parse_ignored_flag", "test::filter_for_ignored_option",
+         "test::sort_tests"];
     let tests =
         {
             let testfn = fn () { };
-            let tests = ~[];
+            let tests = [];
             for name: str in names {
                 let test = {name: name, fn: testfn, ignore: false};
-                tests += ~[test];
+                tests += [test];
             }
             tests
         };
     let filtered = test::filter_tests(opts, tests);
 
     let expected =
-        ~["int::test_pow", "int::test_to_str", "sha1::test",
-          "test::do_not_run_ignored_tests", "test::filter_for_ignored_option",
-          "test::first_free_arg_should_be_a_filter",
-          "test::ignored_tests_result_in_ignored", "test::parse_ignored_flag",
-          "test::sort_tests"];
+        ["int::test_pow", "int::test_to_str", "sha1::test",
+         "test::do_not_run_ignored_tests", "test::filter_for_ignored_option",
+         "test::first_free_arg_should_be_a_filter",
+         "test::ignored_tests_result_in_ignored", "test::parse_ignored_flag",
+         "test::sort_tests"];
 
     let pairs = vec::zip(expected, filtered);
 
 
-    for (a, b) in pairs {
-        assert (a == b.name);
-    }
+    for (a, b) in pairs { assert (a == b.name); }
 }
 
 // Local Variables:
diff --git a/src/test/stdtest/uint.rs b/src/test/stdtest/uint.rs
index 8b450b8a5ff..7361c76b70b 100644
--- a/src/test/stdtest/uint.rs
+++ b/src/test/stdtest/uint.rs
@@ -46,4 +46,4 @@ fn test_next_power_of_two() {
     assert (uint::next_power_of_two(37u) == 64u);
     assert (uint::next_power_of_two(38u) == 64u);
     assert (uint::next_power_of_two(39u) == 64u);
-}
\ No newline at end of file
+}
diff --git a/src/test/stdtest/vec.rs b/src/test/stdtest/vec.rs
index 75b3998e28c..1ffe3982cd2 100644
--- a/src/test/stdtest/vec.rs
+++ b/src/test/stdtest/vec.rs
@@ -20,7 +20,7 @@ fn add(x: &uint, y: &uint) -> uint { ret x + y; }
 
 #[test]
 fn test_reserve_and_on_heap() {
-    let v: [int] = ~[1, 2];
+    let v: [int] = [1, 2];
     assert (!vec::on_heap(v));
     vec::reserve(v, 8u);
     assert (vec::on_heap(v));
@@ -29,26 +29,26 @@ fn test_reserve_and_on_heap() {
 #[test]
 fn test_unsafe_ptrs() {
     // Test on-stack copy-from-buf.
-    let a = ~[1, 2, 3];
+    let a = [1, 2, 3];
     let ptr = vec::to_ptr(a);
-    let b = ~[];
+    let b = [];
     vec::unsafe::copy_from_buf(b, ptr, 3u);
     assert (vec::len(b) == 3u);
-    assert (b.(0) == 1);
-    assert (b.(1) == 2);
-    assert (b.(2) == 3);
+    assert (b[0] == 1);
+    assert (b[1] == 2);
+    assert (b[2] == 3);
 
     // Test on-heap copy-from-buf.
-    let c = ~[1, 2, 3, 4, 5];
+    let c = [1, 2, 3, 4, 5];
     ptr = vec::to_ptr(c);
-    let d = ~[];
+    let d = [];
     vec::unsafe::copy_from_buf(d, ptr, 5u);
     assert (vec::len(d) == 5u);
-    assert (d.(0) == 1);
-    assert (d.(1) == 2);
-    assert (d.(2) == 3);
-    assert (d.(3) == 4);
-    assert (d.(4) == 5);
+    assert (d[0] == 1);
+    assert (d[1] == 2);
+    assert (d[2] == 3);
+    assert (d[3] == 4);
+    assert (d[4] == 5);
 }
 
 #[test]
@@ -56,18 +56,18 @@ fn test_init_fn() {
     // Test on-stack init_fn.
     let v = vec::init_fn(square, 3u);
     assert (vec::len(v) == 3u);
-    assert (v.(0) == 0u);
-    assert (v.(1) == 1u);
-    assert (v.(2) == 4u);
+    assert (v[0] == 0u);
+    assert (v[1] == 1u);
+    assert (v[2] == 4u);
 
     // Test on-heap init_fn.
     v = vec::init_fn(square, 5u);
     assert (vec::len(v) == 5u);
-    assert (v.(0) == 0u);
-    assert (v.(1) == 1u);
-    assert (v.(2) == 4u);
-    assert (v.(3) == 9u);
-    assert (v.(4) == 16u);
+    assert (v[0] == 0u);
+    assert (v[1] == 1u);
+    assert (v[2] == 4u);
+    assert (v[3] == 9u);
+    assert (v[4] == 16u);
 }
 
 #[test]
@@ -75,194 +75,194 @@ fn test_init_elt() {
     // Test on-stack init_elt.
     let v = vec::init_elt(10u, 2u);
     assert (vec::len(v) == 2u);
-    assert (v.(0) == 10u);
-    assert (v.(1) == 10u);
+    assert (v[0] == 10u);
+    assert (v[1] == 10u);
 
     // Test on-heap init_elt.
     v = vec::init_elt(20u, 6u);
-    assert (v.(0) == 20u);
-    assert (v.(1) == 20u);
-    assert (v.(2) == 20u);
-    assert (v.(3) == 20u);
-    assert (v.(4) == 20u);
-    assert (v.(5) == 20u);
+    assert (v[0] == 20u);
+    assert (v[1] == 20u);
+    assert (v[2] == 20u);
+    assert (v[3] == 20u);
+    assert (v[4] == 20u);
+    assert (v[5] == 20u);
 }
 
 #[test]
 fn test_is_empty() {
-    assert (vec::is_empty::<int>(~[]));
-    assert (!vec::is_empty(~[0]));
+    assert (vec::is_empty::<int>([]));
+    assert (!vec::is_empty([0]));
 }
 
 #[test]
 fn test_is_not_empty() {
-    assert (vec::is_not_empty(~[0]));
-    assert (!vec::is_not_empty::<int>(~[]));
+    assert (vec::is_not_empty([0]));
+    assert (!vec::is_not_empty::<int>([]));
 }
 
 #[test]
 fn test_head() {
-    let a = ~[11, 12];
+    let a = [11, 12];
     check (vec::is_not_empty(a));
     assert (vec::head(a) == 11);
 }
 
 #[test]
 fn test_tail() {
-    let a = ~[11];
+    let a = [11];
     check (vec::is_not_empty(a));
-    assert (vec::tail(a) == ~[]);
+    assert (vec::tail(a) == []);
 
-    a = ~[11, 12];
+    a = [11, 12];
     check (vec::is_not_empty(a));
-    assert (vec::tail(a) == ~[12]);
+    assert (vec::tail(a) == [12]);
 }
 
 #[test]
 fn test_last() {
-    let n = vec::last(~[]);
+    let n = vec::last([]);
     assert (n == none);
-    n = vec::last(~[1, 2, 3]);
+    n = vec::last([1, 2, 3]);
     assert (n == some(3));
-    n = vec::last(~[1, 2, 3, 4, 5]);
+    n = vec::last([1, 2, 3, 4, 5]);
     assert (n == some(5));
 }
 
 #[test]
 fn test_slice() {
     // Test on-stack -> on-stack slice.
-    let v = vec::slice(~[1, 2, 3], 1u, 3u);
+    let v = vec::slice([1, 2, 3], 1u, 3u);
     assert (vec::len(v) == 2u);
-    assert (v.(0) == 2);
-    assert (v.(1) == 3);
+    assert (v[0] == 2);
+    assert (v[1] == 3);
 
     // Test on-heap -> on-stack slice.
-    v = vec::slice(~[1, 2, 3, 4, 5], 0u, 3u);
+    v = vec::slice([1, 2, 3, 4, 5], 0u, 3u);
     assert (vec::len(v) == 3u);
-    assert (v.(0) == 1);
-    assert (v.(1) == 2);
-    assert (v.(2) == 3);
+    assert (v[0] == 1);
+    assert (v[1] == 2);
+    assert (v[2] == 3);
 
     // Test on-heap -> on-heap slice.
-    v = vec::slice(~[1, 2, 3, 4, 5, 6], 1u, 6u);
+    v = vec::slice([1, 2, 3, 4, 5, 6], 1u, 6u);
     assert (vec::len(v) == 5u);
-    assert (v.(0) == 2);
-    assert (v.(1) == 3);
-    assert (v.(2) == 4);
-    assert (v.(3) == 5);
-    assert (v.(4) == 6);
+    assert (v[0] == 2);
+    assert (v[1] == 3);
+    assert (v[2] == 4);
+    assert (v[3] == 5);
+    assert (v[4] == 6);
 }
 
 #[test]
 fn test_pop() {
     // Test on-stack pop.
-    let v = ~[1, 2, 3];
+    let v = [1, 2, 3];
     let e = vec::pop(v);
     assert (vec::len(v) == 2u);
-    assert (v.(0) == 1);
-    assert (v.(1) == 2);
+    assert (v[0] == 1);
+    assert (v[1] == 2);
     assert (e == 3);
 
     // Test on-heap pop.
-    v = ~[1, 2, 3, 4, 5];
+    v = [1, 2, 3, 4, 5];
     e = vec::pop(v);
     assert (vec::len(v) == 4u);
-    assert (v.(0) == 1);
-    assert (v.(1) == 2);
-    assert (v.(2) == 3);
-    assert (v.(3) == 4);
+    assert (v[0] == 1);
+    assert (v[1] == 2);
+    assert (v[2] == 3);
+    assert (v[3] == 4);
     assert (e == 5);
 }
 
 #[test]
 fn test_grow() {
     // Test on-stack grow().
-    let v = ~[];
+    let v = [];
     vec::grow(v, 2u, 1);
     assert (vec::len(v) == 2u);
-    assert (v.(0) == 1);
-    assert (v.(1) == 1);
+    assert (v[0] == 1);
+    assert (v[1] == 1);
 
     // Test on-heap grow().
     vec::grow(v, 3u, 2);
     assert (vec::len(v) == 5u);
-    assert (v.(0) == 1);
-    assert (v.(1) == 1);
-    assert (v.(2) == 2);
-    assert (v.(3) == 2);
-    assert (v.(4) == 2);
+    assert (v[0] == 1);
+    assert (v[1] == 1);
+    assert (v[2] == 2);
+    assert (v[3] == 2);
+    assert (v[4] == 2);
 }
 
 #[test]
 fn test_grow_fn() {
-    let v = ~[];
+    let v = [];
     vec::grow_fn(v, 3u, square);
     assert (vec::len(v) == 3u);
-    assert (v.(0) == 0u);
-    assert (v.(1) == 1u);
-    assert (v.(2) == 4u);
+    assert (v[0] == 0u);
+    assert (v[1] == 1u);
+    assert (v[2] == 4u);
 }
 
 #[test]
 fn test_grow_set() {
-    let v = ~[mutable 1, 2, 3];
+    let v = [mutable 1, 2, 3];
     vec::grow_set(v, 4u, 4, 5);
     assert (vec::len(v) == 5u);
-    assert (v.(0) == 1);
-    assert (v.(1) == 2);
-    assert (v.(2) == 3);
-    assert (v.(3) == 4);
-    assert (v.(4) == 5);
+    assert (v[0] == 1);
+    assert (v[1] == 2);
+    assert (v[2] == 3);
+    assert (v[3] == 4);
+    assert (v[4] == 5);
 }
 
 #[test]
 fn test_map() {
     // Test on-stack map.
-    let v = ~[1u, 2u, 3u];
+    let v = [1u, 2u, 3u];
     let w = vec::map(square_alias, v);
     assert (vec::len(w) == 3u);
-    assert (w.(0) == 1u);
-    assert (w.(1) == 4u);
-    assert (w.(2) == 9u);
+    assert (w[0] == 1u);
+    assert (w[1] == 4u);
+    assert (w[2] == 9u);
 
     // Test on-heap map.
-    v = ~[1u, 2u, 3u, 4u, 5u];
+    v = [1u, 2u, 3u, 4u, 5u];
     w = vec::map(square_alias, v);
     assert (vec::len(w) == 5u);
-    assert (w.(0) == 1u);
-    assert (w.(1) == 4u);
-    assert (w.(2) == 9u);
-    assert (w.(3) == 16u);
-    assert (w.(4) == 25u);
+    assert (w[0] == 1u);
+    assert (w[1] == 4u);
+    assert (w[2] == 9u);
+    assert (w[3] == 16u);
+    assert (w[4] == 25u);
 }
 
 #[test]
 fn test_map2() {
     fn times(x: &int, y: &int) -> int { ret x * y; }
     let f = times;
-    let v0 = ~[1, 2, 3, 4, 5];
-    let v1 = ~[5, 4, 3, 2, 1];
+    let v0 = [1, 2, 3, 4, 5];
+    let v1 = [5, 4, 3, 2, 1];
     let u = vec::map2::<int, int, int>(f, v0, v1);
     let i = 0;
-    while i < 5 { assert (v0.(i) * v1.(i) == u.(i)); i += 1; }
+    while i < 5 { assert (v0[i] * v1[i] == u[i]); i += 1; }
 }
 
 #[test]
 fn test_filter_map() {
     // Test on-stack filter-map.
-    let v = ~[1u, 2u, 3u];
+    let v = [1u, 2u, 3u];
     let w = vec::filter_map(square_if_odd, v);
     assert (vec::len(w) == 2u);
-    assert (w.(0) == 1u);
-    assert (w.(1) == 9u);
+    assert (w[0] == 1u);
+    assert (w[1] == 9u);
 
     // Test on-heap filter-map.
-    v = ~[1u, 2u, 3u, 4u, 5u];
+    v = [1u, 2u, 3u, 4u, 5u];
     w = vec::filter_map(square_if_odd, v);
     assert (vec::len(w) == 3u);
-    assert (w.(0) == 1u);
-    assert (w.(1) == 9u);
-    assert (w.(2) == 25u);
+    assert (w[0] == 1u);
+    assert (w[1] == 9u);
+    assert (w[2] == 25u);
 
     fn halve(i: &int) -> option::t<int> {
         if i % 2 == 0 {
@@ -270,14 +270,14 @@ fn test_filter_map() {
         } else { ret option::none::<int>; }
     }
     fn halve_for_sure(i: &int) -> int { ret i / 2; }
-    let all_even: [int] = ~[0, 2, 8, 6];
-    let all_odd1: [int] = ~[1, 7, 3];
-    let all_odd2: [int] = ~[];
-    let mix: [int] = ~[9, 2, 6, 7, 1, 0, 0, 3];
-    let mix_dest: [int] = ~[1, 3, 0, 0];
+    let all_even: [int] = [0, 2, 8, 6];
+    let all_odd1: [int] = [1, 7, 3];
+    let all_odd2: [int] = [];
+    let mix: [int] = [9, 2, 6, 7, 1, 0, 0, 3];
+    let mix_dest: [int] = [1, 3, 0, 0];
     assert (filter_map(halve, all_even) == map(halve_for_sure, all_even));
-    assert (filter_map(halve, all_odd1) == ~[]);
-    assert (filter_map(halve, all_odd2) == ~[]);
+    assert (filter_map(halve, all_odd1) == []);
+    assert (filter_map(halve, all_odd2) == []);
     assert (filter_map(halve, mix) == mix_dest);
 
 }
@@ -285,49 +285,49 @@ fn test_filter_map() {
 #[test]
 fn test_foldl() {
     // Test on-stack fold.
-    let v = ~[1u, 2u, 3u];
+    let v = [1u, 2u, 3u];
     let sum = vec::foldl(add, 0u, v);
     assert (sum == 6u);
 
     // Test on-heap fold.
-    v = ~[1u, 2u, 3u, 4u, 5u];
+    v = [1u, 2u, 3u, 4u, 5u];
     sum = vec::foldl(add, 0u, v);
     assert (sum == 15u);
 }
 
 #[test]
 fn test_any_and_all() {
-    assert (vec::any(is_three, ~[1u, 2u, 3u]));
-    assert (!vec::any(is_three, ~[0u, 1u, 2u]));
-    assert (vec::any(is_three, ~[1u, 2u, 3u, 4u, 5u]));
-    assert (!vec::any(is_three, ~[1u, 2u, 4u, 5u, 6u]));
-
-    assert (vec::all(is_three, ~[3u, 3u, 3u]));
-    assert (!vec::all(is_three, ~[3u, 3u, 2u]));
-    assert (vec::all(is_three, ~[3u, 3u, 3u, 3u, 3u]));
-    assert (!vec::all(is_three, ~[3u, 3u, 0u, 1u, 2u]));
+    assert (vec::any(is_three, [1u, 2u, 3u]));
+    assert (!vec::any(is_three, [0u, 1u, 2u]));
+    assert (vec::any(is_three, [1u, 2u, 3u, 4u, 5u]));
+    assert (!vec::any(is_three, [1u, 2u, 4u, 5u, 6u]));
+
+    assert (vec::all(is_three, [3u, 3u, 3u]));
+    assert (!vec::all(is_three, [3u, 3u, 2u]));
+    assert (vec::all(is_three, [3u, 3u, 3u, 3u, 3u]));
+    assert (!vec::all(is_three, [3u, 3u, 0u, 1u, 2u]));
 }
 
 #[test]
 fn test_zip_unzip() {
-    let v1 = ~[1, 2, 3];
-    let v2 = ~[4, 5, 6];
+    let v1 = [1, 2, 3];
+    let v2 = [4, 5, 6];
     let z1 = vec::zip(v1, v2);
 
-    assert ((1, 4) == z1.(0));
-    assert ((2, 5) == z1.(1));
-    assert ((3, 6) == z1.(2));
+    assert ((1, 4) == z1[0]);
+    assert ((2, 5) == z1[1]);
+    assert ((3, 6) == z1[2]);
 
     let (left, right) = vec::unzip(z1);
 
-    assert ((1, 4) == (left.(0), right.(0)));
-    assert ((2, 5) == (left.(1), right.(1)));
-    assert ((3, 6) == (left.(2), right.(2)));
+    assert ((1, 4) == (left[0], right[0]));
+    assert ((2, 5) == (left[1], right[1]));
+    assert ((3, 6) == (left[2], right[2]));
 }
 
 #[test]
 fn test_position() {
-    let v1: [int] = ~[1, 2, 3, 3, 2, 5];
+    let v1: [int] = [1, 2, 3, 3, 2, 5];
     assert (position(1, v1) == option::some::<uint>(0u));
     assert (position(2, v1) == option::some::<uint>(1u));
     assert (position(5, v1) == option::some::<uint>(5u));
@@ -338,28 +338,28 @@ fn test_position() {
 fn test_position_pred() {
     fn less_than_three(i: &int) -> bool { ret i < 3; }
     fn is_eighteen(i: &int) -> bool { ret i == 18; }
-    let v1: [int] = ~[5, 4, 3, 2, 1];
+    let v1: [int] = [5, 4, 3, 2, 1];
     assert (position_pred(less_than_three, v1) == option::some::<uint>(3u));
     assert (position_pred(is_eighteen, v1) == option::none::<uint>);
 }
 
 #[test]
 fn reverse_and_reversed() {
-    let v: [mutable int] = ~[mutable 10, 20];
-    assert (v.(0) == 10);
-    assert (v.(1) == 20);
+    let v: [mutable int] = [mutable 10, 20];
+    assert (v[0] == 10);
+    assert (v[1] == 20);
     vec::reverse(v);
-    assert (v.(0) == 20);
-    assert (v.(1) == 10);
-    let v2 = vec::reversed::<int>(~[10, 20]);
-    assert (v2.(0) == 20);
-    assert (v2.(1) == 10);
-    v.(0) = 30;
-    assert (v2.(0) == 20);
+    assert (v[0] == 20);
+    assert (v[1] == 10);
+    let v2 = vec::reversed::<int>([10, 20]);
+    assert (v2[0] == 20);
+    assert (v2[1] == 10);
+    v[0] = 30;
+    assert (v2[0] == 20);
     // Make sure they work with 0-length vectors too.
 
-    let v4 = vec::reversed::<int>(~[]);
-    let v3: [mutable int] = ~[mutable];
+    let v4 = vec::reversed::<int>([]);
+    let v3: [mutable int] = [mutable];
     vec::reverse::<int>(v3);
 }
 
diff --git a/src/test/stdtest/vec_str_conversions.rs b/src/test/stdtest/vec_str_conversions.rs
index cc52ec80e95..8e245db256f 100644
--- a/src/test/stdtest/vec_str_conversions.rs
+++ b/src/test/stdtest/vec_str_conversions.rs
@@ -16,8 +16,8 @@ fn test_simple() {
     let n2: uint = vec::len::<u8>(v);
     assert (n1 == n2);
     while i < n1 {
-        let a: u8 = s1.(i);
-        let b: u8 = s2.(i);
+        let a: u8 = s1[i];
+        let b: u8 = s2[i];
         log a;
         log b;
         assert (a == b);