Port the compiler to the ivec type [T] syntax.

15 files changed, 212 insertions, 211 deletions

diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs
index be27e9c2dec..8c5669aac8e 100644
--- a/src/comp/syntax/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -16,13 +16,13 @@ type fn_ident = option::t[ident];
 // FIXME: with typestate constraint, could say
 // idents and types are the same length, and are
 // non-empty
-type path_ = {global: bool, idents: ident[], types: (@ty)[]};
+type path_ = {global: bool, idents: [ident], types: [@ty]};
 
 type path = spanned[path_];
 
 fn path_name(p: &path) -> str { path_name_i(p.node.idents) }
 
-fn path_name_i(idents: &ident[]) -> str { str::connect_ivec(idents, "::") }
+fn path_name_i(idents: &[ident]) -> str { str::connect_ivec(idents, "::") }
 
 type crate_num = int;
 type node_id = int;
@@ -85,22 +85,22 @@ fn def_id_of_def(d: def) -> def_id {
 
 // The set of meta_items that define the compilation environment of the crate,
 // used to drive conditional compilation
-type crate_cfg = (@meta_item)[];
+type crate_cfg = [@meta_item];
 
 type crate = spanned[crate_];
 
 type crate_ =
-    {directives: (@crate_directive)[],
+    {directives: [@crate_directive],
      module: _mod,
-     attrs: attribute[],
+     attrs: [attribute],
      config: crate_cfg};
 
 tag crate_directive_ {
-    cdir_src_mod(ident, option::t[filename], attribute[]);
+    cdir_src_mod(ident, option::t[filename], [attribute]);
     cdir_dir_mod(ident,
                  option::t[filename],
-                 (@crate_directive)[],
-                 attribute[]);
+                 [@crate_directive],
+                 [attribute]);
     cdir_view_item(@view_item);
     cdir_syntax(path);
     cdir_auth(path, _auth);
@@ -112,13 +112,13 @@ type meta_item = spanned[meta_item_];
 
 tag meta_item_ {
     meta_word(ident);
-    meta_list(ident, (@meta_item)[]);
+    meta_list(ident, [@meta_item]);
     meta_name_value(ident, lit);
 }
 
 type blk = spanned[blk_];
 
-type blk_ = {stmts: (@stmt)[], expr: option::t[@expr], id: node_id};
+type blk_ = {stmts: [@stmt], expr: option::t[@expr], id: node_id};
 
 type pat = {id: node_id, node: pat_, span: span};
 
@@ -128,8 +128,8 @@ tag pat_ {
     pat_wild;
     pat_bind(ident);
     pat_lit(@lit);
-    pat_tag(path, (@pat)[]);
-    pat_rec(field_pat[], bool);
+    pat_tag(path, [@pat]);
+    pat_rec([field_pat], bool);
     pat_box(@pat);
 }
 
@@ -174,7 +174,7 @@ iter pat_bindings(pat: &@pat) -> @pat {
     }
 }
 
-fn pat_binding_ids(pat: &@pat) -> node_id[] {
+fn pat_binding_ids(pat: &@pat) -> [node_id] {
     let found = ~[];
     for each b in pat_bindings(pat) { found += ~[b.id]; }
     ret found;
@@ -275,9 +275,9 @@ type local = spanned[local_];
 
 type decl = spanned[decl_];
 
-tag decl_ { decl_local((@local)[]); decl_item(@item); }
+tag decl_ { decl_local([@local]); decl_item(@item); }
 
-type arm = {pats: (@pat)[], block: blk};
+type arm = {pats: [@pat], block: blk};
 
 type elt = {mut: mutability, expr: @expr};
 
@@ -295,12 +295,12 @@ tag seq_kind { sk_unique; sk_rc; }
 type expr = {id: node_id, node: expr_, span: span};
 
 tag expr_ {
-    expr_vec((@expr)[], mutability, seq_kind);
-    expr_rec(field[], option::t[@expr]);
-    expr_call(@expr, (@expr)[]);
+    expr_vec([@expr], mutability, seq_kind);
+    expr_rec([field], option::t[@expr]);
+    expr_call(@expr, [@expr]);
     expr_self_method(ident);
-    expr_bind(@expr, (option::t[@expr])[]);
-    expr_spawn(spawn_dom, option::t[str], @expr, (@expr)[]);
+    expr_bind(@expr, [option::t[@expr]]);
+    expr_spawn(spawn_dom, option::t[str], @expr, [@expr]);
     expr_binary(binop, @expr, @expr);
     expr_unary(unop, @expr);
     expr_lit(@lit);
@@ -311,7 +311,7 @@ tag expr_ {
     expr_for(@local, @expr, blk);
     expr_for_each(@local, @expr, blk);
     expr_do_while(blk, @expr);
-    expr_alt(@expr, arm[]);
+    expr_alt(@expr, [arm]);
     expr_fn(_fn);
     expr_block(blk);
 
@@ -392,10 +392,10 @@ type ty_arg_ = {mode: mode, ty: @ty};
 type ty_method_ =
     {proto: proto,
      ident: ident,
-     inputs: ty_arg[],
+     inputs: [ty_arg],
      output: @ty,
      cf: controlflow,
-     constrs: (@constr)[]};
+     constrs: [@constr]};
 
 type ty_field = spanned[ty_field_];
 
@@ -465,12 +465,12 @@ tag ty_ {
     ty_task;
     ty_port(@ty);
     ty_chan(@ty);
-    ty_rec(ty_field[]);
-    ty_fn(proto, ty_arg[], @ty, controlflow, (@constr)[]);
-    ty_obj(ty_method[]);
+    ty_rec([ty_field]);
+    ty_fn(proto, [ty_arg], @ty, controlflow, [@constr]);
+    ty_obj([ty_method]);
     ty_path(path, node_id);
     ty_type;
-    ty_constr(@ty, (@ty_constr)[]);
+    ty_constr(@ty, [@ty_constr]);
     ty_mac(mac);
 }
 
@@ -496,7 +496,7 @@ type constr_arg = spanned[fn_constr_arg];
 // constrained type, is * (referring to the base record)
 
 type constr_general_[ARG, ID] =
-    {path: path, args: (@spanned[constr_arg_general_[ARG]])[], id: ID};
+    {path: path, args: [@spanned[constr_arg_general_[ARG]]], id: ID};
 
 // In the front end, constraints have a node ID attached.
 // Typeck turns this to a def_id, using the output of resolve.
@@ -514,12 +514,12 @@ type arg = {mode: mode, ty: @ty, ident: ident, id: node_id};
 tag inlineness { il_normal; il_inline; }
 
 type fn_decl =
-    {inputs: arg[],
+    {inputs: [arg],
      output: @ty,
      purity: purity,
      il: inlineness,
      cf: controlflow,
-     constraints: (@constr)[]};
+     constraints: [@constr]};
 
 tag purity {
     pure_fn; // declared with "pred"
@@ -550,16 +550,16 @@ type obj_field = {mut: mutability, ty: @ty, ident: ident, id: node_id};
 type anon_obj_field =
     {mut: mutability, ty: @ty, expr: @expr, ident: ident, id: node_id};
 
-type _obj = {fields: obj_field[], methods: (@method)[]};
+type _obj = {fields: [obj_field], methods: [@method]};
 
 type anon_obj =
     // New fields and methods, if they exist.
-    {fields: option::t[anon_obj_field[]],
-     methods: (@method)[],
+    {fields: option::t[[anon_obj_field]],
+     methods: [@method],
      // inner_obj: the original object being extended, if it exists.
      inner_obj: option::t[@expr]};
 
-type _mod = {view_items: (@view_item)[], items: (@item)[]};
+type _mod = {view_items: [@view_item], items: [@item]};
 
 tag native_abi {
     native_abi_rust;
@@ -572,21 +572,21 @@ tag native_abi {
 type native_mod =
     {native_name: str,
      abi: native_abi,
-     view_items: (@view_item)[],
-     items: (@native_item)[]};
+     view_items: [@view_item],
+     items: [@native_item]};
 
 type variant_arg = {ty: @ty, id: node_id};
 
-type variant_ = {name: str, args: variant_arg[], id: node_id};
+type variant_ = {name: str, args: [variant_arg], id: node_id};
 
 type variant = spanned[variant_];
 
 type view_item = spanned[view_item_];
 
 tag view_item_ {
-    view_item_use(ident, (@meta_item)[], node_id);
-    view_item_import(ident, ident[], node_id);
-    view_item_import_glob(ident[], node_id);
+    view_item_use(ident, [@meta_item], node_id);
+    view_item_import(ident, [ident], node_id);
+    view_item_import_glob([ident], node_id);
     view_item_export(ident, node_id);
 }
 
@@ -605,32 +605,32 @@ tag attr_style { attr_outer; attr_inner; }
 type attribute_ = {style: attr_style, value: meta_item};
 
 type item =  // For objs and resources, this is the type def_id
-    {ident: ident, attrs: attribute[], id: node_id, node: item_, span: span};
+    {ident: ident, attrs: [attribute], id: node_id, node: item_, span: span};
 
 tag item_ {
     item_const(@ty, @expr);
-    item_fn(_fn, ty_param[]);
+    item_fn(_fn, [ty_param]);
     item_mod(_mod);
     item_native_mod(native_mod);
-    item_ty(@ty, ty_param[]);
-    item_tag(variant[], ty_param[]);
-    item_obj(_obj, ty_param[], /* constructor id */node_id);
+    item_ty(@ty, [ty_param]);
+    item_tag([variant], [ty_param]);
+    item_obj(_obj, [ty_param], /* constructor id */node_id);
     item_res(_fn, /* dtor */
              node_id, /* dtor id */
-             ty_param[],
+             [ty_param],
              node_id /* ctor id */);
 }
 
 type native_item =
     {ident: ident,
-     attrs: attribute[],
+     attrs: [attribute],
      node: native_item_,
      id: node_id,
      span: span};
 
 tag native_item_ {
     native_item_ty;
-    native_item_fn(option::t[str], fn_decl, ty_param[]);
+    native_item_fn(option::t[str], fn_decl, [ty_param]);
 }
 
 fn is_exported(i: ident, m: _mod) -> bool {
diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs
index 958ebf705f5..468e94255f0 100644
--- a/src/comp/syntax/codemap.rs
+++ b/src/comp/syntax/codemap.rs
@@ -17,9 +17,9 @@ type file_pos = {ch: uint, byte: uint};
  * compiler.
  */
 type filemap =
-    @{name: filename, start_pos: file_pos, mutable lines: file_pos[]};
+    @{name: filename, start_pos: file_pos, mutable lines: [file_pos]};
 
-type codemap = @{mutable files: filemap[]};
+type codemap = @{mutable files: [filemap]};
 
 type loc = {filename: filename, line: uint, col: uint};
 
@@ -175,7 +175,7 @@ fn emit_note(sp: &option::t[span], msg: &str, cm: &codemap) {
     emit_diagnostic(sp, msg, "note", 10u8, cm);
 }
 
-type file_lines = {name: str, lines: uint[]};
+type file_lines = {name: str, lines: [uint]};
 
 fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
     let lo = lookup_char_pos(cm, sp.lo);
diff --git a/src/comp/syntax/ext/concat_idents.rs b/src/comp/syntax/ext/concat_idents.rs
index d2e6511a993..0106f76982b 100644
--- a/src/comp/syntax/ext/concat_idents.rs
+++ b/src/comp/syntax/ext/concat_idents.rs
@@ -5,7 +5,7 @@ import syntax::ast;
 
 fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
                      body: option::t[str]) -> @ast::expr {
-    let args: (@ast::expr)[] = alt arg.node {
+    let args: [@ast::expr] = alt arg.node {
       ast::expr_vec(elts, _, _) { elts }
       _ { cx.span_fatal(sp, "#concat_idents requires a vector argument .") }
     };
@@ -19,4 +19,4 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
               node: {global: false, idents: ~[res], types: ~[]},
               span: sp}),
           span: sp};
-}
\ No newline at end of file
+}
diff --git a/src/comp/syntax/ext/env.rs b/src/comp/syntax/ext/env.rs
index f2f4ae6a8fa..2a897b570dd 100644
--- a/src/comp/syntax/ext/env.rs
+++ b/src/comp/syntax/ext/env.rs
@@ -12,7 +12,7 @@ export expand_syntax_ext;
 
 fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
                      body: option::t[str]) -> @ast::expr {
-    let args: (@ast::expr)[] = alt arg.node {
+    let args: [@ast::expr] = alt arg.node {
       ast::expr_vec(elts, _, _) { elts }
       _ { cx.span_fatal(sp, "#env requires arguments of the form `[...]`.") }
     };
diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
index 10281a9934d..3df7024054a 100644
--- a/src/comp/syntax/ext/fmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -18,7 +18,7 @@ export expand_syntax_ext;
 
 fn expand_syntax_ext(cx: &ext_ctxt, sp: span, arg: @ast::expr,
                      body: option::t[str]) -> @ast::expr {
-    let args: (@ast::expr)[] = alt arg.node {
+    let args: [@ast::expr] = alt arg.node {
       ast::expr_vec(elts, _, _) { elts }
       _ { cx.span_fatal(sp, "#fmt requires arguments of the form `[...]`.") }
     };
@@ -43,7 +43,7 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: span, arg: @ast::expr,
 // be factored out in common with other code that builds expressions.
 // FIXME: Cleanup the naming of these functions
 fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: vec[piece],
-                  args: &(@ast::expr)[]) -> @ast::expr {
+                  args: &[@ast::expr]) -> @ast::expr {
     fn make_new_lit(cx: &ext_ctxt, sp: span, lit: ast::lit_) -> @ast::expr {
         let sp_lit = @{node: lit, span: sp};
         ret @{id: cx.next_id(), node: ast::expr_lit(sp_lit), span: sp};
@@ -65,20 +65,20 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: vec[piece],
         let binexpr = ast::expr_binary(ast::add, lhs, rhs);
         ret @{id: cx.next_id(), node: binexpr, span: sp};
     }
-    fn make_path_expr(cx: &ext_ctxt, sp: span, idents: &ast::ident[]) ->
+    fn make_path_expr(cx: &ext_ctxt, sp: span, idents: &[ast::ident]) ->
        @ast::expr {
         let path = {global: false, idents: idents, types: ~[]};
         let sp_path = {node: path, span: sp};
         let pathexpr = ast::expr_path(sp_path);
         ret @{id: cx.next_id(), node: pathexpr, span: sp};
     }
-    fn make_vec_expr(cx: &ext_ctxt, sp: span, exprs: &(@ast::expr)[]) ->
+    fn make_vec_expr(cx: &ext_ctxt, sp: span, exprs: &[@ast::expr]) ->
        @ast::expr {
         let vecexpr = ast::expr_vec(exprs, ast::imm, ast::sk_rc);
         ret @{id: cx.next_id(), node: vecexpr, span: sp};
     }
-    fn make_call(cx: &ext_ctxt, sp: span, fn_path: &ast::ident[],
-                 args: &(@ast::expr)[]) -> @ast::expr {
+    fn make_call(cx: &ext_ctxt, sp: span, fn_path: &[ast::ident],
+                 args: &[@ast::expr]) -> @ast::expr {
         let pathexpr = make_path_expr(cx, sp, fn_path);
         let callexpr = ast::expr_call(pathexpr, args);
         ret @{id: cx.next_id(), node: callexpr, span: sp};
@@ -86,7 +86,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: vec[piece],
     fn make_rec_expr(cx: &ext_ctxt, sp: span,
                      fields: vec[{ident: ast::ident, ex: @ast::expr}]) ->
        @ast::expr {
-        let astfields: ast::field[] = ~[];
+        let astfields: [ast::field] = ~[];
         for field: {ident: ast::ident, ex: @ast::expr}  in fields {
             let ident = field.ident;
             let val = field.ex;
@@ -97,7 +97,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: vec[piece],
         let recexpr = ast::expr_rec(astfields, option::none[@ast::expr]);
         ret @{id: cx.next_id(), node: recexpr, span: sp};
     }
-    fn make_path_vec(cx: &ext_ctxt, ident: str) -> str[] {
+    fn make_path_vec(cx: &ext_ctxt, ident: str) -> [str] {
         fn compiling_std(cx: &ext_ctxt) -> bool {
             ret str::find(cx.crate_file_name_hack, "std.rc") >= 0;
         }
@@ -115,7 +115,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: vec[piece],
     fn make_rt_conv_expr(cx: &ext_ctxt, sp: span, cnv: &conv) -> @ast::expr {
         fn make_flags(cx: &ext_ctxt, sp: span, flags: vec[flag]) ->
            @ast::expr {
-            let flagexprs: (@ast::expr)[] = ~[];
+            let flagexprs: [@ast::expr] = ~[];
             for f: flag  in flags {
                 let fstr;
                 alt f {
diff --git a/src/comp/syntax/ext/ident_to_str.rs b/src/comp/syntax/ext/ident_to_str.rs
index 68a4303ec72..9399f2e8fd4 100644
--- a/src/comp/syntax/ext/ident_to_str.rs
+++ b/src/comp/syntax/ext/ident_to_str.rs
@@ -5,7 +5,7 @@ import syntax::ast;
 
 fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
                      body: option::t[str]) -> @ast::expr {
-    let args: (@ast::expr)[] = alt arg.node {
+    let args: [@ast::expr] = alt arg.node {
       ast::expr_vec(elts, _, _) { elts }
       _ { cx.span_fatal(sp, "#ident_to_str requires a vector argument .") }
     };
@@ -18,4 +18,4 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
                                                 "expected an ident"),
                                   ast::sk_rc));
 
-}
\ No newline at end of file
+}
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs
index 4e547094544..e2285aafc0b 100644
--- a/src/comp/syntax/ext/simplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -93,8 +93,8 @@ fn match_error(cx: &ext_ctxt, m: &matchable, expected: &str) -> ! {
 type match_result = option::t[arb_depth[matchable]];
 type selector = fn(&matchable) -> match_result ;
 
-fn elts_to_ell(cx: &ext_ctxt, elts: &(@expr)[])
-    -> {fixed: (@expr)[], rep: option::t[@expr]} {
+fn elts_to_ell(cx: &ext_ctxt, elts: &[@expr])
+    -> {fixed: [@expr], rep: option::t[@expr]} {
     let idx: uint = 0u;
     for elt: @expr  in elts {
         alt elt.node {
@@ -153,7 +153,7 @@ fn compose_sels(s1: selector, s2: selector) -> selector {
 
 type binders =
     {real_binders: hashmap[ident, selector],
-     mutable literal_ast_matchers: selector[]};
+     mutable literal_ast_matchers: [selector]};
 type bindings = hashmap[ident, arb_depth[matchable]];
 
 fn acumm_bindings(cx: &ext_ctxt, b_dest: &bindings, b_src: &bindings) { }
@@ -272,8 +272,8 @@ iter free_vars(b: &bindings, e: @expr) -> ident {
 
 /* handle sequences (anywhere in the AST) of exprs, either real or ...ed */
 fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable vec[uint],
-                    recur: fn(&@expr) -> @expr , exprs: (@expr)[])
-    -> (@expr)[] {
+                    recur: fn(&@expr) -> @expr , exprs: [@expr])
+    -> [@expr] {
     alt elts_to_ell(cx, exprs) {
       {fixed: fixed, rep: repeat_me_maybe} {
         let res = ivec::map(recur, fixed);
@@ -580,7 +580,7 @@ fn p_t_s_r_mac(cx: &ext_ctxt, mac: &ast::mac, s: &selector, b: &binders) {
 
 /* TODO: move this to vec.rs */
 
-fn ivec_to_vec[T](v: &T[]) -> vec[T] {
+fn ivec_to_vec[T](v: &[T]) -> vec[T] {
     let rs: vec[T] = vec::alloc[T](ivec::len(v));
     for ve: T  in v { rs += [ve]; }
     ret rs;
@@ -614,7 +614,7 @@ fn p_t_s_r_ellipses(cx: &ext_ctxt, repeat_me: @expr, offset: uint,
               compose_sels(s, bind select(cx, repeat_me, offset, _)), b);
 }
 
-fn p_t_s_r_actual_vector(cx: &ext_ctxt, elts: (@expr)[], repeat_after: bool,
+fn p_t_s_r_actual_vector(cx: &ext_ctxt, elts: [@expr], repeat_after: bool,
                          s: &selector, b: &binders) {
     fn len_select(cx: &ext_ctxt, m: &matchable, repeat_after: bool, len: uint)
         -> match_result {
@@ -662,7 +662,7 @@ fn p_t_s_r_actual_vector(cx: &ext_ctxt, elts: (@expr)[], repeat_after: bool,
 
 fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
                      body: option::t[str]) -> base::macro_def {
-    let args: (@ast::expr)[] = alt arg.node {
+    let args: [@ast::expr] = alt arg.node {
       ast::expr_vec(elts, _, _) { elts }
       _ {
         cx.span_fatal(sp, "#macro requires arguments of the form `[...]`.")
@@ -670,7 +670,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
     };
 
     let macro_name: option::t[str] = none;
-    let clauses: clause[] = ~[];
+    let clauses: [clause] = ~[];
     for arg: @expr  in args {
         alt arg.node {
           expr_vec(elts, mut, seq_kind) {
@@ -727,7 +727,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
          ext: normal(ext)};
 
     fn generic_extension(cx: &ext_ctxt, sp: span, arg: @expr,
-                         body: option::t[str], clauses: clause[]) -> @expr {
+                         body: option::t[str], clauses: [clause]) -> @expr {
         for c: clause  in clauses {
             alt use_selectors_to_bind(c.params, arg) {
               some(bindings) {
diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs
index af0673da358..d5d9898653d 100644
--- a/src/comp/syntax/fold.rs
+++ b/src/comp/syntax/fold.rs
@@ -43,7 +43,7 @@ type ast_fold_precursor =
      fold_ident: fn(&ident, ast_fold) -> ident ,
      fold_path: fn(&path_, ast_fold) -> path_ ,
      fold_local: fn(&local_, ast_fold) -> local_ ,
-     map_exprs: fn(fn(&@expr) -> @expr , (@expr)[]) -> (@expr)[] };
+     map_exprs: fn(fn(&@expr) -> @expr , [@expr]) -> [@expr] };
 
 type a_f =
     {fold_crate: fn(&crate) -> crate ,
@@ -68,7 +68,7 @@ type a_f =
      fold_ident: fn(&ident) -> ident ,
      fold_path: fn(&path) -> path ,
      fold_local: fn(&@local) -> @local ,
-     map_exprs: fn(fn(&@expr) -> @expr , (@expr)[]) -> (@expr)[] };
+     map_exprs: fn(fn(&@expr) -> @expr , [@expr]) -> [@expr] };
 
 //fn nf_dummy[T](&T node) -> T { fail; }
 fn nf_crate_dummy(c: &crate) -> crate { fail; }
@@ -501,7 +501,7 @@ fn noop_fold_local(l: &local_, fld: ast_fold) -> local_ {
 
 /* temporarily eta-expand because of a compiler bug with using `fn[T]` as a
    value */
-fn noop_map_exprs(f: fn(&@expr) -> @expr , es: (@expr)[]) -> (@expr)[] {
+fn noop_map_exprs(f: fn(&@expr) -> @expr , es: [@expr]) -> [@expr] {
     ret ivec::map(f, es);
 }
 
diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs
index c5bf0f2586b..6dd06a97901 100644
--- a/src/comp/syntax/parse/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -19,32 +19,32 @@ tag eval_mode { mode_depend; mode_parse; }
 type ctx =
     @{p: parser,
       mode: eval_mode,
-      mutable deps: str[],
+      mutable deps: [str],
       sess: parser::parse_sess,
       mutable chpos: uint,
       mutable byte_pos: uint,
       cfg: ast::crate_cfg};
 
-fn eval_crate_directives(cx: ctx, cdirs: &(@ast::crate_directive)[],
+fn eval_crate_directives(cx: ctx, cdirs: &[@ast::crate_directive],
                          prefix: str,
-                         view_items: &mutable (@ast::view_item)[],
-                         items: &mutable (@ast::item)[]) {
+                         view_items: &mutable [@ast::view_item],
+                         items: &mutable [@ast::item]) {
     for sub_cdir: @ast::crate_directive  in cdirs {
         eval_crate_directive(cx, sub_cdir, prefix, view_items, items);
     }
 }
 
-fn eval_crate_directives_to_mod(cx: ctx, cdirs: &(@ast::crate_directive)[],
+fn eval_crate_directives_to_mod(cx: ctx, cdirs: &[@ast::crate_directive],
                                 prefix: str) -> ast::_mod {
-    let view_items: (@ast::view_item)[] = ~[];
-    let items: (@ast::item)[] = ~[];
+    let view_items: [@ast::view_item] = ~[];
+    let items: [@ast::item] = ~[];
     eval_crate_directives(cx, cdirs, prefix, view_items, items);
     ret {view_items: view_items, items: items};
 }
 
 fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
-                        view_items: &mutable (@ast::view_item)[],
-                        items: &mutable (@ast::item)[]) {
+                        view_items: &mutable [@ast::view_item],
+                        items: &mutable [@ast::item]) {
     alt cdir.node {
       ast::cdir_src_mod(id, file_opt, attrs) {
         let file_path = id + ".rs";
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index bf91dfc8a9c..40c0d8b4935 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -37,7 +37,7 @@ fn new_reader(cm: &codemap::codemap, src: str, filemap: codemap::filemap,
                mutable pos: uint,
                mutable ch: char,
                mutable chpos: uint,
-               mutable strs: str[],
+               mutable strs: [str],
                fm: codemap::filemap,
                itr: @interner::interner[str]) {
         fn is_eof() -> bool { ret ch == -1 as char; }
@@ -81,7 +81,7 @@ fn new_reader(cm: &codemap::codemap, src: str, filemap: codemap::filemap,
             codemap::emit_error(some({lo: chpos, hi: chpos}), m, cm);
         }
     }
-    let strs: str[] = ~[];
+    let strs: [str] = ~[];
     let rd =
         reader(cm, src, str::byte_len(src), 0u, 0u, -1 as char,
                filemap.start_pos.ch, strs, filemap, itr);
@@ -550,7 +550,7 @@ tag cmnt_style {
     blank_line; // Just a manual blank line "\n\n", for layout
 }
 
-type cmnt = {style: cmnt_style, lines: str[], pos: uint};
+type cmnt = {style: cmnt_style, lines: [str], pos: uint};
 
 fn read_to_eol(rdr: &reader) -> str {
     let val = "";
@@ -578,14 +578,14 @@ fn consume_non_eol_whitespace(rdr: &reader) {
     }
 }
 
-fn push_blank_line_comment(rdr: &reader, comments: &mutable cmnt[]) {
+fn push_blank_line_comment(rdr: &reader, comments: &mutable [cmnt]) {
     log ">>> blank-line comment";
-    let v: str[] = ~[];
+    let v: [str] = ~[];
     comments += ~[{style: blank_line, lines: v, pos: rdr.get_chpos()}];
 }
 
 fn consume_whitespace_counting_blank_lines(rdr: &reader,
-                                           comments: &mutable cmnt[]) {
+                                           comments: &mutable [cmnt]) {
     while is_whitespace(rdr.curr()) && !rdr.is_eof() {
         if rdr.get_col() == 0u && rdr.curr() == '\n' {
             push_blank_line_comment(rdr, comments);
@@ -597,7 +597,7 @@ fn consume_whitespace_counting_blank_lines(rdr: &reader,
 fn read_line_comments(rdr: &reader, code_to_the_left: bool) -> cmnt {
     log ">>> line comments";
     let p = rdr.get_chpos();
-    let lines: str[] = ~[];
+    let lines: [str] = ~[];
     while rdr.curr() == '/' && rdr.next() == '/' {
         let line = read_one_line_comment(rdr);
         log line;
@@ -619,7 +619,7 @@ fn all_whitespace(s: &str, begin: uint, end: uint) -> bool {
     ret true;
 }
 
-fn trim_whitespace_prefix_and_push_line(lines: &mutable str[], s: &str,
+fn trim_whitespace_prefix_and_push_line(lines: &mutable [str], s: &str,
                                         col: uint) {
     let s1;
     if all_whitespace(s, 0u, col) {
@@ -634,7 +634,7 @@ fn trim_whitespace_prefix_and_push_line(lines: &mutable str[], s: &str,
 fn read_block_comment(rdr: &reader, code_to_the_left: bool) -> cmnt {
     log ">>> block comment";
     let p = rdr.get_chpos();
-    let lines: str[] = ~[];
+    let lines: [str] = ~[];
     let col: uint = rdr.get_col();
     rdr.bump();
     rdr.bump();
@@ -682,7 +682,7 @@ fn peeking_at_comment(rdr: &reader) -> bool {
 }
 
 fn consume_comment(rdr: &reader, code_to_the_left: bool,
-                   comments: &mutable cmnt[]) {
+                   comments: &mutable [cmnt]) {
     log ">>> consume comment";
     if rdr.curr() == '/' && rdr.next() == '/' {
         comments += ~[read_line_comments(rdr, code_to_the_left)];
@@ -710,12 +710,12 @@ type lit = {lit: str, pos: uint};
 
 fn gather_comments_and_literals(cm: &codemap::codemap, path: str,
                                 srdr: ioivec::reader) ->
-   {cmnts: cmnt[], lits: lit[]} {
+   {cmnts: [cmnt], lits: [lit]} {
     let src = str::unsafe_from_bytes_ivec(srdr.read_whole_stream());
     let itr = @interner::mk[str](str::hash, str::eq);
     let rdr = new_reader(cm, src, codemap::new_filemap(path, 0u, 0u), itr);
-    let comments: cmnt[] = ~[];
-    let literals: lit[] = ~[];
+    let comments: [cmnt] = ~[];
+    let literals: [lit] = ~[];
     let first_read: bool = true;
     while !rdr.is_eof() {
         while true {
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 7f4d5b175d3..9bcf6d5aa84 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -47,7 +47,7 @@ type parser =
         fn get_hi_pos() -> uint ;
         fn get_last_lo_pos() -> uint ;
         fn get_last_hi_pos() -> uint ;
-        fn get_prec_table() -> @op_spec[] ;
+        fn get_prec_table() -> @[op_spec] ;
         fn get_str(token::str_num) -> str ;
         fn get_reader() -> lexer::reader ;
         fn get_filemap() -> codemap::filemap ;
@@ -79,10 +79,10 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
                      mutable tok: token::token,
                      mutable tok_span: span,
                      mutable last_tok_span: span,
-                     mutable buffer: {tok: token::token, span: span}[],
+                     mutable buffer: [{tok: token::token, span: span}],
                      mutable restr: restriction,
                      rdr: lexer::reader,
-                     precs: @op_spec[],
+                     precs: @[op_spec],
                      bad_words: hashmap[str, ()]) {
         fn peek() -> token::token { ret tok; }
         fn bump() {
@@ -121,7 +121,7 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
         fn get_last_hi_pos() -> uint { ret last_tok_span.hi; }
         fn get_file_type() -> file_type { ret ftype; }
         fn get_cfg() -> ast::crate_cfg { ret cfg; }
-        fn get_prec_table() -> @op_spec[] { ret precs; }
+        fn get_prec_table() -> @[op_spec] { ret precs; }
         fn get_str(i: token::str_num) -> str {
             ret interner::get(*rdr.get_interner(), i);
         }
@@ -283,7 +283,7 @@ fn parse_ty_fn(proto: ast::proto, p: &parser, lo: uint) -> ast::ty_ {
                   parse_fn_input_ty, p);
     // FIXME: there's no syntax for this right now anyway
     //  auto constrs = parse_constrs(~[], p);
-    let constrs: (@ast::constr)[] = ~[];
+    let constrs: [@ast::constr] = ~[];
     let output: @ast::ty;
     let cf = ast::return;
     if p.peek() == token::RARROW {
@@ -354,7 +354,7 @@ fn parse_ty_field(p: &parser) -> ast::ty_field {
 
 // if i is the jth ident in args, return j
 // otherwise, fail
-fn ident_index(p: &parser, args: &ast::arg[], i: &ast::ident) -> uint {
+fn ident_index(p: &parser, args: &[ast::arg], i: &ast::ident) -> uint {
     let j = 0u;
     for a: ast::arg  in args { if a.ident == i { ret j; } j += 1u; }
     p.fatal("Unbound variable " + i + " in constraint arg");
@@ -374,7 +374,7 @@ fn parse_type_constr_arg(p: &parser) -> @ast::ty_constr_arg {
     ret @{node: carg, span: sp};
 }
 
-fn parse_constr_arg(args: &ast::arg[], p: &parser) -> @ast::constr_arg {
+fn parse_constr_arg(args: &[ast::arg], p: &parser) -> @ast::constr_arg {
     let sp = p.get_span();
     let carg = ast::carg_base;
     if p.peek() == token::BINOP(token::STAR) {
@@ -386,11 +386,11 @@ fn parse_constr_arg(args: &ast::arg[], p: &parser) -> @ast::constr_arg {
     ret @{node: carg, span: sp};
 }
 
-fn parse_ty_constr(fn_args: &ast::arg[], p: &parser) -> @ast::constr {
+fn parse_ty_constr(fn_args: &[ast::arg], p: &parser) -> @ast::constr {
     let lo = p.get_lo_pos();
     let path = parse_path(p);
     let pf = bind parse_constr_arg(fn_args, _);
-    let args: {node: (@ast::constr_arg)[], span: span} =
+    let args: {node: [@ast::constr_arg], span: span} =
         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), pf, p);
     ret @spanned(lo, args.span.hi,
                  {path: path, args: args.node, id: p.get_id()});
@@ -399,7 +399,7 @@ fn parse_ty_constr(fn_args: &ast::arg[], p: &parser) -> @ast::constr {
 fn parse_constr_in_type(p: &parser) -> @ast::ty_constr {
     let lo = p.get_lo_pos();
     let path = parse_path(p);
-    let args: (@ast::ty_constr_arg)[] =
+    let args: [@ast::ty_constr_arg] =
         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                   parse_type_constr_arg, p).node;
     let hi = p.get_lo_pos();
@@ -409,8 +409,8 @@ fn parse_constr_in_type(p: &parser) -> @ast::ty_constr {
 
 
 fn parse_constrs[T](pser: fn(&parser) -> @ast::constr_general[T] , p: &parser)
-   -> (@ast::constr_general[T])[] {
-    let constrs: (@ast::constr_general[T])[] = ~[];
+   -> [@ast::constr_general[T]] {
+    let constrs: [@ast::constr_general[T]] = ~[];
     while true {
         let constr = pser(p);
         constrs += ~[constr];
@@ -419,13 +419,14 @@ fn parse_constrs[T](pser: fn(&parser) -> @ast::constr_general[T] , p: &parser)
     constrs
 }
 
-fn parse_type_constraints(p: &parser) -> (@ast::ty_constr)[] {
+fn parse_type_constraints(p: &parser) -> [@ast::ty_constr] {
     ret parse_constrs(parse_constr_in_type, p);
 }
 
 fn parse_ty_postfix(orig_t: ast::ty_, p: &parser) -> @ast::ty {
     let lo = p.get_lo_pos();
     if p.peek() == token::LBRACKET {
+        // This is explicit type parameter instantiation.
         p.bump();
 
         let mut;
@@ -610,16 +611,16 @@ fn parse_arg(p: &parser) -> ast::arg {
 }
 
 fn parse_seq_to_end[T](ket: token::token, sep: option::t[token::token],
-                       f: fn(&parser) -> T , p: &parser) -> T[] {
+                       f: fn(&parser) -> T , p: &parser) -> [T] {
     let val = parse_seq_to_before_end(ket, sep, f, p);
     p.bump();
     ret val;
 }
 
 fn parse_seq_to_before_end[T](ket: token::token, sep: option::t[token::token],
-                              f: fn(&parser) -> T , p: &parser) -> T[] {
+                              f: fn(&parser) -> T , p: &parser) -> [T] {
     let first: bool = true;
-    let v: T[] = ~[];
+    let v: [T] = ~[];
     while p.peek() != ket {
         alt sep {
           some(t) { if first { first = false; } else { expect(p, t); } }
@@ -633,7 +634,7 @@ fn parse_seq_to_before_end[T](ket: token::token, sep: option::t[token::token],
 
 fn parse_seq[T](bra: token::token, ket: token::token,
                 sep: option::t[token::token], f: fn(&parser) -> T ,
-                p: &parser) -> spanned[T[]] {
+                p: &parser) -> spanned[[T]] {
     let lo = p.get_lo_pos();
     expect(p, bra);
     let result = parse_seq_to_before_end[T](ket, sep, f, p);
@@ -701,7 +702,7 @@ fn parse_path(p: &parser) -> ast::path {
         p.bump();
     } else { global = false; }
 
-    let ids: ast::ident[] = ~[];
+    let ids: [ast::ident] = ~[];
     while true {
         alt p.peek() {
           token::IDENT(i, _) {
@@ -865,14 +866,14 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
         // Anonymous object
 
         // Only make people type () if they're actually adding new fields
-        let fields: option::t[ast::anon_obj_field[]] = none;
+        let fields: option::t[[ast::anon_obj_field]] = none;
         if p.peek() == token::LPAREN {
             p.bump();
             fields =
                 some(parse_seq_to_end(token::RPAREN, some(token::COMMA),
                                       parse_anon_obj_field, p));
         }
-        let meths: (@ast::method)[] = ~[];
+        let meths: [@ast::method] = ~[];
         let inner_obj: option::t[@ast::expr] = none;
         expect(p, token::LBRACE);
         while p.peek() != token::RBRACE {
@@ -1154,7 +1155,7 @@ type op_spec = {tok: token::token, op: ast::binop, prec: int};
 
 
 // FIXME make this a const, don't store it in parser state
-fn prec_table() -> @op_spec[] {
+fn prec_table() -> @[op_spec] {
     ret @~[{tok: token::BINOP(token::STAR), op: ast::mul, prec: 11},
            {tok: token::BINOP(token::SLASH), op: ast::div, prec: 11},
            {tok: token::BINOP(token::PERCENT), op: ast::rem, prec: 11},
@@ -1341,7 +1342,7 @@ fn parse_alt_expr(p: &parser) -> @ast::expr {
     let lo = p.get_last_lo_pos();
     let discriminant = parse_expr(p);
     expect(p, token::LBRACE);
-    let arms: ast::arm[] = ~[];
+    let arms: [ast::arm] = ~[];
     while p.peek() != token::RBRACE {
         let pats = parse_pats(p);
         let blk = parse_block(p);
@@ -1403,7 +1404,7 @@ fn parse_initializer(p: &parser) -> option::t[ast::initializer] {
     }
 }
 
-fn parse_pats(p: &parser) -> (@ast::pat)[] {
+fn parse_pats(p: &parser) -> [@ast::pat] {
     let pats = ~[];
     while true {
         pats += ~[parse_pat(p)];
@@ -1479,7 +1480,7 @@ fn parse_pat(p: &parser) -> @ast::pat {
         } else {
             let tag_path = parse_path_and_ty_param_substs(p);
             hi = tag_path.span.hi;
-            let args: (@ast::pat)[];
+            let args: [@ast::pat];
             alt p.peek() {
               token::LPAREN. {
                 let a =
@@ -1650,7 +1651,7 @@ fn parse_block(p: &parser) -> ast::blk {
 
 // some blocks start with "#{"...
 fn parse_block_tail(p: &parser, lo: uint) -> ast::blk {
-    let stmts: (@ast::stmt)[] = ~[];
+    let stmts: [@ast::stmt] = ~[];
     let expr: option::t[@ast::expr] = none;
     while p.peek() != token::RBRACE {
         alt p.peek() {
@@ -1703,8 +1704,8 @@ fn parse_ty_param(p: &parser) -> ast::ty_param {
     ret {ident: parse_ident(p), kind: k};
 }
 
-fn parse_ty_params(p: &parser) -> ast::ty_param[] {
-    let ty_params: ast::ty_param[] = ~[];
+fn parse_ty_params(p: &parser) -> [ast::ty_param] {
+    let ty_params: [ast::ty_param] = ~[];
     if p.peek() == token::LBRACKET {
         ty_params =
             parse_seq(token::LBRACKET, token::RBRACKET, some(token::COMMA),
@@ -1715,7 +1716,7 @@ fn parse_ty_params(p: &parser) -> ast::ty_param[] {
 
 fn parse_fn_decl(p: &parser, purity: ast::purity, il: ast::inlineness)
         -> ast::fn_decl {
-    let inputs: ast::spanned[ast::arg[]] =
+    let inputs: ast::spanned[[ast::arg]] =
         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_arg,
                   p);
     let rslt: ty_or_bang;
@@ -1760,14 +1761,14 @@ fn parse_fn(p: &parser, proto: ast::proto, purity: ast::purity,
     ret {decl: decl, proto: proto, body: body};
 }
 
-fn parse_fn_header(p: &parser) -> {ident: ast::ident, tps: ast::ty_param[]} {
+fn parse_fn_header(p: &parser) -> {ident: ast::ident, tps: [ast::ty_param]} {
     let id = parse_value_ident(p);
     let ty_params = parse_ty_params(p);
     ret {ident: id, tps: ty_params};
 }
 
 fn mk_item(p: &parser, lo: uint, hi: uint, ident: &ast::ident,
-           node: &ast::item_, attrs: &ast::attribute[]) -> @ast::item {
+           node: &ast::item_, attrs: &[ast::attribute]) -> @ast::item {
     ret @{ident: ident,
           attrs: attrs,
           id: p.get_id(),
@@ -1776,7 +1777,7 @@ fn mk_item(p: &parser, lo: uint, hi: uint, ident: &ast::ident,
 }
 
 fn parse_item_fn_or_iter(p: &parser, purity: ast::purity, proto: ast::proto,
-                         attrs: &ast::attribute[], il: ast::inlineness)
+                         attrs: &[ast::attribute], il: ast::inlineness)
         -> @ast::item {
     let lo = p.get_last_lo_pos();
     let t = parse_fn_header(p);
@@ -1812,15 +1813,15 @@ fn parse_method(p: &parser) -> @ast::method {
     ret @spanned(lo, f.body.span.hi, meth);
 }
 
-fn parse_item_obj(p: &parser, attrs: &ast::attribute[]) ->
+fn parse_item_obj(p: &parser, attrs: &[ast::attribute]) ->
    @ast::item {
     let lo = p.get_last_lo_pos();
     let ident = parse_value_ident(p);
     let ty_params = parse_ty_params(p);
-    let fields: ast::spanned[ast::obj_field[]] =
+    let fields: ast::spanned[[ast::obj_field]] =
         parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                   parse_obj_field, p);
-    let meths: (@ast::method)[] = ~[];
+    let meths: [@ast::method] = ~[];
     expect(p, token::LBRACE);
     while p.peek() != token::RBRACE {
         meths += ~[parse_method(p)];
@@ -1832,7 +1833,7 @@ fn parse_item_obj(p: &parser, attrs: &ast::attribute[]) ->
                 attrs);
 }
 
-fn parse_item_res(p: &parser, attrs: &ast::attribute[]) ->
+fn parse_item_res(p: &parser, attrs: &[ast::attribute]) ->
    @ast::item {
     let lo = p.get_last_lo_pos();
     let ident = parse_value_ident(p);
@@ -1860,11 +1861,11 @@ fn parse_item_res(p: &parser, attrs: &ast::attribute[]) ->
 }
 
 fn parse_mod_items(p: &parser, term: token::token,
-                   first_item_attrs: &ast::attribute[]) -> ast::_mod {
+                   first_item_attrs: &[ast::attribute]) -> ast::_mod {
     // Shouldn't be any view items since we've already parsed an item attr
     let view_items =
         if ivec::len(first_item_attrs) == 0u { parse_view(p) } else { ~[] };
-    let items: (@ast::item)[] = ~[];
+    let items: [@ast::item] = ~[];
     let initial_attrs = first_item_attrs;
     while p.peek() != term {
         let attrs = initial_attrs + parse_outer_attributes(p);
@@ -1880,7 +1881,7 @@ fn parse_mod_items(p: &parser, term: token::token,
     ret {view_items: view_items, items: items};
 }
 
-fn parse_item_const(p: &parser, attrs: &ast::attribute[]) -> @ast::item {
+fn parse_item_const(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
     let lo = p.get_last_lo_pos();
     let id = parse_value_ident(p);
     expect(p, token::COLON);
@@ -1892,7 +1893,7 @@ fn parse_item_const(p: &parser, attrs: &ast::attribute[]) -> @ast::item {
     ret mk_item(p, lo, hi, id, ast::item_const(ty, e), attrs);
 }
 
-fn parse_item_mod(p: &parser, attrs: &ast::attribute[]) -> @ast::item {
+fn parse_item_mod(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
     let lo = p.get_last_lo_pos();
     let id = parse_ident(p);
     expect(p, token::LBRACE);
@@ -1904,7 +1905,7 @@ fn parse_item_mod(p: &parser, attrs: &ast::attribute[]) -> @ast::item {
     ret mk_item(p, lo, hi, id, ast::item_mod(m), attrs + inner_attrs.inner);
 }
 
-fn parse_item_native_type(p: &parser, attrs: &ast::attribute[]) ->
+fn parse_item_native_type(p: &parser, attrs: &[ast::attribute]) ->
    @ast::native_item {
     let t = parse_type_decl(p);
     let hi = p.get_hi_pos();
@@ -1916,7 +1917,7 @@ fn parse_item_native_type(p: &parser, attrs: &ast::attribute[]) ->
           span: {lo: t.lo, hi: hi}};
 }
 
-fn parse_item_native_fn(p: &parser, attrs: &ast::attribute[]) ->
+fn parse_item_native_fn(p: &parser, attrs: &[ast::attribute]) ->
    @ast::native_item {
     let lo = p.get_last_lo_pos();
     let t = parse_fn_header(p);
@@ -1932,7 +1933,7 @@ fn parse_item_native_fn(p: &parser, attrs: &ast::attribute[]) ->
           span: {lo: lo, hi: hi}};
 }
 
-fn parse_native_item(p: &parser, attrs: &ast::attribute[]) ->
+fn parse_native_item(p: &parser, attrs: &[ast::attribute]) ->
    @ast::native_item {
     if eat_word(p, "type") {
         ret parse_item_native_type(p, attrs);
@@ -1942,14 +1943,14 @@ fn parse_native_item(p: &parser, attrs: &ast::attribute[]) ->
 }
 
 fn parse_native_mod_items(p: &parser, native_name: &str, abi: ast::native_abi,
-                          first_item_attrs: &ast::attribute[])
+                          first_item_attrs: &[ast::attribute])
     -> ast::native_mod {
     // Shouldn't be any view items since we've already parsed an item attr
     let view_items =
         if ivec::len(first_item_attrs) == 0u {
             parse_native_view(p)
         } else { ~[] };
-    let items: (@ast::native_item)[] = ~[];
+    let items: [@ast::native_item] = ~[];
     let initial_attrs = first_item_attrs;
     while p.peek() != token::RBRACE {
         let attrs = initial_attrs + parse_outer_attributes(p);
@@ -1962,7 +1963,7 @@ fn parse_native_mod_items(p: &parser, native_name: &str, abi: ast::native_abi,
          items: items};
 }
 
-fn parse_item_native_mod(p: &parser, attrs: &ast::attribute[]) -> @ast::item {
+fn parse_item_native_mod(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
     let lo = p.get_last_lo_pos();
     let abi = ast::native_abi_cdecl;
     if !is_word(p, "mod") {
@@ -2002,7 +2003,7 @@ fn parse_type_decl(p: &parser) -> {lo: uint, ident: ast::ident} {
     ret {lo: lo, ident: id};
 }
 
-fn parse_item_type(p: &parser, attrs: &ast::attribute[]) -> @ast::item {
+fn parse_item_type(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
     let t = parse_type_decl(p);
     let tps = parse_ty_params(p);
     expect(p, token::EQ);
@@ -2012,11 +2013,11 @@ fn parse_item_type(p: &parser, attrs: &ast::attribute[]) -> @ast::item {
     ret mk_item(p, t.lo, hi, t.ident, ast::item_ty(ty, tps), attrs);
 }
 
-fn parse_item_tag(p: &parser, attrs: &ast::attribute[]) -> @ast::item {
+fn parse_item_tag(p: &parser, attrs: &[ast::attribute]) -> @ast::item {
     let lo = p.get_last_lo_pos();
     let id = parse_ident(p);
     let ty_params = parse_ty_params(p);
-    let variants: ast::variant[] = ~[];
+    let variants: [ast::variant] = ~[];
     // Newtype syntax
     if p.peek() == token::EQ {
         if p.get_bad_expr_words().contains_key(id) {
@@ -2041,7 +2042,7 @@ fn parse_item_tag(p: &parser, attrs: &ast::attribute[]) -> @ast::item {
             check_bad_word(p);
             let vlo = p.get_lo_pos();
             p.bump();
-            let args: ast::variant_arg[] = ~[];
+            let args: [ast::variant_arg] = ~[];
             let vhi = p.get_hi_pos();
             alt p.peek() {
               token::LPAREN. {
@@ -2078,7 +2079,7 @@ fn parse_auth(p: &parser) -> ast::_auth {
     } else { unexpected(p, p.peek()); }
 }
 
-fn parse_item(p: &parser, attrs: &ast::attribute[]) -> option::t[@ast::item] {
+fn parse_item(p: &parser, attrs: &[ast::attribute]) -> option::t[@ast::item] {
     if eat_word(p, "const") {
         ret some(parse_item_const(p, attrs));
     } else if (eat_word(p, "inline")) {
@@ -2114,7 +2115,7 @@ fn parse_item(p: &parser, attrs: &ast::attribute[]) -> option::t[@ast::item] {
 
 // A type to distingush between the parsing of item attributes or syntax
 // extensions, which both begin with token.POUND
-type attr_or_ext = option::t[either::t[ast::attribute[], @ast::expr]];
+type attr_or_ext = option::t[either::t[[ast::attribute], @ast::expr]];
 
 fn parse_outer_attrs_or_ext(p: &parser) -> attr_or_ext {
     if p.peek() == token::POUND {
@@ -2130,8 +2131,8 @@ fn parse_outer_attrs_or_ext(p: &parser) -> attr_or_ext {
 }
 
 // Parse attributes that appear before an item
-fn parse_outer_attributes(p: &parser) -> ast::attribute[] {
-    let attrs: ast::attribute[] = ~[];
+fn parse_outer_attributes(p: &parser) -> [ast::attribute] {
+    let attrs: [ast::attribute] = ~[];
     while p.peek() == token::POUND {
         attrs += ~[parse_attribute(p, ast::attr_outer)];
     }
@@ -2160,9 +2161,9 @@ fn parse_attribute_naked(p: &parser, style: ast::attr_style, lo: uint) ->
 // of the containing item or an outer attribute of the first contained item
 // until we see the semi).
 fn parse_inner_attrs_and_next(p: &parser) ->
-   {inner: ast::attribute[], next: ast::attribute[]} {
-    let inner_attrs: ast::attribute[] = ~[];
-    let next_outer_attrs: ast::attribute[] = ~[];
+   {inner: [ast::attribute], next: [ast::attribute]} {
+    let inner_attrs: [ast::attribute] = ~[];
+    let next_outer_attrs: [ast::attribute] = ~[];
     while p.peek() == token::POUND {
         let attr = parse_attribute(p, ast::attr_inner);
         if p.peek() == token::SEMI {
@@ -2202,12 +2203,12 @@ fn parse_meta_item(p: &parser) -> @ast::meta_item {
     }
 }
 
-fn parse_meta_seq(p: &parser) -> (@ast::meta_item)[] {
+fn parse_meta_seq(p: &parser) -> [@ast::meta_item] {
     ret parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
                   parse_meta_item, p).node;
 }
 
-fn parse_optional_meta(p: &parser) -> (@ast::meta_item)[] {
+fn parse_optional_meta(p: &parser) -> [@ast::meta_item] {
     alt p.peek() { token::LPAREN. { ret parse_meta_seq(p); } _ { ret ~[]; } }
 }
 
@@ -2220,7 +2221,7 @@ fn parse_use(p: &parser) -> ast::view_item_ {
 fn parse_rest_import_name(p: &parser, first: ast::ident,
                           def_ident: option::t[ast::ident]) ->
    ast::view_item_ {
-    let identifiers: ast::ident[] = ~[first];
+    let identifiers: [ast::ident] = ~[first];
     let glob: bool = false;
     while true {
         alt p.peek() {
@@ -2315,14 +2316,14 @@ fn is_view_item(p: &parser) -> bool {
     }
 }
 
-fn parse_view(p: &parser) -> (@ast::view_item)[] {
-    let items: (@ast::view_item)[] = ~[];
+fn parse_view(p: &parser) -> [@ast::view_item] {
+    let items: [@ast::view_item] = ~[];
     while is_view_item(p) { items += ~[parse_view_item(p)]; }
     ret items;
 }
 
-fn parse_native_view(p: &parser) -> (@ast::view_item)[] {
-    let items: (@ast::view_item)[] = ~[];
+fn parse_native_view(p: &parser) -> [@ast::view_item] {
+    let items: [@ast::view_item] = ~[];
     while is_view_item(p) { items += ~[parse_view_item(p)]; }
     ret items;
 }
@@ -2370,7 +2371,7 @@ fn parse_str(p: &parser) -> ast::ident {
 // Each crate file is a sequence of directives.
 //
 // Each directive imperatively extends its environment with 0 or more items.
-fn parse_crate_directive(p: &parser, first_outer_attr: &ast::attribute[]) ->
+fn parse_crate_directive(p: &parser, first_outer_attr: &[ast::attribute]) ->
    ast::crate_directive {
 
     // Collect the next attributes
@@ -2425,8 +2426,8 @@ fn parse_crate_directive(p: &parser, first_outer_attr: &ast::attribute[]) ->
 }
 
 fn parse_crate_directives(p: &parser, term: token::token,
-                          first_outer_attr: &ast::attribute[]) ->
-   (@ast::crate_directive)[] {
+                          first_outer_attr: &[ast::attribute]) ->
+   [@ast::crate_directive] {
 
     // This is pretty ugly. If we have an outer attribute then we can't accept
     // seeing the terminator next, so if we do see it then fail the same way
@@ -2435,7 +2436,7 @@ fn parse_crate_directives(p: &parser, term: token::token,
         expect_word(p, "mod");
     }
 
-    let cdirs: (@ast::crate_directive)[] = ~[];
+    let cdirs: [@ast::crate_directive] = ~[];
     while p.peek() != term {
         let cdir = @parse_crate_directive(p, first_outer_attr);
         cdirs += ~[cdir];
@@ -2452,7 +2453,7 @@ fn parse_crate_from_crate_file(input: &str, cfg: &ast::crate_cfg,
     let crate_attrs = leading_attrs.inner;
     let first_cdir_attr = leading_attrs.next;
     let cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
-    let deps: str[] = ~[];
+    let deps: [str] = ~[];
     let cx =
         @{p: p,
           mode: eval::mode_parse,
diff --git a/src/comp/syntax/print/pp.rs b/src/comp/syntax/print/pp.rs
index b1f84782952..00b6c5f32bf 100644
--- a/src/comp/syntax/print/pp.rs
+++ b/src/comp/syntax/print/pp.rs
@@ -74,7 +74,7 @@ fn tok_str(t: token) -> str {
     }
 }
 
-fn buf_str(toks: &token[mutable ], szs: &int[mutable ], left: uint,
+fn buf_str(toks: &[mutable token], szs: &[mutable int], left: uint,
            right: uint, lim: uint) -> str {
     let n = ivec::len(toks);
     assert (n == ivec::len(szs));
@@ -104,10 +104,10 @@ fn mk_printer(out: ioivec::writer, linewidth: uint) -> printer {
 
     let n: uint = 3u * linewidth;
     log #fmt("mk_printer %u", linewidth);
-    let token: token[mutable ] = ivec::init_elt_mut(EOF, n);
-    let size: int[mutable ] = ivec::init_elt_mut(0, n);
-    let scan_stack: uint[mutable ] = ivec::init_elt_mut(0u, n);
-    let print_stack: print_stack_elt[] = ~[];
+    let token: [mutable token] = ivec::init_elt_mut(EOF, n);
+    let size: [mutable int] = ivec::init_elt_mut(0, n);
+    let scan_stack: [mutable uint] = ivec::init_elt_mut(0u, n);
+    let print_stack: [print_stack_elt] = ~[];
     ret printer(out, n, linewidth as int, // margin
                 linewidth as int, // space
                 0u, // left
@@ -208,10 +208,10 @@ obj printer(out: ioivec::writer,
 
             mutable right: uint, // index of right side of input stream
 
-            mutable token: token[mutable ],
+            mutable token: [mutable token],
 
             // ring-buffr stream goes through
-            mutable size: int[mutable ], // ring-buffer of calculated sizes
+            mutable size: [mutable int], // ring-buffer of calculated sizes
 
             mutable left_total: int, // running size of stream "...left"
 
@@ -223,7 +223,7 @@ obj printer(out: ioivec::writer,
              // BEGIN (if there is any) on top of it. Stuff is flushed off the
              // bottom as it becomes irrelevant due to the primary ring-buffer
              // advancing.
-             mutable scan_stack: uint[mutable ],
+             mutable scan_stack: [mutable uint],
             mutable scan_stack_empty: bool, // top==bottom disambiguator
 
             mutable top: uint, // index of top of scan_stack
@@ -231,7 +231,7 @@ obj printer(out: ioivec::writer,
             mutable bottom: uint, // index of bottom of scan_stack
 
              // stack of blocks-in-progress being flushed by print
-            mutable print_stack: print_stack_elt[],
+            mutable print_stack: [print_stack_elt],
 
 
             // buffered indentation to avoid writing trailing whitespace
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index 1b34cd48304..c732039eaa1 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -41,11 +41,11 @@ fn no_ann() -> pp_ann {
 type ps =
     @{s: pp::printer,
       cm: option::t[codemap],
-      comments: option::t[lexer::cmnt[]],
-      literals: option::t[lexer::lit[]],
+      comments: option::t[[lexer::cmnt]],
+      literals: option::t[[lexer::lit]],
       mutable cur_cmnt: uint,
       mutable cur_lit: uint,
-      mutable boxes: pp::breaks[],
+      mutable boxes: [pp::breaks],
       ann: pp_ann};
 
 fn ibox(s: &ps, u: uint) { s.boxes += ~[pp::inconsistent]; pp::ibox(s.s, u); }
@@ -53,11 +53,11 @@ fn ibox(s: &ps, u: uint) { s.boxes += ~[pp::inconsistent]; pp::ibox(s.s, u); }
 fn end(s: &ps) { ivec::pop(s.boxes); pp::end(s.s); }
 
 fn rust_printer(writer: ioivec::writer) -> ps {
-    let boxes: pp::breaks[] = ~[];
+    let boxes: [pp::breaks] = ~[];
     ret @{s: pp::mk_printer(writer, default_columns),
           cm: none[codemap],
-          comments: none[lexer::cmnt[]],
-          literals: none[lexer::lit[]],
+          comments: none[[lexer::cmnt]],
+          literals: none[[lexer::lit]],
           mutable cur_cmnt: 0u,
           mutable cur_lit: 0u,
           mutable boxes: boxes,
@@ -74,7 +74,7 @@ const default_columns: uint = 78u;
 // copy forward.
 fn print_crate(cm: &codemap, crate: @ast::crate, filename: str,
                in: ioivec::reader, out: ioivec::writer, ann: &pp_ann) {
-    let boxes: pp::breaks[] = ~[];
+    let boxes: [pp::breaks] = ~[];
     let r = lexer::gather_comments_and_literals(cm, filename, in);
     let s =
         @{s: pp::mk_printer(out, default_columns),
@@ -102,7 +102,7 @@ fn item_to_str(i: &@ast::item) -> str { be to_str(i, print_item); }
 
 fn path_to_str(p: &ast::path) -> str { be to_str(p, print_path); }
 
-fn fun_to_str(f: &ast::_fn, name: str, params: &ast::ty_param[]) -> str {
+fn fun_to_str(f: &ast::_fn, name: str, params: &[ast::ty_param]) -> str {
     let writer = ioivec::string_writer();
     let s = rust_printer(writer.get_writer());
     print_fn(s, f.decl, f.proto, name, params, f.decl.constraints);
@@ -216,7 +216,7 @@ fn synth_comment(s: &ps, text: str) {
     word(s.s, "*/");
 }
 
-fn commasep[IN](s: &ps, b: breaks, elts: &IN[], op: fn(&ps, &IN) ) {
+fn commasep[IN](s: &ps, b: breaks, elts: &[IN], op: fn(&ps, &IN) ) {
     box(s, 0u, b);
     let first = true;
     for elt: IN  in elts {
@@ -227,7 +227,7 @@ fn commasep[IN](s: &ps, b: breaks, elts: &IN[], op: fn(&ps, &IN) ) {
 }
 
 
-fn commasep_cmnt[IN](s: &ps, b: breaks, elts: &IN[], op: fn(&ps, &IN) ,
+fn commasep_cmnt[IN](s: &ps, b: breaks, elts: &[IN], op: fn(&ps, &IN) ,
                      get_span: fn(&IN) -> codemap::span ) {
     box(s, 0u, b);
     let len = ivec::len[IN](elts);
@@ -246,12 +246,12 @@ fn commasep_cmnt[IN](s: &ps, b: breaks, elts: &IN[], op: fn(&ps, &IN) ,
     end(s);
 }
 
-fn commasep_exprs(s: &ps, b: breaks, exprs: &(@ast::expr)[]) {
+fn commasep_exprs(s: &ps, b: breaks, exprs: &[@ast::expr]) {
     fn expr_span(expr: &@ast::expr) -> codemap::span { ret expr.span; }
     commasep_cmnt(s, b, exprs, print_expr, expr_span);
 }
 
-fn print_mod(s: &ps, _mod: &ast::_mod, attrs: &ast::attribute[]) {
+fn print_mod(s: &ps, _mod: &ast::_mod, attrs: &[ast::attribute]) {
     print_inner_attributes(s, attrs);
     for vitem: @ast::view_item  in _mod.view_items {
         print_view_item(s, vitem);
@@ -260,7 +260,7 @@ fn print_mod(s: &ps, _mod: &ast::_mod, attrs: &ast::attribute[]) {
 }
 
 fn print_native_mod(s: &ps, nmod: &ast::native_mod,
-                    attrs: &ast::attribute[]) {
+                    attrs: &[ast::attribute]) {
     print_inner_attributes(s, attrs);
     for vitem: @ast::view_item  in nmod.view_items {
         print_view_item(s, vitem);
@@ -505,7 +505,7 @@ fn print_item(s: &ps, item: &@ast::item) {
         space(s.s);
         bopen(s);
         for meth: @ast::method  in _obj.methods {
-            let typarams: ast::ty_param[] = ~[];
+            let typarams: [ast::ty_param] = ~[];
             hardbreak_if_not_bol(s);
             maybe_print_comment(s, meth.span.lo);
             print_fn(s, meth.node.meth.decl, meth.node.meth.proto,
@@ -530,7 +530,7 @@ fn print_item(s: &ps, item: &@ast::item) {
     s.ann.post(ann_node);
 }
 
-fn print_outer_attributes(s: &ps, attrs: &ast::attribute[]) {
+fn print_outer_attributes(s: &ps, attrs: &[ast::attribute]) {
     let count = 0;
     for attr: ast::attribute  in attrs {
         alt attr.node.style {
@@ -541,7 +541,7 @@ fn print_outer_attributes(s: &ps, attrs: &ast::attribute[]) {
     if count > 0 { hardbreak_if_not_bol(s); }
 }
 
-fn print_inner_attributes(s: &ps, attrs: &ast::attribute[]) {
+fn print_inner_attributes(s: &ps, attrs: &[ast::attribute]) {
     let count = 0;
     for attr: ast::attribute  in attrs {
         alt attr.node.style {
@@ -1011,7 +1011,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
 
         // Methods
         for meth: @ast::method in anon_obj.methods {
-            let typarams: ast::ty_param[] = ~[];
+            let typarams: [ast::ty_param] = ~[];
             hardbreak_if_not_bol(s);
             maybe_print_comment(s, meth.span.lo);
             print_fn(s, meth.node.meth.decl, meth.node.meth.proto,
@@ -1145,7 +1145,7 @@ fn print_pat(s: &ps, pat: &@ast::pat) {
 }
 
 fn print_fn(s: &ps, decl: ast::fn_decl, proto: ast::proto, name: str,
-            typarams: &ast::ty_param[], constrs: (@ast::constr)[]) {
+            typarams: &[ast::ty_param], constrs: [@ast::constr]) {
     alt decl.purity {
       ast::impure_fn. { head(s, proto_to_str(proto)); }
       _ { head(s, "pred"); }
@@ -1156,7 +1156,7 @@ fn print_fn(s: &ps, decl: ast::fn_decl, proto: ast::proto, name: str,
 }
 
 fn print_fn_args_and_ret(s: &ps, decl: &ast::fn_decl,
-                        constrs: (@ast::constr)[]) {
+                        constrs: [@ast::constr]) {
     popen(s);
     fn print_arg(s: &ps, x: &ast::arg) {
         ibox(s, indent_unit);
@@ -1193,7 +1193,7 @@ fn print_kind(s: &ps, kind: ast::kind) {
     }
 }
 
-fn print_type_params(s: &ps, params: &ast::ty_param[]) {
+fn print_type_params(s: &ps, params: &[ast::ty_param]) {
     if ivec::len(params) > 0u {
         word(s.s, "[");
         fn printParam(s: &ps, param: &ast::ty_param) {
@@ -1308,8 +1308,8 @@ fn print_mt(s: &ps, mt: &ast::mt) {
 }
 
 fn print_ty_fn(s: &ps, proto: &ast::proto, id: &option::t[str],
-               inputs: &ast::ty_arg[], output: &@ast::ty,
-               cf: &ast::controlflow, constrs: &(@ast::constr)[]) {
+               inputs: &[ast::ty_arg], output: &@ast::ty,
+               cf: &ast::controlflow, constrs: &[@ast::constr]) {
     ibox(s, indent_unit);
     word(s.s, proto_to_str(proto));
     alt id { some(id) { word(s.s, " "); word(s.s, id); } _ { } }
@@ -1518,7 +1518,7 @@ fn next_comment(s: &ps) -> option::t[lexer::cmnt] {
 // Removing the aliases from the type of f in the next two functions
 // triggers memory corruption, but I haven't isolated the bug yet. FIXME
 fn constr_args_to_str[T](f: &fn(&T) -> str ,
-                         args: &(@ast::sp_constr_arg[T])[]) -> str {
+                         args: &[@ast::sp_constr_arg[T]]) -> str {
     let comma = false;
     let s = "(";
     for a: @ast::sp_constr_arg[T]  in args {
@@ -1549,7 +1549,7 @@ fn ast_ty_fn_constr_to_str(c: &@ast::constr) -> str {
 }
 
 // FIXME: fix repeated code
-fn ast_ty_fn_constrs_str(constrs: &(@ast::constr)[]) -> str {
+fn ast_ty_fn_constrs_str(constrs: &[@ast::constr]) -> str {
     let s = "";
     let colon = true;
     for c: @ast::constr  in constrs {
@@ -1571,7 +1571,7 @@ fn ast_fn_constr_to_str(decl: &ast::fn_decl, c: &@ast::constr) -> str {
 
 // FIXME: fix repeated code
 fn ast_fn_constrs_str(decl: &ast::fn_decl,
-                      constrs: &(@ast::constr)[]) -> str {
+                      constrs: &[@ast::constr]) -> str {
     let s = "";
     let colon = true;
     for c: @ast::constr  in constrs {
@@ -1596,7 +1596,7 @@ fn ty_constr_to_str(c: &@ast::ty_constr) -> str {
 }
 
 
-fn ast_ty_constrs_str(constrs: &(@ast::ty_constr)[]) -> str {
+fn ast_ty_constrs_str(constrs: &[@ast::ty_constr]) -> str {
     let s = "";
     let colon = true;
     for c: @ast::ty_constr  in constrs {
diff --git a/src/comp/syntax/util/interner.rs b/src/comp/syntax/util/interner.rs
index 7e7a9ca7107..7f95d0ef0e7 100644
--- a/src/comp/syntax/util/interner.rs
+++ b/src/comp/syntax/util/interner.rs
@@ -12,7 +12,7 @@ import std::option::some;
 
 type interner[T] =
     {map: hashmap[T, uint],
-     mutable vect: T[],
+     mutable vect: [T],
      hasher: hashfn[T],
      eqer: eqfn[T]};
 
diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs
index 673fa46d466..9c639b8c5c0 100644
--- a/src/comp/syntax/visit.rs
+++ b/src/comp/syntax/visit.rs
@@ -33,7 +33,7 @@ type visitor[E] =
       visit_ty: fn(&@ty, &E, &vt[E]) ,
       visit_constr: fn(&path, &span, node_id, &E, &vt[E]) ,
       visit_fn:
-          fn(&_fn, &ty_param[], &span, &fn_ident, node_id, &E, &vt[E]) };
+          fn(&_fn, &[ty_param], &span, &fn_ident, node_id, &E, &vt[E]) };
 
 fn default_visitor[E]() -> visitor[E] {
     ret @{visit_mod: bind visit_mod[E](_, _, _, _),
@@ -195,7 +195,7 @@ fn visit_fn_decl[E](fd: &fn_decl, e: &E, v: &vt[E]) {
     v.visit_ty(fd.output, e, v);
 }
 
-fn visit_fn[E](f: &_fn, tp: &ty_param[], sp: &span, i: &fn_ident, id: node_id,
+fn visit_fn[E](f: &_fn, tp: &[ty_param], sp: &span, i: &fn_ident, id: node_id,
                e: &E, v: &vt[E]) {
     visit_fn_decl(f.decl, e, v);
     v.visit_block(f.body, e, v);
@@ -227,7 +227,7 @@ fn visit_expr_opt[E](eo: option::t[@expr], e: &E, v: &vt[E]) {
     alt eo { none. { } some(ex) { v.visit_expr(ex, e, v); } }
 }
 
-fn visit_exprs[E](exprs: &(@expr)[], e: &E, v: &vt[E]) {
+fn visit_exprs[E](exprs: &[@expr], e: &E, v: &vt[E]) {
     for ex: @expr  in exprs { v.visit_expr(ex, e, v); }
 }
 
@@ -362,7 +362,7 @@ type simple_visitor =
       visit_expr: fn(&@expr) ,
       visit_ty: fn(&@ty) ,
       visit_constr: fn(&path, &span, node_id) ,
-      visit_fn: fn(&_fn, &ty_param[], &span, &fn_ident, node_id) };
+      visit_fn: fn(&_fn, &[ty_param], &span, &fn_ident, node_id) };
 
 fn default_simple_visitor() -> simple_visitor {
     ret @{visit_mod: fn (m: &_mod, sp: &span) { },
@@ -379,7 +379,7 @@ fn default_simple_visitor() -> simple_visitor {
           visit_ty: fn (t: &@ty) { },
           visit_constr: fn (p: &path, sp: &span, id: node_id) { },
           visit_fn:
-              fn (f: &_fn, tps: &ty_param[], sp: &span, ident: &fn_ident,
+              fn (f: &_fn, tps: &[ty_param], sp: &span, ident: &fn_ident,
                   id: node_id) {
               }};
 }
@@ -439,8 +439,8 @@ fn mk_simple_visitor(v: &simple_visitor) -> vt[()] {
         f(pt, sp, id);
         visit_constr(pt, sp, id, e, v);
     }
-    fn v_fn(f: fn(&_fn, &ty_param[], &span, &fn_ident, node_id) , ff: &_fn,
-            tps: &ty_param[], sp: &span, ident: &fn_ident, id: node_id,
+    fn v_fn(f: fn(&_fn, &[ty_param], &span, &fn_ident, node_id) , ff: &_fn,
+            tps: &[ty_param], sp: &span, ident: &fn_ident, id: node_id,
             e: &(), v: &vt[()]) {
         f(ff, tps, sp, ident, id);
         visit_fn(ff, tps, sp, ident, id, e, v);