---

yaml
---
r: 4737
b: refs/heads/master
c: 21f46a1
h: refs/heads/master
i:
  4735: e82535e
v: v3

Author: erickt

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: e4a0f997fb01b9cbb650532fea1278159faff064
+refs/heads/master: 21f46a1655f2a026546792546b07dec9e039ec54

trunk/src/test/bench/shootout-fannkuchredux.rs

@@ -59,4 +59,4 @@ fn fannkuch(n: int) -> int {
 fn main(args: [str]) {
     let n = 7;
     log #fmt("Pfannkuchen(%d) = %d", n, fannkuch(n));
-}
+}

trunk/src/test/bench/shootout-nbody.rs

@@ -27,7 +27,7 @@ fn main() {
 }
 
 // Body::props is a record of floats, so
-// vec[Body::props] is a vector of records of floats
+// vec<Body::props> is a vector of records of floats
 
 mod NBodySystem {
 

trunk/src/test/bench/shootout-pfib.rs

@@ -27,13 +27,13 @@ import std::comm::_chan;
 import std::comm::send;
 
 fn fib(n: int) -> int {
-    fn pfib(c: _chan[int], n: int) {
+    fn pfib(c: _chan<int>, n: int) {
         if n == 0 {
             send(c, 0);
         } 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));

trunk/src/test/bench/task-perf-word-count.rs

@@ -63,39 +63,39 @@ mod map_reduce {
 
     type mapper = fn(str, putter) ;
 
-    type getter = fn() -> option[int] ;
+    type getter = fn() -> option<int> ;
 
     type reducer = fn(str, getter) ;
 
     tag ctrl_proto {
-        find_reducer([u8], _chan[_chan[reduce_proto]]);
+        find_reducer([u8], _chan<_chan<reduce_proto>>);
         mapper_done;
     }
 
     tag reduce_proto { emit_val(int); done; ref; release; }
 
-    fn start_mappers(ctrl: _chan[ctrl_proto], inputs: &[str]) -> [task_id] {
+    fn start_mappers(ctrl: _chan<ctrl_proto>, inputs: &[str]) -> [task_id] {
         let tasks = ~[];
         for i: str in inputs {
             tasks += ~[task::_spawn(bind map_task(ctrl, i))];
         }
         ret tasks;
     }
 
-    fn map_task(ctrl: _chan[ctrl_proto], input: str) {
+    fn map_task(ctrl: _chan<ctrl_proto>, input: str) {
         // log_err "map_task " + input;
         let intermediates = map::new_str_hash();
 
-        fn emit(im: &map::hashmap[str, _chan[reduce_proto]],
-                ctrl: _chan[ctrl_proto], key: str, val: int) {
+        fn emit(im: &map::hashmap<str, _chan<reduce_proto>>,
+                ctrl: _chan<ctrl_proto>, key: str, val: int) {
             let c;
             alt im.find(key) {
               some(_c) {
 
                 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();
@@ -108,24 +108,24 @@ mod map_reduce {
 
         map(input, bind emit(intermediates, ctrl, _, _));
 
-        for each kv: @{key: str, val: _chan[reduce_proto]}  in
+        for each kv: @{key: str, val: _chan<reduce_proto>}  in
                  intermediates.items() {
             send(kv.val, release);
         }
 
         send(ctrl, mapper_done);
     }
 
-    fn reduce_task(key: str, out: _chan[_chan[reduce_proto]]) {
+    fn reduce_task(key: str, out: _chan<_chan<reduce_proto>>) {
         let p = mk_port();
 
         send(out, p.mk_chan());
 
         let ref_count = 0;
         let is_done = false;
 
-        fn get(p: &_port[reduce_proto], ref_count: &mutable int,
-               is_done: &mutable bool) -> option[int] {
+        fn get(p: &_port<reduce_proto>, ref_count: &mutable int,
+               is_done: &mutable bool) -> option<int> {
             while !is_done || ref_count > 0 {
                 alt p.recv() {
                   emit_val(v) {
@@ -147,12 +147,12 @@ 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.
 
-        let reducers: map::hashmap[str, _chan[reduce_proto]];
+        let reducers: map::hashmap<str, _chan<reduce_proto>>;
 
         reducers = map::new_str_hash();
 
@@ -189,7 +189,7 @@ mod map_reduce {
             }
         }
 
-        for each kv: @{key: str, val: _chan[reduce_proto]} in reducers.items()
+        for each kv: @{key: str, val: _chan<reduce_proto>} in reducers.items()
                  {
             send(kv.val, done);
         }
@@ -225,7 +225,7 @@ fn main(argv: [str]) {
     log_err "MapReduce completed in " + u64::str(elapsed) + "ms";
 }
 
-fn read_word(r: io::reader) -> option[str] {
+fn read_word(r: io::reader) -> option<str> {
     let w = "";
 
     while !r.eof() {

trunk/src/test/compile-fail/bad-expr-path.rs

@@ -2,4 +2,4 @@
 
 mod m1 { }
 
-fn main(args: [str]) { log m1::a; }
+fn main(args: [str]) { log m1::a; }

trunk/src/test/compile-fail/bad-expr-path2.rs

@@ -4,4 +4,4 @@ mod m1 {
     mod a { }
 }
 
-fn main(args: [str]) { log m1::a; }
+fn main(args: [str]) { log m1::a; }

trunk/src/test/compile-fail/for-loop-decl.rs

@@ -3,7 +3,7 @@ use std;
 import std::map::hashmap;
 import std::bitv;
 
-type fn_info = {vars: hashmap[uint, var_info]};
+type fn_info = {vars: hashmap<uint, var_info>};
 type var_info = {a: uint, b: uint};
 
 fn bitv_to_str(enclosing: fn_info, v: bitv::t) -> str {

trunk/src/test/compile-fail/import.rs

@@ -4,4 +4,4 @@ import zed::baz;
 mod zed {
     fn bar() { log "bar"; }
 }
-fn main(args: [str]) { bar(); }
+fn main(args: [str]) { bar(); }

trunk/src/test/compile-fail/import2.rs

@@ -4,4 +4,4 @@ mod baz { }
 mod zed {
     fn bar() { log "bar3"; }
 }
-fn main(args: [str]) { bar(); }
+fn main(args: [str]) { bar(); }

trunk/src/test/compile-fail/import3.rs

@@ -1,4 +1,4 @@
 // error-pattern: unresolved modulename
 import main::bar;
 
-fn main(args: [str]) { log "foo"; }
+fn main(args: [str]) { log "foo"; }

trunk/src/test/compile-fail/import4.rs

@@ -3,4 +3,4 @@
 import zed::bar;
 import bar::zed;
 
-fn main(args: [str]) { log "loop"; }
+fn main(args: [str]) { log "loop"; }

trunk/src/test/compile-fail/infinite-vec-type-recursion.rs

@@ -3,4 +3,4 @@
 
 type x = [x];
 
-fn main() { let b: x = ~[]; }
+fn main() { let b: x = ~[]; }

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

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

trunk/src/test/compile-fail/pattern-tyvar-2.rs

@@ -6,8 +6,8 @@ import std::option::some;
 
 // error-pattern: mismatched types
 
-tag bar { t1((), option::t[[int]]); t2; }
+tag bar { t1((), option::t<[int]>); t2; }
 
 fn foo(t: bar) -> int { alt t { t1(_, some(x)) { ret x * 3; } _ { fail; } } }
 
-fn main() { }
+fn main() { }

trunk/src/test/compile-fail/pattern-tyvar.rs

@@ -5,8 +5,8 @@ import std::option::some;
 
 // error-pattern: mismatched types
 
-tag bar { t1((), option::t[[int]]); t2; }
+tag bar { t1((), option::t<[int]>); t2; }
 
 fn foo(t: bar) { alt t { t1(_, some[int](x)) { log x; } _ { fail; } } }
 
-fn main() { }
+fn main() { }

trunk/src/test/compile-fail/vec-field.rs

@@ -6,4 +6,4 @@ fn f() {
     log v.some_field_name; //type error
 }
 
-fn main() { }
+fn main() { }

trunk/src/test/compile-fail/writing-through-uninit-vec.rs

@@ -2,4 +2,4 @@
 
 fn test() { let w: [int]; w.(5) = 0; }
 
-fn main() { test(); }
+fn main() { test(); }

trunk/src/test/compile-fail/writing-to-immutable-vec.rs

@@ -1,2 +1,2 @@
 // error-pattern:assignment to immutable vec content
-fn main() { let v: [int] = ~[1, 2, 3]; v.(1) = 4; }
+fn main() { let v: [int] = ~[1, 2, 3]; v.(1) = 4; }

trunk/src/test/compiletest/common.rs

@@ -25,12 +25,12 @@ type config = {
     // Run ignored tests
     run_ignored: bool,
     // Only run tests that match this filter
-    filter: option::t[str],
+    filter: option::t<str>,
     // A command line to prefix program execution with,
     // for running under valgrind
-    runtool: option::t[str],
+    runtool: option::t<str>,
     // Flags to pass to the compiler
-    rustcflags: option::t[str],
+    rustcflags: option::t<str>,
     // Explain what's going on
     verbose: bool
 };

trunk/src/test/compiletest/compiletest.rs

@@ -81,11 +81,11 @@ fn log_config(config: &config) {
     logv(c, #fmt("\n"));
 }
 
-fn opt_str(maybestr: option::t[str]) -> str {
+fn opt_str(maybestr: option::t<str>) -> str {
     alt maybestr { option::some(s) { s } option::none. { "(none)" } }
 }
 
-fn str_opt(maybestr: str) -> option::t[str] {
+fn str_opt(maybestr: str) -> option::t<str> {
     if maybestr != "(none)" { option::some(maybestr) } else { option::none }
 }
 
@@ -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);
@@ -158,7 +158,7 @@ fn is_test(config: &config, testfile: &str) -> bool {
     ret valid;
 }
 
-fn make_test(cx: &cx, testfile: &str, configport: &_port[[u8]]) ->
+fn make_test(cx: &cx, testfile: &str, configport: &_port<[u8]>) ->
    test::test_desc {
     {name: make_test_name(cx.config, testfile),
      fn: make_test_closure(testfile, configport.mk_chan()),
@@ -188,12 +188,12 @@ up. Then we'll spawn that data into another task and return the task.
 Really convoluted. Need to think up of a better definition for tests.
 */
 
-fn make_test_closure(testfile: &str, configchan: _chan[[u8]]) -> test::test_fn
+fn make_test_closure(testfile: &str, configchan: _chan<[u8]>) -> test::test_fn
 {
     bind send_config(testfile, configchan)
 }
 
-fn send_config(testfile: str, configchan: _chan[[u8]]) {
+fn send_config(testfile: str, configchan: _chan<[u8]>) {
     send(configchan, str::bytes(testfile));
 }
 
@@ -207,7 +207,7 @@ break up the config record and pass everything individually to the spawned
 function.
 */
 
-fn closure_to_task(cx: cx, configport: _port[[u8]], testfn: &fn() ) -> task_id
+fn closure_to_task(cx: cx, configport: _port<[u8]>, testfn: &fn() ) -> task_id
 {
     testfn();
     let testfile = configport.recv();

trunk/src/test/compiletest/header.rs

@@ -13,10 +13,10 @@ type test_props = {
     // Lines that should be expected, in order, on standard out
     error_patterns: [str],
     // Extra flags to pass to the compiler
-    compile_flags: option::t[str],
+    compile_flags: option::t<str>,
     // If present, the name of a file that this test should match when
     // pretty-printed
-    pp_exact: option::t[str],
+    pp_exact: option::t<str>,
     // FIXME: no-valgrind is a temporary directive until all of run-fail
     // is valgrind-clean
     no_valgrind: bool
@@ -82,15 +82,15 @@ iter iter_header(testfile: &str) -> str {
     }
 }
 
-fn parse_error_pattern(line: &str) -> option::t[str] {
+fn parse_error_pattern(line: &str) -> option::t<str> {
     parse_name_value_directive(line, "error-pattern")
 }
 
-fn parse_compile_flags(line: &str) -> option::t[str] {
+fn parse_compile_flags(line: &str) -> option::t<str> {
     parse_name_value_directive(line, "compile-flags")
 }
 
-fn parse_pp_exact(line: &str, testfile: &str) -> option::t[str] {
+fn parse_pp_exact(line: &str, testfile: &str) -> option::t<str> {
     alt parse_name_value_directive(line, "pp-exact") {
       option::some(s) { option::some(s) }
       option::none. {
@@ -108,7 +108,7 @@ fn parse_name_directive(line: &str, directive: &str) -> bool {
 }
 
 fn parse_name_value_directive(line: &str,
-                              directive: &str) -> option::t[str] {
+                              directive: &str) -> option::t<str> {
     let keycolon = directive + ":";
     if str::find(line, keycolon) >= 0 {
         let colon = str::find(line, keycolon) as uint;