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

Author: erickt

src/comp/driver/rustc.rs

@@ -150,25 +150,25 @@ fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
         time(time_passes, "freevar finding",
              bind freevars::annotate_freevars(sess, d, crate));
     let ty_cx = ty::mk_ctxt(sess, d, ast_map, freevars);
-    time[()](time_passes, "typechecking",
+    time::<()>(time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, crate));
-    time[()](time_passes, "alt checking",
+    time::<()>(time_passes, "alt checking",
              bind middle::check_alt::check_crate(ty_cx, crate));
     if sess.get_opts().run_typestate {
         time(time_passes, "typestate checking",
              bind middle::tstate::ck::check_crate(ty_cx, crate));
     }
     time(time_passes, "alias checking",
          bind middle::alias::check_crate(ty_cx, crate));
-    time[()](time_passes, "kind checking",
+    time::<()>(time_passes, "kind checking",
              bind kind::check_crate(ty_cx, crate));
     if sess.get_opts().no_trans { ret; }
     let llmod =
-        time[llvm::llvm::ModuleRef](time_passes, "translation",
+        time::<llvm::llvm::ModuleRef>(time_passes, "translation",
                                     bind trans::trans_crate(sess, crate,
                                                             ty_cx, output,
                                                             ast_map));
-    time[()](time_passes, "LLVM passes",
+    time::<()>(time_passes, "LLVM passes",
              bind link::write::run_passes(sess, llmod, output));
 }
 
@@ -459,14 +459,14 @@ fn main(args: vec<str>) {
     }
     let sopts = build_session_options(binary, match, binary_dir);
     let sess = build_session(sopts);
-    let n_inputs = vec::len[str](match.free);
+    let n_inputs = vec::len::<str>(match.free);
     let output_file = getopts::opt_maybe_str(match, "o");
     let glue = opt_present(match, "glue");
     if glue {
         if n_inputs > 0u {
             sess.fatal("No input files allowed with --glue.");
         }
-        let out = option::from_maybe[str]("glue.bc", output_file);
+        let out = option::from_maybe::<str>("glue.bc", output_file);
         middle::trans::make_common_glue(sess, out);
         ret;
     }
@@ -479,26 +479,28 @@ fn main(args: vec<str>) {
     let saved_out_filename: str = "";
     let cfg = build_configuration(sess, binary, ifile);
     let expand =
-        option::map[str,
-                    pp_mode](bind parse_pretty(sess, _),
-                             getopts::opt_default(match, "expand", "normal"));
+        option::map::<str,
+                      pp_mode>(bind parse_pretty(sess, _),
+                               getopts::opt_default(match, "expand",
+                                                    "normal"));
     alt expand {
-      some[pp_mode](ppm) {
+      some::<pp_mode>(ppm) {
         pretty_print_input(sess, cfg, ifile, ppm, true);
         ret;
       }
-      none[pp_mode]. {/* continue */ }
+      none::<pp_mode>. {/* continue */ }
     }
     let pretty =
-        option::map[str,
-                    pp_mode](bind parse_pretty(sess, _),
-                             getopts::opt_default(match, "pretty", "normal"));
+        option::map::<str,
+                      pp_mode>(bind parse_pretty(sess, _),
+                               getopts::opt_default(match, "pretty",
+                                                    "normal"));
     alt pretty {
-      some[pp_mode](ppm) {
+      some::<pp_mode>(ppm) {
         pretty_print_input(sess, cfg, ifile, ppm, false);
         ret;
       }
-      none[pp_mode]. {/* continue */ }
+      none::<pp_mode>. {/* continue */ }
     }
     let ls = opt_present(match, "ls");
     if ls {

src/comp/front/attr.rs

@@ -178,7 +178,7 @@ fn remove_meta_items_by_name(items: &[@ast::meta_item], name: str) ->
 
 fn require_unique_names(sess: &session::session,
                         metas: &[@ast::meta_item]) {
-    let map = map::mk_hashmap[str, ()](str::hash, str::eq);
+    let map = map::mk_hashmap::<str, ()>(str::hash, str::eq);
     for meta: @ast::meta_item in metas {
         let name = get_meta_item_name(meta);
         if map.contains_key(name) {

src/comp/lib/llvm.rs

@@ -1303,15 +1303,15 @@ obj builder(B: BuilderRef, terminated: @mutable bool,
        ValueRef {
         assert (!*terminated);
         let phi = llvm::LLVMBuildPhi(B, Ty, str::buf(""));
-        assert (vec::len[ValueRef](vals) == vec::len[BasicBlockRef](bbs));
+        assert (vec::len::<ValueRef>(vals) == vec::len::<BasicBlockRef>(bbs));
         llvm::LLVMAddIncoming(phi, vec::to_ptr(vals), vec::to_ptr(bbs),
                               vec::len(vals));
         ret phi;
     }
 
     fn AddIncomingToPhi(phi: ValueRef, vals: &[ValueRef],
                         bbs: &[BasicBlockRef]) {
-        assert (vec::len[ValueRef](vals) == vec::len[BasicBlockRef](bbs));
+        assert (vec::len::<ValueRef>(vals) == vec::len::<BasicBlockRef>(bbs));
         llvm::LLVMAddIncoming(phi, vec::to_ptr(vals), vec::to_ptr(bbs),
                               vec::len(vals));
     }
@@ -1440,15 +1440,15 @@ obj type_names(type_names: std::map::hashmap<TypeRef, str>,
 }
 
 fn mk_type_names() -> type_names {
-    let nt = std::map::new_str_hash[TypeRef]();
+    let nt = std::map::new_str_hash::<TypeRef>();
 
     fn hash(t: &TypeRef) -> uint { ret t as uint; }
 
     fn eq(a: &TypeRef, b: &TypeRef) -> bool { ret a as uint == b as uint; }
 
     let hasher: std::map::hashfn<TypeRef> = hash;
     let eqer: std::map::eqfn<TypeRef> = eq;
-    let tn = std::map::mk_hashmap[TypeRef, str](hasher, eqer);
+    let tn = std::map::mk_hashmap::<TypeRef, str>(hasher, eqer);
 
     ret type_names(tn, nt);
 }
@@ -1503,7 +1503,7 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) ->
         let s = "fn(";
         let out_ty: TypeRef = llvm::LLVMGetReturnType(ty);
         let n_args: uint = llvm::LLVMCountParamTypes(ty);
-        let args: [TypeRef] = vec::init_elt[TypeRef](0 as TypeRef, n_args);
+        let args: [TypeRef] = vec::init_elt::<TypeRef>(0 as TypeRef, n_args);
         llvm::LLVMGetParamTypes(ty, vec::to_ptr(args));
         s += tys_str(names, outer, args);
         s += ") -> ";
@@ -1515,7 +1515,7 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) ->
       9 {
         let s: str = "{";
         let n_elts: uint = llvm::LLVMCountStructElementTypes(ty);
-        let elts: [TypeRef] = vec::init_elt[TypeRef](0 as TypeRef, n_elts);
+        let elts: [TypeRef] = vec::init_elt::<TypeRef>(0 as TypeRef, n_elts);
         llvm::LLVMGetStructElementTypes(ty, vec::to_ptr(elts));
         s += tys_str(names, outer, elts);
         s += "}";
@@ -1534,7 +1534,7 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) ->
         for tout: TypeRef in outer0 {
             i += 1u;
             if tout as int == ty as int {
-                let n: uint = vec::len[TypeRef](outer0) - i;
+                let n: uint = vec::len::<TypeRef>(outer0) - i;
                 ret "*\\" + std::int::str(n as int);
             }
         }

src/comp/metadata/creader.rs

@@ -32,7 +32,7 @@ export list_file_metadata;
 fn read_crates(sess: session::session, crate: &ast::crate) {
     let e =
         @{sess: sess,
-          crate_cache: @std::map::new_str_hash[int](),
+          crate_cache: @std::map::new_str_hash::<int>(),
           library_search_paths: sess.get_opts().library_search_paths,
           mutable next_crate_num: 1};
     let v =
@@ -186,7 +186,7 @@ fn find_library_crate_aux(nn: &{prefix: str, suffix: str}, crate_name: str,
 fn get_metadata_section(filename: str) -> option::t<@[u8]> {
     let b = str::buf(filename);
     let mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(b);
-    if mb as int == 0 { ret option::none[@[u8]]; }
+    if mb as int == 0 { ret option::none::<@[u8]>; }
     let of = mk_object_file(mb);
     let si = mk_section_iter(of.llof);
     while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False {
@@ -196,11 +196,11 @@ fn get_metadata_section(filename: str) -> option::t<@[u8]> {
             let cbuf = llvm::LLVMGetSectionContents(si.llsi);
             let csz = llvm::LLVMGetSectionSize(si.llsi);
             let cvbuf: *u8 = std::unsafe::reinterpret_cast(cbuf);
-            ret option::some[@[u8]](@vec::unsafe::from_buf(cvbuf, csz));
+            ret option::some::<@[u8]>(@vec::unsafe::from_buf(cvbuf, csz));
         }
         llvm::LLVMMoveToNextSection(si.llsi);
     }
-    ret option::none[@[u8]];
+    ret option::none::<@[u8]>;
 }
 
 fn load_library_crate(sess: &session::session, span: span, ident: &ast::ident,
@@ -249,7 +249,7 @@ fn resolve_crate_deps(e: env, cdata: &@[u8]) -> cstore::cnum_map {
     log "resolving deps of external crate";
     // The map from crate numbers in the crate we're resolving to local crate
     // numbers
-    let cnum_map = new_int_hash[ast::crate_num]();
+    let cnum_map = new_int_hash::<ast::crate_num>();
     for dep: decoder::crate_dep in decoder::get_crate_deps(cdata) {
         let extrn_cnum = dep.cnum;
         let cname = dep.ident;

src/comp/metadata/cstore.rs

@@ -52,8 +52,8 @@ type use_crate_map = map::hashmap<ast::node_id, ast::crate_num>;
 fn p(cstore: &cstore) -> cstore_private { alt cstore { private(p) { p } } }
 
 fn mk_cstore() -> cstore {
-    let meta_cache = map::new_int_hash[crate_metadata]();
-    let crate_map = map::new_int_hash[ast::crate_num]();
+    let meta_cache = map::new_int_hash::<crate_metadata>();
+    let crate_map = map::new_int_hash::<ast::crate_num>();
     ret private(@{metas: meta_cache,
                   use_crate_map: crate_map,
                   mutable used_crate_files: ~[],

src/comp/metadata/decoder.rs

@@ -48,7 +48,7 @@ fn lookup_hash(d: &ebml::doc, eq_fn: fn(&[u8]) -> bool , hash: uint) ->
     let belt = tag_index_buckets_bucket_elt;
     for each elt: ebml::doc in ebml::tagged_docs(bucket, belt) {
         let pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
-        if eq_fn(vec::slice[u8](*elt.data, elt.start + 4u, elt.end)) {
+        if eq_fn(vec::slice::<u8>(*elt.data, elt.start + 4u, elt.end)) {
             result += ~[ebml::doc_at(d.data, pos)];
         }
     }
@@ -63,8 +63,8 @@ fn maybe_find_item(item_id: int, items: &ebml::doc) ->
     let eqer = bind eq_item(_, item_id);
     let found = lookup_hash(items, eqer, hash_node_id(item_id));
     if vec::len(found) == 0u {
-        ret option::none[ebml::doc];
-    } else { ret option::some[ebml::doc](found.(0)); }
+        ret option::none::<ebml::doc>;
+    } else { ret option::some::<ebml::doc>(found.(0)); }
 }
 
 fn find_item(item_id: int, items: &ebml::doc) -> ebml::doc {
@@ -269,7 +269,7 @@ fn family_has_type_params(fam_ch: u8) -> bool {
 fn read_path(d: &ebml::doc) -> {path: str, pos: uint} {
     let desc = ebml::doc_data(d);
     let pos = ebml::be_uint_from_bytes(@desc, 0u, 4u);
-    let pathbytes = vec::slice[u8](desc, 4u, vec::len[u8](desc));
+    let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc));
     let path = str::unsafe_from_bytes(pathbytes);
     ret {path: path, pos: pos};
 }

src/comp/metadata/encoder.rs

@@ -176,7 +176,7 @@ fn def_to_str(did: &def_id) -> str { ret #fmt("%d:%d", did.crate, did.node); }
 
 fn encode_type_param_kinds(ebml_w: &ebml::writer, tps: &[ty_param]) {
     ebml::start_tag(ebml_w, tag_items_data_item_ty_param_kinds);
-    ebml::write_vint(ebml_w.writer, vec::len[ty_param](tps));
+    ebml::write_vint(ebml_w.writer, vec::len::<ty_param>(tps));
     for tp: ty_param in tps {
         let c = alt tp.kind {
           kind_unique. { 'u' }
@@ -236,7 +236,7 @@ fn encode_tag_variant_info(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
         encode_tag_id(ebml_w, local_def(id));
         encode_type(ecx, ebml_w,
                     node_id_to_monotype(ecx.ccx.tcx, variant.node.id));
-        if vec::len[variant_arg](variant.node.args) > 0u {
+        if vec::len::<variant_arg>(variant.node.args) > 0u {
             encode_symbol(ecx, ebml_w, variant.node.id);
         }
         encode_discriminant(ecx, ebml_w, variant.node.id);

src/comp/metadata/tydecode.rs

@@ -71,7 +71,7 @@ fn parse_constrs(st: @pstate, sd: str_def) -> [@ty::constr] {
         do  {
             next(st);
             let one: @ty::constr =
-                parse_constr[uint](st, sd, parse_constr_arg);
+                parse_constr::<uint>(st, sd, parse_constr_arg);
             rslt += ~[one];
         } while peek(st) as char == ';'
       }
@@ -88,7 +88,7 @@ fn parse_ty_constrs(st: @pstate, sd: str_def) -> [@ty::type_constr] {
         do  {
             next(st);
             let one: @ty::type_constr =
-                parse_constr[path](st, sd, parse_ty_constr_arg);
+                parse_constr::<path>(st, sd, parse_ty_constr_arg);
             rslt += ~[one];
         } while peek(st) as char == ';'
       }
@@ -406,14 +406,14 @@ fn parse_ty_fn(st: @pstate, sd: str_def) ->
 // Rust metadata parsing
 fn parse_def_id(buf: &[u8]) -> ast::def_id {
     let colon_idx = 0u;
-    let len = vec::len[u8](buf);
+    let len = vec::len::<u8>(buf);
     while colon_idx < len && buf.(colon_idx) != ':' as u8 { colon_idx += 1u; }
     if colon_idx == len {
         log_err "didn't find ':' when parsing def id";
         fail;
     }
-    let crate_part = vec::slice[u8](buf, 0u, colon_idx);
-    let def_part = vec::slice[u8](buf, colon_idx + 1u, len);
+    let crate_part = vec::slice::<u8>(buf, 0u, colon_idx);
+    let def_part = vec::slice::<u8>(buf, colon_idx + 1u, len);
 
     let crate_part_vec = ~[];
     let def_part_vec = ~[];

src/comp/middle/alias.rs

@@ -46,7 +46,7 @@ fn check_crate(tcx: ty::ctxt, crate: &@ast::crate) {
               visit_item: bind visit_item(cx, _, _, _),
               visit_expr: bind visit_expr(cx, _, _, _),
               visit_decl: bind visit_decl(cx, _, _, _)
-              with *visit::default_visitor[scope]()};
+              with *visit::default_visitor::<scope>()};
     visit::visit_crate(*crate, @~[], visit::mk_vt(v));
     tcx.sess.abort_if_errors();
 }

src/comp/middle/ast_map.rs

@@ -18,13 +18,13 @@ fn map_crate(c: &crate) -> map {
     // FIXME: This is using an adapter to convert the smallintmap
     // interface to the hashmap interface. It would be better to just
     // convert everything to use the smallintmap.
-    let map = new_smallintmap_int_adapter[ast_node]();
+    let map = new_smallintmap_int_adapter::<ast_node>();
 
     let v_map =
         @{visit_item: bind map_item(map, _, _, _),
           visit_native_item: bind map_native_item(map, _, _, _),
           visit_expr: bind map_expr(map, _, _, _)
-             with *visit::default_visitor[()]()};
+             with *visit::default_visitor::<()>()};
     visit::visit_crate(c, (), visit::mk_vt(v_map));
     ret map;
 }
@@ -110,7 +110,7 @@ fn new_smallintmap_adapter<@K,
         }
     }
 
-    let map = smallintmap::mk[V]();
+    let map = smallintmap::mk::<V>();
     ret adapter(map, key_idx, idx_key);
 }
 

src/comp/middle/check_alt.rs

@@ -5,7 +5,7 @@ fn check_crate(tcx: &ty::ctxt, crate: &@crate) {
     let v =
         @{visit_expr: bind check_expr(tcx, _, _, _),
           visit_local: bind check_local(tcx, _, _, _)
-          with *visit::default_visitor[()]()};
+          with *visit::default_visitor::<()>()};
     visit::visit_crate(*crate, (), visit::mk_vt(v));
     tcx.sess.abort_if_errors();
 }