---

yaml
---
r: 4736
b: refs/heads/master
c: e4a0f99
h: refs/heads/master
v: v3

Author: erickt

[refs]

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

trunk/src/comp/README

@@ -33,7 +33,7 @@ The 3 central data structures:
     structure:
 
       - Many -- though not all -- nodes within this data structure are
-        wrapped in the type spanned[T], meaning that the front-end has
+        wrapped in the type spanned<T>, meaning that the front-end has
         marked the input coordinates of that node. The member .node is
         the data itself, the member .span is the input location (file,
         line, column; both low and high).

trunk/src/comp/back/link.rs

@@ -285,14 +285,14 @@ fn build_link_meta(sess: &session::session, c: &ast::crate, output: &str,
                    sha: sha1) -> link_meta {
 
     type provided_metas =
-        {name: option::t[str],
-         vers: option::t[str],
+        {name: option::t<str>,
+         vers: option::t<str>,
          cmh_items: [@ast::meta_item]};
 
     fn provided_link_metas(sess: &session::session, c: &ast::crate) ->
        provided_metas {
-        let name: option::t[str] = none;
-        let vers: option::t[str] = none;
+        let name: option::t<str> = none;
+        let vers: option::t<str> = none;
         let cmh_items: [@ast::meta_item] = ~[];
         let linkage_metas = attr::find_linkage_metas(c.node.attrs);
         attr::require_unique_names(sess, linkage_metas);

trunk/src/comp/driver/rustc.rs

@@ -437,7 +437,7 @@ fn opts() -> [getopts::opt] {
           optflag("lib"), optflag("static"), optflag("gc")];
 }
 
-fn main(args: vec[str]) {
+fn main(args: vec<str>) {
     let args_ivec = vec::from_vec(args);
     let binary = vec::shift(args_ivec);
     let binary_dir = fs::dirname(binary);

trunk/src/comp/driver/session.rs

@@ -54,7 +54,7 @@ obj session(targ_cfg: @config,
             parse_sess: parse_sess,
 
             // For a library crate, this is always none
-            mutable main_fn: option::t[node_id],
+            mutable main_fn: option::t<node_id>,
             mutable err_count: uint) {
     fn get_targ_cfg() -> @config { ret targ_cfg; }
     fn get_opts() -> @options { ret opts; }
@@ -111,7 +111,7 @@ obj session(targ_cfg: @config,
         ret codemap::span_to_str(sp, self.get_codemap());
     }
     fn set_main_id(d: node_id) { main_fn = some(d); }
-    fn get_main_id() -> option::t[node_id] { main_fn }
+    fn get_main_id() -> option::t<node_id> { main_fn }
 }
 // Local Variables:
 // fill-column: 78;

trunk/src/comp/front/attr.rs

@@ -45,7 +45,7 @@ fn find_attrs_by_name(attrs: &[ast::attribute], name: ast::ident) ->
    [ast::attribute] {
     let filter =
         bind fn (a: &ast::attribute, name: ast::ident) ->
-                option::t[ast::attribute] {
+                option::t<ast::attribute> {
                  if get_attr_name(a) == name {
                      option::some(a)
                  } else { option::none }
@@ -61,7 +61,7 @@ fn find_meta_items_by_name(metas: &[@ast::meta_item], name: ast::ident) ->
    [@ast::meta_item] {
     let filter =
         bind fn (m: &@ast::meta_item, name: ast::ident) ->
-                option::t[@ast::meta_item] {
+                option::t<@ast::meta_item> {
                  if get_meta_item_name(m) == name {
                      option::some(m)
                  } else { option::none }
@@ -79,7 +79,7 @@ fn get_meta_item_name(meta: &@ast::meta_item) -> ast::ident {
 
 // Gets the string value if the meta_item is a meta_name_value variant
 // containing a string, otherwise none
-fn get_meta_item_value_str(meta: &@ast::meta_item) -> option::t[str] {
+fn get_meta_item_value_str(meta: &@ast::meta_item) -> option::t<str> {
     alt meta.node {
       ast::meta_name_value(_, v) {
         alt v.node {
@@ -167,7 +167,7 @@ fn remove_meta_items_by_name(items: &[@ast::meta_item], name: str) ->
 
     let filter =
         bind fn (item: &@ast::meta_item, name: str) ->
-                option::t[@ast::meta_item] {
+                option::t<@ast::meta_item> {
                  if get_meta_item_name(item) != name {
                      option::some(item)
                  } else { option::none }
@@ -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/config.rs

@@ -25,7 +25,7 @@ fn strip_unconfigured_items(crate: @ast::crate) -> @ast::crate {
 }
 
 fn filter_item(cfg: &ast::crate_cfg, item: &@ast::item) ->
-   option::t[@ast::item] {
+   option::t<@ast::item> {
     if item_in_cfg(cfg, item) { option::some(item) } else { option::none }
 }
 
@@ -38,7 +38,7 @@ fn fold_mod(cfg: &ast::crate_cfg, m: &ast::_mod, fld: fold::ast_fold) ->
 }
 
 fn filter_native_item(cfg: &ast::crate_cfg, item: &@ast::native_item) ->
-   option::t[@ast::native_item] {
+   option::t<@ast::native_item> {
     if native_item_in_cfg(cfg, item) {
         option::some(item)
     } else { option::none }
@@ -55,7 +55,7 @@ fn fold_native_mod(cfg: &ast::crate_cfg, nm: &ast::native_mod,
 }
 
 fn filter_stmt(cfg: &ast::crate_cfg, stmt: &@ast::stmt) ->
-   option::t[@ast::stmt] {
+   option::t<@ast::stmt> {
     alt stmt.node {
       ast::stmt_decl(decl, _) {
         alt decl.node {

trunk/src/comp/front/test.rs

@@ -57,7 +57,7 @@ fn fold_mod(cx: &test_ctxt, m: &ast::_mod, fld: fold::ast_fold) -> ast::_mod {
     // the one we're going to add.  FIXME: This is sloppy. Instead we should
     // have some mechanism to indicate to the translation pass which function
     // we want to be main.
-    fn nomain(item: &@ast::item) -> option::t[@ast::item] {
+    fn nomain(item: &@ast::item) -> option::t<@ast::item> {
         alt item.node {
           ast::item_fn(f, _) {
             if item.ident == "main" {
@@ -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/lib/llvm.rs

@@ -1420,8 +1420,8 @@ fn new_builder(llbb: BasicBlockRef) -> builder {
 
 /* Memory-managed object interface to type handles. */
 
-obj type_names(type_names: std::map::hashmap[TypeRef, str],
-               named_types: std::map::hashmap[str, TypeRef]) {
+obj type_names(type_names: std::map::hashmap<TypeRef, str>,
+               named_types: std::map::hashmap<str, TypeRef>) {
 
     fn associate(s: str, t: TypeRef) {
         assert (!named_types.contains_key(s));
@@ -1446,8 +1446,8 @@ fn mk_type_names() -> type_names {
 
     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 hasher: std::map::hashfn<TypeRef> = hash;
+    let eqer: std::map::eqfn<TypeRef> = eq;
     let tn = std::map::mk_hashmap[TypeRef, str](hasher, eqer);
 
     ret type_names(tn, nt);

trunk/src/comp/metadata/creader.rs

@@ -45,7 +45,7 @@ fn read_crates(sess: session::session, crate: &ast::crate) {
 
 type env =
     @{sess: session::session,
-      crate_cache: @hashmap[str, int],
+      crate_cache: @hashmap<str, int>,
       library_search_paths: [str],
       mutable next_crate_num: ast::crate_num};
 
@@ -118,7 +118,7 @@ fn default_native_lib_naming(sess: session::session, static: bool) ->
 fn find_library_crate(sess: &session::session, ident: &ast::ident,
                       metas: &[@ast::meta_item],
                       library_search_paths: &[str]) ->
-   option::t[{ident: str, data: @[u8]}] {
+   option::t<{ident: str, data: @[u8]}> {
 
     attr::require_unique_names(sess, metas);
 
@@ -148,7 +148,7 @@ fn find_library_crate(sess: &session::session, ident: &ast::ident,
 fn find_library_crate_aux(nn: &{prefix: str, suffix: str}, crate_name: str,
                           metas: &[@ast::meta_item],
                           library_search_paths: &[str]) ->
-   option::t[{ident: str, data: @[u8]}] {
+   option::t<{ident: str, data: @[u8]}> {
     let prefix: str = nn.prefix + crate_name;
     // FIXME: we could probably use a 'glob' function in std::fs but it will
     // be much easier to write once the unsafe module knows more about FFI
@@ -183,7 +183,7 @@ fn find_library_crate_aux(nn: &{prefix: str, suffix: str}, crate_name: str,
     ret none;
 }
 
-fn get_metadata_section(filename: str) -> option::t[@[u8]] {
+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]]; }

trunk/src/comp/metadata/cstore.rs

@@ -27,7 +27,7 @@ export get_use_stmt_cnum;
 // local crate numbers (as generated during this session). Each external
 // crate may refer to types in other external crates, and each has their
 // own crate numbers.
-type cnum_map = map::hashmap[ast::crate_num, ast::crate_num];
+type cnum_map = map::hashmap<ast::crate_num, ast::crate_num>;
 
 type crate_metadata = {name: str, data: @[u8], cnum_map: cnum_map};
 
@@ -39,14 +39,14 @@ type crate_metadata = {name: str, data: @[u8], cnum_map: cnum_map};
 tag cstore { private(cstore_private); }
 
 type cstore_private =
-    @{metas: map::hashmap[ast::crate_num, crate_metadata],
+    @{metas: map::hashmap<ast::crate_num, crate_metadata>,
       use_crate_map: use_crate_map,
       mutable used_crate_files: [str],
       mutable used_libraries: [str],
       mutable used_link_args: [str]};
 
 // Map from node_id's of local use statements to crate numbers
-type use_crate_map = map::hashmap[ast::node_id, ast::crate_num];
+type use_crate_map = map::hashmap<ast::node_id, ast::crate_num>;
 
 // Internal method to retrieve the data from the cstore
 fn p(cstore: &cstore) -> cstore_private { alt cstore { private(p) { p } } }

trunk/src/comp/metadata/decoder.rs

@@ -56,7 +56,7 @@ fn lookup_hash(d: &ebml::doc, eq_fn: fn(&[u8]) -> bool , hash: uint) ->
 }
 
 fn maybe_find_item(item_id: int, items: &ebml::doc) ->
-   option::t[ebml::doc] {
+   option::t<ebml::doc> {
     fn eq_item(bytes: &[u8], item_id: int) -> bool {
         ret ebml::be_uint_from_bytes(@bytes, 0u, 4u) as int == item_id;
     }

trunk/src/comp/metadata/encoder.rs

@@ -19,7 +19,7 @@ import front::attr;
 export encode_metadata;
 export encoded_ty;
 
-type abbrev_map = map::hashmap[ty::t, tyencode::ty_abbrev];
+type abbrev_map = map::hashmap<ty::t, tyencode::ty_abbrev>;
 
 type encode_ctxt = {ccx: @crate_ctxt, type_abbrevs: abbrev_map};
 
@@ -39,7 +39,7 @@ fn encode_def_id(ebml_w: &ebml::writer, id: &def_id) {
 type entry[T] = {val: T, pos: uint};
 
 fn encode_tag_variant_paths(ebml_w: &ebml::writer, variants: &[variant],
-                            path: &[str], index: &mutable [entry[str]]) {
+                            path: &[str], index: &mutable [entry<str>]) {
     for variant: variant in variants {
         add_to_index(ebml_w, path, index, variant.node.name);
         ebml::start_tag(ebml_w, tag_paths_data_item);
@@ -50,7 +50,7 @@ fn encode_tag_variant_paths(ebml_w: &ebml::writer, variants: &[variant],
 }
 
 fn add_to_index(ebml_w: &ebml::writer, path: &[str],
-                index: &mutable [entry[str]], name: &str) {
+                index: &mutable [entry<str>], name: &str) {
     let full_path = path + ~[name];
     index +=
         ~[{val: str::connect(full_path, "::"),
@@ -59,7 +59,7 @@ fn add_to_index(ebml_w: &ebml::writer, path: &[str],
 
 fn encode_native_module_item_paths(ebml_w: &ebml::writer,
                                    nmod: &native_mod, path: &[str],
-                                   index: &mutable [entry[str]]) {
+                                   index: &mutable [entry<str>]) {
     for nitem: @native_item in nmod.items {
         add_to_index(ebml_w, path, index, nitem.ident);
         ebml::start_tag(ebml_w, tag_paths_data_item);
@@ -70,7 +70,7 @@ fn encode_native_module_item_paths(ebml_w: &ebml::writer,
 }
 
 fn encode_module_item_paths(ebml_w: &ebml::writer, module: &_mod,
-                            path: &[str], index: &mutable [entry[str]]) {
+                            path: &[str], index: &mutable [entry<str>]) {
     for it: @item in module.items {
         if !is_exported(it.ident, module) { cont; }
         alt it.node {
@@ -149,8 +149,8 @@ fn encode_module_item_paths(ebml_w: &ebml::writer, module: &_mod,
 }
 
 fn encode_item_paths(ebml_w: &ebml::writer, crate: &@crate) ->
-   [entry[str]] {
-    let index: [entry[str]] = ~[];
+   [entry<str>] {
+    let index: [entry<str>] = ~[];
     let path: [str] = ~[];
     ebml::start_tag(ebml_w, tag_paths);
     encode_module_item_paths(ebml_w, crate.node.module, path, index);
@@ -226,7 +226,7 @@ fn encode_tag_id(ebml_w: &ebml::writer, id: &def_id) {
 
 fn encode_tag_variant_info(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
                            id: node_id, variants: &[variant],
-                           index: &mutable [entry[int]],
+                           index: &mutable [entry<int>],
                            ty_params: &[ty_param]) {
     for variant: variant in variants {
         index += ~[{val: variant.node.id, pos: ebml_w.writer.tell()}];
@@ -246,7 +246,7 @@ fn encode_tag_variant_info(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
 }
 
 fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: &ebml::writer,
-                        item: @item, index: &mutable [entry[int]]) {
+                        item: @item, index: &mutable [entry<int>]) {
     alt item.node {
       item_const(_, _) {
         ebml::start_tag(ebml_w, tag_items_data_item);
@@ -368,8 +368,8 @@ fn encode_info_for_native_item(ecx: &@encode_ctxt, ebml_w: &ebml::writer,
 }
 
 fn encode_info_for_items(ecx: &@encode_ctxt, ebml_w: &ebml::writer) ->
-   [entry[int]] {
-    let index: [entry[int]] = ~[];
+   [entry<int>] {
+    let index: [entry<int>] = ~[];
     ebml::start_tag(ebml_w, tag_items_data);
     for each kvp: @{key: node_id, val: middle::ast_map::ast_node}  in
              ecx.ccx.ast_map.items() {
@@ -392,32 +392,32 @@ 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 ) ->
-   [@[entry[T]]] {
-    let buckets: [@mutable [entry[T]]] = ~[];
+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 ~[]]; }
-    for elt: entry[T] in index {
+    for elt: entry<T> in index {
         let h = hash_fn(elt.val);
         *buckets.(h % 256u) += ~[elt];
     }
 
     let buckets_frozen = ~[];
-    for bucket: @mutable [entry[T]] in buckets {
+    for bucket: @mutable [entry<T>] in buckets {
         buckets_frozen += ~[@*bucket];
     }
     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);
     let bucket_locs: [uint] = ~[];
     ebml::start_tag(ebml_w, tag_index_buckets);
-    for bucket: @[entry[T]] in buckets {
+    for bucket: @[entry<T>] in buckets {
         bucket_locs += ~[ebml_w.writer.tell()];
         ebml::start_tag(ebml_w, tag_index_buckets_bucket);
-        for elt: entry[T] in *bucket {
+        for elt: entry<T> in *bucket {
             ebml::start_tag(ebml_w, tag_index_buckets_bucket_elt);
             writer.write_be_uint(elt.pos, 4u);
             write_fn(writer, elt.val);