---

yaml
---
r: 4739
b: refs/heads/master
c: 4abc471
h: refs/heads/master
i:
  4737: aa1a4b2
  4735: e82535e
v: v3

Author: erickt

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 4c9049c50c5c32f556eaefbcc50209ef8ee353d0
+refs/heads/master: 4abc471390d897e97e07eafcb723a8dcb59c520f

trunk/src/comp/driver/rustc.rs

@@ -110,7 +110,7 @@ fn parse_input_src(sess: session::session, cfg: &ast::crate_cfg,
     ret {crate: crate, src: src};
 }
 
-fn time[T](do_it: bool, what: str, thunk: fn() -> T ) -> T {
+fn time<T>(do_it: bool, what: str, thunk: fn() -> T ) -> T {
     if !do_it { ret thunk(); }
     let start = std::time::precise_time_s();
     let rv = thunk();

trunk/src/comp/front/attr.rs

@@ -189,7 +189,7 @@ fn require_unique_names(sess: &session::session,
     }
 }
 
-fn span[T](item: &T) -> ast::spanned<T> {
+fn span<T>(item: &T) -> ast::spanned<T> {
     ret {node: item, span: ast::mk_sp(0u, 0u)};
 }
 

trunk/src/comp/front/test.rs

@@ -167,7 +167,7 @@ fn mk_test_module(cx: &test_ctxt) -> @ast::item {
     ret @item;
 }
 
-fn nospan[T](t: &T) -> ast::spanned<T> {
+fn nospan<T>(t: &T) -> ast::spanned<T> {
     ret {node: t, span: ast::dummy_sp()};
 }
 

trunk/src/comp/metadata/encoder.rs

@@ -36,7 +36,7 @@ fn encode_def_id(ebml_w: &ebml::writer, id: &def_id) {
     ebml::end_tag(ebml_w);
 }
 
-type entry[T] = {val: T, pos: uint};
+type entry<T> = {val: T, pos: uint};
 
 fn encode_tag_variant_paths(ebml_w: &ebml::writer, variants: &[variant],
                             path: &[str], index: &mutable [entry<str>]) {
@@ -392,7 +392,7 @@ fn encode_info_for_items(ecx: &@encode_ctxt, ebml_w: &ebml::writer) ->
 
 // Path and definition ID indexing
 
-fn create_index[T](index: &[entry<T>], hash_fn: fn(&T) -> uint ) ->
+fn create_index<T>(index: &[entry<T>], hash_fn: fn(&T) -> uint ) ->
    [@[entry<T>]] {
     let buckets: [@mutable [entry<T>]] = ~[];
     for each i: uint in uint::range(0u, 256u) { buckets += ~[@mutable ~[]]; }
@@ -408,7 +408,7 @@ fn create_index[T](index: &[entry<T>], hash_fn: fn(&T) -> uint ) ->
     ret buckets_frozen;
 }
 
-fn encode_index[T](ebml_w: &ebml::writer, buckets: &[@[entry<T>]],
+fn encode_index<T>(ebml_w: &ebml::writer, buckets: &[@[entry<T>]],
                    write_fn: fn(&io::writer, &T) ) {
     let writer = io::new_writer_(ebml_w.writer);
     ebml::start_tag(ebml_w, tag_index);

trunk/src/comp/metadata/tydecode.rs

@@ -115,7 +115,7 @@ fn parse_path(st: @pstate, sd: str_def) -> ast::path {
     fail "parse_path: ill-formed path";
 }
 
-type arg_parser[T] = fn(@pstate, str_def) -> ast::constr_arg_general_<T> ;
+type arg_parser<T> = fn(@pstate, str_def) -> ast::constr_arg_general_<T> ;
 
 fn parse_constr_arg(st: @pstate, sd: str_def) -> ast::fn_constr_arg {
     alt peek(st) as char {
@@ -150,7 +150,7 @@ fn parse_ty_constr_arg(st: @pstate, sd: str_def) ->
     }
 }
 
-fn parse_constr[@T](st: @pstate, sd: str_def, pser: arg_parser<T>) ->
+fn parse_constr<@T>(st: @pstate, sd: str_def, pser: arg_parser<T>) ->
    @ty::constr_general<T> {
     let sp = ast::dummy_sp(); // FIXME: use a real span
     let args: [@sp_constr_arg<T>] = ~[];

trunk/src/comp/middle/ast_map.rs

@@ -48,7 +48,7 @@ fn map_expr(map: &map, ex: &@expr, e: &(), v: &vt<()>) {
     visit::visit_expr(ex, e, v);
 }
 
-fn new_smallintmap_int_adapter[@V]() -> std::map::hashmap<int, V> {
+fn new_smallintmap_int_adapter<@V>() -> std::map::hashmap<int, V> {
     let key_idx = fn (key: &int) -> uint { key as uint };
     let idx_key = fn (idx: &uint) -> int { idx as int };
     ret new_smallintmap_adapter(key_idx, idx_key);
@@ -59,13 +59,13 @@ fn new_smallintmap_int_adapter[@V]() -> std::map::hashmap<int, V> {
 // the entire codebase adapting all the callsites to the different
 // interface.
 // FIXME: hashmap and smallintmap should support the same interface.
-fn new_smallintmap_adapter[@K,
-                           @V](key_idx: fn(&K) -> uint ,
+fn new_smallintmap_adapter<@K,
+                           @V>(key_idx: fn(&K) -> uint ,
                                idx_key: fn(&uint) -> K ) ->
    std::map::hashmap<K, V> {
 
-    obj adapter[@K,
-                @V](map: smallintmap::smallintmap<V>,
+    obj adapter<@K,
+                @V>(map: smallintmap::smallintmap<V>,
                     key_idx: fn(&K) -> uint ,
                     idx_key: fn(&uint) -> K ) {
 

trunk/src/comp/middle/resolve.rs

@@ -1392,7 +1392,7 @@ fn add_name(ch: &checker, sp: &span, name: &ident) {
 
 fn ident_id(i: &ident) -> ident { ret i; }
 
-fn ensure_unique[T](e: &env, sp: &span, elts: &[T], id: fn(&T) -> ident ,
+fn ensure_unique<T>(e: &env, sp: &span, elts: &[T], id: fn(&T) -> ident ,
                     kind: &str) {
     let ch = checker(e, kind);
     for elt: T in elts { add_name(ch, sp, id(elt)); }

trunk/src/comp/middle/tstate/auxiliary.rs

@@ -1012,13 +1012,13 @@ fn non_init_constraint_mentions(fcx: &fn_ctxt, c: &norm_constraint,
         };
 }
 
-fn args_mention[T](args: &[@constr_arg_use], q: fn(&[T], node_id) -> bool ,
+fn args_mention<T>(args: &[@constr_arg_use], q: fn(&[T], node_id) -> bool ,
                    s: &[T]) -> bool {
     /*
       FIXME
       The following version causes an assertion in trans to fail
       (something about type_is_tup_like)
-    fn mentions[T](&[T] s, &fn(&[T], def_id) -> bool q,
+    fn mentions<T>(&[T] s, &fn(&[T], def_id) -> bool q,
                             &@constr_arg_use a) -> bool {
         alt (a.node) {
             case (carg_ident(?p1)) {
@@ -1051,7 +1051,7 @@ fn op_to_oper_ty(io: init_op) -> oper_type {
 }
 
 // default function visitor
-fn do_nothing[T](f: &_fn, tp: &[ty_param], sp: &span, i: &fn_ident,
+fn do_nothing<T>(f: &_fn, tp: &[ty_param], sp: &span, i: &fn_ident,
                  iid: node_id, cx: &T, v: &visit::vt<T>) {
 }
 

trunk/src/comp/middle/ty.rs

@@ -284,7 +284,7 @@ tag sty {
 
 // In the middle end, constraints have a def_id attached, referring
 // to the definition of the operator in the constraint.
-type constr_general[ARG] = spanned<constr_general_<ARG, def_id>>;
+type constr_general<ARG> = spanned<constr_general_<ARG, def_id>>;
 type type_constr = constr_general<path>;
 type constr = constr_general<uint>;
 
@@ -1554,7 +1554,7 @@ fn hash_ty(typ: &t) -> uint { ret typ; }
 // users should use `eq_ty()` instead.
 fn eq_int(x: &uint, y: &uint) -> bool { ret x == y; }
 
-fn arg_eq[T](eq: &fn(&T, &T) -> bool , a: @sp_constr_arg<T>,
+fn arg_eq<T>(eq: &fn(&T, &T) -> bool , a: @sp_constr_arg<T>,
              b: @sp_constr_arg<T>) -> bool {
     alt a.node {
       ast::carg_base. {
@@ -1569,7 +1569,7 @@ fn arg_eq[T](eq: &fn(&T, &T) -> bool , a: @sp_constr_arg<T>,
     }
 }
 
-fn args_eq[T](eq: fn(&T, &T) -> bool , a: &[@sp_constr_arg<T>],
+fn args_eq<T>(eq: fn(&T, &T) -> bool , a: &[@sp_constr_arg<T>],
               b: &[@sp_constr_arg<T>]) -> bool {
     let i: uint = 0u;
     for arg: @sp_constr_arg<T> in a {
@@ -3090,7 +3090,7 @@ fn is_binopable(cx: &ctxt, ty: t, op: ast::binop) -> bool {
     ret tbl.(tycat(cx, ty)).(opcat(op));
 }
 
-fn ast_constr_to_constr[T](tcx: ty::ctxt, c: &@ast::constr_general<T>) ->
+fn ast_constr_to_constr<T>(tcx: ty::ctxt, c: &@ast::constr_general<T>) ->
    @ty::constr_general<T> {
     alt tcx.def_map.find(c.node.id) {
       some(ast::def_fn(pred_id, ast::pure_fn.)) {

trunk/src/comp/middle/typeck.rs

@@ -1281,10 +1281,10 @@ fn gather_locals(ccx: &@crate_ctxt, f: &ast::_fn, id: &ast::node_id,
     };
 
     // Don't descend into fns and items
-    fn visit_fn[E](f: &ast::_fn, tp: &[ast::ty_param], sp: &span,
+    fn visit_fn<E>(f: &ast::_fn, tp: &[ast::ty_param], sp: &span,
                    i: &ast::fn_ident, id: ast::node_id, e: &E,
                    v: &visit::vt<E>) { }
-    fn visit_item[E](i: &@ast::item, e: &E, v: &visit::vt<E>) { }
+    fn visit_item<E>(i: &@ast::item, e: &E, v: &visit::vt<E>) { }
 
     let visit =
         @{visit_local: visit_local,

trunk/src/comp/syntax/ast.rs

@@ -5,8 +5,8 @@ import std::str;
 import codemap::span;
 import codemap::filename;
 
-type spanned[T] = {node: T, span: span};
-fn respan[T](sp: &span, t: &T) -> spanned<T> { ret {node: t, span: sp}; }
+type spanned<T> = {node: T, span: span};
+fn respan<T>(sp: &span, t: &T) -> spanned<T> { ret {node: t, span: sp}; }
 
 /* assuming that we're not in macro expansion */
 fn mk_sp(lo: uint, hi: uint) -> span {
@@ -468,10 +468,10 @@ so that the typestate pass doesn't have to map a function name onto its decl.
 So, the constr_arg type is parameterized: it's instantiated with uint for
 declarations, and ident for uses.
 */
-tag constr_arg_general_[T] { carg_base; carg_ident(T); carg_lit(@lit); }
+tag constr_arg_general_<T> { carg_base; carg_ident(T); carg_lit(@lit); }
 
 type fn_constr_arg = constr_arg_general_<uint>;
-type sp_constr_arg[T] = spanned<constr_arg_general_<T>>;
+type sp_constr_arg<T> = spanned<constr_arg_general_<T>>;
 type ty_constr_arg = sp_constr_arg<path>;
 type constr_arg = spanned<fn_constr_arg>;
 
@@ -480,12 +480,12 @@ type constr_arg = spanned<fn_constr_arg>;
 // The implicit root of such path, in the constraint-list for a
 // constrained type, is * (referring to the base record)
 
-type constr_general_[ARG, ID] =
+type constr_general_<ARG, 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.
-type constr_general[ARG] = spanned<constr_general_<ARG, node_id>>;
+type constr_general<ARG> = spanned<constr_general_<ARG, node_id>>;
 type constr_ = constr_general_<uint, node_id>;
 type constr = spanned<constr_general_<uint, node_id>>;
 type ty_constr_ = ast::constr_general_<ast::path, ast::node_id>;

trunk/src/comp/syntax/ext/simplext.rs

@@ -43,7 +43,7 @@ fn path_to_ident(pth: &path) -> option::t<ident> {
 type clause = {params: binders, body: @expr};
 
 /* logically, an arb_depth should contain only one kind of matchable */
-tag arb_depth[T] { leaf(T); seq(@[arb_depth<T>], span); }
+tag arb_depth<T> { leaf(T); seq(@[arb_depth<T>], span); }
 
 
 tag matchable {
@@ -121,7 +121,7 @@ fn elts_to_ell(cx: &ext_ctxt, elts: &[@expr])
     }
 }
 
-fn option_flatten_map[T, U](f: &fn(&T) -> option::t<U>, v: &[T]) ->
+fn option_flatten_map<T, U>(f: &fn(&T) -> option::t<U>, v: &[T]) ->
    option::t<[U]> {
     let res = ~[];
     for elem: T in v {

trunk/src/comp/syntax/fold.rs

@@ -75,7 +75,7 @@ type a_f =
      new_span: fn(&span) -> span};
 
 
-//fn nf_dummy[T](&T node) -> T { fail; }
+//fn nf_dummy<T>(&T node) -> T { fail; }
 fn nf_crate_dummy(c: &crate) -> crate { fail; }
 fn nf_crate_directive_dummy(c: &@crate_directive) -> @crate_directive {
     fail;

trunk/src/comp/syntax/parse/parser.rs

@@ -224,7 +224,7 @@ fn expect_gt(p: &parser) {
     }
 }
 
-fn spanned[T](lo: uint, hi: uint, node: &T) -> spanned<T> {
+fn spanned<T>(lo: uint, hi: uint, node: &T) -> spanned<T> {
     ret {node: node, span: ast::mk_sp(lo, hi)};
 }
 
@@ -429,7 +429,7 @@ fn parse_constr_in_type(p: &parser) -> @ast::ty_constr {
 }
 
 
-fn parse_constrs[T](pser: fn(&parser) -> @ast::constr_general<T>, p: &parser)
+fn parse_constrs<T>(pser: fn(&parser) -> @ast::constr_general<T>, p: &parser)
    -> [@ast::constr_general<T>] {
     let constrs: [@ast::constr_general<T>] = ~[];
     while true {
@@ -643,7 +643,7 @@ fn parse_fn_block_arg(p: &parser) -> ast::arg {
     ret {mode: m, ty: t, ident: i, id: p.get_id()};
 }
 
-fn parse_seq_to_before_gt[T](sep: option::t<token::token>,
+fn parse_seq_to_before_gt<T>(sep: option::t<token::token>,
                              f: fn(&parser) -> T, p: &parser) -> [T] {
     let first = true;
     let v = ~[];
@@ -660,15 +660,15 @@ fn parse_seq_to_before_gt[T](sep: option::t<token::token>,
     ret v;
 }
 
-fn parse_seq_to_gt[T](sep: option::t<token::token>, f: fn(&parser) -> T,
+fn parse_seq_to_gt<T>(sep: option::t<token::token>, f: fn(&parser) -> T,
                       p: &parser) -> [T] {
     let v = parse_seq_to_before_gt(sep, f, p);
     expect_gt(p);
 
     ret v;
 }
 
-fn parse_seq_lt_gt[T](sep: option::t<token::token>, f: fn(&parser) -> T,
+fn parse_seq_lt_gt<T>(sep: option::t<token::token>, f: fn(&parser) -> T,
                       p: &parser) -> spanned<[T]> {
     let lo = p.get_lo_pos();
     expect(p, token::LT);
@@ -678,14 +678,14 @@ fn parse_seq_lt_gt[T](sep: option::t<token::token>, f: fn(&parser) -> T,
     ret spanned(lo, hi, result);
 }
 
-fn parse_seq_to_end[T](ket: token::token, sep: option::t<token::token>,
+fn parse_seq_to_end<T>(ket: token::token, sep: option::t<token::token>,
                        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>,
+fn parse_seq_to_before_end<T>(ket: token::token, sep: option::t<token::token>,
                               f: fn(&parser) -> T , p: &parser) -> [T] {
     let first: bool = true;
     let v: [T] = ~[];
@@ -700,7 +700,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,
+fn parse_seq<T>(bra: token::token, ket: token::token,
                 sep: option::t<token::token>, f: fn(&parser) -> T ,
                 p: &parser) -> spanned<[T]> {
     let lo = p.get_lo_pos();

trunk/src/comp/syntax/print/pprust.rs

@@ -217,7 +217,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 {
@@ -228,7 +228,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 = vec::len[IN](elts);
@@ -1515,7 +1515,7 @@ fn escape_str(st: str, to_escape: char) -> str {
     ret out;
 }
 
-fn to_str[T](t: &T, f: fn(&ps, &T) ) -> str {
+fn to_str<T>(t: &T, f: fn(&ps, &T) ) -> str {
     let writer = io::string_writer();
     let s = rust_printer(writer.get_writer());
     f(s, t);
@@ -1536,7 +1536,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 ,
+fn constr_args_to_str<T>(f: &fn(&T) -> str ,
                          args: &[@ast::sp_constr_arg<T>]) -> str {
     let comma = false;
     let s = "(";
@@ -1548,7 +1548,7 @@ fn constr_args_to_str[T](f: &fn(&T) -> str ,
     ret s;
 }
 
-fn constr_arg_to_str[T](f: &fn(&T) -> str, c: &ast::constr_arg_general_<T>)
+fn constr_arg_to_str<T>(f: &fn(&T) -> str, c: &ast::constr_arg_general_<T>)
    -> str {
     alt c {
       ast::carg_base. { ret "*"; }

trunk/src/comp/syntax/untyped_ast.rs

@@ -370,7 +370,7 @@ fn dummy() {
          extract_fn(ctx, elts.(idx))]];
 }
 
-fn seq_cv[T](conversion: fn (&ctx, &@ast_node) -> T)
+fn seq_cv<T>(conversion: fn (&ctx, &@ast_node) -> T)
     -> fn (&ctx, @ast_node) -> T[] {
     ret lambda(ctx: &ctx, ut: @ast_node) -> T[] {
         ret alt *ut {
@@ -383,7 +383,7 @@ fn seq_cv[T](conversion: fn (&ctx, &@ast_node) -> T)
     }
 }
 
-fn opt_cv[T](conversion: fn (&ctx, &@ast_node) -> T)
+fn opt_cv<T>(conversion: fn (&ctx, &@ast_node) -> T)
     -> fn (&ctx, @ast_node) -> option::t<T> {
     ret lambda(ctx: &ctx, ut: @ast_node) -> option::t<T> {
         ret alt *ut {