Port the tests to the decl foo<T> syntax.

Author: erickt

src/fuzzer/ast_match.rs

@@ -1,7 +1,7 @@
 use std;
 import std::vec;
 
-fn ivec_equal[T](v: &[T], u: &[T], element_equality_test: fn(&T, &T) -> bool )
+fn ivec_equal<T>(v: &[T], u: &[T], element_equality_test: fn(&T, &T) -> bool )
    -> bool {
     let Lv = vec::len(v);
     if Lv != vec::len(u) { ret false; }
@@ -13,7 +13,7 @@ fn ivec_equal[T](v: &[T], u: &[T], element_equality_test: fn(&T, &T) -> bool )
     ret true;
 }
 
-fn builtin_equal[T](a: &T, b: &T) -> bool { ret a == b; }
+fn builtin_equal<T>(a: &T, b: &T) -> bool { ret a == b; }
 
 fn main() {
     assert (builtin_equal(5, 5));

src/fuzzer/ivec_fuzz.rs

@@ -7,7 +7,7 @@ Idea: provide functions for 'exhaustive' and 'random' modification of vecs.
   two functions, "return the number of possible edits" and "return edit #n"
 
 It would be nice if this could be data-driven, so the two functions could share information:
-  type vec_modifier = rec(fn (&[T] v, uint i) -> [T] fun, uint lo, uint di);
+  type vec_modifier = rec(fn (&<T> v, uint i) -> [T] fun, uint lo, uint di);
   const [vec_modifier] vec_modifiers = ~[rec(fun=vec_omit, 0u, 1u), ...];
 But that gives me "error: internal compiler error unimplemented consts that's not a plain literal".
 https://github.com/graydon/rust/issues/570
@@ -26,24 +26,24 @@ import std::ivec::slice;
 import std::ivec::len;
 import std::int;
 
-//fn vec_reverse(&[T] v) -> [T] { ... }
+//fn vec_reverse(&<T> v) -> [T] { ... }
 
-fn vec_omit[T](v: &[T], i: uint) -> [T] {
+fn vec_omit<T>(v: &[T], i: uint) -> [T] {
     slice(v, 0u, i) + slice(v, i + 1u, len(v))
 }
-fn vec_dup[T](v: &[T], i: uint) -> [T] {
+fn vec_dup<T>(v: &[T], i: uint) -> [T] {
     slice(v, 0u, i) + ~[v.(i)] + slice(v, i, len(v))
 }
-fn vec_swadj[T](v: &[T], i: uint) -> [T] {
+fn vec_swadj<T>(v: &[T], i: uint) -> [T] {
     slice(v, 0u, i) + ~[v.(i + 1u), v.(i)] + slice(v, i + 2u, len(v))
 }
-fn vec_prefix[T](v: &[T], i: uint) -> [T] { slice(v, 0u, i) }
-fn vec_suffix[T](v: &[T], i: uint) -> [T] { slice(v, i, len(v)) }
+fn vec_prefix<T>(v: &[T], i: uint) -> [T] { slice(v, 0u, i) }
+fn vec_suffix<T>(v: &[T], i: uint) -> [T] { slice(v, i, len(v)) }
 
-fn vec_poke[T](v: &[T], i: uint, x: &T) -> [T] {
+fn vec_poke<T>(v: &[T], i: uint, x: &T) -> [T] {
     slice(v, 0u, i) + ~[x] + slice(v, i + 1u, len(v))
 }
-fn vec_insert[T](v: &[T], i: uint, x: &T) -> [T] {
+fn vec_insert<T>(v: &[T], i: uint, x: &T) -> [T] {
     slice(v, 0u, i) + ~[x] + slice(v, i, len(v))
 }
 
@@ -54,7 +54,7 @@ iter ix(skip_low: uint, skip_high: uint, length: uint) -> uint {
 }
 
 // Returns a bunch of modified versions of v, some of which introduce new elements (borrowed from xs).
-fn vec_edits[T](v: &[T], xs: &[T]) -> [[T]] {
+fn vec_edits<T>(v: &[T], xs: &[T]) -> [[T]] {
     let edits: [[T]] = ~[];
     let Lv: uint = len(v);
 

src/test/compile-fail/bad-type-env-capture.rs

@@ -2,7 +2,7 @@
 // xfail-stage2
 // xfail-stage3
 // error-pattern: attempted dynamic environment-capture
-fn foo[T]() {
+fn foo<T>() {
     obj bar(b: T) { }
 }
-fn main() { }
+fn main() { }

src/test/compile-fail/item-name-overload.rs

@@ -2,8 +2,8 @@
 // error-pattern: Dynamically sized arguments must be passed by alias
 
 mod foo {
-    fn bar[T](f: T) -> int { ret 17; }
-    type bar[U, T] = {a: int, b: U, c: T};
+    fn bar<T>(f: T) -> int { ret 17; }
+    type bar<U, T> = {a: int, b: U, c: T};
 }
 
-fn main() { }
+fn main() { }

src/test/compile-fail/nested-ty-params.rs

@@ -1,5 +1,5 @@
 // error-pattern:Attempt to use a type argument out of scope
-fn hd[U](v: &[U]) -> U {
+fn hd<U>(v: &[U]) -> U {
     fn hd1(w: &[U]) -> U { ret w.(0); }
 
     ret hd1(v);

src/test/compile-fail/occurs-check-3.rs

@@ -1,4 +1,4 @@
 // error-pattern:mismatched types
 // From Issue #778
-tag clam[T] { a(T); }
+tag clam<T> { a(T); }
 fn main() { let c; c = a(c); alt c { a[int](_) { } } }

src/test/compile-fail/tag-type-args.rs

@@ -1,7 +1,7 @@
 // error-pattern: Wrong number of type arguments
 
-tag quux[T] { }
+tag quux<T> { }
 
 fn foo(c: quux) { assert (false); }
 
-fn main() { fail; }
+fn main() { fail; }

src/test/compile-fail/type-arg-out-of-scope.rs

@@ -1,5 +1,5 @@
 // error-pattern:Attempt to use a type argument out of scope
-fn foo[T](x: &T) {
+fn foo<T>(x: &T) {
     fn bar(f: fn(&T) -> T ) { }
 }
-fn main() { foo(1); }
+fn main() { foo(1); }

src/test/compiletest/procsrv.rs

@@ -167,7 +167,7 @@ fn worker(p: _port<request>) {
     }
 }
 
-fn with_lib_path[T](path: &str, f: fn() -> T ) -> T {
+fn with_lib_path<T>(path: &str, f: fn() -> T ) -> T {
     let maybe_oldpath = getenv(util::lib_path_env_var());
     append_lib_path(path);
     let res = f();

src/test/run-fail/bug-811.rs

@@ -6,11 +6,11 @@ fn test00_start(ch: chan_t<int>, message: int) {
 type task_id = int;
 type port_id = int;
 
-type chan_t[~T] = {
+type chan_t<~T> = {
     task : task_id,
     port : port_id
 };
 
-fn send[~T](ch : chan_t<T>, data : -T) { fail; }
+fn send<~T>(ch : chan_t<T>, data : -T) { fail; }
 
 fn main() { fail "quux"; }