Remove oldmap::HashMap

doc/rust.md

@@ -441,11 +441,11 @@ expression context, the final namespace qualifier is omitted.
 Two examples of paths with type arguments:
 
 ~~~~
-# use std::oldmap;
+# use core::hashmap::linear::LinearMap;
 # fn f() {
 # fn id<T:Copy>(t: T) -> T { t }
-type t = oldmap::HashMap<int,~str>;  // Type arguments used in a type expression
-let x = id::<int>(10);           // Type arguments used in a call expression
+type t = LinearMap<int,~str>;  // Type arguments used in a type expression
+let x = id::<int>(10);         // Type arguments used in a call expression
 # }
 ~~~~
 

doc/tutorial.md

@@ -1829,8 +1829,8 @@ illegal to copy and pass by value.
 Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 
 ~~~~
-# use std::oldmap::HashMap;
-type Set<T> = HashMap<T, ()>;
+# use core::hashmap::linear::LinearMap;
+type Set<T> = LinearMap<T, ()>;
 
 struct Stack<T> {
     elements: ~[T]

src/libcore/flate.rs

@@ -17,10 +17,10 @@ Simple compression
 use libc;
 use libc::{c_void, size_t, c_int};
 use ptr;
-use rand::RngUtil;
 use vec;
 
 #[cfg(test)] use rand;
+#[cfg(test)] use rand::RngUtil;
 
 pub mod rustrt {
     use libc::{c_int, c_void, size_t};

src/libcore/hashmap.rs

@@ -656,6 +656,11 @@ pub mod linear {
         fn reserve_at_least(&mut self, n: uint) {
             self.map.reserve_at_least(n)
         }
+
+        /// Consumes all of the elements in the set, emptying it out
+        fn consume(&mut self, f: &fn(T)) {
+            self.map.consume(|k, _| f(k))
+        }
     }
 
     #[test]

src/libcore/logging.rs

@@ -10,8 +10,6 @@
 
 //! Logging
 
-use libc;
-
 pub mod rustrt {
     use libc;
 
@@ -49,6 +47,7 @@ pub fn console_off() {
 pub fn log_type<T>(level: u32, object: &T) {
     use cast::transmute;
     use io;
+    use libc;
     use repr;
     use vec;
 

src/libcore/rt/io/mod.rs

@@ -8,9 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use option::*;
-use comm::{GenericPort, GenericChan};
-
 pub mod file;
 
 // FIXME #5370 Strongly want this to be StreamError(&mut Stream)

src/libcore/rt/uv/mod.rs

@@ -42,7 +42,6 @@ use ptr;
 use libc::{c_void, c_int, size_t, malloc, free, ssize_t};
 use cast::{transmute, transmute_mut_region};
 use ptr::null;
-use sys::size_of;
 use super::uvll;
 use super::uvll::*;
 use unstable::finally::Finally;

src/libcore/rt/uvll.rs

@@ -32,7 +32,6 @@
 use libc::{size_t, c_int, c_uint, c_void, c_char, uintptr_t};
 use libc::{malloc, free};
 use prelude::*;
-use ptr::to_unsafe_ptr;
 
 pub struct uv_err_t {
     code: c_int,

src/librustc/back/link.rs

@@ -642,7 +642,7 @@ pub fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
 
 pub fn get_symbol_hash(ccx: @CrateContext, t: ty::t) -> @str {
     match ccx.type_hashcodes.find(&t) {
-      Some(h) => h,
+      Some(&h) => h,
       None => {
         let hash = symbol_hash(ccx.tcx, ccx.symbol_hasher, t, ccx.link_meta);
         ccx.type_hashcodes.insert(t, hash);

src/librustc/driver/driver.rs

@@ -246,7 +246,7 @@ pub fn compile_rest(sess: Session, cfg: ast::crate_cfg,
 
         // These next two const passes can probably be merged
         time(time_passes, ~"const marking", ||
-             middle::const_eval::process_crate(crate, def_map, ty_cx));
+             middle::const_eval::process_crate(crate, ty_cx));
 
         time(time_passes, ~"const checking", ||
              middle::check_const::check_crate(sess, crate, ast_map, def_map,
@@ -546,11 +546,11 @@ pub fn build_session_options(+binary: ~str,
         let flags = vec::append(getopts::opt_strs(matches, level_short),
                                 getopts::opt_strs(matches, level_name));
         for flags.each |lint_name| {
-            let lint_name = @str::replace(*lint_name, ~"-", ~"_");
+            let lint_name = str::replace(*lint_name, ~"-", ~"_");
             match lint_dict.find(&lint_name) {
               None => {
                 early_error(demitter, fmt!("unknown %s flag: %s",
-                                           level_name, *lint_name));
+                                           level_name, lint_name));
               }
               Some(lint) => {
                 lint_opts.push((lint.lint, *level));

src/librustc/lib/llvm.rs

@@ -10,12 +10,12 @@
 
 use core::prelude::*;
 
+use core::hashmap::linear::LinearMap;
 use core::libc::{c_char, c_int, c_uint, c_longlong, c_ulonglong};
 use core::option;
 use core::ptr;
 use core::str;
 use core::vec;
-use std::oldmap::HashMap;
 
 pub type Opcode = u32;
 pub type Bool = c_uint;
@@ -1467,8 +1467,8 @@ pub fn SetLinkage(Global: ValueRef, Link: Linkage) {
 /* Memory-managed object interface to type handles. */
 
 pub struct TypeNames {
-    type_names: HashMap<TypeRef, @str>,
-    named_types: HashMap<@str, TypeRef>
+    type_names: @mut LinearMap<TypeRef, @str>,
+    named_types: @mut LinearMap<@str, TypeRef>
 }
 
 pub fn associate_type(tn: @TypeNames, s: @str, t: TypeRef) {
@@ -1477,17 +1477,17 @@ pub fn associate_type(tn: @TypeNames, s: @str, t: TypeRef) {
 }
 
 pub fn type_has_name(tn: @TypeNames, t: TypeRef) -> Option<@str> {
-    return tn.type_names.find(&t);
+    return tn.type_names.find(&t).map_consume(|x| *x);
 }
 
 pub fn name_has_type(tn: @TypeNames, s: @str) -> Option<TypeRef> {
-    return tn.named_types.find(&s);
+    return tn.named_types.find(&s).map_consume(|x| *x);
 }
 
 pub fn mk_type_names() -> @TypeNames {
     @TypeNames {
-        type_names: HashMap(),
-        named_types: HashMap()
+        type_names: @mut LinearMap::new(),
+        named_types: @mut LinearMap::new()
     }
 }
 

src/librustc/metadata/creader.rs

@@ -19,14 +19,14 @@ use metadata::filesearch::FileSearch;
 use metadata::loader;
 
 use core::either;
+use core::hashmap::linear::LinearMap;
 use core::vec;
 use syntax::attr;
 use syntax::codemap::{span, dummy_sp};
 use syntax::diagnostic::span_handler;
 use syntax::parse::token::ident_interner;
 use syntax::visit;
 use syntax::{ast, ast_util};
-use std::oldmap::HashMap;
 
 // Traverses an AST, reading all the information about use'd crates and extern
 // libraries necessary for later resolving, typechecking, linking, etc.
@@ -307,7 +307,7 @@ fn resolve_crate_deps(e: @mut 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 = HashMap();
+    let mut cnum_map = LinearMap::new();
     for decoder::get_crate_deps(e.intr, cdata).each |dep| {
         let extrn_cnum = dep.cnum;
         let cname = dep.name;
@@ -334,7 +334,7 @@ fn resolve_crate_deps(e: @mut Env, cdata: @~[u8]) -> cstore::cnum_map {
           }
         }
     }
-    return cnum_map;
+    return @mut cnum_map;
 }
 
 // Local Variables:

src/librustc/metadata/cstore.rs

@@ -17,8 +17,8 @@ use core::prelude::*;
 use metadata::cstore;
 use metadata::decoder;
 
+use core::hashmap::linear::LinearMap;
 use core::vec;
-use std::oldmap;
 use std;
 use syntax::{ast, attr};
 use syntax::parse::token::ident_interner;
@@ -27,7 +27,7 @@ use syntax::parse::token::ident_interner;
 // 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.
-pub type cnum_map = oldmap::HashMap<ast::crate_num, ast::crate_num>;
+pub type cnum_map = @mut LinearMap<ast::crate_num, ast::crate_num>;
 
 pub struct crate_metadata {
     name: @~str,
@@ -37,7 +37,7 @@ pub struct crate_metadata {
 }
 
 pub struct CStore {
-    priv metas: oldmap::HashMap<ast::crate_num, @crate_metadata>,
+    priv metas: LinearMap <ast::crate_num, @crate_metadata>,
     priv extern_mod_crate_map: extern_mod_crate_map,
     priv used_crate_files: ~[Path],
     priv used_libraries: ~[~str],
@@ -46,111 +46,102 @@ pub struct CStore {
 }
 
 // Map from node_id's of local extern mod statements to crate numbers
-type extern_mod_crate_map = oldmap::HashMap<ast::node_id, ast::crate_num>;
+type extern_mod_crate_map = LinearMap<ast::node_id, ast::crate_num>;
 
 pub fn mk_cstore(intr: @ident_interner) -> CStore {
-    let meta_cache = oldmap::HashMap();
-    let crate_map = oldmap::HashMap();
     return CStore {
-        metas: meta_cache,
-        extern_mod_crate_map: crate_map,
+        metas: LinearMap::new(),
+        extern_mod_crate_map: LinearMap::new(),
         used_crate_files: ~[],
         used_libraries: ~[],
         used_link_args: ~[],
         intr: intr
     };
 }
 
-pub fn get_crate_data(cstore: @mut CStore, cnum: ast::crate_num)
+pub fn get_crate_data(cstore: &CStore, cnum: ast::crate_num)
                    -> @crate_metadata {
-    return cstore.metas.get(&cnum);
+    return *cstore.metas.get(&cnum);
 }
 
-pub fn get_crate_hash(cstore: @mut CStore, cnum: ast::crate_num) -> @~str {
+pub fn get_crate_hash(cstore: &CStore, cnum: ast::crate_num) -> @~str {
     let cdata = get_crate_data(cstore, cnum);
     decoder::get_crate_hash(cdata.data)
 }
 
-pub fn get_crate_vers(cstore: @mut CStore, cnum: ast::crate_num) -> @~str {
+pub fn get_crate_vers(cstore: &CStore, cnum: ast::crate_num) -> @~str {
     let cdata = get_crate_data(cstore, cnum);
     decoder::get_crate_vers(cdata.data)
 }
 
-pub fn set_crate_data(cstore: @mut CStore,
+pub fn set_crate_data(cstore: &mut CStore,
                       cnum: ast::crate_num,
                       data: @crate_metadata) {
-    let metas = cstore.metas;
-    metas.insert(cnum, data);
+    cstore.metas.insert(cnum, data);
 }
 
-pub fn have_crate_data(cstore: @mut CStore, cnum: ast::crate_num) -> bool {
+pub fn have_crate_data(cstore: &CStore, cnum: ast::crate_num) -> bool {
     cstore.metas.contains_key(&cnum)
 }
 
-pub fn iter_crate_data(cstore: @mut CStore,
+pub fn iter_crate_data(cstore: &CStore,
                        i: &fn(ast::crate_num, @crate_metadata)) {
-    let metas = cstore.metas;
-    for metas.each |&k, &v| {
+    for cstore.metas.each |&(&k, &v)| {
         i(k, v);
     }
 }
 
-pub fn add_used_crate_file(cstore: @mut CStore, lib: &Path) {
-    let cstore = &mut *cstore;
+pub fn add_used_crate_file(cstore: &mut CStore, lib: &Path) {
     if !vec::contains(cstore.used_crate_files, lib) {
         cstore.used_crate_files.push(copy *lib);
     }
 }
 
-pub fn get_used_crate_files(cstore: @mut CStore) -> ~[Path] {
+pub fn get_used_crate_files(cstore: &CStore) -> ~[Path] {
     return /*bad*/copy cstore.used_crate_files;
 }
 
-pub fn add_used_library(cstore: @mut CStore, lib: @~str) -> bool {
+pub fn add_used_library(cstore: &mut CStore, lib: @~str) -> bool {
     fail_unless!(*lib != ~"");
 
-    let cstore = &mut *cstore;
     if cstore.used_libraries.contains(&*lib) { return false; }
     cstore.used_libraries.push(/*bad*/ copy *lib);
     true
 }
 
-pub fn get_used_libraries(cstore: @mut CStore) -> ~[~str] {
+pub fn get_used_libraries(cstore: &CStore) -> ~[~str] {
     /*bad*/copy cstore.used_libraries
 }
 
-pub fn add_used_link_args(cstore: @mut CStore, args: &str) {
+pub fn add_used_link_args(cstore: &mut CStore, args: &str) {
     for args.each_split_char(' ') |s| {
         cstore.used_link_args.push(s.to_owned());
     }
 }
 
-pub fn get_used_link_args(cstore: @mut CStore) -> ~[~str] {
+pub fn get_used_link_args(cstore: &CStore) -> ~[~str] {
     /*bad*/copy cstore.used_link_args
 }
 
-pub fn add_extern_mod_stmt_cnum(cstore: @mut CStore,
+pub fn add_extern_mod_stmt_cnum(cstore: &mut CStore,
                                 emod_id: ast::node_id,
                                 cnum: ast::crate_num) {
-    let extern_mod_crate_map = cstore.extern_mod_crate_map;
-    extern_mod_crate_map.insert(emod_id, cnum);
+    cstore.extern_mod_crate_map.insert(emod_id, cnum);
 }
 
-pub fn find_extern_mod_stmt_cnum(cstore: @mut CStore,
+pub fn find_extern_mod_stmt_cnum(cstore: &CStore,
                                  emod_id: ast::node_id)
                        -> Option<ast::crate_num> {
-    let extern_mod_crate_map = cstore.extern_mod_crate_map;
-    extern_mod_crate_map.find(&emod_id)
+    cstore.extern_mod_crate_map.find(&emod_id).map_consume(|x| *x)
 }
 
 // returns hashes of crates directly used by this crate. Hashes are sorted by
 // (crate name, crate version, crate hash) in lexicographic order (not semver)
-pub fn get_dep_hashes(cstore: @mut CStore) -> ~[~str] {
+pub fn get_dep_hashes(cstore: &CStore) -> ~[~str] {
     struct crate_hash { name: @~str, vers: @~str, hash: @~str }
     let mut result = ~[];
 
-    let extern_mod_crate_map = cstore.extern_mod_crate_map;
-    for extern_mod_crate_map.each_value |&cnum| {
+    for cstore.extern_mod_crate_map.each_value |&cnum| {
         let cdata = cstore::get_crate_data(cstore, cnum);
         let hash = decoder::get_crate_hash(cdata.data);
         let vers = decoder::get_crate_vers(cdata.data);

src/librustc/metadata/decoder.rs

@@ -1132,7 +1132,7 @@ pub fn translate_def_id(cdata: cmd, did: ast::def_id) -> ast::def_id {
     }
 
     match cdata.cnum_map.find(&did.crate) {
-      option::Some(n) => ast::def_id { crate: n, node: did.node },
+      option::Some(&n) => ast::def_id { crate: n, node: did.node },
       option::None => fail!(~"didn't find a crate in the cnum_map")
     }
 }