Remove redundant hashmap constructor functions.

Author: graydon

src/cargo/cargo.rs

@@ -668,11 +668,11 @@ fn configure(opts: options) -> cargo {
 
     let p = result::get(get_cargo_dir());
 
-    let sources = map::str_hash();
+    let sources = map::HashMap();
     try_parse_sources(&home.push("sources.json"), sources);
     try_parse_sources(&home.push("local-sources.json"), sources);
 
-    let dep_cache = map::str_hash();
+    let dep_cache = map::HashMap();
 
     let mut c = {
         pgp: pgp::supported(),
@@ -1577,7 +1577,7 @@ fn dump_cache(c: &cargo) {
     need_dir(&c.root);
 
     let out = c.root.push("cache.json");
-    let _root = json::Dict(map::str_hash());
+    let _root = json::Dict(map::HashMap());
 
     if os::path_exists(&out) {
         copy_warn(&out, &c.root.push("cache.json.old"));
@@ -1598,11 +1598,11 @@ fn dump_sources(c: &cargo) {
 
     match io::buffered_file_writer(&out) {
         result::Ok(writer) => {
-            let hash = map::str_hash();
+            let hash = map::HashMap();
             let root = json::Dict(hash);
 
           for c.sources.each |k, v| {
-                let chash = map::str_hash();
+                let chash = map::HashMap();
                 let child = json::Dict(chash);
 
                 chash.insert(~"url", json::String(@v.url));

src/libstd/json.rs

@@ -517,7 +517,7 @@ impl Parser {
         self.bump();
         self.parse_whitespace();
 
-        let values = map::str_hash();
+        let values = map::HashMap();
 
         if self.ch == '}' {
           self.bump();
@@ -802,7 +802,7 @@ impl <A: ToJson> ~[A]: ToJson {
 
 impl <A: ToJson Copy> HashMap<~str, A>: ToJson {
     fn to_json() -> Json {
-        let d = map::str_hash();
+        let d = map::HashMap();
         for self.each() |key, value| {
             d.insert(copy key, value.to_json());
         }
@@ -832,7 +832,7 @@ impl Error: to_str::ToStr {
 #[cfg(test)]
 mod tests {
     fn mk_dict(items: &[(~str, Json)]) -> Json {
-        let d = map::str_hash();
+        let d = map::HashMap();
 
         for vec::each(items) |item| {
             let (key, value) = copy *item;

src/libstd/map.rs

@@ -12,11 +12,8 @@ use core::cmp::Eq;
 use hash::Hash;
 use to_bytes::IterBytes;
 
-export HashMap, hashfn, eqfn, Set, Map, chained, hashmap, str_hash;
-export box_str_hash;
-export bytes_hash, int_hash, uint_hash, set_add;
-export hash_from_vec, hash_from_strs, hash_from_bytes;
-export hash_from_ints, hash_from_uints;
+export HashMap, hashfn, eqfn, Set, Map, chained, set_add;
+export hash_from_vec;
 export vec_from_set;
 
 /// A convenience type to treat a hashmap as a set
@@ -385,36 +382,6 @@ fn HashMap<K:Eq IterBytes Hash Const, V: Copy>()
     chained::mk()
 }
 
-/// Construct a hashmap for string-slice keys
-fn str_slice_hash<V: Copy>() -> HashMap<&str, V> {
-    return HashMap();
-}
-
-/// Construct a hashmap for string keys
-fn str_hash<V: Copy>() -> HashMap<~str, V> {
-    return HashMap();
-}
-
-/// Construct a hashmap for boxed string keys
-fn box_str_hash<V: Copy>() -> HashMap<@~str, V> {
-    HashMap()
-}
-
-/// Construct a hashmap for byte string keys
-fn bytes_hash<V: Copy>() -> HashMap<~[u8], V> {
-    return HashMap();
-}
-
-/// Construct a hashmap for int keys
-fn int_hash<V: Copy>() -> HashMap<int, V> {
-    return HashMap();
-}
-
-/// Construct a hashmap for uint keys
-fn uint_hash<V: Copy>() -> HashMap<uint, V> {
-    return HashMap();
-}
-
 /// Convenience function for adding keys to a hashmap with nil type keys
 fn set_add<K:Eq IterBytes Hash Const Copy>(set: Set<K>, +key: K) -> bool {
     set.insert(key, ())
@@ -445,26 +412,6 @@ fn hash_from_vec<K: Eq IterBytes Hash Const Copy, V: Copy>(
     map
 }
 
-/// Construct a hashmap from a vector with string keys
-fn hash_from_strs<V: Copy>(items: &[(~str, V)]) -> HashMap<~str, V> {
-    hash_from_vec(items)
-}
-
-/// Construct a hashmap from a vector with byte keys
-fn hash_from_bytes<V: Copy>(items: &[(~[u8], V)]) -> HashMap<~[u8], V> {
-    hash_from_vec(items)
-}
-
-/// Construct a hashmap from a vector with int keys
-fn hash_from_ints<V: Copy>(items: &[(int, V)]) -> HashMap<int, V> {
-    hash_from_vec(items)
-}
-
-/// Construct a hashmap from a vector with uint keys
-fn hash_from_uints<V: Copy>(items: &[(uint, V)]) -> HashMap<uint, V> {
-    hash_from_vec(items)
-}
-
 // XXX Transitional
 impl<K: Eq IterBytes Hash Copy, V: Copy> @Mut<LinearMap<K, V>>:
     Map<K, V> {
@@ -810,7 +757,7 @@ mod tests {
 
     #[test]
     fn test_hash_from_vec() {
-        let map = map::hash_from_strs(~[
+        let map = map::hash_from_vec(~[
             (~"a", 1),
             (~"b", 2),
             (~"c", 3)

src/libstd/net_url.rs

@@ -3,7 +3,7 @@
 #[forbid(deprecated_pattern)];
 
 use core::cmp::Eq;
-use map::{HashMap, str_hash};
+use map::HashMap;
 use io::{Reader, ReaderUtil};
 use dvec::DVec;
 use from_str::FromStr;
@@ -213,7 +213,7 @@ fn encode_form_urlencoded(m: HashMap<~str, @DVec<@~str>>) -> ~str {
 fn decode_form_urlencoded(s: ~[u8]) ->
     map::HashMap<~str, @dvec::DVec<@~str>> {
     do io::with_bytes_reader(s) |rdr| {
-        let m = str_hash();
+        let m = HashMap();
         let mut key = ~"";
         let mut value = ~"";
         let mut parsing_key = true;
@@ -1069,26 +1069,24 @@ mod tests {
 
     #[test]
     fn test_encode_form_urlencoded() {
-        let m = str_hash();
+        let m = HashMap();
         assert encode_form_urlencoded(m) == ~"";
 
         m.insert(~"", @DVec());
         m.insert(~"foo", @DVec());
         assert encode_form_urlencoded(m) == ~"";
 
-        let m = str_hash();
+        let m = HashMap();
         m.insert(~"foo", @dvec::from_vec(~[@~"bar", @~"123"]));
         assert encode_form_urlencoded(m) == ~"foo=bar&foo=123";
 
-        let m = str_hash();
+        let m = HashMap();
         m.insert(~"foo bar", @dvec::from_vec(~[@~"abc", @~"12 = 34"]));
         assert encode_form_urlencoded(m) == ~"foo+bar=abc&foo+bar=12+%3D+34";
     }
 
     #[test]
     fn test_decode_form_urlencoded() {
-        use map::hash_from_strs;
-
         assert decode_form_urlencoded(~[]).size() == 0;
 
         let s = str::to_bytes(~"a=1&foo+bar=abc&foo+bar=12+%3D+34");

src/libsyntax/ast_map.rs

@@ -103,7 +103,7 @@ fn mk_ast_map_visitor() -> vt {
 }
 
 fn map_crate(diag: span_handler, c: crate) -> map {
-    let cx = {map: std::map::int_hash(),
+    let cx = {map: std::map::HashMap(),
               mut path: ~[],
               mut local_id: 0u,
               diag: diag};

src/libsyntax/ast_util.rs

@@ -259,10 +259,6 @@ impl def_id : core::to_bytes::IterBytes {
     }
 }
 
-fn new_def_hash<V: Copy>() -> std::map::HashMap<ast::def_id, V> {
-    return std::map::HashMap::<ast::def_id, V>();
-}
-
 fn block_from_expr(e: @expr) -> blk {
     let blk_ = default_block(~[], option::Some::<@expr>(e), e.id);
     return {node: blk_, span: e.span};

src/libsyntax/attr.rs

@@ -368,7 +368,7 @@ fn find_inline_attr(attrs: ~[ast::attribute]) -> inline_attr {
 
 fn require_unique_names(diagnostic: span_handler,
                         metas: ~[@ast::meta_item]) {
-    let map = map::str_hash();
+    let map = map::HashMap();
     for metas.each |meta| {
         let name = get_meta_item_name(meta);
 

src/libsyntax/ext/auto_serialize.rs

@@ -564,7 +564,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
                       id: cx.next_id()}],
                     tp_inputs);
 
-    let tps_map = map::uint_hash();
+    let tps_map = map::HashMap();
     do vec::iter2(tps, tp_inputs) |tp, arg| {
         let arg_ident = arg.ident;
         tps_map.insert(
@@ -771,7 +771,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
                       id: cx.next_id()}],
                     tp_inputs);
 
-    let tps_map = map::uint_hash();
+    let tps_map = map::HashMap();
     do vec::iter2(tps, tp_inputs) |tp, arg| {
         let arg_ident = arg.ident;
         tps_map.insert(

src/libsyntax/ext/base.rs

@@ -2,7 +2,6 @@ use std::map::HashMap;
 use parse::parser;
 use diagnostic::span_handler;
 use codemap::{codemap, span, expn_info, expanded_from};
-use std::map::str_hash;
 
 // obsolete old-style #macro code:
 //
@@ -74,7 +73,7 @@ fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
     fn builtin_item_tt(f: syntax_expander_tt_item_) -> syntax_extension {
         item_tt({expander: f, span: None})
     }
-    let syntax_expanders = str_hash::<syntax_extension>();
+    let syntax_expanders = HashMap::<~str,syntax_extension>();
     syntax_expanders.insert(~"macro",
                             macro_defining(ext::simplext::add_new_extension));
     syntax_expanders.insert(~"macro_rules",

src/libsyntax/ext/simplext.rs

@@ -1,5 +1,5 @@
 use codemap::span;
-use std::map::{HashMap, str_hash, uint_hash};
+use std::map::HashMap;
 use dvec::DVec;
 
 use base::*;
@@ -135,7 +135,7 @@ fn acumm_bindings(_cx: ext_ctxt, _b_dest: bindings, _b_src: bindings) { }
 
 fn pattern_to_selectors(cx: ext_ctxt, e: @expr) -> binders {
     let res: binders =
-        {real_binders: uint_hash::<selector>(),
+        {real_binders: HashMap(),
          literal_ast_matchers: DVec()};
     //this oughta return binders instead, but macro args are a sequence of
     //expressions, rather than a single expression
@@ -153,7 +153,7 @@ bindings. Most of the work is done in p_t_s, which generates the
 selectors. */
 
 fn use_selectors_to_bind(b: binders, e: @expr) -> Option<bindings> {
-    let res = uint_hash::<arb_depth<matchable>>();
+    let res = HashMap();
     //need to do this first, to check vec lengths.
     for b.literal_ast_matchers.each |sel| {
         match sel(match_expr(e)) { None => return None, _ => () }
@@ -237,7 +237,7 @@ fn follow_for_trans(cx: ext_ctxt, mmaybe: Option<arb_depth<matchable>>,
 
 /* helper for transcribe_exprs: what vars from `b` occur in `e`? */
 fn free_vars(b: bindings, e: @expr, it: fn(ident)) {
-    let idents: HashMap<ident, ()> = uint_hash::<()>();
+    let idents: HashMap<ident, ()> = HashMap();
     fn mark_ident(&&i: ident, _fld: ast_fold, b: bindings,
                   idents: HashMap<ident, ()>) -> ident {
         if b.contains_key(i) { idents.insert(i, ()); }

src/libsyntax/ext/tt/macro_parser.rs

@@ -10,7 +10,7 @@ use parse::parse_sess;
 use dvec::DVec;
 use ast::{matcher, match_tok, match_seq, match_nonterminal, ident};
 use ast_util::mk_sp;
-use std::map::{HashMap, uint_hash};
+use std::map::HashMap;
 
 /* This is an Earley-like parser, without support for in-grammar nonterminals,
 only by calling out to the main rust parser for named nonterminals (which it
@@ -185,7 +185,7 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
           }
         }
     }
-    let ret_val = uint_hash::<@named_match>();
+    let ret_val = HashMap::<uint,@named_match>();
     for ms.each() |m| { n_rec(p_s, m, res, ret_val) }
     return ret_val;
 }

src/libsyntax/ext/tt/transcribe.rs

@@ -4,7 +4,7 @@ use macro_parser::{named_match, matched_seq, matched_nonterminal};
 use codemap::span;
 use parse::token::{EOF, INTERPOLATED, IDENT, token, nt_ident,
                       ident_interner};
-use std::map::{HashMap, box_str_hash};
+use std::map::HashMap;
 
 export tt_reader,  new_tt_reader, dup_tt_reader, tt_next_token;
 
@@ -47,7 +47,7 @@ fn new_tt_reader(sp_diag: span_handler, itr: ident_interner,
               mut cur: @{readme: src, mut idx: 0u, dotdotdoted: false,
                          sep: None, up: tt_frame_up(option::None)},
               interpolations: match interp { /* just a convienience */
-                None => std::map::uint_hash::<@named_match>(),
+                None => std::map::HashMap::<uint,@named_match>(),
                 Some(x) => x
               },
               mut repeat_idx: ~[mut], mut repeat_len: ~[],

src/libsyntax/parse/parser.rs

@@ -2,7 +2,7 @@ use print::pprust::expr_to_str;
 
 use result::Result;
 use either::{Either, Left, Right};
-use std::map::{HashMap, str_hash};
+use std::map::HashMap;
 use token::{can_begin_expr, is_ident, is_ident_or_path, is_plain_ident,
             INTERPOLATED, special_idents};
 use codemap::{span,fss_none};

src/libsyntax/parse/token.rs

@@ -1,6 +1,6 @@
 use util::interner;
 use util::interner::interner;
-use std::map::{HashMap, str_hash};
+use std::map::HashMap;
 use std::serialization::{Serializer,
                             Deserializer,
                             serialize_uint,
@@ -369,7 +369,7 @@ fn mk_fake_ident_interner() -> ident_interner {
  * the language and may not appear as identifiers.
  */
 fn keyword_table() -> HashMap<~str, ()> {
-    let keywords = str_hash();
+    let keywords = HashMap();
     for temporary_keyword_table().each_key |word| {
         keywords.insert(word, ());
     }
@@ -384,7 +384,7 @@ fn keyword_table() -> HashMap<~str, ()> {
 
 /// Keywords that may be used as identifiers
 fn temporary_keyword_table() -> HashMap<~str, ()> {
-    let words = str_hash();
+    let words = HashMap();
     let keys = ~[
         ~"self", ~"static",
     ];
@@ -396,7 +396,7 @@ fn temporary_keyword_table() -> HashMap<~str, ()> {
 
 /// Full keywords. May not appear anywhere else.
 fn strict_keyword_table() -> HashMap<~str, ()> {
-    let words = str_hash();
+    let words = HashMap();
     let keys = ~[
         ~"as", ~"assert",
         ~"break",
@@ -421,7 +421,7 @@ fn strict_keyword_table() -> HashMap<~str, ()> {
 }
 
 fn reserved_keyword_table() -> HashMap<~str, ()> {
-    let words = str_hash();
+    let words = HashMap();
     let keys = ~[
         ~"be"
     ];

src/rustc/back/rpath.rs

@@ -167,7 +167,7 @@ fn get_install_prefix_rpath(target_triple: &str) -> Path {
 }
 
 fn minimize_rpaths(rpaths: &[Path]) -> ~[Path] {
-    let set = map::str_hash::<()>();
+    let set = map::HashMap();
     let mut minimized = ~[];
     for rpaths.each |rpath| {
         let s = rpath.to_str();