rustc: Purge of HashMap, fixing segfaulting cases

Various FIXME comments added around to denote copies which when removed cause
the compiler to segfault at some point before stage2. None of these copies
should even be necessary.

Author: alexcrichton

src/librustc/metadata/tyencode.rs

@@ -61,7 +61,7 @@ pub fn enc_ty(w: @io::Writer, cx: @ctxt, t: ty::t) {
     match cx.abbrevs {
       ac_no_abbrevs => {
         let result_str = match cx.tcx.short_names_cache.find(&t) {
-            Some(s) => /*bad*/copy *s,
+            Some(&s) => /*bad*/copy *s,
             None => {
                 let s = do io::with_str_writer |wr| {
                     enc_sty(wr, cx, /*bad*/copy ty::get(t).sty);

src/librustc/middle/astencode.rs

@@ -856,7 +856,9 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,
         do ebml_w.tag(c::tag_table_node_type_subst) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {
-                ebml_w.emit_tys(ecx, /*bad*/copy *tys)
+                // FIXME(#5562): removing this copy causes a segfault
+                //               before stage2
+                ebml_w.emit_tys(ecx, /*bad*/copy **tys)
             }
         }
     }
@@ -922,7 +924,7 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext,
         }
     }
 
-    for maps.method_map.find(&id).each |mme| {
+    for maps.method_map.find(&id).each |&mme| {
         do ebml_w.tag(c::tag_table_method_map) {
             ebml_w.id(id);
             do ebml_w.tag(c::tag_table_val) {

src/librustc/middle/const_eval.rs

@@ -17,7 +17,6 @@ use middle;
 
 use core::float;
 use core::vec;
-use std::oldmap::HashMap;
 use syntax::{ast, ast_map, ast_util, visit};
 use syntax::ast::*;
 
@@ -194,7 +193,7 @@ pub fn lookup_const_by_id(tcx: ty::ctxt,
             mutbl_map: @mut LinearSet::new(),
             root_map: @mut LinearMap::new(),
             last_use_map: @mut LinearMap::new(),
-            method_map: HashMap(),
+            method_map: @mut LinearMap::new(),
             vtable_map: @mut LinearMap::new(),
             write_guard_map: @mut LinearSet::new(),
             moves_map: @mut LinearSet::new(),

src/librustc/middle/kind.rs

@@ -274,6 +274,8 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt<Context>) {
         _ => e.id
     };
     for cx.tcx.node_type_substs.find(&type_parameter_id).each |ts| {
+        // FIXME(#5562): removing this copy causes a segfault before stage2
+        let ts = /*bad*/ copy **ts;
         let bounds = match e.node {
           expr_path(_) => {
             let did = ast_util::def_id_of_def(*cx.tcx.def_map.get(&e.id));
@@ -289,15 +291,15 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt<Context>) {
                 ~"non path/method call expr has type substs??")
           }
         };
-        if vec::len(*ts) != vec::len(*bounds) {
+        if ts.len() != bounds.len() {
             // Fail earlier to make debugging easier
             fail!(fmt!("internal error: in kind::check_expr, length \
                        mismatch between actual and declared bounds: actual = \
                         %s (%u tys), declared = %? (%u tys)",
-                      tys_to_str(cx.tcx, *ts), ts.len(),
-                      *bounds, (*bounds).len()));
+                      tys_to_str(cx.tcx, ts), ts.len(),
+                      *bounds, bounds.len()));
         }
-        for vec::each2(*ts, *bounds) |ty, bound| {
+        for vec::each2(ts, *bounds) |ty, bound| {
             check_bounds(cx, type_parameter_id, e.span, *ty, *bound)
         }
     }
@@ -335,9 +337,11 @@ fn check_ty(aty: @Ty, cx: Context, v: visit::vt<Context>) {
     match aty.node {
       ty_path(_, id) => {
         for cx.tcx.node_type_substs.find(&id).each |ts| {
+            // FIXME(#5562): removing this copy causes a segfault before stage2
+            let ts = /*bad*/ copy **ts;
             let did = ast_util::def_id_of_def(*cx.tcx.def_map.get(&id));
             let bounds = ty::lookup_item_type(cx.tcx, did).bounds;
-            for vec::each2(*ts, *bounds) |ty, bound| {
+            for vec::each2(ts, *bounds) |ty, bound| {
                 check_bounds(cx, aty.id, aty.span, *ty, *bound)
             }
         }

src/librustc/middle/trans/base.rs

@@ -72,8 +72,7 @@ use core::int;
 use core::io;
 use core::libc::{c_uint, c_ulonglong};
 use core::uint;
-use std::oldmap::HashMap;
-use std::{oldmap, time, list};
+use std::{time, list};
 use syntax::ast::ident;
 use syntax::ast_map::{path, path_elt_to_str, path_mod, path_name};
 use syntax::ast_util::{def_id_of_def, local_def, path_to_ident};
@@ -170,16 +169,22 @@ pub fn get_extern_fn(externs: ExternMap,
                      name: @str,
                      cc: lib::llvm::CallConv,
                      ty: TypeRef) -> ValueRef {
-    if externs.contains_key(&name) { return externs.get(&name); }
+    match externs.find(&name) {
+        Some(n) => return copy *n,
+        None => ()
+    }
     let f = decl_fn(llmod, name, cc, ty);
     externs.insert(name, f);
     return f;
 }
 
 pub fn get_extern_const(externs: ExternMap, llmod: ModuleRef,
                         name: @str, ty: TypeRef) -> ValueRef {
+    match externs.find(&name) {
+        Some(n) => return copy *n,
+        None => ()
+    }
     unsafe {
-        if externs.contains_key(&name) { return externs.get(&name); }
         let c = str::as_c_str(name, |buf| {
             llvm::LLVMAddGlobal(llmod, ty, buf)
         });
@@ -3061,7 +3066,7 @@ pub fn trans_crate(sess: session::Session,
               llmod: llmod,
               td: td,
               tn: tn,
-              externs: HashMap(),
+              externs: @mut LinearMap::new(),
               intrinsics: intrinsics,
               item_vals: @mut LinearMap::new(),
               exp_map2: emap2,
@@ -3082,8 +3087,8 @@ pub fn trans_crate(sess: session::Session,
               const_globals: @mut LinearMap::new(),
               const_values: @mut LinearMap::new(),
               module_data: @mut LinearMap::new(),
-              lltypes: ty::new_ty_hash(),
-              llsizingtypes: ty::new_ty_hash(),
+              lltypes: @mut LinearMap::new(),
+              llsizingtypes: @mut LinearMap::new(),
               adt_reprs: @mut LinearMap::new(),
               names: new_namegen(sess.parse_sess.interner),
               next_addrspace: new_addrspace_gen(),

src/librustc/middle/trans/callee.rs

@@ -82,9 +82,12 @@ pub fn trans(bcx: block, expr: @ast::expr) -> Callee {
         }
         ast::expr_field(base, _, _) => {
             match bcx.ccx().maps.method_map.find(&expr.id) {
-                Some(ref origin) => { // An impl method
+                Some(origin) => { // An impl method
+                    // FIXME(#5562): removing this copy causes a segfault
+                    //               before stage2
+                    let origin = /*bad*/ copy *origin;
                     return meth::trans_method_callee(bcx, expr.id,
-                                                     base, (*origin));
+                                                     base, origin);
                 }
                 None => {} // not a method, just a field
             }
@@ -343,11 +346,14 @@ pub fn trans_method_call(in_cx: block,
         expr_ty(in_cx, call_ex),
         |cx| {
             match cx.ccx().maps.method_map.find(&call_ex.id) {
-                Some(ref origin) => {
+                Some(origin) => {
+                    // FIXME(#5562): removing this copy causes a segfault
+                    //               before stage2
+                    let origin = /*bad*/ copy *origin;
                     meth::trans_method_callee(cx,
                                               call_ex.callee_id,
                                               rcvr,
-                                              (*origin))
+                                              origin)
                 }
                 None => {
                     cx.tcx().sess.span_bug(call_ex.span,

src/librustc/middle/trans/common.rs

@@ -52,7 +52,6 @@ use core::str;
 use core::to_bytes;
 use core::vec::raw::to_ptr;
 use core::vec;
-use std::oldmap::{HashMap, Set};
 use syntax::ast::ident;
 use syntax::ast_map::{path, path_elt};
 use syntax::codemap::span;
@@ -156,7 +155,7 @@ pub fn BuilderRef_res(B: BuilderRef) -> BuilderRef_res {
     }
 }
 
-pub type ExternMap = HashMap<@str, ValueRef>;
+pub type ExternMap = @mut LinearMap<@str, ValueRef>;
 
 // Crate context.  Every crate we compile has one of these.
 pub struct CrateContext {
@@ -203,8 +202,8 @@ pub struct CrateContext {
      // Cache of emitted const values
      const_values: @mut LinearMap<ast::node_id, ValueRef>,
      module_data: @mut LinearMap<~str, ValueRef>,
-     lltypes: HashMap<ty::t, TypeRef>,
-     llsizingtypes: HashMap<ty::t, TypeRef>,
+     lltypes: @mut LinearMap<ty::t, TypeRef>,
+     llsizingtypes: @mut LinearMap<ty::t, TypeRef>,
      adt_reprs: @mut LinearMap<ty::t, @adt::Repr>,
      names: namegen,
      next_addrspace: addrspace_gen,

src/librustc/middle/trans/expr.rs

@@ -1647,7 +1647,7 @@ fn trans_overloaded_op(bcx: block,
                        dest: Dest,
                        +autoref_arg: AutorefArg) -> block
 {
-    let origin = bcx.ccx().maps.method_map.get(&expr.id);
+    let origin = *bcx.ccx().maps.method_map.get(&expr.id);
     let fty = node_id_type(bcx, expr.callee_id);
     return callee::trans_call_inner(
         bcx, expr.info(), fty,

src/librustc/middle/trans/glue.rs

@@ -402,7 +402,7 @@ pub fn make_visit_glue(bcx: block, v: ValueRef, t: ty::t) {
     let mut bcx = bcx;
     let ty_visitor_name = special_idents::ty_visitor;
     fail_unless!(bcx.ccx().tcx.intrinsic_defs.contains_key(&ty_visitor_name));
-    let (trait_id, ty) = bcx.ccx().tcx.intrinsic_defs.get(&ty_visitor_name);
+    let (trait_id, ty) = *bcx.ccx().tcx.intrinsic_defs.get(&ty_visitor_name);
     let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty)));
     bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, trait_id);
     build_return(bcx);

src/librustc/middle/trans/reachable.rs

@@ -193,7 +193,7 @@ fn traverse_inline_body(cx: ctx, body: &blk) {
           }
           expr_field(_, _, _) => {
             match cx.method_map.find(&e.id) {
-              Some(typeck::method_map_entry {
+              Some(&typeck::method_map_entry {
                   origin: typeck::method_static(did),
                   _
                 }) => {
@@ -204,7 +204,7 @@ fn traverse_inline_body(cx: ctx, body: &blk) {
           }
           expr_method_call(*) => {
             match cx.method_map.find(&e.id) {
-              Some(typeck::method_map_entry {
+              Some(&typeck::method_map_entry {
                   origin: typeck::method_static(did),
                   _
                 }) => {

src/librustc/middle/trans/reflect.rs

@@ -337,7 +337,7 @@ pub fn emit_calls_to_trait_visit_ty(bcx: block,
     use syntax::parse::token::special_idents::tydesc;
     let final = sub_block(bcx, ~"final");
     fail_unless!(bcx.ccx().tcx.intrinsic_defs.contains_key(&tydesc));
-    let (_, tydesc_ty) = bcx.ccx().tcx.intrinsic_defs.get(&tydesc);
+    let (_, tydesc_ty) = *bcx.ccx().tcx.intrinsic_defs.get(&tydesc);
     let tydesc_ty = type_of(bcx.ccx(), tydesc_ty);
     let mut r = Reflector {
         visitor_val: visitor_val,

src/librustc/middle/trans/type_of.rs

@@ -101,8 +101,10 @@ pub fn type_of_non_gc_box(cx: @CrateContext, t: ty::t) -> TypeRef {
 //     behavior.
 
 pub fn sizing_type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
-    if cx.llsizingtypes.contains_key(&t) {
-        return cx.llsizingtypes.get(&t);
+    match cx.llsizingtypes.find(&t) {
+        // FIXME(#5562): removing this copy causes a segfault in stage1 core
+        Some(t) => return /*bad*/ copy *t,
+        None => ()
     }
 
     let llsizingty = match ty::get(t).sty {
@@ -161,7 +163,11 @@ pub fn type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
     debug!("type_of %?: %?", t, ty::get(t));
 
     // Check the cache.
-    if cx.lltypes.contains_key(&t) { return cx.lltypes.get(&t); }
+    match cx.lltypes.find(&t) {
+        // FIXME(#5562): removing this copy causes a segfault in stage1 core
+        Some(t) => return /*bad*/ copy *t,
+        None => ()
+    }
 
     // Replace any typedef'd types with their equivalent non-typedef
     // type. This ensures that all LLVM nominal types that contain

src/librustc/middle/trans/type_use.rs

@@ -250,8 +250,11 @@ pub fn mark_for_method_call(cx: Context, e_id: node_id, callee_id: node_id) {
         match mth.origin {
           typeck::method_static(did) => {
             for cx.ccx.tcx.node_type_substs.find(&callee_id).each |ts| {
+                // FIXME(#5562): removing this copy causes a segfault
+                //               before stage2
+                let ts = /*bad*/ copy **ts;
                 let type_uses = type_uses_for(cx.ccx, did, ts.len());
-                for vec::each2(type_uses, *ts) |uses, subst| {
+                for vec::each2(type_uses, ts) |uses, subst| {
                     type_needs(cx, *uses, *subst)
                 }
             }
@@ -296,9 +299,11 @@ pub fn mark_for_expr(cx: Context, e: @expr) {
       }
       expr_path(_) => {
         for cx.ccx.tcx.node_type_substs.find(&e.id).each |ts| {
+            // FIXME(#5562): removing this copy causes a segfault before stage2
+            let ts = copy **ts;
             let id = ast_util::def_id_of_def(*cx.ccx.tcx.def_map.get(&e.id));
             let uses_for_ts = type_uses_for(cx.ccx, id, ts.len());
-            for vec::each2(uses_for_ts, *ts) |uses, subst| {
+            for vec::each2(uses_for_ts, ts) |uses, subst| {
                 type_needs(cx, *uses, *subst)
             }
         }