Port the tests to the expr foo::<T> syntax.

88 files changed, 198 insertions, 190 deletions

diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index cf83653261f..25a3756346a 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -40,7 +40,7 @@ fn select_random(r: u32, genelist: &[aminoacids]) -> char {
             } else { be bisect(v, mid, hi, target); }
         } else { ret v.(hi).ch; }
     }
-    ret bisect(genelist, 0u, vec::len[aminoacids](genelist) - 1u, r);
+    ret bisect(genelist, 0u, vec::len::<aminoacids>(genelist) - 1u, r);
 }
 
 fn make_random_fasta(id: str, desc: str, genelist: &[aminoacids], n: int) {
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 31e6ea6fff0..67cbf77968e 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -33,7 +33,7 @@ fn fib(n: int) -> int {
         } else if (n <= 2) {
             send(c, 1);
         } else {
-            let p = mk_port<int>();
+            let p = mk_port::<int>();
 
             let t1 = task::_spawn(bind pfib(p.mk_chan(), n - 1));
             let t2 = task::_spawn(bind pfib(p.mk_chan(), n - 2));
diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs
index 6baa75e2fa4..914446e1300 100644
--- a/src/test/bench/task-perf-word-count.rs
+++ b/src/test/bench/task-perf-word-count.rs
@@ -95,7 +95,7 @@ mod map_reduce {
                 c = _c
               }
               none. {
-                let p = mk_port<_chan<reduce_proto>>();
+                let p = mk_port::<_chan<reduce_proto>>();
                 let keyi = str::bytes(key);
                 send(ctrl, find_reducer(keyi, p.mk_chan()));
                 c = p.recv();
@@ -147,7 +147,7 @@ mod map_reduce {
     }
 
     fn map_reduce(inputs: &[str]) {
-        let ctrl = mk_port<ctrl_proto>();
+        let ctrl = mk_port::<ctrl_proto>();
 
         // This task becomes the master control task. It task::_spawns
         // to do the rest.
diff --git a/src/test/compile-fail/bad-name.rs b/src/test/compile-fail/bad-name.rs
index a53b8284d59..bfb27a5a988 100644
--- a/src/test/compile-fail/bad-name.rs
+++ b/src/test/compile-fail/bad-name.rs
@@ -1,5 +1,5 @@
 // error-pattern: expecting
 
 fn main() {
-  let x.y[int].z foo;
+  let x.y::<int>.z foo;
 }
diff --git a/src/test/compile-fail/occurs-check-3.rs b/src/test/compile-fail/occurs-check-3.rs
index 802fa934f0c..88da7c14350 100644
--- a/src/test/compile-fail/occurs-check-3.rs
+++ b/src/test/compile-fail/occurs-check-3.rs
@@ -1,4 +1,4 @@
 // error-pattern:mismatched types
 // From Issue #778
 tag clam<T> { a(T); }
-fn main() { let c; c = a(c); alt c { a[int](_) { } } }
+fn main() { let c; c = a(c); alt c { a::<int>(_) { } } }
diff --git a/src/test/compile-fail/pattern-tyvar.rs b/src/test/compile-fail/pattern-tyvar.rs
index cd5d0ffc290..107ebf2c7b6 100644
--- a/src/test/compile-fail/pattern-tyvar.rs
+++ b/src/test/compile-fail/pattern-tyvar.rs
@@ -7,6 +7,6 @@ import std::option::some;
 
 tag bar { t1((), option::t<[int]>); t2; }
 
-fn foo(t: bar) { alt t { t1(_, some[int](x)) { log x; } _ { fail; } } }
+fn foo(t: bar) { alt t { t1(_, some::<int>(x)) { log x; } _ { fail; } } }
 
 fn main() { }
diff --git a/src/test/compiletest/compiletest.rs b/src/test/compiletest/compiletest.rs
index c147e676de3..141649ff0ed 100644
--- a/src/test/compiletest/compiletest.rs
+++ b/src/test/compiletest/compiletest.rs
@@ -125,7 +125,7 @@ type tests_and_conv_fn =
 
 fn make_tests(cx: &cx) -> tests_and_conv_fn {
     log #fmt("making tests from %s", cx.config.src_base);
-    let configport = mk_port<[u8]>();
+    let configport = mk_port::<[u8]>();
     let tests = ~[];
     for file: str in fs::list_dir(cx.config.src_base) {
         log #fmt("inspecting file %s", file);
diff --git a/src/test/compiletest/procsrv.rs b/src/test/compiletest/procsrv.rs
index 41a511b396c..67628fc82dc 100644
--- a/src/test/compiletest/procsrv.rs
+++ b/src/test/compiletest/procsrv.rs
@@ -60,7 +60,7 @@ fn close(handle: &handle) {
 fn run(handle: &handle, lib_path: &str,
        prog: &str, args: &[str], input: &option::t<str>) ->
 {status: int, out: str, err: str} {
-    let p = mk_port<response>();
+    let p = mk_port::<response>();
     let ch = p.mk_chan();
     send(handle.chan, exec(str::bytes(lib_path),
                            str::bytes(prog),
diff --git a/src/test/run-fail/alt-bot-fail.rs b/src/test/run-fail/alt-bot-fail.rs
index 087f6dbde25..7a414b3ca6a 100644
--- a/src/test/run-fail/alt-bot-fail.rs
+++ b/src/test/run-fail/alt-bot-fail.rs
@@ -7,6 +7,9 @@ import std::option::*;
 fn foo(s: str) { }
 
 fn main() {
-    let i = alt some[int](3) { none[int]. { fail } some[int](_) { fail } };
+    let i = alt some::<int>(3) {
+        none::<int>. { fail }
+        some::<int>(_) { fail }
+    };
     foo(i);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
index 4fbb0d1498b..9d076b0203c 100644
--- a/src/test/run-fail/linked-failure.rs
+++ b/src/test/run-fail/linked-failure.rs
@@ -10,7 +10,7 @@ import std::comm::mk_port;
 fn child() { assert (1 == 2); }
 
 fn main() {
-    let p = mk_port[int]();
+    let p = mk_port::<int>();
     task::_spawn(bind child());
     let x = p.recv();
 }
diff --git a/src/test/run-fail/port-type.rs b/src/test/run-fail/port-type.rs
index 55843e4bbe1..a5c077d0f8f 100644
--- a/src/test/run-fail/port-type.rs
+++ b/src/test/run-fail/port-type.rs
@@ -7,7 +7,7 @@ import std::comm::send;
 fn echo<~T>(c: _chan<T>, oc: _chan<_chan<T>>) {
     // Tests that the type argument in port gets
     // visited
-    let p = mk_port[T]();
+    let p = mk_port::<T>();
     send(oc, p.mk_chan());
 
     let x = p.recv();
diff --git a/src/test/run-pass/alias-uninit-value.rs b/src/test/run-pass/alias-uninit-value.rs
index b3cb9d0a374..22a14dc3e50 100644
--- a/src/test/run-pass/alias-uninit-value.rs
+++ b/src/test/run-pass/alias-uninit-value.rs
@@ -13,4 +13,4 @@ fn mk_raw_ty(st: sty, cname: &option::t<str>) -> raw_t {
     ret {struct: st, cname: cname, hash: 0u};
 }
 
-fn main() { mk_raw_ty(ty_nil, none[str]); }
+fn main() { mk_raw_ty(ty_nil, none::<str>); }
diff --git a/src/test/run-pass/alt-bot.rs b/src/test/run-pass/alt-bot.rs
index fdd6f1d3266..a5369804d00 100644
--- a/src/test/run-pass/alt-bot.rs
+++ b/src/test/run-pass/alt-bot.rs
@@ -2,6 +2,9 @@ use std;
 import std::option::*;
 
 fn main() {
-    let i: int = alt some[int](3) { none[int]. { fail } some[int](_) { 5 } };
+    let i: int = alt some::<int>(3) {
+        none::<int>. { fail }
+        some::<int>(_) { 5 }
+    };
     log i;
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/alt-join.rs b/src/test/run-pass/alt-join.rs
index 48e87c9b069..423d08fc66a 100644
--- a/src/test/run-pass/alt-join.rs
+++ b/src/test/run-pass/alt-join.rs
@@ -12,8 +12,8 @@ fn foo<T>(y: &option::t<T>) {
        entire if expression */
 
     if true {
-    } else { alt y { none[T]. { x = 17; } _ { x = 42; } } rs += ~[x]; }
+    } else { alt y { none::<T>. { x = 17; } _ { x = 42; } } rs += ~[x]; }
     ret;
 }
 
-fn main() { log "hello"; foo[int](some[int](5)); }
+fn main() { log "hello"; foo::<int>(some::<int>(5)); }
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index d84a86bb569..511dcda6b26 100644
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -61,8 +61,8 @@ fn test_box() {
 }
 
 fn test_port() {
-    let p1 = comm::mk_port[int]();
-    let p2 = comm::mk_port[int]();
+    let p1 = comm::mk_port::<int>();
+    let p2 = comm::mk_port::<int>();
 
     assert p1 == p1;
     assert p1 != p2;
diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs
index 03618cf5e0e..e27954d4d65 100644
--- a/src/test/run-pass/box-unbox.rs
+++ b/src/test/run-pass/box-unbox.rs
@@ -8,5 +8,5 @@ fn main() {
     let foo: int = 17;
     let bfoo: box<int> = {c: @foo};
     log "see what's in our box";
-    assert (unbox[int](bfoo) == foo);
+    assert (unbox::<int>(bfoo) == foo);
 }
diff --git a/src/test/run-pass/chan-leak.rs b/src/test/run-pass/chan-leak.rs
index 43ddd80562c..39e445b47ec 100644
--- a/src/test/run-pass/chan-leak.rs
+++ b/src/test/run-pass/chan-leak.rs
@@ -34,7 +34,7 @@ fn new() -> ctx {
 fn main() {
     let cx = new();
 
-    let p = mk_port<bool>();
+    let p = mk_port::<bool>();
     send(cx, close(p.mk_chan()));
     send(cx, quit);
 }
diff --git a/src/test/run-pass/drop-parametric-closure-with-bound-box.rs b/src/test/run-pass/drop-parametric-closure-with-bound-box.rs
index f330f900d2b..f24cf65e70e 100644
--- a/src/test/run-pass/drop-parametric-closure-with-bound-box.rs
+++ b/src/test/run-pass/drop-parametric-closure-with-bound-box.rs
@@ -2,4 +2,4 @@
 
 fn f<T>(i: @int, t: &T) { }
 
-fn main() { let x = bind f[char](@0xdeafbeef, _); }
+fn main() { let x = bind f::<char>(@0xdeafbeef, _); }
diff --git a/src/test/run-pass/expr-alt-generic-box1.rs b/src/test/run-pass/expr-alt-generic-box1.rs
index 9f1fd139905..ec299544094 100644
--- a/src/test/run-pass/expr-alt-generic-box1.rs
+++ b/src/test/run-pass/expr-alt-generic-box1.rs
@@ -12,7 +12,7 @@ fn test_generic<T>(expected: @T, eq: &compare<T>) {
 fn test_box() {
     fn compare_box(b1: @bool, b2: @bool) -> bool { ret *b1 == *b2; }
     let eq = bind compare_box(_, _);
-    test_generic[bool](@true, eq);
+    test_generic::<bool>(@true, eq);
 }
 
 fn main() { test_box(); }
diff --git a/src/test/run-pass/expr-alt-generic-box2.rs b/src/test/run-pass/expr-alt-generic-box2.rs
index a512a6c376d..f7e96af98d5 100644
--- a/src/test/run-pass/expr-alt-generic-box2.rs
+++ b/src/test/run-pass/expr-alt-generic-box2.rs
@@ -12,7 +12,7 @@ fn test_generic<T>(expected: &T, eq: &compare<T>) {
 fn test_vec() {
     fn compare_box(v1: &@int, v2: &@int) -> bool { ret v1 == v2; }
     let eq = bind compare_box(_, _);
-    test_generic[@int](@1, eq);
+    test_generic::<@int>(@1, eq);
 }
 
 fn main() { test_vec(); }
diff --git a/src/test/run-pass/expr-alt-generic.rs b/src/test/run-pass/expr-alt-generic.rs
index f9a9e55c872..cfecd0302a1 100644
--- a/src/test/run-pass/expr-alt-generic.rs
+++ b/src/test/run-pass/expr-alt-generic.rs
@@ -12,7 +12,7 @@ fn test_generic<T>(expected: &T, eq: &compare<T>) {
 fn test_bool() {
     fn compare_bool(b1: &bool, b2: &bool) -> bool { ret b1 == b2; }
     let eq = bind compare_bool(_, _);
-    test_generic[bool](true, eq);
+    test_generic::<bool>(true, eq);
 }
 
 fn test_rec() {
@@ -20,7 +20,7 @@ fn test_rec() {
 
     fn compare_rec(t1: &t, t2: &t) -> bool { ret t1 == t2; }
     let eq = bind compare_rec(_, _);
-    test_generic[t]({a: 1, b: 2}, eq);
+    test_generic::<t>({a: 1, b: 2}, eq);
 }
 
 fn main() { test_bool(); test_rec(); }
diff --git a/src/test/run-pass/expr-block-generic-box1.rs b/src/test/run-pass/expr-block-generic-box1.rs
index 97469dc5cc3..d68f0cf5d89 100644
--- a/src/test/run-pass/expr-block-generic-box1.rs
+++ b/src/test/run-pass/expr-block-generic-box1.rs
@@ -16,7 +16,7 @@ fn test_box() {
         ret *b1 == *b2;
     }
     let eq = bind compare_box(_, _);
-    test_generic[bool](@true, eq);
+    test_generic::<bool>(@true, eq);
 }
 
 fn main() { test_box(); }
diff --git a/src/test/run-pass/expr-block-generic-box2.rs b/src/test/run-pass/expr-block-generic-box2.rs
index 9e41231d155..d630b65c822 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_generic<T>(expected: &T, eq: &compare<T>) {
 fn test_vec() {
     fn compare_vec(v1: &@int, v2: &@int) -> bool { ret v1 == v2; }
     let eq = bind compare_vec(_, _);
-    test_generic[@int](@1, eq);
+    test_generic::<@int>(@1, eq);
 }
 
 fn main() { test_vec(); }
diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs
index b7f588a5806..d7c17731559 100644
--- a/src/test/run-pass/expr-block-generic.rs
+++ b/src/test/run-pass/expr-block-generic.rs
@@ -14,7 +14,7 @@ fn test_generic<T>(expected: &T, eq: &compare<T>) {
 fn test_bool() {
     fn compare_bool(b1: &bool, b2: &bool) -> bool { ret b1 == b2; }
     let eq = bind compare_bool(_, _);
-    test_generic[bool](true, eq);
+    test_generic::<bool>(true, eq);
 }
 
 fn test_rec() {
@@ -22,7 +22,7 @@ fn test_rec() {
 
     fn compare_rec(t1: &t, t2: &t) -> bool { ret t1 == t2; }
     let eq = bind compare_rec(_, _);
-    test_generic[t]({a: 1, b: 2}, eq);
+    test_generic::<t>({a: 1, b: 2}, eq);
 }
 
 fn main() { test_bool(); test_rec(); }
diff --git a/src/test/run-pass/expr-if-generic-box1.rs b/src/test/run-pass/expr-if-generic-box1.rs
index f23ca216f4e..82bbbb840a6 100644
--- a/src/test/run-pass/expr-if-generic-box1.rs
+++ b/src/test/run-pass/expr-if-generic-box1.rs
@@ -12,7 +12,7 @@ fn test_generic<T>(expected: @T, not_expected: @T, eq: &compare<T>) {
 fn test_box() {
     fn compare_box(b1: @bool, b2: @bool) -> bool { ret *b1 == *b2; }
     let eq = bind compare_box(_, _);
-    test_generic[bool](@true, @false, eq);
+    test_generic::<bool>(@true, @false, eq);
 }
 
 fn main() { test_box(); }
diff --git a/src/test/run-pass/expr-if-generic-box2.rs b/src/test/run-pass/expr-if-generic-box2.rs
index 0ebeb20d615..7cf77d61686 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_generic<T>(expected: &T, not_expected: &T, eq: &compare<T>) {
 fn test_vec() {
     fn compare_box(v1: &@int, v2: &@int) -> bool { ret v1 == v2; }
     let eq = bind compare_box(_, _);
-    test_generic[@int](@1, @2, eq);
+    test_generic::<@int>(@1, @2, eq);
 }
 
 fn main() { test_vec(); }
diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs
index 732694d6cee..df466051ce4 100644
--- a/src/test/run-pass/expr-if-generic.rs
+++ b/src/test/run-pass/expr-if-generic.rs
@@ -14,7 +14,7 @@ fn test_generic<T>(expected: &T, not_expected: &T, eq: &compare<T>) {
 fn test_bool() {
     fn compare_bool(b1: &bool, b2: &bool) -> bool { ret b1 == b2; }
     let eq = bind compare_bool(_, _);
-    test_generic[bool](true, false, eq);
+    test_generic::<bool>(true, false, eq);
 }
 
 fn test_rec() {
@@ -22,7 +22,7 @@ fn test_rec() {
 
     fn compare_rec(t1: &t, t2: &t) -> bool { ret t1 == t2; }
     let eq = bind compare_rec(_, _);
-    test_generic[t]({a: 1, b: 2}, {a: 2, b: 3}, eq);
+    test_generic::<t>({a: 1, b: 2}, {a: 2, b: 3}, eq);
 }
 
 fn main() { test_bool(); test_rec(); }
diff --git a/src/test/run-pass/foreach-box-drop.rs b/src/test/run-pass/foreach-box-drop.rs
index b849d05cc9d..5ad4d1ca607 100644
--- a/src/test/run-pass/foreach-box-drop.rs
+++ b/src/test/run-pass/foreach-box-drop.rs
@@ -6,4 +6,4 @@ obj ob<K>(k: K) {
 
 fn x(o: &ob<str>) { for each i: @{a: str} in o.foo() { } }
 
-fn main() { let o = ob[str]("hi" + "there"); x(o); }
+fn main() { let o = ob::<str>("hi" + "there"); x(o); }
diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs
index 98cf7708bed..8d58c580fba 100644
--- a/src/test/run-pass/generic-alias-box.rs
+++ b/src/test/run-pass/generic-alias-box.rs
@@ -4,7 +4,7 @@ fn id<T>(t: &T) -> T { ret t; }
 
 fn main() {
     let expected = @100;
-    let actual = id[@int](expected);
+    let actual = id::<@int>(expected);
     log *actual;
     assert (*expected == *actual);
 }
diff --git a/src/test/run-pass/generic-bind.rs b/src/test/run-pass/generic-bind.rs
index bb8e4adfc1f..97b000ee1b5 100644
--- a/src/test/run-pass/generic-bind.rs
+++ b/src/test/run-pass/generic-bind.rs
@@ -6,12 +6,12 @@ fn main() {
     let t = {_0: 1, _1: 2, _2: 3, _3: 4, _4: 5, _5: 6, _6: 7};
     assert (t._5 == 6);
     let f1 =
-        bind id[{_0: int,
-                 _1: int,
-                 _2: int,
-                 _3: int,
-                 _4: int,
-                 _5: int,
-                 _6: int}](_);
+        bind id::<{_0: int,
+                   _1: int,
+                   _2: int,
+                   _3: int,
+                   _4: int,
+                   _5: int,
+                   _6: int}>(_);
     assert (f1(t)._5 == 6);
 }
diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs
index f5294da042a..5762847139d 100644
--- a/src/test/run-pass/generic-box.rs
+++ b/src/test/run-pass/generic-box.rs
@@ -3,6 +3,6 @@
 fn box<T>(x: &{x: T, y: T, z: T}) -> @{x: T, y: T, z: T} { ret @x; }
 
 fn main() {
-    let x: @{x: int, y: int, z: int} = box[int]({x: 1, y: 2, z: 3});
+    let x: @{x: int, y: int, z: int} = box::<int>({x: 1, y: 2, z: 3});
     assert (x.y == 2);
 }
diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs
index a5519ec88c2..d0b98b1068e 100644
--- a/src/test/run-pass/generic-derived-type.rs
+++ b/src/test/run-pass/generic-derived-type.rs
@@ -6,11 +6,11 @@ fn f<T>(t: &T) -> {a: T, b: T} {
     type pair = {a: T, b: T};
 
     let x: pair = {a: t, b: t};
-    ret g[pair](x);
+    ret g::<pair>(x);
 }
 
 fn main() {
-    let b = f[int](10);
+    let b = f::<int>(10);
     log b.a;
     log b.b;
     assert (b.a == 10);
diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs
index 35c51011ba6..266fa987c3c 100644
--- a/src/test/run-pass/generic-exterior-box.rs
+++ b/src/test/run-pass/generic-exterior-box.rs
@@ -6,6 +6,6 @@ fn reclift<T>(t: &T) -> recbox<T> { ret {x: @t}; }
 
 fn main() {
     let foo: int = 17;
-    let rbfoo: recbox<int> = reclift[int](foo);
+    let rbfoo: recbox<int> = reclift::<int>(foo);
     assert (*rbfoo.x == foo);
 }
diff --git a/src/test/run-pass/generic-fn-twice.rs b/src/test/run-pass/generic-fn-twice.rs
index 7d5fc711244..ae972fbd0d0 100644
--- a/src/test/run-pass/generic-fn-twice.rs
+++ b/src/test/run-pass/generic-fn-twice.rs
@@ -6,4 +6,4 @@ mod foomod {
     fn foo<T>() { }
 }
 
-fn main() { foomod::foo[int](); foomod::foo[int](); }
+fn main() { foomod::foo::<int>(); foomod::foo::<int>(); }
diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs
index c6afc697071..5eb4e0aae32 100644
--- a/src/test/run-pass/generic-fn.rs
+++ b/src/test/run-pass/generic-fn.rs
@@ -13,13 +13,13 @@ fn main() {
     let b = 'b';
     let p: triple = {x: 65, y: 66, z: 67};
     let q: triple = {x: 68, y: 69, z: 70};
-    y = id[int](x);
+    y = id::<int>(x);
     log y;
     assert (x == y);
-    b = id[char](a);
+    b = id::<char>(a);
     log b;
     assert (a == b);
-    q = id[triple](p);
+    q = id::<triple>(p);
     x = p.z;
     y = q.z;
     log y;
diff --git a/src/test/run-pass/generic-obj-with-derived-type.rs b/src/test/run-pass/generic-obj-with-derived-type.rs
index e0d92fd1d4c..05552db04ff 100644
--- a/src/test/run-pass/generic-obj-with-derived-type.rs
+++ b/src/test/run-pass/generic-obj-with-derived-type.rs
@@ -7,7 +7,7 @@ obj handle<T>(data: T) {
 fn main() {
     type rgb = {x: u8, y: u8, z: u8};
 
-    let h: handle<rgb> = handle[rgb]({x: 1 as u8, y: 2 as u8, z: 3 as u8});
+    let h: handle<rgb> = handle::<rgb>({x: 1 as u8, y: 2 as u8, z: 3 as u8});
     log "constructed object";
     log h.get().x;
     log h.get().y;
diff --git a/src/test/run-pass/generic-obj.rs b/src/test/run-pass/generic-obj.rs
index 0b2978c5960..f22addc8b51 100644
--- a/src/test/run-pass/generic-obj.rs
+++ b/src/test/run-pass/generic-obj.rs
@@ -11,7 +11,7 @@ obj buf<T>(data: {_0: T, _1: T, _2: T}) {
 }
 
 fn main() {
-    let b: buf<int> = buf[int]({_0: 1, _1: 2, _2: 3});
+    let b: buf<int> = buf::<int>({_0: 1, _1: 2, _2: 3});
     log "constructed object";
     log b.get(0);
     log b.get(1);
diff --git a/src/test/run-pass/generic-recursive-tag.rs b/src/test/run-pass/generic-recursive-tag.rs
index fa9f1016a31..94e97bf170d 100644
--- a/src/test/run-pass/generic-recursive-tag.rs
+++ b/src/test/run-pass/generic-recursive-tag.rs
@@ -4,5 +4,5 @@ tag list<T> { cons(@T, @list<T>); nil; }
 
 fn main() {
     let a: list<int> =
-        cons[int](@10, @cons[int](@12, @cons[int](@13, @nil[int])));
+        cons::<int>(@10, @cons::<int>(@12, @cons::<int>(@13, @nil::<int>)));
 }
diff --git a/src/test/run-pass/generic-tag-alt.rs b/src/test/run-pass/generic-tag-alt.rs
index 0edb4899ab0..0041e0fd268 100644
--- a/src/test/run-pass/generic-tag-alt.rs
+++ b/src/test/run-pass/generic-tag-alt.rs
@@ -4,8 +4,8 @@ tag foo<T> { arm(T); }
 
 fn altfoo<T>(f: &foo<T>) {
     let hit = false;
-    alt f { arm[T](x) { log "in arm"; hit = true; } }
+    alt f { arm::<T>(x) { log "in arm"; hit = true; } }
     assert (hit);
 }
 
-fn main() { altfoo[int](arm[int](10)); }
+fn main() { altfoo::<int>(arm::<int>(10)); }
diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs
index 38ad190a913..cd9b0144166 100644
--- a/src/test/run-pass/generic-tag-values.rs
+++ b/src/test/run-pass/generic-tag-values.rs
@@ -5,8 +5,8 @@
 tag noption<T> { some(T); }
 
 fn main() {
-    let nop: noption<int> = some[int](5);
-    alt nop { some[int](n) { log n; assert (n == 5); } }
+    let nop: noption<int> = some::<int>(5);
+    alt nop { some::<int>(n) { log n; assert (n == 5); } }
     let nop2: noption<{x: int, y: int}> = some({x: 17, y: 42});
     alt nop2 {
       some(t) { log t.x; log t.y; assert (t.x == 17); assert (t.y == 42); }
diff --git a/src/test/run-pass/generic-tag.rs b/src/test/run-pass/generic-tag.rs
index 3434f00b448..6bc7c452824 100644
--- a/src/test/run-pass/generic-tag.rs
+++ b/src/test/run-pass/generic-tag.rs
@@ -2,4 +2,4 @@
 
 tag option<T> { some(@T); none; }
 
-fn main() { let a: option<int> = some[int](@10); a = none[int]; }
+fn main() { let a: option<int> = some::<int>(@10); a = none::<int>; }
diff --git a/src/test/run-pass/generic-temporary.rs b/src/test/run-pass/generic-temporary.rs
index fe7d1dcd6e5..1abd0f7daf9 100644
--- a/src/test/run-pass/generic-temporary.rs
+++ b/src/test/run-pass/generic-temporary.rs
@@ -9,5 +9,5 @@ fn apply<T>(produce: fn() -> T , consume: fn(&T) ) { consume(produce()); }
 fn main() {
     let produce: fn() -> int  = mk;
     let consume: fn(&int)  = chk;
-    apply[int](produce, consume);
+    apply::<int>(produce, consume);
 }
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 7d99ee112a2..ecf13f39595 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -62,7 +62,7 @@ mod map_reduce {
     }
 
     fn map_reduce(inputs: &[str]) {
-        let ctrl = mk_port<ctrl_proto>();
+        let ctrl = mk_port::<ctrl_proto>();
 
         // This task becomes the master control task. It spawns others
         // to do the rest.
diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs
index f1b3bc855cd..c32973fa377 100644
--- a/src/test/run-pass/import-glob-crate.rs
+++ b/src/test/run-pass/import-glob-crate.rs
@@ -6,4 +6,4 @@ fn main() {
     let v = init_elt(0, 0u);
     v += ~[4, 2];
     assert (reversed(v) == ~[2, 4]);
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs
index fa93645418c..12afefe57b1 100644
--- a/src/test/run-pass/issue-333.rs
+++ b/src/test/run-pass/issue-333.rs
@@ -1,4 +1,4 @@
-fn quux<T>(x: &T) -> T { let f = id[T]; ret f(x); }
+fn quux<T>(x: &T) -> T { let f = id::<T>; ret f(x); }
 
 fn id<T>(x: &T) -> T { ret x; }
 
diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs
index 11731fca56d..8b9fef446da 100644
--- a/src/test/run-pass/issue-687.rs
+++ b/src/test/run-pass/issue-687.rs
@@ -51,7 +51,7 @@ fn main() {
           closed. { log "Got close message"; break; }
           received(data) {
             log "Got data. Length is:";
-            log vec::len[u8](data);
+            log vec::len::<u8>(data);
           }
         }
     }
diff --git a/src/test/run-pass/leak-box-as-tydesc.rs b/src/test/run-pass/leak-box-as-tydesc.rs
index d48887304ef..5a5cb1e4da4 100644
--- a/src/test/run-pass/leak-box-as-tydesc.rs
+++ b/src/test/run-pass/leak-box-as-tydesc.rs
@@ -2,4 +2,4 @@
 
 fn leaky<T>(t: &T) { }
 
-fn main() { let x = @10; leaky[@int](x); }
+fn main() { let x = @10; leaky::<@int>(x); }
diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index 96e7425d2a5..b620c2236dc 100644
--- a/src/test/run-pass/mutable-alias-vec.rs
+++ b/src/test/run-pass/mutable-alias-vec.rs
@@ -10,7 +10,7 @@ fn main() {
     grow(v);
     grow(v);
     grow(v);
-    let len = std::vec::len[int](v);
+    let len = std::vec::len::<int>(v);
     log len;
     assert (len == 3 as uint);
 }
diff --git a/src/test/run-pass/nested-alts.rs b/src/test/run-pass/nested-alts.rs
index 5d7b3d7853a..aa91eeeb00a 100644
--- a/src/test/run-pass/nested-alts.rs
+++ b/src/test/run-pass/nested-alts.rs
@@ -5,14 +5,14 @@ import std::option::*;
 fn baz() -> ! { fail; }
 
 fn foo() {
-    alt some[int](5) {
-      some[int](x) {
+    alt some::<int>(5) {
+      some::<int>(x) {
         let bar;
-        alt none[int] { none[int]. { bar = 5; } _ { baz(); } }
+        alt none::<int> { none::<int>. { bar = 5; } _ { baz(); } }
         log bar;
       }
-      none[int]. { log "hello"; }
+      none::<int>. { log "hello"; }
     }
 }
 
-fn main() { foo(); }
\ No newline at end of file
+fn main() { foo(); }
diff --git a/src/test/run-pass/nested-pattern.rs b/src/test/run-pass/nested-pattern.rs
index 4b77fc5f870..8072378b581 100644
--- a/src/test/run-pass/nested-pattern.rs
+++ b/src/test/run-pass/nested-pattern.rs
@@ -10,9 +10,9 @@ tag t { foo(int, uint); bar(int, option::t<int>); }
 
 fn nested(o: t) {
     alt o {
-      bar(i, some[int](_)) { log_err "wrong pattern matched"; fail; }
+      bar(i, some::<int>(_)) { log_err "wrong pattern matched"; fail; }
       _ { log_err "succeeded"; }
     }
 }
 
-fn main() { nested(bar(1, none[int])); }
+fn main() { nested(bar(1, none::<int>)); }
diff --git a/src/test/run-pass/obj-docs.rs b/src/test/run-pass/obj-docs.rs
index 8d4600d90e8..cdda794acff 100644
--- a/src/test/run-pass/obj-docs.rs
+++ b/src/test/run-pass/obj-docs.rs
@@ -59,7 +59,7 @@ fn main() {
         t.take(3);
     }
 
-    let p = mk_port[int]();
+    let p = mk_port::<int>();
 
     let t1: taker = adder(@mutable 0);
     let t2: taker = sender(p.mk_chan());
diff --git a/src/test/run-pass/obj-return-polytypes.rs b/src/test/run-pass/obj-return-polytypes.rs
index 397eafd33ca..5cc45871f01 100644
--- a/src/test/run-pass/obj-return-polytypes.rs
+++ b/src/test/run-pass/obj-return-polytypes.rs
@@ -4,10 +4,10 @@
 // -*- rust -*-
 tag clam<T> { signed(int); unsigned(uint); }
 
-fn getclam<T>() -> clam<T> { ret signed[T](42); }
+fn getclam<T>() -> clam<T> { ret signed::<T>(42); }
 
 obj impatience<T>() {
-    fn moreclam() -> clam<T> { be getclam[T](); }
+    fn moreclam() -> clam<T> { be getclam::<T>(); }
 }
 
 fn main() { }
diff --git a/src/test/run-pass/ret-none.rs b/src/test/run-pass/ret-none.rs
index a10508b7f25..b56db9f9c70 100644
--- a/src/test/run-pass/ret-none.rs
+++ b/src/test/run-pass/ret-none.rs
@@ -4,4 +4,4 @@ tag option<T> { none; some(T); }
 
 fn f<T>() -> option<T> { ret none; }
 
-fn main() { f[int](); }
+fn main() { f::<int>(); }
diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index cfd946e86af..4a6839a8de5 100644
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/src/test/run-pass/rt-circular-buffer.rs
@@ -18,7 +18,7 @@ type record = {val1: u32, val2: u32, val3: u32};
 // power of two so needs to be rounded up. Don't trigger any
 // assertions.
 fn test_init() {
-    let myport = mk_port[record]();
+    let myport = mk_port::<record>();
     let mychan = myport.mk_chan();
     let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
     send(mychan, val);
@@ -39,14 +39,14 @@ fn test_grow() {
 
 // Don't allow the buffer to shrink below it's original size
 fn test_shrink1() {
-    let myport = comm::mk_port[i8]();
+    let myport = comm::mk_port::<i8>();
     let mychan = myport.mk_chan();
     send(mychan, 0i8);
     let x = myport.recv();
 }
 
 fn test_shrink2() {
-    let myport = mk_port[record]();
+    let myport = mk_port::<record>();
     let mychan = myport.mk_chan();
     for each i: uint  in uint::range(0u, 100u) {
         let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
@@ -58,7 +58,7 @@ fn test_shrink2() {
 
 // Test rotating the buffer when the unit size is not a power of two
 fn test_rotate() {
-    let myport = mk_port[record]();
+    let myport = mk_port::<record>();
     let mychan = myport.mk_chan();
     for each i: uint  in uint::range(0u, 100u) {
         let val = {val1: i as u32, val2: i as u32, val3: i as u32};
@@ -74,7 +74,7 @@ fn test_rotate() {
 // Test rotating and growing the buffer when
 // the unit size is not a power of two
 fn test_rotate_grow() {
-    let myport = mk_port[record]();
+    let myport = mk_port::<record>();
     let mychan = myport.mk_chan();
     for each j: uint  in uint::range(0u, 10u) {
         for each i: uint  in uint::range(0u, 10u) {
diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs
index 4dd7f8bf28e..919c45a55f4 100644
--- a/src/test/run-pass/send-type-inference.rs
+++ b/src/test/run-pass/send-type-inference.rs
@@ -7,7 +7,7 @@ import std::comm::mk_port;
 type command<K, V> = {key: K, val: V};
 
 fn cache_server<K, V>(c: _chan<_chan<command<K, V>>>) {
-    let ctrl = mk_port[_chan<command<K, V>>]();
+    let ctrl = mk_port::<_chan<command<K, V>>>();
     send(c, ctrl.mk_chan());
 }
 fn main() { }
diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs
index b024b7b9a8f..e3f86246594 100644
--- a/src/test/run-pass/shadow.rs
+++ b/src/test/run-pass/shadow.rs
@@ -4,8 +4,8 @@ fn foo(c: [int]) {
     let b: [int] = ~[];
 
 
-    alt none[int] {
-      some[int](_) { for i: int in c { log a; let a = 17; b += ~[a]; } }
+    alt none::<int> {
+        some::<int>(_) { for i: int in c { log a; let a = 17; b += ~[a]; } }
       _ {}
     }
 }
diff --git a/src/test/run-pass/simple-alt-generic-tag.rs b/src/test/run-pass/simple-alt-generic-tag.rs
index ac6d8f11f53..39a9619b1c6 100644
--- a/src/test/run-pass/simple-alt-generic-tag.rs
+++ b/src/test/run-pass/simple-alt-generic-tag.rs
@@ -2,4 +2,6 @@
 
 tag opt<T> { none; }
 
-fn main() { let x = none[int]; alt x { none[int]. { log "hello world"; } } }
+fn main() {
+    let x = none::<int>; alt x { none::<int>. { log "hello world"; } }
+}
diff --git a/src/test/run-pass/simple-generic-alt.rs b/src/test/run-pass/simple-generic-alt.rs
index de731c007ea..6bf9566f156 100644
--- a/src/test/run-pass/simple-generic-alt.rs
+++ b/src/test/run-pass/simple-generic-alt.rs
@@ -2,4 +2,4 @@
 
 tag clam<T> { a(T); }
 
-fn main() { let c = a(2); alt c { a[int](_) { } } }
+fn main() { let c = a(2); alt c { a::<int>(_) { } } }
diff --git a/src/test/run-pass/size-and-align.rs b/src/test/run-pass/size-and-align.rs
index 996073fc906..8628e359ccb 100644
--- a/src/test/run-pass/size-and-align.rs
+++ b/src/test/run-pass/size-and-align.rs
@@ -6,12 +6,12 @@ tag clam<T> { a(T, int); b; }
 
 fn uhoh<T>(v: &[clam<T>]) {
     alt v.(1) {
-      a[T](t, u) { log "incorrect"; log u; fail; }
-      b[T]. { log "correct"; }
+      a::<T>(t, u) { log "incorrect"; log u; fail; }
+      b::<T>. { log "correct"; }
     }
 }
 
 fn main() {
-    let v: [clam<int>] = ~[b[int], b[int], a[int](42, 17)];
-    uhoh[int](v);
+    let v: [clam<int>] = ~[b::<int>, b::<int>, a::<int>(42, 17)];
+    uhoh::<int>(v);
 }
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index 310fe5d3769..568bf1bf3e6 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/src/test/run-pass/spawn-types.rs
@@ -15,6 +15,6 @@ type ctx = comm::_chan<int>;
 fn iotask(cx: ctx, ip: str) { assert (str::eq(ip, "localhost")); }
 
 fn main() {
-    let p = comm::mk_port<int>();
+    let p = comm::mk_port::<int>();
     task::_spawn(bind iotask(p.mk_chan(), "localhost"));
 }
diff --git a/src/test/run-pass/syntax-extension-minor.rs b/src/test/run-pass/syntax-extension-minor.rs
index eabf3ebcbd0..f5f7f5564f6 100644
--- a/src/test/run-pass/syntax-extension-minor.rs
+++ b/src/test/run-pass/syntax-extension-minor.rs
@@ -5,4 +5,4 @@ fn main() {
 
     assert(#ident_to_str[use_mention_distinction]
            == "use_mention_distinction");
-}
\ No newline at end of file
+}
diff --git a/src/test/run-pass/tag-and-generic-obj.rs b/src/test/run-pass/tag-and-generic-obj.rs
index eecba139f33..de38f08cbf8 100644
--- a/src/test/run-pass/tag-and-generic-obj.rs
+++ b/src/test/run-pass/tag-and-generic-obj.rs
@@ -6,4 +6,4 @@ obj foo<T>() {
     fn meth(x: &T) { }
 }
 
-fn main() { foo[colour]().meth(red); }
+fn main() { foo::<colour>().meth(red); }
diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs
index f49c2088b79..acaa2b5f9b7 100644
--- a/src/test/run-pass/task-comm-0.rs
+++ b/src/test/run-pass/task-comm-0.rs
@@ -20,7 +20,7 @@ fn test05_start(ch : _chan<int>) {
 }
 
 fn test05() {
-    let po = comm::mk_port<int>();
+    let po = comm::mk_port::<int>();
     let ch = po.mk_chan();
     task::_spawn(bind test05_start(ch));
     let value = po.recv();
diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs
index 0eba6429969..39157600263 100644
--- a/src/test/run-pass/task-comm-10.rs
+++ b/src/test/run-pass/task-comm-10.rs
@@ -10,7 +10,7 @@ import std::task;
 import std::comm;
 
 fn start(c: comm::_chan<str>) {
-    let p = comm::mk_port<str>();
+    let p = comm::mk_port::<str>();
     c.send(p.mk_chan().unsafe_ptr());
 
     let a;
diff --git a/src/test/run-pass/task-comm-11.rs b/src/test/run-pass/task-comm-11.rs
index 50b1e9c7f02..ab994c7f378 100644
--- a/src/test/run-pass/task-comm-11.rs
+++ b/src/test/run-pass/task-comm-11.rs
@@ -9,7 +9,7 @@ fn start(c: comm::_chan<comm::_chan<int>>) {
 }
 
 fn main() {
-    let p = comm::mk_port<comm::_chan<int>>();
+    let p = comm::mk_port::<comm::_chan<int>>();
     let child = task::_spawn(bind start(p.mk_chan()));
     let c = p.recv();
 }
diff --git a/src/test/run-pass/task-comm-15.rs b/src/test/run-pass/task-comm-15.rs
index f7fc38724a1..64cdc3553be 100644
--- a/src/test/run-pass/task-comm-15.rs
+++ b/src/test/run-pass/task-comm-15.rs
@@ -13,7 +13,7 @@ fn start(c : comm::_chan<int>, n: int) {
 }
 
 fn main() {
-    let p = comm::mk_port<comm::_chan<int>>();
+    let p = comm::mk_port::<comm::_chan<int>>();
     // Spawn a task that sends us back messages. The parent task
     // is likely to terminate before the child completes, so from
     // the child's point of view the receiver may die. We should
diff --git a/src/test/run-pass/task-compare.rs b/src/test/run-pass/task-compare.rs
index f5b914454bb..39eff3eb78e 100644
--- a/src/test/run-pass/task-compare.rs
+++ b/src/test/run-pass/task-compare.rs
@@ -24,8 +24,8 @@ fn main() {
     let p1;
     let p2;
 
-    p1 = comm::mk_port<int>();
-    p2 = comm::mk_port<int>();
+    p1 = comm::mk_port::<int>();
+    p2 = comm::mk_port::<int>();
 
     assert (p1 == p1);
     assert (p1 != p2);
diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs
index 438f4431fcf..d27dcfaa9ab 100644
--- a/src/test/run-pass/trivial-message.rs
+++ b/src/test/run-pass/trivial-message.rs
@@ -7,7 +7,7 @@ import std::comm::send;
   message.
  */
 fn main() {
-    let po = mk_port[int]();
+    let po = mk_port::<int>();
     let ch = po.mk_chan();
     send(ch, 42);
     let r = po.recv();
diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs
index 8dbdba619d8..25020ec3ed0 100644
--- a/src/test/run-pass/type-sizes.rs
+++ b/src/test/run-pass/type-sizes.rs
@@ -5,19 +5,19 @@ import std::sys::rustrt::size_of;
 use std;
 
 fn main() {
-    assert (size_of[u8]() == 1 as uint);
-    assert (size_of[u32]() == 4 as uint);
-    assert (size_of[char]() == 4 as uint);
-    assert (size_of[i8]() == 1 as uint);
-    assert (size_of[i32]() == 4 as uint);
-    assert (size_of[{a: u8, b: i8}]() == 2 as uint);
-    assert (size_of[{a: u8, b: i8, c: u8}]() == 3 as uint);
+    assert (size_of::<u8>() == 1 as uint);
+    assert (size_of::<u32>() == 4 as uint);
+    assert (size_of::<char>() == 4 as uint);
+    assert (size_of::<i8>() == 1 as uint);
+    assert (size_of::<i32>() == 4 as uint);
+    assert (size_of::<{a: u8, b: i8}>() == 2 as uint);
+    assert (size_of::<{a: u8, b: i8, c: u8}>() == 3 as uint);
     // Alignment causes padding before the char and the u32.
 
-    assert (size_of[{a: u8, b: i8, c: {u: char, v: u8}, d: u32}]() ==
+    assert (size_of::<{a: u8, b: i8, c: {u: char, v: u8}, d: u32}>() ==
                 16 as uint);
-    assert (size_of[int]() == size_of[uint]());
-    assert (size_of[{a: int, b: ()}]() == size_of[int]());
-    assert (size_of[{a: int, b: (), c: ()}]() == size_of[int]());
-    assert (size_of[int]() == size_of[{x: int}]());
-}
\ No newline at end of file
+    assert (size_of::<int>() == size_of::<uint>());
+    assert (size_of::<{a: int, b: ()}>() == size_of::<int>());
+    assert (size_of::<{a: int, b: (), c: ()}>() == size_of::<int>());
+    assert (size_of::<int>() == size_of::<{x: int}>());
+}
diff --git a/src/test/run-pass/unify-return-ty.rs b/src/test/run-pass/unify-return-ty.rs
index 8d36f2b4b55..0538618ff88 100644
--- a/src/test/run-pass/unify-return-ty.rs
+++ b/src/test/run-pass/unify-return-ty.rs
@@ -7,5 +7,5 @@ import std::unsafe;
 fn null<T>() -> *T { unsafe::reinterpret_cast(0) }
 
 fn main() {
-    null[int]();
+    null::<int>();
 }
diff --git a/src/test/run-pass/use-uninit-alt.rs b/src/test/run-pass/use-uninit-alt.rs
index 43985cac7ca..7315bf08fef 100644
--- a/src/test/run-pass/use-uninit-alt.rs
+++ b/src/test/run-pass/use-uninit-alt.rs
@@ -2,7 +2,7 @@
 
 fn foo<T>(o: &myoption<T>) -> int {
     let x: int = 5;
-    alt o { none[T]. { } some[T](t) { x += 1; } }
+    alt o { none::<T>. { } some::<T>(t) { x += 1; } }
     ret x;
 }
 
diff --git a/src/test/run-pass/use-uninit-alt2.rs b/src/test/run-pass/use-uninit-alt2.rs
index c9021328cea..615296d974f 100644
--- a/src/test/run-pass/use-uninit-alt2.rs
+++ b/src/test/run-pass/use-uninit-alt2.rs
@@ -2,7 +2,7 @@
 
 fn foo<T>(o: &myoption<T>) -> int {
     let x: int;
-    alt o { none[T]. { fail; } some[T](t) { x = 5; } }
+    alt o { none::<T>. { fail; } some::<T>(t) { x = 5; } }
     ret x;
 }
 
diff --git a/src/test/run-pass/user.rs b/src/test/run-pass/user.rs
index b0313aa4dce..994003d1fe2 100644
--- a/src/test/run-pass/user.rs
+++ b/src/test/run-pass/user.rs
@@ -13,5 +13,5 @@ fn main() {
   log s;
   s += "there";
   log s;
-  auto z = std::vec.alloc[int](10 as uint);
+  auto z = std::vec.alloc::<int>(10 as uint);
 }
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index f329908bfe2..c94cef4bba3 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -9,7 +9,7 @@ fn main() {
 
     assert (str::byte_len(s) == 10u);
     assert (str::char_len(s) == 4u);
-    assert (vec::len[char](str::to_chars(s)) == 4u);
+    assert (vec::len::<char>(str::to_chars(s)) == 4u);
     assert (str::eq(str::from_chars(str::to_chars(s)), s));
     assert (str::char_at(s, 0u) == 'e');
     assert (str::char_at(s, 1u) == 'é');
diff --git a/src/test/run-pass/vec-append.rs b/src/test/run-pass/vec-append.rs
index 6a07ebf9b4f..68076d41287 100644
--- a/src/test/run-pass/vec-append.rs
+++ b/src/test/run-pass/vec-append.rs
@@ -57,9 +57,9 @@ fn slow_growth2_helper(s: str) { // ref up: s
         assert (str::refcount(s) == const_refcount);
         assert (str::refcount(mumble) == const_refcount);
         log v.(0);
-        log vec::len[str](v);
+        log vec::len::<str>(v);
         assert (str::eq(v.(0), mumble));
-        assert (vec::len[str](v) == 1u);
+        assert (vec::len::<str>(v) == 1u);
     } // ref down: mumble, s,
 
     log str::refcount(s);
diff --git a/src/test/stdtest/bitv.rs b/src/test/stdtest/bitv.rs
index d95a0cf414a..9ad241bb3f1 100644
--- a/src/test/stdtest/bitv.rs
+++ b/src/test/stdtest/bitv.rs
@@ -8,8 +8,8 @@ fn test_0_elements() {
     let act;
     let exp;
     act = bitv::create(0u, false);
-    exp = vec::init_elt[uint](0u, 0u);
-    // FIXME: why can't I write vec[uint]()?
+    exp = vec::init_elt::<uint>(0u, 0u);
+    // FIXME: why can't I write vec::<uint>()?
 
     assert (bitv::eq_ivec(act, exp));
 }
diff --git a/src/test/stdtest/box.rs b/src/test/stdtest/box.rs
index 6212ec63965..c28cb520be8 100644
--- a/src/test/stdtest/box.rs
+++ b/src/test/stdtest/box.rs
@@ -6,8 +6,8 @@ import std::box;
 fn test() {
     let x = @3;
     let y = @3;
-    assert (box::ptr_eq[int](x, x));
-    assert (box::ptr_eq[int](y, y));
-    assert (!box::ptr_eq[int](x, y));
-    assert (!box::ptr_eq[int](y, x));
-}
\ No newline at end of file
+    assert (box::ptr_eq::<int>(x, x));
+    assert (box::ptr_eq::<int>(y, y));
+    assert (!box::ptr_eq::<int>(x, y));
+    assert (!box::ptr_eq::<int>(y, x));
+}
diff --git a/src/test/stdtest/comm.rs b/src/test/stdtest/comm.rs
index 5f83542001d..e0e310e5ee2 100644
--- a/src/test/stdtest/comm.rs
+++ b/src/test/stdtest/comm.rs
@@ -3,13 +3,13 @@ import std::comm;
 
 #[test]
 fn create_port_and_chan() {
-    let p = comm::mk_port<int>();
+    let p = comm::mk_port::<int>();
     let c = p.mk_chan();
 }
 
 #[test]
 fn send_recv() {
-    let p = comm::mk_port<int>();
+    let p = comm::mk_port::<int>();
     let c = p.mk_chan();
 
     comm::send(c, 42);
diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs
index 0c53895bd37..d751bd5c45d 100644
--- a/src/test/stdtest/deque.rs
+++ b/src/test/stdtest/deque.rs
@@ -6,7 +6,7 @@ import std::deque;
 
 #[test]
 fn test_simple() {
-    let d: deque::t<int> = deque::create[int]();
+    let d: deque::t<int> = deque::create::<int>();
     assert (d.size() == 0u);
     d.add_front(17);
     d.add_front(42);
@@ -50,7 +50,7 @@ fn test_simple() {
 }
 
 fn test_boxes(a: @int, b: @int, c: @int, d: @int) {
-    let deq: deque::t<@int> = deque::create[@int]();
+    let deq: deque::t<@int> = deque::create::<@int>();
     assert (deq.size() == 0u);
     deq.add_front(a);
     deq.add_front(b);
@@ -82,7 +82,7 @@ fn test_boxes(a: @int, b: @int, c: @int, d: @int) {
 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]();
+    let deq: deque::t<T> = deque::create::<T>();
     assert (deq.size() == 0u);
     deq.add_front(a);
     deq.add_front(b);
@@ -140,18 +140,18 @@ fn test() {
     }
     fn taggypareq<@T>(a: &taggypar<T>, b: &taggypar<T>) -> bool {
         alt a {
-          onepar[T](a1) {
-            alt b { onepar[T](b1) { ret a1 == b1; } _ { ret false; } }
+          onepar::<T>(a1) {
+            alt b { onepar::<T>(b1) { ret a1 == b1; } _ { ret false; } }
           }
-          twopar[T](a1, a2) {
+          twopar::<T>(a1, a2) {
             alt b {
-              twopar[T](b1, b2) { ret a1 == b1 && a2 == b2; }
+              twopar::<T>(b1, b2) { ret a1 == b1 && a2 == b2; }
               _ { ret false; }
             }
           }
-          threepar[T](a1, a2, a3) {
+          threepar::<T>(a1, a2, a3) {
             alt b {
-              threepar[T](b1, b2, b3) {
+              threepar::<T>(b1, b2, b3) {
                 ret a1 == b1 && a2 == b2 && a3 == b3;
               }
               _ { ret false; }
@@ -167,24 +167,24 @@ fn test() {
     log "*** end test boxes";
     log "test parameterized: int";
     let eq1: eqfn<int> = inteq;
-    test_parameterized[int](eq1, 5, 72, 64, 175);
+    test_parameterized::<int>(eq1, 5, 72, 64, 175);
     log "*** test parameterized: @int";
     let eq2: eqfn<@int> = intboxeq;
-    test_parameterized[@int](eq2, @5, @72, @64, @175);
+    test_parameterized::<@int>(eq2, @5, @72, @64, @175);
     log "*** end test parameterized @int";
     log "test parameterized: taggy";
     let eq3: eqfn<taggy> = taggyeq;
-    test_parameterized[taggy](eq3, one(1), two(1, 2), three(1, 2, 3),
+    test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3),
                               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));
-    log "*** end 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));
+    log "*** end test parameterized: taggypar::<int>";
 
     log "*** test parameterized: reccy";
     let reccy1: reccy = {x: 1, y: 2, t: one(1)};
@@ -192,7 +192,7 @@ fn test() {
     let reccy3: reccy = {x: 1, y: 777, t: three(1, 2, 3)};
     let reccy4: reccy = {x: 19, y: 252, t: two(17, 42)};
     let eq5: eqfn<reccy> = reccyeq;
-    test_parameterized[reccy](eq5, reccy1, reccy2, reccy3, reccy4);
+    test_parameterized::<reccy>(eq5, reccy1, reccy2, reccy3, reccy4);
     log "*** end test parameterized: reccy";
     log "*** done";
 }
diff --git a/src/test/stdtest/list.rs b/src/test/stdtest/list.rs
index 383a6ce49fe..4a44508efc4 100644
--- a/src/test/stdtest/list.rs
+++ b/src/test/stdtest/list.rs
@@ -26,7 +26,7 @@ fn test_foldl() {
 fn test_find_success() {
     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] };
+        ret if i == 2 { option::some(i) } else { option::none::<int> };
     }
     let rs = list::find(l, match);
     assert (rs == option::some(2));
@@ -35,15 +35,15 @@ fn test_find_success() {
 #[test]
 fn test_find_fail() {
     let l = from_vec(~[0, 1, 2]);
-    fn match(i: &int) -> option::t<int> { ret option::none[int]; }
+    fn match(i: &int) -> option::t<int> { ret option::none::<int>; }
     let rs = list::find(l, match);
-    assert (rs == option::none[int]);
+    assert (rs == option::none::<int>);
 }
 
 #[test]
 fn test_has() {
     let l = from_vec(~[5, 8, 6]);
-    let empty = list::nil[int];
+    let empty = list::nil::<int>;
     assert (list::has(l, 5));
     assert (!list::has(l, 7));
     assert (list::has(l, 8));
diff --git a/src/test/stdtest/map.rs b/src/test/stdtest/map.rs
index ffda00c4947..2da579cf472 100644
--- a/src/test/stdtest/map.rs
+++ b/src/test/stdtest/map.rs
@@ -23,7 +23,7 @@ fn test_simple() {
     let eqer_str: map::eqfn<str> = str::eq;
     log "uint -> uint";
     let hm_uu: map::hashmap<uint, uint> =
-        map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
+        map::mk_hashmap::<uint, uint>(hasher_uint, eqer_uint);
     assert (hm_uu.insert(10u, 12u));
     assert (hm_uu.insert(11u, 13u));
     assert (hm_uu.insert(12u, 14u));
@@ -39,7 +39,7 @@ fn test_simple() {
     let twelve: str = "twelve";
     log "str -> uint";
     let hm_su: map::hashmap<str, uint> =
-        map::mk_hashmap[str, uint](hasher_str, eqer_str);
+        map::mk_hashmap::<str, uint>(hasher_str, eqer_str);
     assert (hm_su.insert("ten", 12u));
     assert (hm_su.insert(eleven, 13u));
     assert (hm_su.insert("twelve", 14u));
@@ -53,7 +53,7 @@ fn test_simple() {
     assert (hm_su.get("twelve") == 12u);
     log "uint -> str";
     let hm_us: map::hashmap<uint, str> =
-        map::mk_hashmap[uint, str](hasher_uint, eqer_uint);
+        map::mk_hashmap::<uint, str>(hasher_uint, eqer_uint);
     assert (hm_us.insert(10u, "twelve"));
     assert (hm_us.insert(11u, "thirteen"));
     assert (hm_us.insert(12u, "fourteen"));
@@ -66,7 +66,7 @@ fn test_simple() {
     assert (str::eq(hm_us.get(12u), "twelve"));
     log "str -> str";
     let hm_ss: map::hashmap<str, str> =
-        map::mk_hashmap[str, str](hasher_str, eqer_str);
+        map::mk_hashmap::<str, str>(hasher_str, eqer_str);
     assert (hm_ss.insert(ten, "twelve"));
     assert (hm_ss.insert(eleven, "thirteen"));
     assert (hm_ss.insert(twelve, "fourteen"));
@@ -99,7 +99,7 @@ fn test_growth() {
     let hasher_uint: map::hashfn<uint> = hash_uint;
     let eqer_uint: map::eqfn<uint> = eq_uint;
     let hm_uu: map::hashmap<uint, uint> =
-        map::mk_hashmap[uint, uint](hasher_uint, eqer_uint);
+        map::mk_hashmap::<uint, uint>(hasher_uint, eqer_uint);
     let i: uint = 0u;
     while i < num_to_insert {
         assert (hm_uu.insert(i, i * i));
@@ -130,7 +130,7 @@ fn test_growth() {
     let hasher_str: map::hashfn<str> = str::hash;
     let eqer_str: map::eqfn<str> = str::eq;
     let hm_ss: map::hashmap<str, str> =
-        map::mk_hashmap[str, str](hasher_str, eqer_str);
+        map::mk_hashmap::<str, str>(hasher_str, eqer_str);
     i = 0u;
     while i < num_to_insert {
         assert (hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u)));
@@ -181,7 +181,7 @@ fn test_removal() {
     let hasher: map::hashfn<uint> = hash;
     let eqer: map::eqfn<uint> = eq;
     let hm: map::hashmap<uint, uint> =
-        map::mk_hashmap[uint, uint](hasher, eqer);
+        map::mk_hashmap::<uint, uint>(hasher, eqer);
     let i: uint = 0u;
     while i < num_to_insert {
         assert (hm.insert(i, i * i));
@@ -200,10 +200,10 @@ fn test_removal() {
 
         let v: util.option<uint> = hm.remove(i);
         alt (v) {
-          case (util.some[uint](u)) {
+          case (util.some::<uint>(u)) {
             assert (u == (i * i));
           }
-          case (util.none[uint]()) { fail; }
+          case (util.none::<uint>()) { fail; }
         }
 
          * but we util.option is a tag type so util.some and util.none are
@@ -268,7 +268,7 @@ fn test_removal() {
 #[test]
 fn test_contains_key() {
     let key = "k";
-    let map = map::mk_hashmap[str, str](str::hash, str::eq);
+    let map = map::mk_hashmap::<str, str>(str::hash, str::eq);
     assert (!map.contains_key(key));
     map.insert(key, "val");
     assert (map.contains_key(key));
@@ -277,7 +277,7 @@ fn test_contains_key() {
 #[test]
 fn test_find() {
     let key = "k";
-    let map = map::mk_hashmap[str, str](str::hash, str::eq);
+    let map = map::mk_hashmap::<str, str>(str::hash, str::eq);
     assert (std::option::is_none(map.find(key)));
     map.insert(key, "val");
     assert (std::option::get(map.find(key)) == "val");
diff --git a/src/test/stdtest/option.rs b/src/test/stdtest/option.rs
index 6426c96ffb6..ef383832604 100644
--- a/src/test/stdtest/option.rs
+++ b/src/test/stdtest/option.rs
@@ -2,4 +2,4 @@
 use std;
 
 #[test]
-fn test() { let x = std::option::some[int](10); }
\ No newline at end of file
+fn test() { let x = std::option::some::<int>(10); }
diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs
index 0abf551a28f..4e557b533a4 100644
--- a/src/test/stdtest/qsort.rs
+++ b/src/test/stdtest/qsort.rs
@@ -6,10 +6,10 @@ import std::vec;
 import std::int;
 
 fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
-    let len = std::vec::len[int](v1);
+    let len = std::vec::len::<int>(v1);
     fn ltequal(a: &int, b: &int) -> bool { ret a <= b; }
     let f = ltequal;
-    std::sort::quick_sort[int](f, v1);
+    std::sort::quick_sort::<int>(f, v1);
     let i = 0u;
     while i < len { log v2.(i); assert (v2.(i) == v1.(i)); i += 1u; }
 }
diff --git a/src/test/stdtest/qsort3.rs b/src/test/stdtest/qsort3.rs
index 707e17967cd..21f43218806 100644
--- a/src/test/stdtest/qsort3.rs
+++ b/src/test/stdtest/qsort3.rs
@@ -2,12 +2,12 @@
 use std;
 
 fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
-    let len = std::vec::len[int](v1);
+    let len = std::vec::len::<int>(v1);
     fn lt(a: &int, b: &int) -> bool { ret a < b; }
     fn equal(a: &int, b: &int) -> bool { ret a == b; }
     let f1 = lt;
     let f2 = equal;
-    std::sort::quick_sort3[int](f1, f2, v1);
+    std::sort::quick_sort3::<int>(f1, f2, v1);
     let i = 0u;
     while i < len { log v2.(i); assert (v2.(i) == v1.(i)); i += 1u; }
 }
diff --git a/src/test/stdtest/sha1.rs b/src/test/stdtest/sha1.rs
index ef581d18c69..74729fa52ae 100644
--- a/src/test/stdtest/sha1.rs
+++ b/src/test/stdtest/sha1.rs
@@ -61,8 +61,8 @@ fn test() {
                 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);
+        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);
diff --git a/src/test/stdtest/sort.rs b/src/test/stdtest/sort.rs
index f4f7d5ea75e..be15881e65a 100644
--- a/src/test/stdtest/sort.rs
+++ b/src/test/stdtest/sort.rs
@@ -2,10 +2,10 @@
 use std;
 
 fn check_sort(v1: &[int], v2: &[int]) {
-    let len = std::vec::len[int](v1);
+    let len = std::vec::len::<int>(v1);
     fn lteq(a: &int, b: &int) -> bool { ret a <= b; }
     let f = lteq;
-    let v3 = std::sort::merge_sort[int](f, v1);
+    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; }
 }
diff --git a/src/test/stdtest/vec.rs b/src/test/stdtest/vec.rs
index dab250ce142..75b3998e28c 100644
--- a/src/test/stdtest/vec.rs
+++ b/src/test/stdtest/vec.rs
@@ -90,14 +90,14 @@ fn test_init_elt() {
 
 #[test]
 fn test_is_empty() {
-    assert (vec::is_empty[int](~[]));
+    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::<int>(~[]));
 }
 
 #[test]
@@ -242,7 +242,7 @@ fn test_map2() {
     let f = times;
     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 u = vec::map2::<int, int, int>(f, v0, v1);
     let i = 0;
     while i < 5 { assert (v0.(i) * v1.(i) == u.(i)); i += 1; }
 }
@@ -266,8 +266,8 @@ fn test_filter_map() {
 
     fn halve(i: &int) -> option::t<int> {
         if i % 2 == 0 {
-            ret option::some[int](i / 2);
-        } else { ret option::none[int]; }
+            ret option::some::<int>(i / 2);
+        } else { ret option::none::<int>; }
     }
     fn halve_for_sure(i: &int) -> int { ret i / 2; }
     let all_even: [int] = ~[0, 2, 8, 6];
@@ -328,10 +328,10 @@ fn test_zip_unzip() {
 #[test]
 fn test_position() {
     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));
-    assert (position(4, v1) == option::none[uint]);
+    assert (position(1, v1) == option::some::<uint>(0u));
+    assert (position(2, v1) == option::some::<uint>(1u));
+    assert (position(5, v1) == option::some::<uint>(5u));
+    assert (position(4, v1) == option::none::<uint>);
 }
 
 #[test]
@@ -339,8 +339,8 @@ 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];
-    assert (position_pred(less_than_three, v1) == option::some[uint](3u));
-    assert (position_pred(is_eighteen, v1) == option::none[uint]);
+    assert (position_pred(less_than_three, v1) == option::some::<uint>(3u));
+    assert (position_pred(is_eighteen, v1) == option::none::<uint>);
 }
 
 #[test]
@@ -351,16 +351,16 @@ fn reverse_and_reversed() {
     vec::reverse(v);
     assert (v.(0) == 20);
     assert (v.(1) == 10);
-    let v2 = vec::reversed[int](~[10, 20]);
+    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 v4 = vec::reversed::<int>(~[]);
     let v3: [mutable int] = ~[mutable];
-    vec::reverse[int](v3);
+    vec::reverse::<int>(v3);
 }
 
 // Local Variables:
diff --git a/src/test/stdtest/vec_str_conversions.rs b/src/test/stdtest/vec_str_conversions.rs
index e2b11cbfb28..cc52ec80e95 100644
--- a/src/test/stdtest/vec_str_conversions.rs
+++ b/src/test/stdtest/vec_str_conversions.rs
@@ -13,7 +13,7 @@ fn test_simple() {
     let s2: str = str::unsafe_from_bytes(v);
     let i: uint = 0u;
     let n1: uint = str::byte_len(s1);
-    let n2: uint = vec::len[u8](v);
+    let n2: uint = vec::len::<u8>(v);
     assert (n1 == n2);
     while i < n1 {
         let a: u8 = s1.(i);