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

Author: erickt

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) {

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));

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.

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;
 }

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>(_) { } } }

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() { }

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);

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),

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);
-}
+}

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();
 }

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();

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>); }

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;
-}
+}

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)); }

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;

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);
 }

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);
 }

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, _); }

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(); }

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(); }

src/test/run-pass/expr-alt-generic.rs

@@ -12,15 +12,15 @@ 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() {
     type t = {a: int, b: int};
 
     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(); }

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(); }

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(); }

src/test/run-pass/expr-block-generic.rs

@@ -14,15 +14,15 @@ 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() {
     type t = {a: int, b: int};
 
     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(); }

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(); }

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(); }

src/test/run-pass/expr-if-generic.rs

@@ -14,15 +14,15 @@ 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() {
     type t = {a: int, b: int};
 
     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(); }

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); }

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);
 }

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);
 }

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);
 }

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);

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);
 }

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>(); }

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;

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;

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);

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>)));
 }