---

yaml
---
r: 11850
b: refs/heads/master
c: 3864d6d
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 383a80199351c6b9f9f4834242231c8586fb2ab6
+refs/heads/master: 3864d6d845f6bf9493698606bba2220daede4738
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/cargo/cargo.rs

@@ -387,7 +387,7 @@ fn configure(opts: options) -> cargo {
         result::err(e) { fail e }
     };
 
-    let sources = map::new_str_hash::<source>();
+    let sources = map::str_hash::<source>();
     try_parse_sources(path::connect(syscargo, "sources.json"), sources);
     try_parse_sources(path::connect(syscargo, "local-sources.json"), sources);
     let c = {

trunk/src/libstd/ebml.rs

@@ -7,8 +7,6 @@ import core::option;
 import option::{some, none};
 
 export doc;
-
-export new_doc;
 export doc_at;
 export maybe_get_doc;
 export get_doc;
@@ -64,7 +62,7 @@ fn vuint_at(data: [u8], start: uint) -> {val: uint, next: uint} {
     } else { #error("vint too big"); fail; }
 }
 
-fn new_doc(data: @[u8]) -> doc {
+fn doc(data: @[u8]) -> doc {
     ret {data: data, start: 0u, end: vec::len::<u8>(*data)};
 }
 
@@ -575,7 +573,7 @@ fn test_option_int() {
         let mbuf = io::mem_buffer();
         let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf));
         serialize_0(ebml_w, v);
-        let ebml_doc = ebml::new_doc(@io::mem_buffer_buf(mbuf));
+        let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
         let deser = ebml_deserializer(ebml_doc);
         let v1 = deserialize_0(deser);
         #debug["v1 == %?", v1];

trunk/src/libstd/json.rs

@@ -407,7 +407,7 @@ impl parser for parser {
         self.bump();
         self.parse_whitespace();
 
-        let values = map::new_str_hash();
+        let values = map::str_hash();
 
         if self.ch == '}' {
           self.bump();
@@ -501,7 +501,7 @@ fn eq(value0: json, value1: json) -> bool {
 #[cfg(test)]
 mod tests {
     fn mk_dict(items: [(str, json)]) -> json {
-        let d = map::new_str_hash();
+        let d = map::str_hash();
 
         vec::iter(items) { |item|
             let (key, value) = item;

trunk/src/libstd/map.rs

@@ -1,8 +1,8 @@
 #[doc = "A map type"];
 
 import chained::hashmap;
-export hashmap, hashfn, eqfn, set, map, chained, new_hashmap, new_str_hash;
-export new_bytes_hash, new_int_hash, new_uint_hash, set_add;
+export hashmap, hashfn, eqfn, set, map, chained, hashmap, str_hash;
+export bytes_hash, int_hash, uint_hash, set_add;
 
 #[doc = "
 A function that returns a hash of a value
@@ -289,7 +289,7 @@ mod chained {
 }
 
 /*
-Function: new_hashmap
+Function: hashmap
 
 Construct a hashmap.
 
@@ -298,33 +298,33 @@ Parameters:
 hasher - The hash function for key type K
 eqer - The equality function for key type K
 */
-fn new_hashmap<K: copy, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>)
+fn hashmap<K: copy, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>)
         -> hashmap<K, V> {
     chained::mk(hasher, eqer)
 }
 
 #[doc = "Construct a hashmap for string keys"]
-fn new_str_hash<V: copy>() -> hashmap<str, V> {
-    ret new_hashmap(str::hash, str::eq);
+fn str_hash<V: copy>() -> hashmap<str, V> {
+    ret hashmap(str::hash, str::eq);
 }
 
 #[doc = "Construct a hashmap for byte string keys"]
-fn new_bytes_hash<V: copy>() -> hashmap<[u8], V> {
-    ret new_hashmap(vec::u8::hash, vec::u8::eq);
+fn bytes_hash<V: copy>() -> hashmap<[u8], V> {
+    ret hashmap(vec::u8::hash, vec::u8::eq);
 }
 
 #[doc = "Construct a hashmap for int keys"]
-fn new_int_hash<V: copy>() -> hashmap<int, V> {
+fn int_hash<V: copy>() -> hashmap<int, V> {
     fn hash_int(&&x: int) -> uint { int::hash(x) }
     fn eq_int(&&a: int, &&b: int) -> bool { ret a == b; }
-    ret new_hashmap(hash_int, eq_int);
+    ret hashmap(hash_int, eq_int);
 }
 
 #[doc = "Construct a hashmap for uint keys"]
-fn new_uint_hash<V: copy>() -> hashmap<uint, V> {
+fn uint_hash<V: copy>() -> hashmap<uint, V> {
     fn hash_uint(&&x: uint) -> uint { uint::hash(x) }
     fn eq_uint(&&a: uint, &&b: uint) -> bool { ret a == b; }
-    ret new_hashmap(hash_uint, eq_uint);
+    ret hashmap(hash_uint, eq_uint);
 }
 
 #[doc = "
@@ -346,7 +346,7 @@ mod tests {
         let eqer_str: map::eqfn<str> = str::eq;
         #debug("uint -> uint");
         let hm_uu: map::hashmap<uint, uint> =
-            map::new_hashmap::<uint, uint>(hasher_uint, eqer_uint);
+            map::hashmap::<uint, uint>(hasher_uint, eqer_uint);
         assert (hm_uu.insert(10u, 12u));
         assert (hm_uu.insert(11u, 13u));
         assert (hm_uu.insert(12u, 14u));
@@ -362,7 +362,7 @@ mod tests {
         let twelve: str = "twelve";
         #debug("str -> uint");
         let hm_su: map::hashmap<str, uint> =
-            map::new_hashmap::<str, uint>(hasher_str, eqer_str);
+            map::hashmap::<str, uint>(hasher_str, eqer_str);
         assert (hm_su.insert("ten", 12u));
         assert (hm_su.insert(eleven, 13u));
         assert (hm_su.insert("twelve", 14u));
@@ -376,7 +376,7 @@ mod tests {
         assert (hm_su.get("twelve") == 12u);
         #debug("uint -> str");
         let hm_us: map::hashmap<uint, str> =
-            map::new_hashmap::<uint, str>(hasher_uint, eqer_uint);
+            map::hashmap::<uint, str>(hasher_uint, eqer_uint);
         assert (hm_us.insert(10u, "twelve"));
         assert (hm_us.insert(11u, "thirteen"));
         assert (hm_us.insert(12u, "fourteen"));
@@ -389,7 +389,7 @@ mod tests {
         assert (str::eq(hm_us.get(12u), "twelve"));
         #debug("str -> str");
         let hm_ss: map::hashmap<str, str> =
-            map::new_hashmap::<str, str>(hasher_str, eqer_str);
+            map::hashmap::<str, str>(hasher_str, eqer_str);
         assert (hm_ss.insert(ten, "twelve"));
         assert (hm_ss.insert(eleven, "thirteen"));
         assert (hm_ss.insert(twelve, "fourteen"));
@@ -417,7 +417,7 @@ mod tests {
         let hasher_uint: map::hashfn<uint> = uint_id;
         let eqer_uint: map::eqfn<uint> = eq_uint;
         let hm_uu: map::hashmap<uint, uint> =
-            map::new_hashmap::<uint, uint>(hasher_uint, eqer_uint);
+            map::hashmap::<uint, uint>(hasher_uint, eqer_uint);
         let i: uint = 0u;
         while i < num_to_insert {
             assert (hm_uu.insert(i, i * i));
@@ -444,7 +444,7 @@ mod tests {
         let hasher_str: map::hashfn<str> = str::hash;
         let eqer_str: map::eqfn<str> = str::eq;
         let hm_ss: map::hashmap<str, str> =
-            map::new_hashmap::<str, str>(hasher_str, eqer_str);
+            map::hashmap::<str, str>(hasher_str, eqer_str);
         i = 0u;
         while i < num_to_insert {
             assert hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u));
@@ -497,7 +497,7 @@ mod tests {
         let hasher: map::hashfn<uint> = hash;
         let eqer: map::eqfn<uint> = eq;
         let hm: map::hashmap<uint, uint> =
-            map::new_hashmap::<uint, uint>(hasher, eqer);
+            map::hashmap::<uint, uint>(hasher, eqer);
         let i: uint = 0u;
         while i < num_to_insert {
             assert (hm.insert(i, i * i));
@@ -560,7 +560,7 @@ mod tests {
     #[test]
     fn test_contains_key() {
         let key = "k";
-        let map = map::new_hashmap::<str, str>(str::hash, str::eq);
+        let map = map::hashmap::<str, str>(str::hash, str::eq);
         assert (!map.contains_key(key));
         map.insert(key, "val");
         assert (map.contains_key(key));
@@ -569,7 +569,7 @@ mod tests {
     #[test]
     fn test_find() {
         let key = "k";
-        let map = map::new_hashmap::<str, str>(str::hash, str::eq);
+        let map = map::hashmap::<str, str>(str::hash, str::eq);
         assert (option::is_none(map.find(key)));
         map.insert(key, "val");
         assert (option::get(map.find(key)) == "val");

trunk/src/libstd/uv.rs

@@ -131,17 +131,17 @@ fn loop_new() -> uv_loop unsafe {
 
         // all state goes here
         let handles: map::hashmap<[u8], *libc::c_void> =
-            map::new_bytes_hash();
+            map::bytes_hash();
         let id_to_handle: map::hashmap<[u8], uv_handle> =
-            map::new_bytes_hash();
+            map::bytes_hash();
         let after_cbs: map::hashmap<[u8], fn~(uv_handle)> =
-            map::new_bytes_hash();
+            map::bytes_hash();
         let close_callbacks: map::hashmap<[u8], fn~()> =
-            map::new_bytes_hash();
+            map::bytes_hash();
         let async_cbs: map::hashmap<[u8], fn~(uv_handle)> =
-            map::new_bytes_hash();
+            map::bytes_hash();
         let timer_cbs: map::hashmap<[u8], fn~(uv_handle)> =
-            map::new_bytes_hash();
+            map::bytes_hash();
 
         // the main loop that this task blocks on.
         // should have the same lifetime as the C libuv

trunk/src/rustc/back/rpath.rs

@@ -178,7 +178,7 @@ fn get_install_prefix_rpath(cwd: path::path, target_triple: str) -> str {
 }
 
 fn minimize_rpaths(rpaths: [str]) -> [str] {
-    let set = map::new_str_hash::<()>();
+    let set = map::str_hash::<()>();
     let minimized = [];
     for rpath in rpaths {
         if !set.contains_key(rpath) {

trunk/src/rustc/front/attr.rs

@@ -220,7 +220,7 @@ fn remove_meta_items_by_name(items: [@ast::meta_item], name: str) ->
 }
 
 fn require_unique_names(sess: session, metas: [@ast::meta_item]) {
-    let map = map::new_str_hash();
+    let map = map::str_hash();
     for meta: @ast::meta_item in metas {
         let name = get_meta_item_name(meta);
         if map.contains_key(name) {

trunk/src/rustc/lib/llvm.rs

@@ -940,8 +940,8 @@ fn name_has_type(tn: type_names, s: str) -> option<TypeRef> {
 fn mk_type_names() -> type_names {
     fn hash(&&t: TypeRef) -> uint { ret t as uint; }
     fn eq(&&a: TypeRef, &&b: TypeRef) -> bool { ret a as uint == b as uint; }
-    @{type_names: std::map::new_hashmap(hash, eq),
-      named_types: std::map::new_str_hash()}
+    @{type_names: std::map::hashmap(hash, eq),
+      named_types: std::map::str_hash()}
 }
 
 fn type_to_str(names: type_names, ty: TypeRef) -> str {

trunk/src/rustc/metadata/astencode.rs

@@ -951,7 +951,7 @@ fn roundtrip(in_item: @ast::item) {
     let mbuf = io::mem_buffer();
     let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf));
     encode_item_ast(ebml_w, in_item);
-    let ebml_doc = ebml::new_doc(@io::mem_buffer_buf(mbuf));
+    let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
     let out_item = decode_item_ast(ebml_doc);
     #debug["out_item = %s", pprust::item_to_str(out_item)];
     assert in_item == out_item;

trunk/src/rustc/metadata/creader.rs

@@ -9,7 +9,7 @@ import syntax::visit;
 import syntax::codemap::span;
 import util::{filesearch};
 import io::writer_util;
-import std::map::{hashmap, new_int_hash};
+import std::map::{hashmap, int_hash};
 import syntax::print::pprust;
 import common::*;
 
@@ -20,7 +20,7 @@ export list_file_metadata;
 // libraries necessary for later resolving, typechecking, linking, etc.
 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::str_hash::<int>(),
               mutable next_crate_num: 1};
     let v =
         visit::mk_simple_visitor(@{visit_view_item:
@@ -275,7 +275,7 @@ fn resolve_crate_deps(e: env, cdata: @[u8]) -> cstore::cnum_map {
     #debug("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 = 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;

trunk/src/rustc/metadata/cstore.rs

@@ -64,8 +64,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::int_hash::<crate_metadata>();
+    let crate_map = map::int_hash::<ast::crate_num>();
     let mod_path_map = new_def_hash();
     ret private(@{metas: meta_cache,
                   use_crate_map: crate_map,

trunk/src/rustc/metadata/decoder.rs

@@ -81,7 +81,7 @@ fn find_item(item_id: int, items: ebml::doc) -> ebml::doc {
 // Looks up an item in the given metadata and returns an ebml doc pointing
 // to the item data.
 fn lookup_item(item_id: int, data: @[u8]) -> ebml::doc {
-    let items = ebml::get_doc(ebml::new_doc(data), tag_items);
+    let items = ebml::get_doc(ebml::doc(data), tag_items);
     ret find_item(item_id, items);
 }
 
@@ -169,7 +169,7 @@ fn resolve_path(path: [ast::ident], data: @[u8]) -> [ast::def_id] {
         ret str::eq(str::from_bytes(data), s);
     }
     let s = str::connect(path, "::");
-    let md = ebml::new_doc(data);
+    let md = ebml::doc(data);
     let paths = ebml::get_doc(md, tag_paths);
     let eqer = bind eq_item(_, s);
     let result: [ast::def_id] = [];
@@ -274,7 +274,7 @@ fn maybe_get_item_ast(cdata: cmd, tcx: ty::ctxt, maps: maps,
 fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
     -> [ty::variant_info] {
     let data = cdata.data;
-    let items = ebml::get_doc(ebml::new_doc(data), tag_items);
+    let items = ebml::get_doc(ebml::doc(data), tag_items);
     let item = find_item(id, items);
     let infos: [ty::variant_info] = [];
     let variant_ids = enum_variant_ids(item, cdata);
@@ -459,14 +459,14 @@ fn list_crate_attributes(md: ebml::doc, hash: str, out: io::writer) {
 }
 
 fn get_crate_attributes(data: @[u8]) -> [ast::attribute] {
-    ret get_attributes(ebml::new_doc(data));
+    ret get_attributes(ebml::doc(data));
 }
 
 type crate_dep = {cnum: ast::crate_num, ident: str};
 
 fn get_crate_deps(data: @[u8]) -> [crate_dep] {
     let deps: [crate_dep] = [];
-    let cratedoc = ebml::new_doc(data);
+    let cratedoc = ebml::doc(data);
     let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
     let crate_num = 1;
     ebml::tagged_docs(depsdoc, tag_crate_dep) {|depdoc|
@@ -488,7 +488,7 @@ fn list_crate_deps(data: @[u8], out: io::writer) {
 }
 
 fn get_crate_hash(data: @[u8]) -> str {
-    let cratedoc = ebml::new_doc(data);
+    let cratedoc = ebml::doc(data);
     let hashdoc = ebml::get_doc(cratedoc, tag_crate_hash);
     ret str::from_bytes(ebml::doc_data(hashdoc));
 }
@@ -503,7 +503,7 @@ fn list_crate_items(bytes: @[u8], md: ebml::doc, out: io::writer) {
 }
 
 fn iter_crate_items(bytes: @[u8], proc: fn(str, ast::def_id)) {
-    let md = ebml::new_doc(bytes);
+    let md = ebml::doc(bytes);
     let paths = ebml::get_doc(md, tag_paths);
     let index = ebml::get_doc(paths, tag_index);
     let bs = ebml::get_doc(index, tag_index_buckets);
@@ -527,7 +527,7 @@ fn get_crate_module_paths(bytes: @[u8]) -> [(ast::def_id, str)] {
     // find all module (path, def_ids), which are not
     // fowarded path due to renamed import or reexport
     let res = [];
-    let mods = map::new_str_hash();
+    let mods = map::str_hash();
     iter_crate_items(bytes) {|path, did|
         let m = mod_of_path(path);
         if str::is_not_empty(m) {
@@ -547,7 +547,7 @@ fn get_crate_module_paths(bytes: @[u8]) -> [(ast::def_id, str)] {
 
 fn list_crate_metadata(bytes: @[u8], out: io::writer) {
     let hash = get_crate_hash(bytes);
-    let md = ebml::new_doc(bytes);
+    let md = ebml::doc(bytes);
     list_crate_attributes(md, hash, out);
     list_crate_deps(bytes, out);
     list_crate_items(bytes, md, out);

trunk/src/rustc/metadata/reachable.rs

@@ -21,7 +21,7 @@ type ctx = {ccx: @middle::trans::common::crate_ctxt,
 
 fn find_reachable(ccx: @middle::trans::common::crate_ctxt, crate_mod: _mod)
     -> map {
-    let rmap = std::map::new_int_hash();
+    let rmap = std::map::int_hash();
     traverse_public_mod({ccx: ccx, rmap: rmap}, crate_mod);
     rmap
 }