Convert std::map::new_str_hash to istrs. Issue #855

Author: brson

src/comp/lib/llvm.rs

@@ -901,22 +901,26 @@ native "cdecl" mod llvm = "rustllvm" {
 /* Memory-managed object interface to type handles. */
 
 obj type_names(type_names: std::map::hashmap<TypeRef, str>,
-               named_types: std::map::hashmap<str, TypeRef>) {
+               named_types: std::map::hashmap<istr, TypeRef>) {
 
     fn associate(s: str, t: TypeRef) {
-        assert (!named_types.contains_key(s));
+        assert (!named_types.contains_key(istr::from_estr(s)));
         assert (!type_names.contains_key(t));
         type_names.insert(t, s);
-        named_types.insert(s, t);
+        named_types.insert(istr::from_estr(s), t);
     }
 
     fn type_has_name(t: TypeRef) -> bool { ret type_names.contains_key(t); }
 
     fn get_name(t: TypeRef) -> str { ret type_names.get(t); }
 
-    fn name_has_type(s: str) -> bool { ret named_types.contains_key(s); }
+    fn name_has_type(s: str) -> bool {
+        ret named_types.contains_key(istr::from_estr(s));
+    }
 
-    fn get_type(s: str) -> TypeRef { ret named_types.get(s); }
+    fn get_type(s: str) -> TypeRef {
+        ret named_types.get(istr::from_estr(s));
+    }
 }
 
 fn mk_type_names() -> type_names {

src/comp/metadata/creader.rs

@@ -47,7 +47,7 @@ fn read_crates(sess: session::session, crate: &ast::crate) {
 
 type env =
     @{sess: session::session,
-      crate_cache: @hashmap<str, int>,
+      crate_cache: @hashmap<istr, int>,
       library_search_paths: [str],
       mutable next_crate_num: ast::crate_num};
 
@@ -226,7 +226,7 @@ fn load_library_crate(sess: &session::session, span: span, ident: &ast::ident,
 
 fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item],
                  span: span) -> ast::crate_num {
-    if !e.crate_cache.contains_key(ident) {
+    if !e.crate_cache.contains_key(istr::from_estr(ident)) {
         let cinfo =
             load_library_crate(e.sess, span, ident, metas,
                                e.library_search_paths);
@@ -236,7 +236,7 @@ fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item],
 
         // Claim this crate number and cache it
         let cnum = e.next_crate_num;
-        e.crate_cache.insert(ident, cnum);
+        e.crate_cache.insert(istr::from_estr(ident), cnum);
         e.next_crate_num += 1;
 
         // Now resolve the crates referenced by this crate
@@ -248,7 +248,7 @@ fn resolve_crate(e: env, ident: ast::ident, metas: [@ast::meta_item],
         cstore::set_crate_data(cstore, cnum, cmeta);
         cstore::add_used_crate_file(cstore, cfilename);
         ret cnum;
-    } else { ret e.crate_cache.get(ident); }
+    } else { ret e.crate_cache.get(istr::from_estr(ident)); }
 }
 
 // Go through the crate metadata and load any crates that it references
@@ -261,10 +261,10 @@ fn resolve_crate_deps(e: env, cdata: &@[u8]) -> cstore::cnum_map {
         let extrn_cnum = dep.cnum;
         let cname = dep.ident;
         log #fmt["resolving dep %s", cname];
-        if e.crate_cache.contains_key(cname) {
+        if e.crate_cache.contains_key(istr::from_estr(cname)) {
             log "already have it";
             // We've already seen this crate
-            let local_cnum = e.crate_cache.get(cname);
+            let local_cnum = e.crate_cache.get(istr::from_estr(cname));
             cnum_map.insert(extrn_cnum, local_cnum);
         } else {
             log "need to load it";

src/comp/middle/gc.rs

@@ -47,7 +47,7 @@ fn add_gc_root(cx: &@block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt {
     bcx = td_r.result.bcx;
     let lltydesc = td_r.result.val;
 
-    let gcroot = bcx_ccx(bcx).intrinsics.get("llvm.gcroot");
+    let gcroot = bcx_ccx(bcx).intrinsics.get(~"llvm.gcroot");
     let llvalptr = bld::PointerCast(bcx, llval, T_ptr(T_ptr(T_i8())));
 
     alt td_r.kind {

src/comp/middle/resolve.rs

@@ -33,6 +33,7 @@ import std::option::is_none;
 import std::option::some;
 import std::option::none;
 import std::str;
+import std::istr;
 import syntax::print::pprust::*;
 
 export resolve_crate;
@@ -101,7 +102,7 @@ tag mod_index_entry {
     mie_tag_variant(/* tag item */@ast::item, /* variant index */uint);
 }
 
-type mod_index = hashmap<ident, list<mod_index_entry>>;
+type mod_index = hashmap<identistr, list<mod_index_entry>>;
 
 // A tuple of an imported def and the import stmt that brung it
 type glob_imp_def = {def: def, item: @ast::view_item};
@@ -110,7 +111,7 @@ type indexed_mod =
     {m: option::t<ast::_mod>,
      index: mod_index,
      mutable glob_imports: [glob_imp_def],
-     glob_imported_names: hashmap<str, import_state>};
+     glob_imported_names: hashmap<istr, import_state>};
 
 
 /* native modules can't contain tags, and we don't store their ASTs because we
@@ -954,7 +955,7 @@ fn lookup_in_local_mod(e: &env, node_id: node_id, sp: &span, id: &ident,
         ret none::<def>; // name is not visible
 
     }
-    alt info.index.find(id) {
+    alt info.index.find(istr::from_estr(id)) {
       none. { }
       some(lst_) {
         let lst = lst_;
@@ -1009,14 +1010,15 @@ fn lookup_glob_in_mod(e: &env, info: @indexed_mod, sp: &span, id: &ident,
     // since we don't know what names we have in advance,
     // absence takes the place of todo()
 
-    if !info.glob_imported_names.contains_key(id) {
-        info.glob_imported_names.insert(id, resolving(sp));
+    if !info.glob_imported_names.contains_key(istr::from_estr(id)) {
+        info.glob_imported_names.insert(istr::from_estr(id), resolving(sp));
         let val = per_ns(e, info, sp, id, ns_value, dr);
         let typ = per_ns(e, info, sp, id, ns_type, dr);
         let md = per_ns(e, info, sp, id, ns_module, dr);
-        info.glob_imported_names.insert(id, resolved(val, typ, md));
+        info.glob_imported_names.insert(istr::from_estr(id),
+                                        resolved(val, typ, md));
     }
-    alt info.glob_imported_names.get(id) {
+    alt info.glob_imported_names.get(istr::from_estr(id)) {
       todo(_, _, _, _, _) { e.sess.bug("Shouldn't've put a todo in."); }
       resolving(sp) {
         ret none::<def>; //circularity is okay in import globs
@@ -1071,10 +1073,12 @@ fn lookup_in_mie(e: &env, mie: &mod_index_entry, ns: namespace) ->
 
 
 // Module indexing
-fn add_to_index(index: &hashmap<ident, list<mod_index_entry>>, id: &ident,
-                ent: &mod_index_entry) {
+fn add_to_index(index: &hashmap<identistr, list<mod_index_entry>>,
+                id: &ident, ent: &mod_index_entry) {
+    let id = istr::from_estr(id);
     alt index.find(id) {
-      none. { index.insert(id, cons(ent, @nil::<mod_index_entry>)); }
+      none. { index.insert(id,
+                           cons(ent, @nil::<mod_index_entry>)); }
       some(prev) { index.insert(id, cons(ent, @prev)); }
     }
 }
@@ -1187,9 +1191,9 @@ fn check_for_collisions(e: &@env, c: &ast::crate) {
     // Module indices make checking those relatively simple -- just check each
     // name for multiple entities in the same namespace.
     for each m: @{key: ast::node_id, val: @indexed_mod} in e.mod_map.items() {
-        for each name: @{key: ident, val: list<mod_index_entry>} in
+        for each name: @{key: identistr, val: list<mod_index_entry>} in
                  m.val.index.items() {
-            check_mod_name(*e, name.key, name.val);
+            check_mod_name(*e, istr::to_estr(name.key), name.val);
         }
     }
     // Other scopes have to be checked the hard way.

src/comp/middle/trans.rs

@@ -355,31 +355,35 @@ fn decl_glue(llmod: ModuleRef, cx: &crate_ctxt, s: &str) -> ValueRef {
     ret decl_cdecl_fn(llmod, s, T_fn([T_taskptr(cx)], T_void()));
 }
 
-fn get_extern_fn(externs: &hashmap<str, ValueRef>, llmod: ModuleRef,
+fn get_extern_fn(externs: &hashmap<istr, ValueRef>, llmod: ModuleRef,
                  name: &str, cc: uint, ty: TypeRef) -> ValueRef {
-    if externs.contains_key(name) { ret externs.get(name); }
+    if externs.contains_key(istr::from_estr(name)) {
+        ret externs.get(istr::from_estr(name));
+    }
     let f = decl_fn(llmod, name, cc, ty);
-    externs.insert(name, f);
+    externs.insert(istr::from_estr(name), f);
     ret f;
 }
 
-fn get_extern_const(externs: &hashmap<str, ValueRef>, llmod: ModuleRef,
+fn get_extern_const(externs: &hashmap<istr, ValueRef>, llmod: ModuleRef,
                     name: &str, ty: TypeRef) -> ValueRef {
-    if externs.contains_key(name) { ret externs.get(name); }
+    if externs.contains_key(istr::from_estr(name)) {
+        ret externs.get(istr::from_estr(name));
+    }
     let c = llvm::LLVMAddGlobal(llmod, ty, str::buf(name));
-    externs.insert(name, c);
+    externs.insert(istr::from_estr(name), c);
     ret c;
 }
 
-fn get_simple_extern_fn(externs: &hashmap<str, ValueRef>, llmod: ModuleRef,
+fn get_simple_extern_fn(externs: &hashmap<istr, ValueRef>, llmod: ModuleRef,
                         name: &str, n_args: int) -> ValueRef {
     let inputs = std::vec::init_elt::<TypeRef>(T_int(), n_args as uint);
     let output = T_int();
     let t = T_fn(inputs, output);
     ret get_extern_fn(externs, llmod, name, lib::llvm::LLVMCCallConv, t);
 }
 
-fn trans_native_call(cx: &@block_ctxt, externs: &hashmap<str, ValueRef>,
+fn trans_native_call(cx: &@block_ctxt, externs: &hashmap<istr, ValueRef>,
                      llmod: ModuleRef, name: &str, args: &[ValueRef]) ->
    ValueRef {
     let n: int = std::vec::len::<ValueRef>(args) as int;
@@ -2287,8 +2291,8 @@ fn call_memmove(cx: &@block_ctxt, dst: ValueRef, src: ValueRef,
     // LLVM complains -- not even a constant element of a tydesc works).
 
     let i = bcx_ccx(cx).intrinsics;
-    assert (i.contains_key("llvm.memmove.p0i8.p0i8.i32"));
-    let memmove = i.get("llvm.memmove.p0i8.p0i8.i32");
+    assert (i.contains_key(~"llvm.memmove.p0i8.p0i8.i32"));
+    let memmove = i.get(~"llvm.memmove.p0i8.p0i8.i32");
     let src_ptr = bld::PointerCast(cx, src, T_ptr(T_i8()));
     let dst_ptr = bld::PointerCast(cx, dst, T_ptr(T_i8()));
     let size = bld::IntCast(cx, n_bytes, T_i32());
@@ -2304,8 +2308,8 @@ fn call_bzero(cx: &@block_ctxt, dst: ValueRef, n_bytes: ValueRef,
     // FIXME: switch to the 64-bit variant when on such a platform.
 
     let i = bcx_ccx(cx).intrinsics;
-    assert (i.contains_key("llvm.memset.p0i8.i32"));
-    let memset = i.get("llvm.memset.p0i8.i32");
+    assert (i.contains_key(~"llvm.memset.p0i8.i32"));
+    let memset = i.get(~"llvm.memset.p0i8.i32");
     let dst_ptr = bld::PointerCast(cx, dst, T_ptr(T_i8()));
     let size = bld::IntCast(cx, n_bytes, T_i32());
     let align =
@@ -4524,8 +4528,8 @@ fn trans_log(lvl: int, cx: &@block_ctxt, e: &@ast::expr) -> result {
     let lcx = cx.fcx.lcx;
     let modname = str::connect(lcx.module_path, "::");
     let global;
-    if lcx.ccx.module_data.contains_key(modname) {
-        global = lcx.ccx.module_data.get(modname);
+    if lcx.ccx.module_data.contains_key(istr::from_estr(modname)) {
+        global = lcx.ccx.module_data.get(istr::from_estr(modname));
     } else {
         let s =
             link::mangle_internal_name_by_path_and_seq(lcx.ccx,
@@ -4536,7 +4540,7 @@ fn trans_log(lvl: int, cx: &@block_ctxt, e: &@ast::expr) -> result {
         llvm::LLVMSetInitializer(global, C_null(T_int()));
         llvm::LLVMSetLinkage(global,
                              lib::llvm::LLVMInternalLinkage as llvm::Linkage);
-        lcx.ccx.module_data.insert(modname, global);
+        lcx.ccx.module_data.insert(istr::from_estr(modname), global);
     }
     let log_cx = new_scope_block_ctxt(cx, "log");
     let after_cx = new_sub_block_ctxt(cx, "after");
@@ -6168,7 +6172,7 @@ fn vi2p(cx: &@block_ctxt, v: ValueRef, t: TypeRef) -> ValueRef {
 
 fn p2i(v: ValueRef) -> ValueRef { ret llvm::LLVMConstPtrToInt(v, T_int()); }
 
-fn declare_intrinsics(llmod: ModuleRef) -> hashmap<str, ValueRef> {
+fn declare_intrinsics(llmod: ModuleRef) -> hashmap<istr, ValueRef> {
     let T_memmove32_args: [TypeRef] =
         [T_ptr(T_i8()), T_ptr(T_i8()), T_i32(), T_i32(), T_i1()];
     let T_memmove64_args: [TypeRef] =
@@ -6198,19 +6202,19 @@ fn declare_intrinsics(llmod: ModuleRef) -> hashmap<str, ValueRef> {
                       T_fn(T_memset64_args, T_void()));
     let trap = decl_cdecl_fn(llmod, "llvm.trap", T_fn(T_trap_args, T_void()));
     let intrinsics = new_str_hash::<ValueRef>();
-    intrinsics.insert("llvm.gcroot", gcroot);
-    intrinsics.insert("llvm.gcread", gcread);
-    intrinsics.insert("llvm.memmove.p0i8.p0i8.i32", memmove32);
-    intrinsics.insert("llvm.memmove.p0i8.p0i8.i64", memmove64);
-    intrinsics.insert("llvm.memset.p0i8.i32", memset32);
-    intrinsics.insert("llvm.memset.p0i8.i64", memset64);
-    intrinsics.insert("llvm.trap", trap);
+    intrinsics.insert(~"llvm.gcroot", gcroot);
+    intrinsics.insert(~"llvm.gcread", gcread);
+    intrinsics.insert(~"llvm.memmove.p0i8.p0i8.i32", memmove32);
+    intrinsics.insert(~"llvm.memmove.p0i8.p0i8.i64", memmove64);
+    intrinsics.insert(~"llvm.memset.p0i8.i32", memset32);
+    intrinsics.insert(~"llvm.memset.p0i8.i64", memset64);
+    intrinsics.insert(~"llvm.trap", trap);
     ret intrinsics;
 }
 
 fn trap(bcx: &@block_ctxt) {
     let v: [ValueRef] = [];
-    alt bcx_ccx(bcx).intrinsics.find("llvm.trap") {
+    alt bcx_ccx(bcx).intrinsics.find(~"llvm.trap") {
       some(x) { bld::Call(bcx, x, v); }
       _ { bcx_ccx(bcx).sess.bug("unbound llvm.trap in trap"); }
     }
@@ -6264,8 +6268,9 @@ fn create_module_map(ccx: &@crate_ctxt) -> ValueRef {
     llvm::LLVMSetLinkage(map,
                          lib::llvm::LLVMInternalLinkage as llvm::Linkage);
     let elts: [ValueRef] = [];
-    for each item: @{key: str, val: ValueRef} in ccx.module_data.items() {
-        let elt = C_struct([p2i(C_cstr(ccx, item.key)), p2i(item.val)]);
+    for each item: @{key: istr, val: ValueRef} in ccx.module_data.items() {
+        let elt = C_struct([p2i(C_cstr(ccx, istr::to_estr(item.key))),
+                            p2i(item.val)]);
         elts += [elt];
     }
     let term = C_struct([C_int(0), C_int(0)]);

src/comp/middle/trans_alt.rs

@@ -1,4 +1,5 @@
 import std::str;
+import std::istr;
 import std::vec;
 import std::option;
 import option::some;
@@ -303,7 +304,8 @@ fn compile_submatch(bcx: @block_ctxt, m: &match, vals: [ValueRef],
             // the actual arm block.
             for each @{key, val} in data.id_map.items() {
                 bcx.fcx.lllocals.insert
-                    (val, option::get(assoc(key, m[0].bound)));
+                    (val, option::get(assoc(istr::to_estr(key),
+                                            m[0].bound)));
             }
             let {bcx: guard_bcx, val: guard_val} =
                 trans::trans_expr(guard_cx, e);
@@ -467,12 +469,12 @@ fn make_phi_bindings(bcx: &@block_ctxt, map: &[exit_node],
                      ids: &ast_util::pat_id_map) -> bool {
     let our_block = bcx.llbb as uint;
     let success = true;
-    for each item: @{key: ast::ident, val: ast::node_id} in ids.items() {
+    for each item: @{key: ast::identistr, val: ast::node_id} in ids.items() {
         let llbbs = [];
         let vals = [];
         for ex: exit_node in map {
             if ex.to as uint == our_block {
-                alt assoc(item.key, ex.bound) {
+                alt assoc(istr::to_estr(item.key), ex.bound) {
                   some(val) { llbbs += [ex.from]; vals += [val]; }
                   none. { }
                 }

src/comp/middle/trans_common.rs

@@ -127,8 +127,8 @@ type crate_ctxt =
      llmod: ModuleRef,
      td: target_data,
      tn: type_names,
-     externs: hashmap<str, ValueRef>,
-     intrinsics: hashmap<str, ValueRef>,
+     externs: hashmap<istr, ValueRef>,
+     intrinsics: hashmap<istr, ValueRef>,
      item_ids: hashmap<ast::node_id, ValueRef>,
      ast_map: ast_map::map,
      item_symbols: hashmap<ast::node_id, str>,
@@ -141,7 +141,7 @@ type crate_ctxt =
      consts: hashmap<ast::node_id, ValueRef>,
      obj_methods: hashmap<ast::node_id, ()>,
      tydescs: hashmap<ty::t, @tydesc_info>,
-     module_data: hashmap<str, ValueRef>,
+     module_data: hashmap<istr, ValueRef>,
      lltypes: hashmap<ty::t, TypeRef>,
      glues: @glue_fns,
      names: namegen,

src/comp/middle/typeck.rs

@@ -1322,7 +1322,7 @@ fn check_pat(fcx: &@fn_ctxt, map: &ast_util::pat_id_map, pat: &@ast::pat,
         let vid = lookup_local(fcx, pat.span, pat.id);
         let typ = ty::mk_var(fcx.ccx.tcx, vid);
         typ = demand::simple(fcx, pat.span, expected, typ);
-        let canon_id = map.get(name);
+        let canon_id = map.get(istr::from_estr(name));
         if canon_id != pat.id {
             let ct =
                 ty::mk_var(fcx.ccx.tcx,

src/comp/syntax/ast.rs

@@ -8,6 +8,8 @@ import codemap::filename;
 type spanned<T> = {node: T, span: span};
 
 type ident = str;
+type identistr = istr;
+
 // Functions may or may not have names.
 type fn_ident = option::t<ident>;