diff options
106 files changed, 1226 insertions, 1636 deletions
diff --git a/doc/rust.md b/doc/rust.md index 3847b0b9755..287dcb950f7 100644 --- a/doc/rust.md +++ b/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 # } ~~~~ diff --git a/doc/tutorial.md b/doc/tutorial.md index 30e230b67b0..8c0f5f1ebdf 100644 --- a/doc/tutorial.md +++ b/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] diff --git a/src/libcore/flate.rs b/src/libcore/flate.rs index d9dc89097d0..2ddf9277096 100644 --- a/src/libcore/flate.rs +++ b/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}; diff --git a/src/libcore/hashmap.rs b/src/libcore/hashmap.rs index 8c290553a45..6f97bf6dde2 100644 --- a/src/libcore/hashmap.rs +++ b/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] diff --git a/src/libcore/logging.rs b/src/libcore/logging.rs index be6469abc92..ba976de50ab 100644 --- a/src/libcore/logging.rs +++ b/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; diff --git a/src/libcore/rt/io/mod.rs b/src/libcore/rt/io/mod.rs index f82092b829c..1634e7443b4 100644 --- a/src/libcore/rt/io/mod.rs +++ b/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) diff --git a/src/libcore/rt/uv/mod.rs b/src/libcore/rt/uv/mod.rs index 28d695273e7..94a3b562fd8 100644 --- a/src/libcore/rt/uv/mod.rs +++ b/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; diff --git a/src/libcore/rt/uvll.rs b/src/libcore/rt/uvll.rs index 5111b2bdc1d..4eaf9dcf40a 100644 --- a/src/libcore/rt/uvll.rs +++ b/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, diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 5f9a3e606f2..d0c318d16a2 100644 --- a/src/librustc/back/link.rs +++ b/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); diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 360a5ddccfd..1de69ed85a8 100644 --- a/src/librustc/driver/driver.rs +++ b/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)); diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs index e01c4ae7d72..e97252c5341 100644 --- a/src/librustc/lib/llvm.rs +++ b/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() } } diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 21b035f2242..ce37054cba2 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -19,6 +19,7 @@ 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}; @@ -26,7 +27,6 @@ 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: diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 018a365f37f..d4360a7d491 100644 --- a/src/librustc/metadata/cstore.rs +++ b/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,14 +46,12 @@ 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: ~[], @@ -61,96 +59,89 @@ pub fn mk_cstore(intr: @ident_interner) -> CStore { }; } -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); diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index b952aff9e1c..0e9246eedbc 100644 --- a/src/librustc/metadata/decoder.rs +++ b/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") } } diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index ccc29fbbccb..490fa357bb5 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -17,6 +17,7 @@ use metadata::common::*; use metadata::cstore; use metadata::decoder; use metadata::tyencode; +use middle::trans::reachable; use middle::ty::node_id_to_type; use middle::ty; use middle; @@ -24,6 +25,7 @@ use util::ppaux::ty_to_str; use core::flate; use core::hash::{Hash, HashUtil}; +use core::hashmap::linear::{LinearMap, LinearSet}; use core::int; use core::io::{Writer, WriterUtil}; use core::io; @@ -31,9 +33,7 @@ use core::str; use core::to_bytes::IterBytes; use core::uint; use core::vec; -use std::oldmap::HashMap; use std::serialize::Encodable; -use std::{ebml, oldmap}; use std; use syntax::ast::*; use syntax::ast; @@ -49,7 +49,7 @@ use syntax; use writer = std::ebml::writer; // used by astencode: -type abbrev_map = oldmap::HashMap<ty::t, tyencode::ty_abbrev>; +type abbrev_map = @mut LinearMap<ty::t, tyencode::ty_abbrev>; pub type encode_inlined_item = @fn(ecx: @EncodeContext, ebml_w: writer::Encoder, @@ -59,10 +59,10 @@ pub type encode_inlined_item = @fn(ecx: @EncodeContext, pub struct EncodeParams { diag: @span_handler, tcx: ty::ctxt, - reachable: HashMap<ast::node_id, ()>, + reachable: reachable::map, reexports2: middle::resolve::ExportMap2, - item_symbols: HashMap<ast::node_id, ~str>, - discrim_symbols: HashMap<ast::node_id, ~str>, + item_symbols: @mut LinearMap<ast::node_id, ~str>, + discrim_symbols: @mut LinearMap<ast::node_id, ~str>, link_meta: LinkMeta, cstore: @mut cstore::CStore, encode_inlined_item: encode_inlined_item @@ -86,10 +86,10 @@ pub struct EncodeContext { diag: @span_handler, tcx: ty::ctxt, stats: @mut Stats, - reachable: HashMap<ast::node_id, ()>, + reachable: reachable::map, reexports2: middle::resolve::ExportMap2, - item_symbols: HashMap<ast::node_id, ~str>, - discrim_symbols: HashMap<ast::node_id, ~str>, + item_symbols: @mut LinearMap<ast::node_id, ~str>, + discrim_symbols: @mut LinearMap<ast::node_id, ~str>, link_meta: LinkMeta, cstore: @mut cstore::CStore, encode_inlined_item: encode_inlined_item, @@ -97,7 +97,7 @@ pub struct EncodeContext { } pub fn reachable(ecx: @EncodeContext, id: node_id) -> bool { - ecx.reachable.contains_key(&id) + ecx.reachable.contains(&id) } fn encode_name(ecx: @EncodeContext, ebml_w: writer::Encoder, name: ident) { @@ -188,7 +188,7 @@ fn encode_type_param_bounds(ebml_w: writer::Encoder, ecx: @EncodeContext, params: &OptVec<TyParam>) { let ty_param_bounds = - @params.map_to_vec(|param| ecx.tcx.ty_param_bounds.get(¶m.id)); + @params.map_to_vec(|param| *ecx.tcx.ty_param_bounds.get(¶m.id)); encode_ty_type_param_bounds(ebml_w, ecx, ty_param_bounds); } @@ -229,7 +229,7 @@ fn encode_type(ecx: @EncodeContext, ebml_w: writer::Encoder, typ: ty::t) { fn encode_symbol(ecx: @EncodeContext, ebml_w: writer::Encoder, id: node_id) { ebml_w.start_tag(tag_items_data_item_symbol); match ecx.item_symbols.find(&id) { - Some(ref x) => { + Some(x) => { debug!("encode_symbol(id=%?, str=%s)", id, *x); ebml_w.writer.write(str::to_bytes(*x)); } @@ -244,7 +244,7 @@ fn encode_symbol(ecx: @EncodeContext, ebml_w: writer::Encoder, id: node_id) { fn encode_discriminant(ecx: @EncodeContext, ebml_w: writer::Encoder, id: node_id) { ebml_w.start_tag(tag_items_data_item_symbol); - ebml_w.writer.write(str::to_bytes(ecx.discrim_symbols.get(&id))); + ebml_w.writer.write(str::to_bytes(*ecx.discrim_symbols.get(&id))); ebml_w.end_tag(); } @@ -1026,7 +1026,7 @@ fn encode_info_for_items(ecx: @EncodeContext, ebml_w: writer::Encoder, let ebml_w = copy ebml_w; |i, cx, v| { visit::visit_item(i, cx, v); - match ecx.tcx.items.get(&i.id) { + match *ecx.tcx.items.get(&i.id) { ast_map::node_item(_, pt) => { encode_info_for_item(ecx, ebml_w, i, index, *pt); @@ -1039,7 +1039,7 @@ fn encode_info_for_items(ecx: @EncodeContext, ebml_w: writer::Encoder, let ebml_w = copy ebml_w; |ni, cx, v| { visit::visit_foreign_item(ni, cx, v); - match ecx.tcx.items.get(&ni.id) { + match *ecx.tcx.items.get(&ni.id) { ast_map::node_foreign_item(_, abi, _, pt) => { encode_info_for_foreign_item(ecx, ebml_w, ni, index, /*bad*/copy *pt, @@ -1320,7 +1320,7 @@ pub static metadata_encoding_version : &'static [u8] = 0x74, //'t' as u8, 0, 0, 0, 1 ]; -pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] { +pub fn encode_metadata(+parms: EncodeParams, crate: &crate) -> ~[u8] { let wr = @io::BytesWriter(); let mut stats = Stats { inline_bytes: 0, @@ -1334,18 +1334,21 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] { total_bytes: 0, n_inlines: 0 }; + let EncodeParams{item_symbols, diag, tcx, reachable, reexports2, + discrim_symbols, cstore, encode_inlined_item, + link_meta, _} = parms; let ecx = @EncodeContext { - diag: parms.diag, - tcx: parms.tcx, + diag: diag, + tcx: tcx, stats: @mut stats, - reachable: parms.reachable, - reexports2: parms.reexports2, - item_symbols: parms.item_symbols, - discrim_symbols: parms.discrim_symbols, - link_meta: /*bad*/copy parms.link_meta, - cstore: parms.cstore, - encode_inlined_item: parms.encode_inlined_item, - type_abbrevs: ty::new_ty_hash() + reachable: reachable, + reexports2: reexports2, + item_symbols: item_symbols, + discrim_symbols: discrim_symbols, + link_meta: link_meta, + cstore: cstore, + encode_inlined_item: encode_inlined_item, + type_abbrevs: @mut LinearMap::new() }; let ebml_w = writer::Encoder(wr as @io::Writer); @@ -1385,7 +1388,7 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] { ecx.stats.total_bytes = wr.pos; - if (parms.tcx.sess.meta_stats()) { + if (tcx.sess.meta_stats()) { do wr.bytes.each |e| { if *e == 0 { diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index f12cc140d8a..1eb82c6277e 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -337,7 +337,7 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t { pos: pos, len: len }; match st.tcx.rcache.find(&key) { - Some(tt) => return tt, + Some(&tt) => return tt, None => { let ps = @mut PState {pos: pos ,.. copy *st}; let tt = parse_ty(ps, conv); diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 880d01d1cdb..6734abb7e80 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -16,11 +16,11 @@ use core::prelude::*; use middle::ty::{Vid, param_ty}; use middle::ty; +use core::hashmap::linear::LinearMap; use core::io::WriterUtil; use core::io; use core::uint; use core::vec; -use std::oldmap::HashMap; use syntax::ast::*; use syntax::diagnostic::span_handler; use syntax::print::pprust::*; @@ -47,7 +47,7 @@ pub struct ty_abbrev { pub enum abbrev_ctxt { ac_no_abbrevs, - ac_use_abbrevs(HashMap<ty::t, ty_abbrev>), + ac_use_abbrevs(@mut LinearMap<ty::t, ty_abbrev>), } fn cx_uses_abbrevs(cx: @ctxt) -> bool { @@ -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); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 853bb8df3a4..1e1dde33037 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -856,12 +856,14 @@ 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) } } } - for tcx.freevars.find(&id).each |fv| { + for tcx.freevars.find(&id).each |&fv| { do ebml_w.tag(c::tag_table_freevars) { ebml_w.id(id); do ebml_w.tag(c::tag_table_val) { @@ -873,7 +875,7 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext, } let lid = ast::def_id { crate: ast::local_crate, node: id }; - for tcx.tcache.find(&lid).each |tpbt| { + for tcx.tcache.find(&lid).each |&tpbt| { do ebml_w.tag(c::tag_table_tcache) { ebml_w.id(id); do ebml_w.tag(c::tag_table_val) { @@ -882,7 +884,7 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext, } } - for tcx.ty_param_bounds.find(&id).each |pbs| { + for tcx.ty_param_bounds.find(&id).each |&pbs| { do ebml_w.tag(c::tag_table_param_bounds) { ebml_w.id(id); do ebml_w.tag(c::tag_table_val) { @@ -905,7 +907,7 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext, // } //} - if maps.mutbl_map.contains_key(&id) { + if maps.mutbl_map.contains(&id) { do ebml_w.tag(c::tag_table_mutbl) { ebml_w.id(id); } @@ -915,14 +917,14 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext, do ebml_w.tag(c::tag_table_last_use) { ebml_w.id(id); do ebml_w.tag(c::tag_table_val) { - do ebml_w.emit_from_vec(/*bad*/ copy *m) |id| { + do ebml_w.emit_from_vec(/*bad*/ copy **m) |id| { id.encode(&ebml_w); } } } } - 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) { @@ -931,7 +933,7 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext, } } - for maps.vtable_map.find(&id).each |dr| { + for maps.vtable_map.find(&id).each |&dr| { do ebml_w.tag(c::tag_table_vtable_map) { ebml_w.id(id); do ebml_w.tag(c::tag_table_val) { @@ -949,13 +951,13 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext, } } - for maps.moves_map.find(&id).each |_| { + if maps.moves_map.contains(&id) { do ebml_w.tag(c::tag_table_moves_map) { ebml_w.id(id); } } - for maps.capture_map.find(&id).each |cap_vars| { + for maps.capture_map.find(&id).each |&cap_vars| { do ebml_w.tag(c::tag_table_capture_map) { ebml_w.id(id); do ebml_w.tag(c::tag_table_val) { @@ -1097,9 +1099,9 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext, tag, id, id0); if tag == (c::tag_table_mutbl as uint) { - dcx.maps.mutbl_map.insert(id, ()); + dcx.maps.mutbl_map.insert(id); } else if tag == (c::tag_table_moves_map as uint) { - dcx.maps.moves_map.insert(id, ()); + dcx.maps.moves_map.insert(id); } else { let val_doc = entry_doc[c::tag_table_val as uint]; let val_dsr = &reader::Decoder(val_doc); diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 6dfcf6ddf91..045a3b2b677 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -31,8 +31,8 @@ use middle::mem_categorization::{lp_comp, lp_deref, lp_local}; use middle::ty; use util::ppaux::ty_to_str; +use core::hashmap::linear::LinearSet; use core::uint; -use std::oldmap::HashMap; use syntax::ast::{m_const, m_imm, m_mutbl}; use syntax::ast; use syntax::ast_util; @@ -44,7 +44,7 @@ struct CheckLoanCtxt { bccx: @BorrowckCtxt, req_maps: ReqMaps, - reported: HashMap<ast::node_id, ()>, + reported: LinearSet<ast::node_id>, declared_purity: @mut ast::purity, fn_args: @mut @~[ast::node_id] @@ -63,12 +63,12 @@ enum purity_cause { } pub fn check_loans(bccx: @BorrowckCtxt, - req_maps: ReqMaps, + +req_maps: ReqMaps, crate: @ast::crate) { let clcx = @mut CheckLoanCtxt { bccx: bccx, req_maps: req_maps, - reported: HashMap(), + reported: LinearSet::new(), declared_purity: @mut ast::impure_fn, fn_args: @mut @~[] }; @@ -104,9 +104,9 @@ pub impl assignment_type { } pub impl CheckLoanCtxt { - fn tcx(@mut self) -> ty::ctxt { self.bccx.tcx } + fn tcx(&self) -> ty::ctxt { self.bccx.tcx } - fn purity(@mut self, scope_id: ast::node_id) -> Option<purity_cause> { + fn purity(&mut self, scope_id: ast::node_id) -> Option<purity_cause> { let default_purity = match *self.declared_purity { // an unsafe declaration overrides all ast::unsafe_fn => return None, @@ -122,43 +122,38 @@ pub impl CheckLoanCtxt { // purity. if so, that overrides the declaration. let mut scope_id = scope_id; - let region_map = self.tcx().region_map; - let pure_map = self.req_maps.pure_map; loop { - match pure_map.find(&scope_id) { + match self.req_maps.pure_map.find(&scope_id) { None => (), - Some(ref e) => return Some(pc_cmt((*e))) + Some(e) => return Some(pc_cmt(*e)) } - match region_map.find(&scope_id) { + match self.tcx().region_map.find(&scope_id) { None => return default_purity, - Some(next_scope_id) => scope_id = next_scope_id + Some(&next_scope_id) => scope_id = next_scope_id } } } - fn walk_loans(@mut self, - scope_id: ast::node_id, + fn walk_loans(&self, + mut scope_id: ast::node_id, f: &fn(v: &Loan) -> bool) { - let mut scope_id = scope_id; - let region_map = self.tcx().region_map; - let req_loan_map = self.req_maps.req_loan_map; loop { - for req_loan_map.find(&scope_id).each |loans| { + for self.req_maps.req_loan_map.find(&scope_id).each |loans| { for loans.each |loan| { if !f(loan) { return; } } } - match region_map.find(&scope_id) { + match self.tcx().region_map.find(&scope_id) { None => return, - Some(next_scope_id) => scope_id = next_scope_id, + Some(&next_scope_id) => scope_id = next_scope_id, } } } - fn walk_loans_of(@mut self, + fn walk_loans_of(&mut self, scope_id: ast::node_id, lp: @loan_path, f: &fn(v: &Loan) -> bool) { @@ -175,7 +170,7 @@ pub impl CheckLoanCtxt { // note: we take opt_expr and expr_id separately because for // overloaded operators the callee has an id but no expr. // annoying. - fn check_pure_callee_or_arg(@mut self, + fn check_pure_callee_or_arg(&mut self, pc: purity_cause, opt_expr: Option<@ast::expr>, callee_id: ast::node_id, @@ -202,7 +197,7 @@ pub impl CheckLoanCtxt { Some(expr) => { match expr.node { ast::expr_path(_) if pc == pc_pure_fn => { - let def = self.tcx().def_map.get(&expr.id); + let def = *self.tcx().def_map.get(&expr.id); let did = ast_util::def_id_of_def(def); let is_fn_arg = did.crate == ast::local_crate && @@ -242,7 +237,7 @@ pub impl CheckLoanCtxt { // True if the expression with the given `id` is a stack closure. // The expression must be an expr_fn_block(*) - fn is_stack_closure(@mut self, id: ast::node_id) -> bool { + fn is_stack_closure(&mut self, id: ast::node_id) -> bool { let fn_ty = ty::node_id_to_type(self.tcx(), id); match ty::get(fn_ty).sty { ty::ty_closure(ty::ClosureTy {sigil: ast::BorrowedSigil, @@ -251,10 +246,10 @@ pub impl CheckLoanCtxt { } } - fn is_allowed_pure_arg(@mut self, expr: @ast::expr) -> bool { + fn is_allowed_pure_arg(&mut self, expr: @ast::expr) -> bool { return match expr.node { ast::expr_path(_) => { - let def = self.tcx().def_map.get(&expr.id); + let def = *self.tcx().def_map.get(&expr.id); let did = ast_util::def_id_of_def(def); did.crate == ast::local_crate && (*self.fn_args).contains(&(did.node)) @@ -264,18 +259,18 @@ pub impl CheckLoanCtxt { }; } - fn check_for_conflicting_loans(@mut self, scope_id: ast::node_id) { + fn check_for_conflicting_loans(&mut self, scope_id: ast::node_id) { debug!("check_for_conflicting_loans(scope_id=%?)", scope_id); let new_loans = match self.req_maps.req_loan_map.find(&scope_id) { None => return, - Some(loans) => loans + Some(&loans) => loans }; let new_loans: &mut ~[Loan] = new_loans; debug!("new_loans has length %?", new_loans.len()); - let par_scope_id = self.tcx().region_map.get(&scope_id); + let par_scope_id = *self.tcx().region_map.get(&scope_id); for self.walk_loans(par_scope_id) |old_loan| { debug!("old_loan=%?", self.bccx.loan_to_repr(old_loan)); @@ -294,7 +289,7 @@ pub impl CheckLoanCtxt { } } - fn report_error_if_loans_conflict(@mut self, + fn report_error_if_loans_conflict(&self, old_loan: &Loan, new_loan: &Loan) { if old_loan.lp != new_loan.lp { @@ -330,19 +325,19 @@ pub impl CheckLoanCtxt { } } - fn is_local_variable(@mut self, cmt: cmt) -> bool { + fn is_local_variable(&self, cmt: cmt) -> bool { match cmt.cat { cat_local(_) => true, _ => false } } - fn check_assignment(@mut self, at: assignment_type, ex: @ast::expr) { + fn check_assignment(&mut self, at: assignment_type, ex: @ast::expr) { // We don't use cat_expr() here because we don't want to treat // auto-ref'd parameters in overloaded operators as rvalues. let cmt = match self.bccx.tcx.adjustments.find(&ex.id) { None => self.bccx.cat_expr_unadjusted(ex), - Some(adj) => self.bccx.cat_expr_autoderefd(ex, adj) + Some(&adj) => self.bccx.cat_expr_autoderefd(ex, adj) }; debug!("check_assignment(cmt=%s)", @@ -369,6 +364,7 @@ pub impl CheckLoanCtxt { match self.purity(ex.id) { None => (), Some(pc_cmt(_)) => { + let purity = self.purity(ex.id).get(); // Subtle: Issue #3162. If we are enforcing purity // because there is a reference to aliasable, mutable data // that we require to be immutable, we can't allow writes @@ -376,7 +372,7 @@ pub impl CheckLoanCtxt { // because that aliasable data might have been located on // the current stack frame, we don't know. self.report_purity_error( - self.purity(ex.id).get(), + purity, ex.span, at.ing_form(self.bccx.cmt_to_str(cmt))); } @@ -404,7 +400,7 @@ pub impl CheckLoanCtxt { self.add_write_guards_if_necessary(cmt); } - fn add_write_guards_if_necessary(@mut self, cmt: cmt) { + fn add_write_guards_if_necessary(&mut self, cmt: cmt) { match cmt.cat { cat_deref(base, deref_count, ptr_kind) => { self.add_write_guards_if_necessary(base); @@ -415,7 +411,7 @@ pub impl CheckLoanCtxt { id: base.id, derefs: deref_count }; - self.bccx.write_guard_map.insert(key, ()); + self.bccx.write_guard_map.insert(key); } _ => {} } @@ -427,7 +423,7 @@ pub impl CheckLoanCtxt { } } - fn check_for_loan_conflicting_with_assignment(@mut self, + fn check_for_loan_conflicting_with_assignment(&mut self, at: assignment_type, ex: @ast::expr, cmt: cmt, @@ -466,7 +462,7 @@ pub impl CheckLoanCtxt { } } - fn report_purity_error(@mut self, pc: purity_cause, sp: span, msg: ~str) { + fn report_purity_error(&mut self, pc: purity_cause, sp: span, msg: ~str) { match pc { pc_pure_fn => { self.tcx().sess.span_err( @@ -474,8 +470,7 @@ pub impl CheckLoanCtxt { fmt!("%s prohibited in pure context", msg)); } pc_cmt(ref e) => { - let reported = self.reported; - if reported.insert((*e).cmt.id, ()) { + if self.reported.insert((*e).cmt.id) { self.tcx().sess.span_err( (*e).cmt.span, fmt!("illegal borrow unless pure: %s", @@ -522,7 +517,7 @@ pub impl CheckLoanCtxt { } } - fn analyze_move_out_from_cmt(@mut self, cmt: cmt) -> MoveError { + fn analyze_move_out_from_cmt(&mut self, cmt: cmt) -> MoveError { debug!("check_move_out_from_cmt(cmt=%s)", self.bccx.cmt_to_repr(cmt)); @@ -555,7 +550,7 @@ pub impl CheckLoanCtxt { return MoveOk; } - fn check_call(@mut self, + fn check_call(&mut self, expr: @ast::expr, callee: Option<@ast::expr>, callee_id: ast::node_id, @@ -695,7 +690,7 @@ fn check_loans_in_expr(expr: @ast::expr, self.check_for_conflicting_loans(expr.id); - if self.bccx.moves_map.contains_key(&expr.id) { + if self.bccx.moves_map.contains(&expr.id) { self.check_move_out_from_expr(expr); } diff --git a/src/librustc/middle/borrowck/gather_loans.rs b/src/librustc/middle/borrowck/gather_loans.rs index bab652a3d1e..bd6a9ab3097 100644 --- a/src/librustc/middle/borrowck/gather_loans.rs +++ b/src/librustc/middle/borrowck/gather_loans.rs @@ -32,9 +32,8 @@ use middle::ty; use util::common::indenter; use util::ppaux::{expr_repr, region_to_str}; -use core::hashmap::linear::LinearSet; +use core::hashmap::linear::{LinearSet, LinearMap}; use core::vec; -use std::oldmap::HashMap; use syntax::ast::{m_const, m_imm, m_mutbl}; use syntax::ast; use syntax::codemap::span; @@ -80,7 +79,8 @@ struct GatherLoanCtxt { pub fn gather_loans(bccx: @BorrowckCtxt, crate: @ast::crate) -> ReqMaps { let glcx = @mut GatherLoanCtxt { bccx: bccx, - req_maps: ReqMaps { req_loan_map: HashMap(), pure_map: HashMap() }, + req_maps: ReqMaps { req_loan_map: LinearMap::new(), + pure_map: LinearMap::new() }, item_ub: 0, root_ub: 0, ignore_adjustments: LinearSet::new() @@ -90,7 +90,8 @@ pub fn gather_loans(bccx: @BorrowckCtxt, crate: @ast::crate) -> ReqMaps { visit_stmt: add_stmt_to_map, .. *visit::default_visitor()}); visit::visit_crate(*crate, glcx, v); - return glcx.req_maps; + let @GatherLoanCtxt{req_maps, _} = glcx; + return req_maps; } fn req_loans_in_fn(fk: &visit::fn_kind, @@ -132,7 +133,7 @@ fn req_loans_in_expr(ex: @ast::expr, { let mut this = &mut *self; if !this.ignore_adjustments.contains(&ex.id) { - for tcx.adjustments.find(&ex.id).each |adjustments| { + for tcx.adjustments.find(&ex.id).each |&adjustments| { this.guarantee_adjustments(ex, *adjustments); } } @@ -257,7 +258,7 @@ fn req_loans_in_expr(ex: @ast::expr, // (if used like `a.b(...)`), the call where it's an argument // (if used like `x(a.b)`), or the block (if used like `let x // = a.b`). - let scope_r = ty::re_scope(self.tcx().region_map.get(&ex.id)); + let scope_r = ty::re_scope(*self.tcx().region_map.get(&ex.id)); let rcvr_cmt = self.bccx.cat_expr(rcvr); self.guarantee_valid(rcvr_cmt, m_imm, scope_r); visit::visit_expr(ex, self, vt); @@ -429,8 +430,7 @@ pub impl GatherLoanCtxt { // if the scope is some block/expr in the // fn, then just require that this scope // be pure - let pure_map = self.req_maps.pure_map; - pure_map.insert(pure_id, *e); + self.req_maps.pure_map.insert(pure_id, *e); self.bccx.stats.req_pure_paths += 1; debug!("requiring purity for scope %?", @@ -575,12 +575,11 @@ pub impl GatherLoanCtxt { match self.req_maps.req_loan_map.find(&scope_id) { Some(req_loans) => { req_loans.push_all(loans); + return; } - None => { - let req_loan_map = self.req_maps.req_loan_map; - req_loan_map.insert(scope_id, @mut loans); - } + None => {} } + self.req_maps.req_loan_map.insert(scope_id, @mut loans); } fn gather_pat(@mut self, @@ -683,7 +682,7 @@ fn add_stmt_to_map(stmt: @ast::stmt, vt: visit::vt<@mut GatherLoanCtxt>) { match stmt.node { ast::stmt_expr(_, id) | ast::stmt_semi(_, id) => { - self.bccx.stmt_map.insert(id, ()); + self.bccx.stmt_map.insert(id); } _ => () } diff --git a/src/librustc/middle/borrowck/loan.rs b/src/librustc/middle/borrowck/loan.rs index e095c970931..c0551436ede 100644 --- a/src/librustc/middle/borrowck/loan.rs +++ b/src/librustc/middle/borrowck/loan.rs @@ -130,7 +130,7 @@ pub impl LoanContext { } cat_local(local_id) | cat_arg(local_id) | cat_self(local_id) => { // FIXME(#4903) - let local_scope_id = self.bccx.tcx.region_map.get(&local_id); + let local_scope_id = *self.bccx.tcx.region_map.get(&local_id); self.issue_loan(cmt, ty::re_scope(local_scope_id), loan_kind, owns_lent_data) } diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index d5c4b27e6cb..cdec64b7b4c 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -234,10 +234,10 @@ use middle::moves; use util::common::{indenter, stmt_set}; use util::ppaux::note_and_explain_region; +use core::hashmap::linear::{LinearSet, LinearMap}; use core::io; use core::result::{Result, Ok, Err}; use core::to_bytes; -use std::oldmap::{HashMap, Set}; use syntax::ast::{mutability, m_mutbl, m_imm, m_const}; use syntax::ast; use syntax::codemap::span; @@ -260,9 +260,9 @@ pub fn check_crate( moves_map: moves_map, capture_map: capture_map, root_map: root_map(), - mutbl_map: HashMap(), - write_guard_map: HashMap(), - stmt_map: HashMap(), + mutbl_map: @mut LinearSet::new(), + write_guard_map: @mut LinearSet::new(), + stmt_map: @mut LinearSet::new(), stats: @mut BorrowStats { loaned_paths_same: 0, loaned_paths_imm: 0, @@ -333,7 +333,7 @@ pub struct RootInfo { // a map mapping id's of expressions of gc'd type (@T, @[], etc) where // the box needs to be kept live to the id of the scope for which they // must stay live. -pub type root_map = HashMap<root_map_key, RootInfo>; +pub type root_map = @mut LinearMap<root_map_key, RootInfo>; // the keys to the root map combine the `id` of the expression with // the number of types that it is autodereferenced. So, for example, @@ -348,11 +348,11 @@ pub struct root_map_key { // set of ids of local vars / formal arguments that are modified / moved. // this is used in trans for optimization purposes. -pub type mutbl_map = HashMap<ast::node_id, ()>; +pub type mutbl_map = @mut LinearSet<ast::node_id>; // A set containing IDs of expressions of gc'd type that need to have a write // guard. -pub type write_guard_map = HashMap<root_map_key, ()>; +pub type write_guard_map = @mut LinearSet<root_map_key>; // Errors that can occur #[deriving(Eq)] @@ -405,8 +405,8 @@ pub struct Loan { /// - `pure_map`: map from block/expr that must be pure to the error message /// that should be reported if they are not pure pub struct ReqMaps { - req_loan_map: HashMap<ast::node_id, @mut ~[Loan]>, - pure_map: HashMap<ast::node_id, bckerr> + req_loan_map: LinearMap<ast::node_id, @mut ~[Loan]>, + pure_map: LinearMap<ast::node_id, bckerr> } pub fn save_and_restore<T:Copy,U>(save_and_restore_t: &mut T, @@ -450,7 +450,7 @@ impl to_bytes::IterBytes for root_map_key { } pub fn root_map() -> root_map { - return HashMap(); + return @mut LinearMap::new(); } // ___________________________________________________________________________ @@ -541,7 +541,7 @@ pub impl BorrowckCtxt { fn add_to_mutbl_map(&self, cmt: cmt) { match cmt.cat { cat_local(id) | cat_arg(id) => { - self.mutbl_map.insert(id, ()); + self.mutbl_map.insert(id); } cat_stack_upvar(cmt) => { self.add_to_mutbl_map(cmt); diff --git a/src/librustc/middle/borrowck/preserve.rs b/src/librustc/middle/borrowck/preserve.rs index 0440f4525ff..2ce47d8d0a1 100644 --- a/src/librustc/middle/borrowck/preserve.rs +++ b/src/librustc/middle/borrowck/preserve.rs @@ -108,7 +108,7 @@ pub impl<'self> PreserveCtxt<'self> { // Maybe if we pass in the parent instead here, // we can prevent the "scope not found" error debug!("scope_region thing: %? ", cmt.id); - ty::re_scope(self.tcx().region_map.get(&cmt.id)) + ty::re_scope(*self.tcx().region_map.get(&cmt.id)) }; self.compare_scope(cmt, scope_region) @@ -128,14 +128,14 @@ pub impl<'self> PreserveCtxt<'self> { cmt.span, ~"preserve() called with local and !root_managed_data"); } - let local_scope_id = self.tcx().region_map.get(&local_id); + let local_scope_id = *self.tcx().region_map.get(&local_id); self.compare_scope(cmt, ty::re_scope(local_scope_id)) } cat_binding(local_id) => { // Bindings are these kind of weird implicit pointers (cc // #2329). We require (in gather_loans) that they be // rooted in an immutable location. - let local_scope_id = self.tcx().region_map.get(&local_id); + let local_scope_id = *self.tcx().region_map.get(&local_id); self.compare_scope(cmt, ty::re_scope(local_scope_id)) } cat_arg(local_id) => { @@ -143,11 +143,11 @@ pub impl<'self> PreserveCtxt<'self> { // modes). In that case, the caller guarantees stability // for at least the scope of the fn. This is basically a // deref of a region ptr. - let local_scope_id = self.tcx().region_map.get(&local_id); + let local_scope_id = *self.tcx().region_map.get(&local_id); self.compare_scope(cmt, ty::re_scope(local_scope_id)) } cat_self(local_id) => { - let local_scope_id = self.tcx().region_map.get(&local_id); + let local_scope_id = *self.tcx().region_map.get(&local_id); self.compare_scope(cmt, ty::re_scope(local_scope_id)) } cat_comp(cmt_base, comp_field(*)) | @@ -371,7 +371,7 @@ pub impl<'self> PreserveCtxt<'self> { // scope_id;`. Though that would potentially re-introduce // the ICE. See #3511 for more details. let scope_to_use = if - self.bccx.stmt_map.contains_key(&scope_id) { + self.bccx.stmt_map.contains(&scope_id) { // Root it in its parent scope, b/c // trans won't introduce a new scope for the // stmt diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 7d228f76871..f9212d1ff7b 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -124,12 +124,12 @@ pub fn check_expr(sess: Session, items without type parameters"); } match def_map.find(&e.id) { - Some(def_const(_)) | - Some(def_fn(_, _)) | - Some(def_variant(_, _)) | - Some(def_struct(_)) => { } + Some(&def_const(_)) | + Some(&def_fn(_, _)) | + Some(&def_variant(_, _)) | + Some(&def_struct(_)) => { } - Some(def) => { + Some(&def) => { debug!("(checking const) found bad def: %?", def); sess.span_err( e.span, @@ -143,8 +143,8 @@ pub fn check_expr(sess: Session, } expr_call(callee, _, NoSugar) => { match def_map.find(&callee.id) { - Some(def_struct(*)) => {} // OK. - Some(def_variant(*)) => {} // OK. + Some(&def_struct(*)) => {} // OK. + Some(&def_variant(*)) => {} // OK. _ => { sess.span_err( e.span, @@ -238,9 +238,9 @@ pub fn check_item_recursion(sess: Session, match e.node { expr_path(*) => { match env.def_map.find(&e.id) { - Some(def_const(def_id)) => { + Some(&def_const(def_id)) => { if ast_util::is_local(def_id) { - match env.ast_map.get(&def_id.node) { + match *env.ast_map.get(&def_id.node) { ast_map::node_item(it, _) => { (v.visit_item)(it, env, v); } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index ddc00000c6b..3f3ffe1598a 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -55,7 +55,7 @@ pub fn expr_is_non_moving_lvalue(cx: @MatchCheckCtxt, expr: @expr) -> bool { return false; } - !cx.moves_map.contains_key(&expr.id) + !cx.moves_map.contains(&expr.id) } pub fn check_expr(cx: @MatchCheckCtxt, ex: @expr, &&s: (), v: visit::vt<()>) { @@ -303,8 +303,8 @@ pub fn pat_ctor_id(cx: @MatchCheckCtxt, p: @pat) -> Option<ctor> { pat_wild => { None } pat_ident(_, _, _) | pat_enum(_, _) => { match cx.tcx.def_map.find(&pat.id) { - Some(def_variant(_, id)) => Some(variant(id)), - Some(def_const(did)) => { + Some(&def_variant(_, id)) => Some(variant(id)), + Some(&def_const(did)) => { let const_expr = lookup_const_by_id(cx.tcx, did).get(); Some(val(eval_const_expr(cx.tcx, const_expr))) } @@ -317,7 +317,7 @@ pub fn pat_ctor_id(cx: @MatchCheckCtxt, p: @pat) -> Option<ctor> { } pat_struct(*) => { match cx.tcx.def_map.find(&pat.id) { - Some(def_variant(_, id)) => Some(variant(id)), + Some(&def_variant(_, id)) => Some(variant(id)), _ => Some(single) } } @@ -339,7 +339,7 @@ pub fn is_wild(cx: @MatchCheckCtxt, p: @pat) -> bool { pat_wild => { true } pat_ident(_, _, _) => { match cx.tcx.def_map.find(&pat.id) { - Some(def_variant(_, _)) | Some(def_const(*)) => { false } + Some(&def_variant(_, _)) | Some(&def_const(*)) => { false } _ => { true } } } @@ -490,14 +490,14 @@ pub fn specialize(cx: @MatchCheckCtxt, } pat_ident(_, _, _) => { match cx.tcx.def_map.find(&pat_id) { - Some(def_variant(_, id)) => { + Some(&def_variant(_, id)) => { if variant(id) == ctor_id { Some(vec::from_slice(r.tail())) } else { None } } - Some(def_const(did)) => { + Some(&def_const(did)) => { let const_expr = lookup_const_by_id(cx.tcx, did).get(); let e_v = eval_const_expr(cx.tcx, const_expr); @@ -527,7 +527,7 @@ pub fn specialize(cx: @MatchCheckCtxt, } } pat_enum(_, args) => { - match cx.tcx.def_map.get(&pat_id) { + match *cx.tcx.def_map.get(&pat_id) { def_const(did) => { let const_expr = lookup_const_by_id(cx.tcx, did).get(); @@ -569,7 +569,7 @@ pub fn specialize(cx: @MatchCheckCtxt, } pat_struct(_, ref flds, _) => { // Is this a struct or an enum variant? - match cx.tcx.def_map.get(&pat_id) { + match *cx.tcx.def_map.get(&pat_id) { def_variant(_, variant_id) => { if variant(variant_id) == ctor_id { // FIXME #4731: Is this right? --pcw @@ -714,12 +714,12 @@ pub fn check_fn(cx: @MatchCheckCtxt, pub fn is_refutable(cx: @MatchCheckCtxt, pat: &pat) -> bool { match cx.tcx.def_map.find(&pat.id) { - Some(def_variant(enum_id, _)) => { + Some(&def_variant(enum_id, _)) => { if vec::len(*ty::enum_variants(cx.tcx, enum_id)) != 1u { return true; } } - Some(def_const(*)) => return true, + Some(&def_const(*)) => return true, _ => () } @@ -766,7 +766,7 @@ pub fn check_legality_of_move_bindings(cx: @MatchCheckCtxt, by_ref_span = Some(span); } bind_infer => { - if cx.moves_map.contains_key(&id) { + if cx.moves_map.contains(&id) { any_by_move = true; } } @@ -806,7 +806,7 @@ pub fn check_legality_of_move_bindings(cx: @MatchCheckCtxt, if pat_is_binding(def_map, p) { match p.node { pat_ident(_, _, sub) => { - if cx.moves_map.contains_key(&p.id) { + if cx.moves_map.contains(&p.id) { check_move(p, sub); } } @@ -832,7 +832,7 @@ pub fn check_legality_of_move_bindings(cx: @MatchCheckCtxt, behind_bad_pointer); if behind_bad_pointer && - cx.moves_map.contains_key(&pat.id) + cx.moves_map.contains(&pat.id) { cx.tcx.sess.span_err( pat.span, diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 7e0a36be0a0..a25d873af41 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -12,7 +12,6 @@ use core::prelude::*; use metadata::csearch; use middle::astencode; -use middle::resolve; use middle::ty; use middle; @@ -21,7 +20,7 @@ use core::vec; use syntax::{ast, ast_map, ast_util, visit}; use syntax::ast::*; -use std::oldmap::HashMap; +use core::hashmap::linear::{LinearMap, LinearSet}; // // This pass classifies expressions by their constant-ness. @@ -77,12 +76,11 @@ pub fn join_all(cs: &[constness]) -> constness { } pub fn classify(e: @expr, - def_map: resolve::DefMap, tcx: ty::ctxt) -> constness { let did = ast_util::local_def(e.id); match tcx.ccache.find(&did) { - Some(x) => x, + Some(&x) => x, None => { let cn = match e.node { @@ -97,23 +95,23 @@ pub fn classify(e: @expr, ast::expr_copy(inner) | ast::expr_unary(_, inner) | ast::expr_paren(inner) => { - classify(inner, def_map, tcx) + classify(inner, tcx) } ast::expr_binary(_, a, b) => { - join(classify(a, def_map, tcx), - classify(b, def_map, tcx)) + join(classify(a, tcx), + classify(b, tcx)) } ast::expr_tup(ref es) | ast::expr_vec(ref es, ast::m_imm) => { - join_all(vec::map(*es, |e| classify(*e, def_map, tcx))) + join_all(vec::map(*es, |e| classify(*e, tcx))) } ast::expr_vstore(e, vstore) => { match vstore { ast::expr_vstore_fixed(_) | - ast::expr_vstore_slice => classify(e, def_map, tcx), + ast::expr_vstore_slice => classify(e, tcx), ast::expr_vstore_uniq | ast::expr_vstore_box | ast::expr_vstore_mut_box | @@ -124,7 +122,7 @@ pub fn classify(e: @expr, ast::expr_struct(_, ref fs, None) => { let cs = do vec::map((*fs)) |f| { if f.node.mutbl == ast::m_imm { - classify(f.node.expr, def_map, tcx) + classify(f.node.expr, tcx) } else { non_const } @@ -134,7 +132,7 @@ pub fn classify(e: @expr, ast::expr_cast(base, _) => { let ty = ty::expr_ty(tcx, e); - let base = classify(base, def_map, tcx); + let base = classify(base, tcx); if ty::type_is_integral(ty) { join(integral_const, base) } else if ty::type_is_fp(ty) { @@ -145,16 +143,16 @@ pub fn classify(e: @expr, } ast::expr_field(base, _, _) => { - classify(base, def_map, tcx) + classify(base, tcx) } ast::expr_index(base, idx) => { - join(classify(base, def_map, tcx), - classify(idx, def_map, tcx)) + join(classify(base, tcx), + classify(idx, tcx)) } ast::expr_addr_of(ast::m_imm, base) => { - classify(base, def_map, tcx) + classify(base, tcx) } // FIXME: (#3728) we can probably do something CCI-ish @@ -173,7 +171,7 @@ pub fn classify(e: @expr, pub fn lookup_const(tcx: ty::ctxt, e: @expr) -> Option<@expr> { match tcx.def_map.find(&e.id) { - Some(ast::def_const(def_id)) => lookup_const_by_id(tcx, def_id), + Some(&ast::def_const(def_id)) => lookup_const_by_id(tcx, def_id), _ => None } } @@ -184,7 +182,7 @@ pub fn lookup_const_by_id(tcx: ty::ctxt, if ast_util::is_local(def_id) { match tcx.items.find(&def_id.node) { None => None, - Some(ast_map::node_item(it, _)) => match it.node { + Some(&ast_map::node_item(it, _)) => match it.node { item_const(_, const_expr) => Some(const_expr), _ => None }, @@ -192,14 +190,14 @@ pub fn lookup_const_by_id(tcx: ty::ctxt, } } else { let maps = astencode::Maps { - mutbl_map: HashMap(), - root_map: HashMap(), - last_use_map: HashMap(), - method_map: HashMap(), - vtable_map: HashMap(), - write_guard_map: HashMap(), - moves_map: HashMap(), - capture_map: HashMap() + mutbl_map: @mut LinearSet::new(), + root_map: @mut LinearMap::new(), + last_use_map: @mut LinearMap::new(), + method_map: @mut LinearMap::new(), + vtable_map: @mut LinearMap::new(), + write_guard_map: @mut LinearSet::new(), + moves_map: @mut LinearSet::new(), + capture_map: @mut LinearMap::new() }; match csearch::maybe_get_item_ast(tcx, def_id, |a, b, c, d| astencode::decode_inlined_item(a, b, maps, /*bar*/ copy c, d)) { @@ -227,10 +225,9 @@ pub fn lookup_constness(tcx: ty::ctxt, e: @expr) -> constness { } pub fn process_crate(crate: @ast::crate, - def_map: resolve::DefMap, tcx: ty::ctxt) { let v = visit::mk_simple_visitor(@visit::SimpleVisitor { - visit_expr_post: |e| { classify(e, def_map, tcx); }, + visit_expr_post: |e| { classify(e, tcx); }, .. *visit::default_simple_visitor() }); visit::visit_crate(*crate, (), v); diff --git a/src/librustc/middle/freevars.rs b/src/librustc/middle/freevars.rs index e4ea2333d27..19d3e1f431d 100644 --- a/src/librustc/middle/freevars.rs +++ b/src/librustc/middle/freevars.rs @@ -12,13 +12,12 @@ // A pass that annotates for each loops and functions with the free // variables that they contain. +use core::prelude::*; + use middle::resolve; use middle::ty; -use core::int; -use core::option::*; -use core::vec; -use std::oldmap::*; +use core::hashmap::linear::LinearMap; use syntax::codemap::span; use syntax::{ast, ast_util, visit}; @@ -31,7 +30,7 @@ pub struct freevar_entry { span: span //< First span where it is accessed (there can be multiple) } pub type freevar_info = @~[@freevar_entry]; -pub type freevar_map = HashMap<ast::node_id, freevar_info>; +pub type freevar_map = @mut LinearMap<ast::node_id, freevar_info>; // Searches through part of the AST for all references to locals or // upvars in this frame and returns the list of definition IDs thus found. @@ -40,7 +39,7 @@ pub type freevar_map = HashMap<ast::node_id, freevar_info>; // in order to start the search. fn collect_freevars(def_map: resolve::DefMap, blk: &ast::blk) -> freevar_info { - let seen = HashMap(); + let seen = @mut LinearMap::new(); let refs = @mut ~[]; fn ignore_item(_i: @ast::item, &&_depth: int, _v: visit::vt<int>) { } @@ -53,7 +52,7 @@ fn collect_freevars(def_map: resolve::DefMap, blk: &ast::blk) let mut i = 0; match def_map.find(&expr.id) { None => fail!(~"path not found"), - Some(df) => { + Some(&df) => { let mut def = df; while i < depth { match def { @@ -93,7 +92,7 @@ fn collect_freevars(def_map: resolve::DefMap, blk: &ast::blk) // one pass. This could be improved upon if it turns out to matter. pub fn annotate_freevars(def_map: resolve::DefMap, crate: @ast::crate) -> freevar_map { - let freevars = HashMap(); + let freevars = @mut LinearMap::new(); let walk_fn: @fn(&visit::fn_kind, &ast::fn_decl, @@ -116,7 +115,7 @@ pub fn annotate_freevars(def_map: resolve::DefMap, crate: @ast::crate) -> pub fn get_freevars(tcx: ty::ctxt, fid: ast::node_id) -> freevar_info { match tcx.freevars.find(&fid) { None => fail!(~"get_freevars: "+int::to_str(fid)+~" has no freevars"), - Some(d) => return d + Some(&d) => return d } } diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index 0861e57c9b4..ca301182e6f 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -18,9 +18,6 @@ use middle::ty; use middle::typeck; use util::ppaux::{ty_to_str, tys_to_str}; -use core::str; -use core::vec; -use std::oldmap::HashMap; use syntax::ast::*; use syntax::attr::attrs_contains_name; use syntax::codemap::{span, spanned}; @@ -58,8 +55,6 @@ use syntax::{visit, ast_util}; pub static try_adding: &'static str = "Try adding a move"; -pub type rval_map = HashMap<node_id, ()>; - pub struct Context { tcx: ty::ctxt, method_map: typeck::method_map, @@ -133,13 +128,13 @@ fn check_item(item: @item, cx: Context, visitor: visit::vt<Context>) { item_impl(_, Some(trait_ref), self_type, _) => { match cx.tcx.def_map.find(&trait_ref.ref_id) { None => cx.tcx.sess.bug(~"trait ref not in def map!"), - Some(trait_def) => { + Some(&trait_def) => { let trait_def_id = ast_util::def_id_of_def(trait_def); if cx.tcx.lang_items.drop_trait() == trait_def_id { // Yes, it's a destructor. match self_type.node { ty_path(_, path_node_id) => { - let struct_def = cx.tcx.def_map.get( + let struct_def = *cx.tcx.def_map.get( &path_node_id); let struct_did = ast_util::def_id_of_def(struct_def); @@ -279,9 +274,11 @@ 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)); + let did = ast_util::def_id_of_def(*cx.tcx.def_map.get(&e.id)); ty::lookup_item_type(cx.tcx, did).bounds } _ => { @@ -294,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) } } @@ -340,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| { - let did = ast_util::def_id_of_def(cx.tcx.def_map.get(&id)); + // 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) } } @@ -405,7 +404,7 @@ pub fn check_bounds(cx: Context, fn is_nullary_variant(cx: Context, ex: @expr) -> bool { match ex.node { expr_path(_) => { - match cx.tcx.def_map.get(&ex.id) { + match *cx.tcx.def_map.get(&ex.id) { def_variant(edid, vdid) => { vec::len(ty::enum_variant_with_id(cx.tcx, edid, vdid).args) == 0u } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 669587205d5..9de7b5088f3 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -31,8 +31,8 @@ use syntax::ast_util::{local_def}; use syntax::visit::{default_simple_visitor, mk_simple_visitor, SimpleVisitor}; use syntax::visit::{visit_crate, visit_item}; +use core::hashmap::linear::LinearMap; use core::ptr; -use std::oldmap::HashMap; pub enum LangItem { ConstTraitLangItem, // 0 @@ -259,7 +259,7 @@ fn LanguageItemCollector<'r>(crate: @crate, session: Session, items: &'r mut LanguageItems) -> LanguageItemCollector<'r> { - let item_refs = HashMap(); + let mut item_refs = LinearMap::new(); item_refs.insert(@~"const", ConstTraitLangItem as uint); item_refs.insert(@~"copy", CopyTraitLangItem as uint); @@ -317,7 +317,7 @@ struct LanguageItemCollector { crate: @crate, session: Session, - item_refs: HashMap<@~str, uint>, + item_refs: LinearMap<@~str, uint>, } pub impl<'self> LanguageItemCollector<'self> { @@ -362,7 +362,7 @@ pub impl<'self> LanguageItemCollector<'self> { None => { // Didn't match. } - Some(item_index) => { + Some(&item_index) => { self.collect_item(item_index, item_def_id) } } @@ -397,7 +397,7 @@ pub impl<'self> LanguageItemCollector<'self> { } fn check_completeness(&self) { - for self.item_refs.each |&key, &item_ref| { + for self.item_refs.each |&(&key, &item_ref)| { match self.items.items[item_ref] { None => { self.session.err(fmt!("no item found for `%s`", *key)); diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 2b16ccdd1d2..a75ade0c585 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -15,6 +15,7 @@ use driver::session; use middle::ty; use util::ppaux::{ty_to_str}; +use core::hashmap::linear::LinearMap; use core::char; use core::cmp; use core::either; @@ -30,8 +31,6 @@ use core::u32; use core::u64; use core::uint; use core::vec; -use std::oldmap::{Map, HashMap}; -use std::oldmap; use std::smallintmap::SmallIntMap; use syntax::attr; use syntax::codemap::span; @@ -110,7 +109,7 @@ struct LintSpec { default: level } -pub type LintDict = HashMap<@~str, @LintSpec>; +pub type LintDict = @LinearMap<~str, LintSpec>; /* Pass names should not contain a '-', as the compiler normalizes @@ -118,142 +117,142 @@ pub type LintDict = HashMap<@~str, @LintSpec>; */ pub fn get_lint_dict() -> LintDict { let v = ~[ - (@~"ctypes", - @LintSpec { + (~"ctypes", + LintSpec { lint: ctypes, desc: "proper use of core::libc types in foreign modules", default: warn }), - (@~"unused_imports", - @LintSpec { + (~"unused_imports", + LintSpec { lint: unused_imports, desc: "imports that are never used", default: warn }), - (@~"while_true", - @LintSpec { + (~"while_true", + LintSpec { lint: while_true, desc: "suggest using loop { } instead of while(true) { }", default: warn }), - (@~"path_statement", - @LintSpec { + (~"path_statement", + LintSpec { lint: path_statement, desc: "path statements with no effect", default: warn }), - (@~"unrecognized_lint", - @LintSpec { + (~"unrecognized_lint", + LintSpec { lint: unrecognized_lint, desc: "unrecognized lint attribute", default: warn }), - (@~"non_implicitly_copyable_typarams", - @LintSpec { + (~"non_implicitly_copyable_typarams", + LintSpec { lint: non_implicitly_copyable_typarams, desc: "passing non implicitly copyable types as copy type params", default: warn }), - (@~"vecs_implicitly_copyable", - @LintSpec { + (~"vecs_implicitly_copyable", + LintSpec { lint: vecs_implicitly_copyable, desc: "make vecs and strs not implicitly copyable \ (only checked at top level)", default: warn }), - (@~"implicit_copies", - @LintSpec { + (~"implicit_copies", + LintSpec { lint: implicit_copies, desc: "implicit copies of non implicitly copyable data", default: warn }), - (@~"deprecated_mode", - @LintSpec { + (~"deprecated_mode", + LintSpec { lint: deprecated_mode, desc: "warn about deprecated uses of modes", default: warn }), - (@~"foreign_mode", - @LintSpec { + (~"foreign_mode", + LintSpec { lint: foreign_mode, desc: "warn about deprecated uses of modes in foreign fns", default: warn }), - (@~"deprecated_pattern", - @LintSpec { + (~"deprecated_pattern", + LintSpec { lint: deprecated_pattern, desc: "warn about deprecated uses of pattern bindings", default: allow }), - (@~"non_camel_case_types", - @LintSpec { + (~"non_camel_case_types", + LintSpec { lint: non_camel_case_types, desc: "types, variants and traits should have camel case names", default: allow }), - (@~"managed_heap_memory", - @LintSpec { + (~"managed_heap_memory", + LintSpec { lint: managed_heap_memory, desc: "use of managed (@ type) heap memory", default: allow }), - (@~"owned_heap_memory", - @LintSpec { + (~"owned_heap_memory", + LintSpec { lint: owned_heap_memory, desc: "use of owned (~ type) heap memory", default: allow }), - (@~"heap_memory", - @LintSpec { + (~"heap_memory", + LintSpec { lint: heap_memory, desc: "use of any (~ type or @ type) heap memory", default: allow }), - (@~"legacy modes", - @LintSpec { + (~"legacy modes", + LintSpec { lint: legacy_modes, desc: "allow legacy modes", default: forbid }), - (@~"type_limits", - @LintSpec { + (~"type_limits", + LintSpec { lint: type_limits, desc: "comparisons made useless by limits of the types involved", default: warn }), - (@~"default_methods", - @LintSpec { + (~"default_methods", + LintSpec { lint: default_methods, desc: "allow default methods", default: deny }), - (@~"deprecated_mutable_fields", - @LintSpec { + (~"deprecated_mutable_fields", + LintSpec { lint: deprecated_mutable_fields, desc: "deprecated mutable fields in structures", default: deny }), - (@~"deprecated_drop", - @LintSpec { + (~"deprecated_drop", + LintSpec { lint: deprecated_drop, desc: "deprecated \"drop\" notation for the destructor", default: deny @@ -275,12 +274,16 @@ pub fn get_lint_dict() -> LintDict { }), */ ]; - oldmap::hash_from_vec(v) + let mut map = LinearMap::new(); + do vec::consume(v) |_, (k, v)| { + map.insert(k, v); + } + return @map; } // This is a highly not-optimal set of data structure decisions. type LintModes = @mut SmallIntMap<level>; -type LintModeMap = HashMap<ast::node_id, LintModes>; +type LintModeMap = @mut LinearMap<ast::node_id, LintModes>; // settings_map maps node ids of items with non-default lint settings // to their settings; default_settings contains the settings for everything @@ -293,7 +296,7 @@ pub struct LintSettings { pub fn mk_lint_settings() -> LintSettings { LintSettings { default_settings: @mut SmallIntMap::new(), - settings_map: HashMap() + settings_map: @mut LinearMap::new() } } @@ -310,7 +313,7 @@ pub fn get_lint_settings_level(settings: LintSettings, item_id: ast::node_id) -> level { match settings.settings_map.find(&item_id) { - Some(modes) => get_lint_level(modes, lint_mode), + Some(&modes) => get_lint_level(modes, lint_mode), None => get_lint_level(settings.default_settings, lint_mode) } } @@ -392,7 +395,7 @@ pub impl Context { (ref meta, level, lintname) => (meta, level, lintname) }; - match self.dict.find(&lintname) { + match self.dict.find(lintname) { None => { self.span_lint( new_ctxt.get_level(unrecognized_lint), @@ -735,7 +738,7 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) { for vec::each(vec::append_one(tys, decl.output)) |ty| { match ty.node { ast::ty_path(_, id) => { - match cx.def_map.get(&id) { + match *cx.def_map.get(&id) { ast::def_prim_ty(ast::ty_int(ast::ty_i)) => { cx.sess.span_lint( ctypes, id, fn_id, diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index e3a595a8552..a92234ba129 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -112,13 +112,13 @@ use middle::moves; use util::ppaux::ty_to_str; use core::cmp; +use core::hashmap::linear::LinearMap; use core::io::WriterUtil; use core::io; use core::ptr; use core::to_str; use core::uint; use core::vec; -use std::oldmap::HashMap; use syntax::ast::*; use syntax::codemap::span; use syntax::parse::token::special_idents; @@ -135,7 +135,7 @@ use syntax::{visit, ast_util}; // // Very subtle (#2633): borrowck will remove entries from this table // if it detects an outstanding loan (that is, the addr is taken). -pub type last_use_map = HashMap<node_id, @mut ~[node_id]>; +pub type last_use_map = @mut LinearMap<node_id, @mut ~[node_id]>; struct Variable(uint); struct LiveNode(uint); @@ -212,7 +212,7 @@ pub fn check_crate(tcx: ty::ctxt, .. *visit::default_visitor() }); - let last_use_map = HashMap(); + let last_use_map = @mut LinearMap::new(); let initial_maps = @mut IrMaps(tcx, method_map, variable_moves_map, @@ -304,9 +304,9 @@ struct IrMaps { num_live_nodes: uint, num_vars: uint, - live_node_map: HashMap<node_id, LiveNode>, - variable_map: HashMap<node_id, Variable>, - capture_info_map: HashMap<node_id, @~[CaptureInfo]>, + live_node_map: LinearMap<node_id, LiveNode>, + variable_map: LinearMap<node_id, Variable>, + capture_info_map: LinearMap<node_id, @~[CaptureInfo]>, var_kinds: ~[VarKind], lnks: ~[LiveNodeKind], } @@ -325,9 +325,9 @@ fn IrMaps(tcx: ty::ctxt, last_use_map: last_use_map, num_live_nodes: 0, num_vars: 0, - live_node_map: HashMap(), - variable_map: HashMap(), - capture_info_map: HashMap(), + live_node_map: LinearMap::new(), + variable_map: LinearMap::new(), + capture_info_map: LinearMap::new(), var_kinds: ~[], lnks: ~[] } @@ -374,7 +374,7 @@ pub impl IrMaps { fn variable(&mut self, node_id: node_id, span: span) -> Variable { match self.variable_map.find(&node_id) { - Some(var) => var, + Some(&var) => var, None => { self.tcx.sess.span_bug( span, fmt!("No variable registered for id %d", node_id)); @@ -396,7 +396,7 @@ pub impl IrMaps { fn captures(&mut self, expr: @expr) -> @~[CaptureInfo] { match self.capture_info_map.find(&expr.id) { - Some(caps) => caps, + Some(&caps) => caps, None => { self.tcx.sess.span_bug(expr.span, ~"no registered caps"); } @@ -416,7 +416,7 @@ pub impl IrMaps { Local(LocalInfo {id: id, kind: FromLetWithInitializer, _}) | Local(LocalInfo {id: id, kind: FromMatch(_), _}) => { let v = match self.last_use_map.find(&expr_id) { - Some(v) => v, + Some(&v) => v, None => { let v = @mut ~[]; self.last_use_map.insert(expr_id, v); @@ -562,7 +562,7 @@ fn visit_expr(expr: @expr, &&self: @mut IrMaps, vt: vt<@mut IrMaps>) { match expr.node { // live nodes required for uses or definitions of variables: expr_path(_) => { - let def = self.tcx.def_map.get(&expr.id); + let def = *self.tcx.def_map.get(&expr.id); debug!("expr %d: path that leads to %?", expr.id, def); if relevant_def(def).is_some() { self.add_live_node_for_node(expr.id, ExprNode(expr.span)); @@ -657,7 +657,7 @@ static ACC_READ: uint = 1u; static ACC_WRITE: uint = 2u; static ACC_USE: uint = 4u; -type LiveNodeMap = HashMap<node_id, LiveNode>; +type LiveNodeMap = @mut LinearMap<node_id, LiveNode>; struct Liveness { tcx: ty::ctxt, @@ -684,15 +684,16 @@ fn Liveness(ir: @mut IrMaps, specials: Specials) -> Liveness { users: @mut vec::from_elem(ir.num_live_nodes * ir.num_vars, invalid_users()), loop_scope: @mut ~[], - break_ln: HashMap(), - cont_ln: HashMap() + break_ln: @mut LinearMap::new(), + cont_ln: @mut LinearMap::new() } } pub impl Liveness { fn live_node(&self, node_id: node_id, span: span) -> LiveNode { - match self.ir.live_node_map.find(&node_id) { - Some(ln) => ln, + let ir: &mut IrMaps = self.ir; + match ir.live_node_map.find(&node_id) { + Some(&ln) => ln, None => { // This must be a mismatch between the ir_map construction // above and the propagation code below; the two sets of @@ -708,7 +709,7 @@ pub impl Liveness { fn variable_from_path(&self, expr: @expr) -> Option<Variable> { match expr.node { expr_path(_) => { - let def = self.tcx.def_map.get(&expr.id); + let def = *self.tcx.def_map.get(&expr.id); relevant_def(def).map( |rdef| self.variable(*rdef, expr.span) ) @@ -724,7 +725,7 @@ pub impl Liveness { fn variable_from_def_map(&self, node_id: node_id, span: span) -> Option<Variable> { match self.tcx.def_map.find(&node_id) { - Some(def) => { + Some(&def) => { relevant_def(def).map( |rdef| self.variable(*rdef, span) ) @@ -845,7 +846,7 @@ pub impl Liveness { Some(_) => // Refers to a labeled loop. Use the results of resolve // to find with one match self.tcx.def_map.find(&id) { - Some(def_label(loop_id)) => loop_id, + Some(&def_label(loop_id)) => loop_id, _ => self.tcx.sess.span_bug(sp, ~"Label on break/loop \ doesn't refer to a loop") }, @@ -1226,7 +1227,7 @@ pub impl Liveness { // look it up in the break loop nodes table match self.break_ln.find(&sc) { - Some(b) => b, + Some(&b) => b, None => self.tcx.sess.span_bug(expr.span, ~"Break to unknown label") } @@ -1240,7 +1241,7 @@ pub impl Liveness { // look it up in the continue loop nodes table match self.cont_ln.find(&sc) { - Some(b) => b, + Some(&b) => b, None => self.tcx.sess.span_bug(expr.span, ~"Loop to unknown label") } @@ -1448,7 +1449,7 @@ pub impl Liveness { fn access_path(&self, expr: @expr, succ: LiveNode, acc: uint) -> LiveNode { - let def = self.tcx.def_map.get(&expr.id); + let def = *self.tcx.def_map.get(&expr.id); match relevant_def(def) { Some(nid) => { let ln = self.live_node(expr.id, expr.span); @@ -1587,7 +1588,7 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) { match self.ir.variable_moves_map.find(&expr.id) { None => {} - Some(entire_expr) => { + Some(&entire_expr) => { debug!("(checking expr) is a move: `%s`", expr_to_str(expr, self.tcx.sess.intr())); self.check_move_from_var(ln, *var, entire_expr); @@ -1723,7 +1724,7 @@ pub impl Liveness { fn check_lvalue(@self, expr: @expr, vt: vt<@Liveness>) { match expr.node { expr_path(_) => { - match self.tcx.def_map.get(&expr.id) { + match *self.tcx.def_map.get(&expr.id) { def_local(nid, false) => { // Assignment to an immutable variable or argument: // only legal if there is no later assignment. diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index e767b0ff812..b7ec6208d56 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -359,7 +359,7 @@ pub impl mem_categorization_ctxt { self.cat_expr_unadjusted(expr) } - Some(@ty::AutoAddEnv(*)) => { + Some(&@ty::AutoAddEnv(*)) => { // Convert a bare fn to a closure by adding NULL env. // Result is an rvalue. let expr_ty = ty::expr_ty_adjusted(self.tcx, expr); @@ -367,7 +367,7 @@ pub impl mem_categorization_ctxt { } Some( - @ty::AutoDerefRef( + &@ty::AutoDerefRef( ty::AutoDerefRef { autoref: Some(_), _})) => { // Equivalent to &*expr or something similar. @@ -377,7 +377,7 @@ pub impl mem_categorization_ctxt { } Some( - @ty::AutoDerefRef( + &@ty::AutoDerefRef( ty::AutoDerefRef { autoref: None, autoderefs: autoderefs})) => { // Equivalent to *expr or something similar. @@ -431,7 +431,7 @@ pub impl mem_categorization_ctxt { } ast::expr_path(_) => { - let def = self.tcx.def_map.get(&expr.id); + let def = *self.tcx.def_map.get(&expr.id); self.cat_def(expr.id, expr.span, expr_ty, def) } @@ -902,21 +902,21 @@ pub impl mem_categorization_ctxt { } ast::pat_enum(_, Some(ref subpats)) => { match self.tcx.def_map.find(&pat.id) { - Some(ast::def_variant(enum_did, _)) => { + Some(&ast::def_variant(enum_did, _)) => { // variant(x, y, z) for subpats.each |subpat| { let subcmt = self.cat_variant(*subpat, enum_did, cmt); self.cat_pattern(subcmt, *subpat, op); } } - Some(ast::def_struct(*)) => { + Some(&ast::def_struct(*)) => { for subpats.each |subpat| { let cmt_field = self.cat_anon_struct_field(*subpat, cmt); self.cat_pattern(cmt_field, *subpat, op); } } - Some(ast::def_const(*)) => { + Some(&ast::def_const(*)) => { for subpats.each |subpat| { self.cat_pattern(cmt, *subpat, op); } @@ -1124,7 +1124,7 @@ pub fn field_mutbl(tcx: ty::ctxt, } } ty::ty_enum(*) => { - match tcx.def_map.get(&node_id) { + match *tcx.def_map.get(&node_id) { ast::def_variant(_, variant_id) => { for ty::lookup_struct_fields(tcx, variant_id).each |fld| { if fld.ident == f_name { diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index 9848c65ac43..16f133b8794 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -216,8 +216,8 @@ use middle::typeck::check::{DerefArgs, DoDerefArgs, DontDerefArgs}; use util::ppaux; use util::common::indenter; +use core::hashmap::linear::{LinearSet, LinearMap}; use core::vec; -use std::oldmap::HashMap; use syntax::ast::*; use syntax::ast_util; use syntax::visit; @@ -242,14 +242,14 @@ pub struct CaptureVar { mode: CaptureMode // How variable is being accessed } -pub type CaptureMap = HashMap<node_id, @[CaptureVar]>; +pub type CaptureMap = @mut LinearMap<node_id, @[CaptureVar]>; -pub type MovesMap = HashMap<node_id, ()>; +pub type MovesMap = @mut LinearSet<node_id>; /** * For each variable which will be moved, links to the * expression */ -pub type VariableMovesMap = HashMap<node_id, @expr>; +pub type VariableMovesMap = @mut LinearMap<node_id, @expr>; /** See the section Output on the module comment for explanation. */ pub struct MoveMaps { @@ -260,7 +260,7 @@ pub struct MoveMaps { struct VisitContext { tcx: ty::ctxt, - method_map: HashMap<node_id,method_map_entry>, + method_map: method_map, move_maps: MoveMaps } @@ -282,9 +282,9 @@ pub fn compute_moves(tcx: ty::ctxt, tcx: tcx, method_map: method_map, move_maps: MoveMaps { - moves_map: HashMap(), - variable_moves_map: HashMap(), - capture_map: HashMap() + moves_map: @mut LinearSet::new(), + variable_moves_map: @mut LinearMap::new(), + capture_map: @mut LinearMap::new() } }; visit::visit_crate(*crate, visit_cx, visitor); @@ -402,7 +402,7 @@ pub impl VisitContext { expr_mode); match expr_mode { - MoveInWhole => { self.move_maps.moves_map.insert(expr.id, ()); } + MoveInWhole => { self.move_maps.moves_map.insert(expr.id); } MoveInPart(_) | Read => {} } @@ -410,7 +410,7 @@ pub impl VisitContext { // those adjustments is to take a reference, then it's only // reading the underlying expression, not moving it. let comp_mode = match self.tcx.adjustments.find(&expr.id) { - Some(@ty::AutoDerefRef( + Some(&@ty::AutoDerefRef( ty::AutoDerefRef { autoref: Some(_), _})) => Read, _ => expr_mode.component_mode(expr) @@ -725,7 +725,7 @@ pub impl VisitContext { }; match mode { - MoveInWhole => { self.move_maps.moves_map.insert(id, ()); } + MoveInWhole => { self.move_maps.moves_map.insert(id); } MoveInPart(_) | Read => {} } } @@ -795,7 +795,7 @@ pub impl VisitContext { for arm.pats.each |pat| { let mut found = false; do pat_bindings(self.tcx.def_map, *pat) |_, node_id, _, _| { - if moves_map.contains_key(&node_id) { + if moves_map.contains(&node_id) { found = true; } } diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index a25fddcad88..6bf75b50cb4 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -12,17 +12,17 @@ use core::prelude::*; use middle::resolve; +use core::hashmap::linear::LinearMap; use syntax::ast::*; use syntax::ast_util::{path_to_ident, walk_pat}; use syntax::codemap::{span, respan}; -use std::oldmap::HashMap; -pub type PatIdMap = HashMap<ident, node_id>; +pub type PatIdMap = LinearMap<ident, node_id>; // This is used because same-named variables in alternative patterns need to // use the node_id of their namesake in the first pattern. pub fn pat_id_map(dm: resolve::DefMap, pat: @pat) -> PatIdMap { - let map = HashMap(); + let mut map = LinearMap::new(); do pat_bindings(dm, pat) |_bm, p_id, _s, n| { map.insert(path_to_ident(n), p_id); }; @@ -33,7 +33,7 @@ pub fn pat_is_variant_or_struct(dm: resolve::DefMap, pat: @pat) -> bool { match pat.node { pat_enum(_, _) | pat_ident(_, _, None) | pat_struct(*) => { match dm.find(&pat.id) { - Some(def_variant(*)) | Some(def_struct(*)) => true, + Some(&def_variant(*)) | Some(&def_struct(*)) => true, _ => false } } @@ -45,7 +45,7 @@ pub fn pat_is_const(dm: resolve::DefMap, pat: &pat) -> bool { match pat.node { pat_ident(_, _, None) | pat_enum(*) => { match dm.find(&pat.id) { - Some(def_const(*)) => true, + Some(&def_const(*)) => true, _ => false } } diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index c3a65a4f256..50e8ed23446 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -113,8 +113,8 @@ pub fn check_crate(tcx: ty::ctxt, @fn(span: span, method_id: node_id) -> def_id = |span, method_id| { match tcx.items.find(&method_id) { - Some(node_method(_, impl_id, _)) => impl_id, - Some(node_trait_method(_, trait_id, _)) => trait_id, + Some(&node_method(_, impl_id, _)) => impl_id, + Some(&node_trait_method(_, trait_id, _)) => trait_id, Some(_) => { tcx.sess.span_bug(span, fmt!("method was a %s?!", @@ -148,7 +148,7 @@ pub fn check_crate(tcx: ty::ctxt, } match tcx.items.find(&container_id.node) { - Some(node_item(item, _)) => { + Some(&node_item(item, _)) => { match item.node { item_impl(_, None, _, _) if item.vis != public => { @@ -170,10 +170,10 @@ pub fn check_crate(tcx: ty::ctxt, }; match tcx.items.find(&method_id) { - Some(node_method(method, impl_id, _)) => { + Some(&node_method(method, impl_id, _)) => { check(method.vis, impl_id) } - Some(node_trait_method(trait_method, trait_id, _)) => { + Some(&node_trait_method(trait_method, trait_id, _)) => { match *trait_method { required(_) => check(public, trait_id), provided(method) => check(method.vis, trait_id), @@ -200,16 +200,16 @@ pub fn check_crate(tcx: ty::ctxt, let mut f: &fn(node_id) -> bool = |_| false; f = |item_id| { match tcx.items.find(&item_id) { - Some(node_item(item, _)) => item.vis != public, - Some(node_foreign_item(_, _, vis, _)) => vis != public, - Some(node_method(method, impl_did, _)) => { + Some(&node_item(item, _)) => item.vis != public, + Some(&node_foreign_item(_, _, vis, _)) => vis != public, + Some(&node_method(method, impl_did, _)) => { match method.vis { private => true, public => false, inherited => f(impl_did.node) } } - Some(node_trait_method(_, trait_did, _)) => f(trait_did.node), + Some(&node_trait_method(_, trait_did, _)) => f(trait_did.node), Some(_) => { tcx.sess.span_bug(span, fmt!("local_item_is_private: item was \ @@ -332,7 +332,7 @@ pub fn check_crate(tcx: ty::ctxt, method_super(trait_id, method_num) => { if trait_id.crate == local_crate { match tcx.items.find(&trait_id.node) { - Some(node_item(item, _)) => { + Some(&node_item(item, _)) => { match item.node { item_trait(_, _, ref methods) => { if method_num >= (*methods).len() { @@ -484,7 +484,7 @@ pub fn check_crate(tcx: ty::ctxt, } } expr_path(path) => { - check_path(expr.span, tcx.def_map.get(&expr.id), path); + check_path(expr.span, *tcx.def_map.get(&expr.id), path); } expr_struct(_, ref fields, _) => { match ty::get(ty::expr_ty(tcx, expr)).sty { @@ -502,7 +502,7 @@ pub fn check_crate(tcx: ty::ctxt, ty_enum(id, _) => { if id.crate != local_crate || !privileged_items.contains(&(id.node)) { - match tcx.def_map.get(&expr.id) { + match *tcx.def_map.get(&expr.id) { def_variant(_, variant_id) => { for (*fields).each |field| { debug!("(privacy checking) \ @@ -570,7 +570,7 @@ pub fn check_crate(tcx: ty::ctxt, !privileged_items.contains( &enum_id.node) { match tcx.def_map.find(&pattern.id) { - Some(def_variant(_, variant_id)) => { + Some(&def_variant(_, variant_id)) => { for fields.each |field| { debug!("(privacy checking) \ checking field in \ diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 10838a7a8dc..f49a37d7301 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -26,8 +26,8 @@ use middle::ty::{region_variance, rv_covariant, rv_invariant}; use middle::ty::{rv_contravariant}; use middle::ty; +use core::hashmap::linear::{LinearMap, LinearSet}; use core::vec; -use std::oldmap::HashMap; use syntax::ast_map; use syntax::codemap::span; use syntax::print::pprust; @@ -46,7 +46,7 @@ Encodes the bounding lifetime for a given AST node: - Variables and bindings are mapped to the block in which they are declared. */ -pub type region_map = HashMap<ast::node_id, ast::node_id>; +pub type region_map = @mut LinearMap<ast::node_id, ast::node_id>; pub struct ctxt { sess: Session, @@ -62,7 +62,7 @@ pub struct ctxt { // the condition in a while loop is always a parent. In those // cases, we add the node id of such an expression to this set so // that when we visit it we can view it as a parent. - root_exprs: HashMap<ast::node_id, ()>, + root_exprs: @mut LinearSet<ast::node_id>, // The parent scope is the innermost block, statement, call, or match // expression during the execution of which the current expression @@ -106,7 +106,7 @@ pub fn scope_contains(region_map: region_map, superscope: ast::node_id, while superscope != subscope { match region_map.find(&subscope) { None => return false, - Some(scope) => subscope = scope + Some(&scope) => subscope = scope } } return true; @@ -150,7 +150,7 @@ pub fn nearest_common_ancestor(region_map: region_map, loop { match region_map.find(&scope) { None => return result, - Some(superscope) => { + Some(&superscope) => { result.push(superscope); scope = superscope; } @@ -228,7 +228,7 @@ pub fn resolve_pat(pat: @ast::pat, cx: ctxt, visitor: visit::vt<ctxt>) { ast::pat_ident(*) => { let defn_opt = cx.def_map.find(&pat.id); match defn_opt { - Some(ast::def_variant(_,_)) => { + Some(&ast::def_variant(_,_)) => { /* Nothing to do; this names a variant. */ } _ => { @@ -280,12 +280,12 @@ pub fn resolve_expr(expr: @ast::expr, cx: ctxt, visitor: visit::vt<ctxt>) { new_cx.parent = Some(expr.id); } ast::expr_while(cond, _) => { - new_cx.root_exprs.insert(cond.id, ()); + new_cx.root_exprs.insert(cond.id); } _ => {} }; - if new_cx.root_exprs.contains_key(&expr.id) { + if new_cx.root_exprs.contains(&expr.id) { new_cx.parent = Some(expr.id); } @@ -350,8 +350,8 @@ pub fn resolve_crate(sess: Session, -> region_map { let cx: ctxt = ctxt {sess: sess, def_map: def_map, - region_map: HashMap(), - root_exprs: HashMap(), + region_map: @mut LinearMap::new(), + root_exprs: @mut LinearSet::new(), parent: None}; let visitor = visit::mk_vt(@visit::Visitor { visit_block: resolve_block, @@ -387,7 +387,7 @@ pub fn resolve_crate(sess: Session, // a worklist. We can then process the worklist, propagating indirect // dependencies until a fixed point is reached. -pub type region_paramd_items = HashMap<ast::node_id, region_variance>; +pub type region_paramd_items = @mut LinearMap<ast::node_id, region_variance>; #[deriving(Eq)] pub struct region_dep { @@ -395,7 +395,7 @@ pub struct region_dep { id: ast::node_id } -pub type dep_map = HashMap<ast::node_id, @mut ~[region_dep]>; +pub type dep_map = @mut LinearMap<ast::node_id, @mut ~[region_dep]>; pub struct DetermineRpCtxt { sess: Session, @@ -464,7 +464,8 @@ pub impl DetermineRpCtxt { /// the new variance is joined with the old variance. fn add_rp(&mut self, id: ast::node_id, variance: region_variance) { fail_unless!(id != 0); - let old_variance = self.region_paramd_items.find(&id); + let old_variance = self.region_paramd_items.find(&id). + map_consume(|x| *x); let joined_variance = match old_variance { None => variance, Some(v) => join_variance(v, variance) @@ -496,7 +497,7 @@ pub impl DetermineRpCtxt { self.sess.parse_sess.interner), copy self.ambient_variance); let vec = match self.dep_map.find(&from) { - Some(vec) => vec, + Some(&vec) => vec, None => { let vec = @mut ~[]; let dep_map = self.dep_map; @@ -689,7 +690,7 @@ pub fn determine_rp_in_ty(ty: @ast::Ty, match ty.node { ast::ty_path(path, id) => { match cx.def_map.find(&id) { - Some(ast::def_ty(did)) | Some(ast::def_struct(did)) => { + Some(&ast::def_ty(did)) | Some(&ast::def_struct(did)) => { if did.crate == ast::local_crate { if cx.region_is_relevant(path.rp) { cx.add_dep(did.node); @@ -782,15 +783,15 @@ pub fn determine_rp_in_struct_field( pub fn determine_rp_in_crate(sess: Session, ast_map: ast_map::map, - def_map: resolve::DefMap, + +def_map: resolve::DefMap, crate: @ast::crate) -> region_paramd_items { let cx = @mut DetermineRpCtxt { sess: sess, ast_map: ast_map, def_map: def_map, - region_paramd_items: HashMap(), - dep_map: HashMap(), + region_paramd_items: @mut LinearMap::new(), + dep_map: @mut LinearMap::new(), worklist: ~[], item_id: 0, anon_implies_rp: false, @@ -822,7 +823,7 @@ pub fn determine_rp_in_crate(sess: Session, let cx = &mut *cx; while cx.worklist.len() != 0 { let c_id = cx.worklist.pop(); - let c_variance = cx.region_paramd_items.get(&c_id); + let c_variance = *cx.region_paramd_items.get(&c_id); debug!("popped %d from worklist", c_id); match cx.dep_map.find(&c_id) { None => {} @@ -839,7 +840,7 @@ pub fn determine_rp_in_crate(sess: Session, debug!("%s", { debug!("Region variance results:"); let region_paramd_items = cx.region_paramd_items; - for region_paramd_items.each |&key, &value| { + for region_paramd_items.each |&(&key, &value)| { debug!("item %? (%s) is parameterized with variance %?", key, ast_map::node_id_to_str(ast_map, key, diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 079110e67f5..f956c8cb10c 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -77,11 +77,10 @@ use syntax::opt_vec::OptVec; use core::option::{Some, get, is_some, is_none}; use core::str::{connect, each_split_str}; -use core::hashmap::linear::LinearMap; -use std::oldmap::HashMap; +use core::hashmap::linear::{LinearMap, LinearSet}; // Definition mapping -pub type DefMap = HashMap<node_id,def>; +pub type DefMap = @mut LinearMap<node_id,def>; pub struct binding_info { span: span, @@ -89,7 +88,7 @@ pub struct binding_info { } // Map from the name in a pattern to its binding mode. -pub type BindingMap = HashMap<ident,binding_info>; +pub type BindingMap = LinearMap<ident,binding_info>; // Implementation resolution // @@ -110,11 +109,11 @@ pub struct Impl { } // Trait method resolution -pub type TraitMap = @HashMap<node_id,@mut ~[def_id]>; +pub type TraitMap = LinearMap<node_id,@mut ~[def_id]>; // This is the replacement export map. It maps a module to all of the exports // within. -pub type ExportMap2 = HashMap<node_id, ~[Export2]>; +pub type ExportMap2 = @mut LinearMap<node_id, ~[Export2]>; pub struct Export2 { name: @~str, // The name of the target. @@ -335,13 +334,13 @@ pub fn namespace_for_duplicate_checking_mode(mode: DuplicateCheckingMode) /// One local scope. pub struct Rib { - bindings: HashMap<ident,def_like>, + bindings: @mut LinearMap<ident,def_like>, kind: RibKind, } pub fn Rib(kind: RibKind) -> Rib { Rib { - bindings: HashMap(), + bindings: @mut LinearMap::new(), kind: kind } } @@ -475,7 +474,7 @@ pub struct Module { // There will be an anonymous module created around `g` with the ID of the // entry block for `f`. - anonymous_children: @HashMap<node_id,@mut Module>, + anonymous_children: @mut LinearMap<node_id,@mut Module>, // The status of resolving each import in this module. import_resolutions: @mut LinearMap<ident, @mut ImportResolution>, @@ -497,7 +496,7 @@ pub fn Module(parent_link: ParentLink, kind: kind, children: @mut LinearMap::new(), imports: @mut ~[], - anonymous_children: @HashMap(), + anonymous_children: @mut LinearMap::new(), import_resolutions: @mut LinearMap::new(), glob_count: 0, resolved_import_count: 0 @@ -709,11 +708,11 @@ pub fn NameBindings() -> NameBindings { /// Interns the names of the primitive types. pub struct PrimitiveTypeTable { - primitive_types: HashMap<ident,prim_ty>, + primitive_types: LinearMap<ident,prim_ty>, } pub impl PrimitiveTypeTable { - fn intern(&self, intr: @ident_interner, string: @~str, + fn intern(&mut self, intr: @ident_interner, string: @~str, primitive_type: prim_ty) { let ident = intr.intern(string); self.primitive_types.insert(ident, primitive_type); @@ -721,8 +720,8 @@ pub impl PrimitiveTypeTable { } pub fn PrimitiveTypeTable(intr: @ident_interner) -> PrimitiveTypeTable { - let table = PrimitiveTypeTable { - primitive_types: HashMap() + let mut table = PrimitiveTypeTable { + primitive_types: LinearMap::new() }; table.intern(intr, @~"bool", ty_bool); @@ -777,8 +776,8 @@ pub fn Resolver(session: Session, graph_root: graph_root, - trait_info: @HashMap(), - structs: @HashMap(), + trait_info: LinearMap::new(), + structs: LinearSet::new(), unresolved_imports: 0, @@ -801,9 +800,9 @@ pub fn Resolver(session: Session, attr_main_fn: None, main_fns: ~[], - def_map: @HashMap(), - export_map2: @HashMap(), - trait_map: @HashMap(), + def_map: @mut LinearMap::new(), + export_map2: @mut LinearMap::new(), + trait_map: LinearMap::new(), intr: session.intr() }; @@ -821,8 +820,8 @@ pub struct Resolver { graph_root: @mut NameBindings, - trait_info: @HashMap<def_id,@HashMap<ident,()>>, - structs: @HashMap<def_id,()>, + trait_info: LinearMap<def_id, LinearSet<ident>>, + structs: LinearSet<def_id>, // The number of imports that are currently unresolved. unresolved_imports: uint, @@ -863,8 +862,8 @@ pub struct Resolver { // The functions named 'main' main_fns: ~[Option<(node_id, span)>], - def_map: @DefMap, - export_map2: @ExportMap2, + def_map: DefMap, + export_map2: ExportMap2, trait_map: TraitMap, } @@ -1192,7 +1191,7 @@ pub impl Resolver { } // Record the def ID of this struct. - self.structs.insert(local_def(item.id), ()); + self.structs.insert(local_def(item.id)); visit_item(item, new_parent, visitor); } @@ -1305,8 +1304,8 @@ pub impl Resolver { } // Add the names of all the methods to the trait info. - let method_names = @HashMap(); - for (*methods).each |method| { + let mut method_names = LinearSet::new(); + for methods.each |method| { let ty_m = trait_method_to_ty_method(method); let ident = ty_m.ident; @@ -1329,7 +1328,7 @@ pub impl Resolver { ty_m.span); } _ => { - method_names.insert(ident, ()); + method_names.insert(ident); } } } @@ -1378,7 +1377,7 @@ pub impl Resolver { def_variant(item_id, local_def(variant.node.id)), variant.span); - self.structs.insert(local_def(variant.node.id), ()); + self.structs.insert(local_def(variant.node.id)); } enum_variant_kind(ref enum_definition) => { child.define_type(privacy, @@ -1565,7 +1564,7 @@ pub impl Resolver { fn handle_external_def(@mut self, def: def, - modules: HashMap<def_id, @mut Module>, + modules: &mut LinearMap<def_id, @mut Module>, child_name_bindings: @mut NameBindings, final_ident: &str, ident: ident, @@ -1585,8 +1584,8 @@ pub impl Resolver { %s", final_ident); let parent_link = self.get_parent_link(new_parent, ident); - match modules.find(&def_id) { - None => { + // FIXME (#5074): this should be a match on find + if !modules.contains_key(&def_id) { child_name_bindings.define_module(Public, parent_link, Some(def_id), @@ -1594,8 +1593,8 @@ pub impl Resolver { dummy_sp()); modules.insert(def_id, child_name_bindings.get_module()); - } - Some(existing_module) => { + } else { + let existing_module = *modules.get(&def_id); // Create an import resolution to // avoid creating cycles in the // module graph. @@ -1623,7 +1622,6 @@ pub impl Resolver { ... creating import resolution"); new_parent.import_resolutions.insert(ident, resolution); - } } } } @@ -1646,7 +1644,7 @@ pub impl Resolver { // Nothing to do. } Some(method_names) => { - let interned_method_names = @HashMap(); + let mut interned_method_names = LinearSet::new(); for method_names.each |method_data| { let (method_name, self_ty) = *method_data; debug!("(building reduced graph for \ @@ -1656,7 +1654,7 @@ pub impl Resolver { // Add it to the trait info if not static. if self_ty != sty_static { - interned_method_names.insert(method_name, ()); + interned_method_names.insert(method_name); } } self.trait_info.insert(def_id, interned_method_names); @@ -1670,7 +1668,7 @@ pub impl Resolver { crate) building type %s", final_ident); child_name_bindings.define_type(Public, def, dummy_sp()); - self.structs.insert(def_id, ()); + self.structs.insert(def_id); } def_self(*) | def_arg(*) | def_local(*) | def_prim_ty(*) | def_ty_param(*) | def_binding(*) | @@ -1686,7 +1684,7 @@ pub impl Resolver { * crate. */ fn build_reduced_graph_for_external_crate(@mut self, root: @mut Module) { - let modules = HashMap(); + let mut modules = LinearMap::new(); // Create all the items reachable by paths. for each_path(self.session.cstore, root.def_id.get().crate) @@ -1758,7 +1756,7 @@ pub impl Resolver { dummy_sp()); self.handle_external_def(def, - modules, + &mut modules, child_name_bindings, *self.session.str_of( final_ident), @@ -3338,8 +3336,9 @@ pub impl Resolver { // If the def is a ty param, and came from the parent // item, it's ok match def { - def_ty_param(did, _) if self.def_map.find(&did.node) - == Some(def_typaram_binder(item_id)) => { + def_ty_param(did, _) + if self.def_map.find(&did.node).map_consume(|x| *x) + == Some(def_typaram_binder(item_id)) => { // ok } _ => { @@ -3412,7 +3411,7 @@ pub impl Resolver { while i != 0 { i -= 1; match ribs[i].bindings.find(&name) { - Some(def_like) => { + Some(&def_like) => { return self.upvarify(ribs, i, def_like, span, allow_capturing_self); } @@ -3995,8 +3994,8 @@ pub impl Resolver { } fn binding_mode_map(@mut self, pat: @pat) -> BindingMap { - let result = HashMap(); - do pat_bindings(*self.def_map, pat) |binding_mode, _id, sp, path| { + let mut result = LinearMap::new(); + do pat_bindings(self.def_map, pat) |binding_mode, _id, sp, path| { let ident = path_to_ident(path); result.insert(ident, binding_info {span: sp, @@ -4011,7 +4010,7 @@ pub impl Resolver { for arm.pats.eachi() |i, p| { let map_i = self.binding_mode_map(*p); - for map_0.each |&key, &binding_0| { + for map_0.each |&(&key, &binding_0)| { match map_i.find(&key) { None => { self.session.span_err( @@ -4032,7 +4031,7 @@ pub impl Resolver { } } - for map_i.each |&key, &binding| { + for map_i.each |&(&key, &binding)| { if !map_0.contains_key(&key) { self.session.span_err( binding.span, @@ -4047,7 +4046,7 @@ pub impl Resolver { fn resolve_arm(@mut self, arm: &arm, visitor: ResolveVisitor) { self.value_ribs.push(@Rib(NormalRibKind)); - let bindings_list = HashMap(); + let bindings_list = @mut LinearMap::new(); for arm.pats.each |pattern| { self.resolve_pattern(*pattern, RefutableMode, Immutable, Some(bindings_list), visitor); @@ -4071,7 +4070,7 @@ pub impl Resolver { let orig_module = self.current_module; match self.current_module.anonymous_children.find(&block.node.id) { None => { /* Nothing to do. */ } - Some(anonymous_module) => { + Some(&anonymous_module) => { debug!("(resolving block) found anonymous module, moving \ down"); self.current_module = anonymous_module; @@ -4106,7 +4105,7 @@ pub impl Resolver { .primitive_types .find(&name) { - Some(primitive_type) => { + Some(&primitive_type) => { result_def = Some(def_prim_ty(primitive_type)); } @@ -4167,7 +4166,7 @@ pub impl Resolver { mutability: Mutability, // Maps idents to the node ID for the (outermost) // pattern that binds them - bindings_list: Option<HashMap<ident,node_id>>, + bindings_list: Option<@mut LinearMap<ident,node_id>>, visitor: ResolveVisitor) { let pat_id = pattern.id; do walk_pat(pattern) |pattern| { @@ -4271,7 +4270,7 @@ pub impl Resolver { bindings_list.insert(ident, pat_id); } Some(b) => { - if b.find(&ident) == Some(pat_id) { + if b.find(&ident) == Some(&pat_id) { // Then this is a duplicate variable // in the same disjunct, which is an // error @@ -4371,21 +4370,19 @@ pub impl Resolver { } pat_struct(path, _, _) => { + let structs: &mut LinearSet<def_id> = &mut self.structs; match self.resolve_path(path, TypeNS, false, visitor) { Some(def_ty(class_id)) - if self.structs.contains_key(&class_id) - => { + if structs.contains(&class_id) => { let class_def = def_struct(class_id); self.record_def(pattern.id, class_def); } Some(definition @ def_struct(class_id)) - if self.structs.contains_key(&class_id) - => { + if structs.contains(&class_id) => { self.record_def(pattern.id, definition); } Some(definition @ def_variant(_, variant_id)) - if self.structs.contains_key(&variant_id) - => { + if structs.contains(&variant_id) => { self.record_def(pattern.id, definition); } result => { @@ -4869,14 +4866,15 @@ pub impl Resolver { expr_struct(path, _, _) => { // Resolve the path to the structure it goes to. + let structs: &mut LinearSet<def_id> = &mut self.structs; match self.resolve_path(path, TypeNS, false, visitor) { Some(def_ty(class_id)) | Some(def_struct(class_id)) - if self.structs.contains_key(&class_id) => { + if structs.contains(&class_id) => { let class_def = def_struct(class_id); self.record_def(expr.id, class_def); } Some(definition @ def_variant(_, class_id)) - if self.structs.contains_key(&class_id) => { + if structs.contains(&class_id) => { self.record_def(expr.id, definition); } _ => { @@ -5095,7 +5093,7 @@ pub impl Resolver { return found_traits; } - fn add_trait_info_if_containing_method(@mut self, + fn add_trait_info_if_containing_method(&self, found_traits: &mut ~[def_id], trait_def_id: def_id, name: ident) @@ -5107,7 +5105,7 @@ pub impl Resolver { *self.session.str_of(name)); match self.trait_info.find(&trait_def_id) { - Some(trait_info) if trait_info.contains_key(&name) => { + Some(trait_info) if trait_info.contains(&name) => { debug!("(adding trait info if containing method) found trait \ %d:%d for method '%s'", trait_def_id.crate, @@ -5351,10 +5349,11 @@ pub fn resolve_crate(session: Session, -> CrateMap { let resolver = @mut Resolver(session, lang_items, crate); resolver.resolve(); + let @Resolver{def_map, export_map2, trait_map, _} = resolver; CrateMap { - def_map: *resolver.def_map, - exp_map2: *resolver.export_map2, - trait_map: resolver.trait_map + def_map: def_map, + exp_map2: export_map2, + trait_map: trait_map } } diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 7529b2132fd..d4081352468 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -167,7 +167,7 @@ use middle::trans::type_of; use middle::ty; use util::common::indenter; -use std::oldmap::HashMap; +use core::hashmap::linear::LinearMap; use syntax::ast; use syntax::ast::ident; use syntax::ast_util::path_to_ident; @@ -282,7 +282,7 @@ pub fn trans_opt(bcx: block, o: &Opt) -> opt_result { pub fn variant_opt(bcx: block, pat_id: ast::node_id) -> Opt { let ccx = bcx.ccx(); - match ccx.tcx.def_map.get(&pat_id) { + match *ccx.tcx.def_map.get(&pat_id) { ast::def_variant(enum_id, var_id) => { let variants = ty::enum_variants(ccx.tcx, enum_id); for vec::each(*variants) |v| { @@ -323,7 +323,7 @@ pub struct BindingInfo { ty: ty::t, } -pub type BindingsMap = HashMap<ident, BindingInfo>; +pub type BindingsMap = LinearMap<ident, BindingInfo>; pub struct ArmData { bodycx: block, @@ -517,7 +517,7 @@ pub fn enter_opt<'r>(bcx: block, match p.node { ast::pat_enum(*) | ast::pat_ident(_, _, None) if pat_is_const(tcx.def_map, p) => { - let const_def = tcx.def_map.get(&p.id); + let const_def = *tcx.def_map.get(&p.id); let const_def_id = ast_util::def_id_of_def(const_def); if opt_eq(tcx, &lit(ConstLit(const_def_id)), opt) { Some(~[]) @@ -553,7 +553,7 @@ pub fn enter_opt<'r>(bcx: block, if opt_eq(tcx, &variant_opt(bcx, p.id), opt) { // Look up the struct variant ID. let struct_id; - match tcx.def_map.get(&p.id) { + match *tcx.def_map.get(&p.id) { ast::def_variant(_, found_struct_id) => { struct_id = found_struct_id; } @@ -801,15 +801,15 @@ pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] { // This is one of: an enum variant, a unit-like struct, or a // variable binding. match ccx.tcx.def_map.find(&cur.id) { - Some(ast::def_variant(*)) => { + Some(&ast::def_variant(*)) => { add_to_set(ccx.tcx, &mut found, variant_opt(bcx, cur.id)); } - Some(ast::def_struct(*)) => { + Some(&ast::def_struct(*)) => { add_to_set(ccx.tcx, &mut found, lit(UnitLikeStructLit(cur.id))); } - Some(ast::def_const(const_did)) => { + Some(&ast::def_const(const_did)) => { add_to_set(ccx.tcx, &mut found, lit(ConstLit(const_did))); } @@ -820,11 +820,11 @@ pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] { // This could be one of: a tuple-like enum variant, a // struct-like enum variant, or a struct. match ccx.tcx.def_map.find(&cur.id) { - Some(ast::def_variant(*)) => { + Some(&ast::def_variant(*)) => { add_to_set(ccx.tcx, &mut found, variant_opt(bcx, cur.id)); } - Some(ast::def_const(const_did)) => { + Some(&ast::def_const(const_did)) => { add_to_set(ccx.tcx, &mut found, lit(ConstLit(const_did))); } @@ -959,7 +959,7 @@ pub fn root_pats_as_necessary(bcx: block, let key = root_map_key {id: pat_id, derefs: 0u }; match bcx.ccx().maps.root_map.find(&key) { None => (), - Some(root_info) => { + Some(&root_info) => { // Note: the scope_id will always be the id of the match. See // the extended comment in rustc::middle::borrowck::preserve() // for details (look for the case covering cat_discr). @@ -1013,7 +1013,7 @@ pub fn any_tuple_struct_pat(bcx: block, m: &[@Match], col: uint) -> bool { match pat.node { ast::pat_enum(_, Some(_)) => { match bcx.tcx().def_map.find(&pat.id) { - Some(ast::def_struct(*)) => true, + Some(&ast::def_struct(*)) => true, _ => false } } @@ -1620,7 +1620,7 @@ pub fn trans_match_inner(scope_cx: block, // to an alloca() that will be the value for that local variable. // Note that we use the names because each binding will have many ids // from the various alternatives. - let bindings_map = HashMap(); + let mut bindings_map = LinearMap::new(); do pat_bindings(tcx.def_map, arm.pats[0]) |bm, p_id, _s, path| { let ident = path_to_ident(path); let variable_ty = node_id_type(bcx, p_id); @@ -1633,7 +1633,7 @@ pub fn trans_match_inner(scope_cx: block, // but during matching we need to store a *T as explained // above let is_move = - scope_cx.ccx().maps.moves_map.contains_key(&p_id); + scope_cx.ccx().maps.moves_map.contains(&p_id); llmatch = alloca(bcx, T_ptr(llvariable_ty)); trmode = TrByValue(is_move, alloca(bcx, llvariable_ty)); } @@ -1765,7 +1765,7 @@ pub fn bind_irrefutable_pat(bcx: block, } ast::pat_enum(_, ref sub_pats) => { match bcx.tcx().def_map.find(&pat.id) { - Some(ast::def_variant(enum_id, var_id)) => { + Some(&ast::def_variant(enum_id, var_id)) => { let repr = adt::represent_node(bcx, pat.id); let vinfo = ty::enum_variant_with_id(ccx.tcx, enum_id, @@ -1784,7 +1784,7 @@ pub fn bind_irrefutable_pat(bcx: block, } } } - Some(ast::def_struct(*)) => { + Some(&ast::def_struct(*)) => { match *sub_pats { None => { // This is a unit-like struct. Nothing to do here. @@ -1804,7 +1804,7 @@ pub fn bind_irrefutable_pat(bcx: block, } } } - Some(ast::def_const(*)) => { + Some(&ast::def_const(*)) => { bcx = bind_irrefutable_pat(bcx, pat, val, make_copy, binding_mode); } _ => { diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 1a5b01feb0a..fb05cf0b739 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -67,13 +67,12 @@ use util::ppaux::{ty_to_str, ty_to_short_str}; use util::ppaux; use core::hash; -use core::hashmap::linear::LinearMap; +use core::hashmap::linear::{LinearMap, LinearSet}; 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,7 +169,10 @@ 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; @@ -178,8 +180,11 @@ pub fn get_extern_fn(externs: ExternMap, 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) }); @@ -383,7 +388,7 @@ pub fn get_tydesc_simple(ccx: @CrateContext, t: ty::t) -> ValueRef { pub fn get_tydesc(ccx: @CrateContext, t: ty::t) -> @mut tydesc_info { match ccx.tydescs.find(&t) { - Some(inf) => inf, + Some(&inf) => inf, _ => { ccx.stats.n_static_tydescs += 1u; let inf = glue::declare_tydesc(ccx, t); @@ -467,10 +472,12 @@ pub fn set_glue_inlining(f: ValueRef, t: ty::t) { // Double-check that we never ask LLVM to declare the same symbol twice. It // silently mangles such symbols, breaking our linkage model. pub fn note_unique_llvm_symbol(ccx: @CrateContext, +sym: ~str) { - if ccx.all_llvm_symbols.contains_key(&sym) { + // XXX: this should not be necessary + use core::container::Set; + if ccx.all_llvm_symbols.contains(&sym) { ccx.sess.bug(~"duplicate LLVM symbol: " + sym); } - ccx.all_llvm_symbols.insert(sym, ()); + ccx.all_llvm_symbols.insert(sym); } @@ -1100,7 +1107,7 @@ pub fn init_local(bcx: block, local: @ast::local) -> block { } let llptr = match bcx.fcx.lllocals.find(&local.node.id) { - Some(local_mem(v)) => v, + Some(&local_mem(v)) => v, _ => { bcx.tcx().sess.span_bug(local.span, ~"init_local: Someone forgot to document why it's\ safe to assume local.node.init must be local_mem!"); @@ -1453,7 +1460,7 @@ pub fn call_memcpy(cx: block, dst: ValueRef, src: ValueRef, | session::arch_mips => ~"llvm.memcpy.p0i8.p0i8.i32", session::arch_x86_64 => ~"llvm.memcpy.p0i8.p0i8.i64" }; - let memcpy = ccx.intrinsics.get(&key); + let memcpy = *ccx.intrinsics.get(&key); let src_ptr = PointerCast(cx, src, T_ptr(T_i8())); let dst_ptr = PointerCast(cx, dst, T_ptr(T_i8())); let size = IntCast(cx, n_bytes, ccx.int_type); @@ -1502,7 +1509,7 @@ pub fn memzero(cx: block, llptr: ValueRef, llty: TypeRef) { } } - let llintrinsicfn = ccx.intrinsics.get(&intrinsic_key); + let llintrinsicfn = *ccx.intrinsics.get(&intrinsic_key); let llptr = PointerCast(cx, llptr, T_ptr(T_i8())); let llzeroval = C_u8(0); let size = IntCast(cx, machine::llsize_of(ccx, llty), ccx.int_type); @@ -1601,9 +1608,9 @@ pub fn new_fn_ctxt_w_id(ccx: @CrateContext, llself: None, personality: None, loop_ret: None, - llargs: @HashMap(), - lllocals: @HashMap(), - llupvars: @HashMap(), + llargs: @mut LinearMap::new(), + lllocals: @mut LinearMap::new(), + llupvars: @mut LinearMap::new(), id: id, impl_id: impl_id, param_substs: param_substs, @@ -1905,7 +1912,7 @@ pub fn trans_enum_variant(ccx: @CrateContext, // this function as an opaque blob due to the way that type_of() // works. So we have to cast to the destination's view of the type. let llarg = match fcx.llargs.find(&va.id) { - Some(local_mem(x)) => x, + Some(&local_mem(x)) => x, _ => fail!(~"trans_enum_variant: how do we know this works?"), }; let arg_ty = arg_tys[i].ty; @@ -1969,7 +1976,7 @@ pub fn trans_tuple_struct(ccx: @CrateContext, for fields.eachi |i, field| { let lldestptr = adt::trans_field_ptr(bcx, repr, fcx.llretptr, 0, i); - let llarg = match fcx.llargs.get(&field.node.id) { + let llarg = match *fcx.llargs.get(&field.node.id) { local_mem(x) => x, _ => { ccx.tcx.sess.bug(~"trans_tuple_struct: llarg wasn't \ @@ -2058,7 +2065,7 @@ pub fn trans_enum_def(ccx: @CrateContext, enum_definition: ast::enum_def, pub fn trans_item(ccx: @CrateContext, item: ast::item) { let _icx = ccx.insn_ctxt("trans_item"); - let path = match ccx.tcx.items.get(&item.id) { + let path = match *ccx.tcx.items.get(&item.id) { ast_map::node_item(_, p) => p, // tjc: ? _ => fail!(~"trans_item"), @@ -2329,13 +2336,12 @@ pub fn fill_fn_pair(bcx: block, pair: ValueRef, llfn: ValueRef, } pub fn item_path(ccx: @CrateContext, i: @ast::item) -> path { - vec::append( - /*bad*/copy *match ccx.tcx.items.get(&i.id) { - ast_map::node_item(_, p) => p, - // separate map for paths? - _ => fail!(~"item_path") - }, - ~[path_name(i.ident)]) + let base = match *ccx.tcx.items.get(&i.id) { + ast_map::node_item(_, p) => p, + // separate map for paths? + _ => fail!(~"item_path") + }; + vec::append(/*bad*/copy *base, ~[path_name(i.ident)]) } /* If there's already a symbol for the dtor with <id> and substs <substs>, @@ -2347,7 +2353,7 @@ pub fn get_dtor_symbol(ccx: @CrateContext, -> ~str { let t = ty::node_id_to_type(ccx.tcx, id); match ccx.item_symbols.find(&id) { - Some(ref s) => (/*bad*/copy *s), + Some(s) => (/*bad*/copy *s), None if substs.is_none() => { let s = mangle_exported_name( ccx, @@ -2382,11 +2388,11 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef { debug!("get_item_val(id=`%?`)", id); let tcx = ccx.tcx; match ccx.item_vals.find(&id) { - Some(v) => v, + Some(&v) => v, None => { let mut exprt = false; - let val = match ccx.tcx.items.get(&id) { + let val = match *ccx.tcx.items.get(&id) { ast_map::node_item(i, pth) => { let my_path = vec::append(/*bad*/copy *pth, ~[path_name(i.ident)]); @@ -2538,7 +2544,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef { ccx.sess.bug(~"get_item_val(): unexpected variant") } }; - if !(exprt || ccx.reachable.contains_key(&id)) { + if !(exprt || ccx.reachable.contains(&id)) { lib::llvm::SetLinkage(val, lib::llvm::InternalLinkage); } ccx.item_vals.insert(id, val); @@ -2617,7 +2623,7 @@ pub fn p2i(ccx: @CrateContext, v: ValueRef) -> ValueRef { } } -pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<~str, ValueRef> { +pub fn declare_intrinsics(llmod: ModuleRef) -> LinearMap<~str, ValueRef> { let T_memcpy32_args: ~[TypeRef] = ~[T_ptr(T_i8()), T_ptr(T_i8()), T_i32(), T_i32(), T_i1()]; let T_memcpy64_args: ~[TypeRef] = @@ -2750,7 +2756,7 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<~str, ValueRef> { let bswap64 = decl_cdecl_fn(llmod, ~"llvm.bswap.i64", T_fn(~[T_i64()], T_i64())); - let intrinsics = HashMap(); + let mut intrinsics = LinearMap::new(); intrinsics.insert(~"llvm.gcroot", gcroot); intrinsics.insert(~"llvm.gcread", gcread); intrinsics.insert(~"llvm.memcpy.p0i8.p0i8.i32", memcpy32); @@ -2811,7 +2817,7 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<~str, ValueRef> { } pub fn declare_dbg_intrinsics(llmod: ModuleRef, - intrinsics: HashMap<~str, ValueRef>) { + intrinsics: &mut LinearMap<~str, ValueRef>) { let declare = decl_cdecl_fn(llmod, ~"llvm.dbg.declare", T_fn(~[T_metadata(), T_metadata()], T_void())); @@ -2826,7 +2832,7 @@ pub fn declare_dbg_intrinsics(llmod: ModuleRef, pub fn trap(bcx: block) { let v: ~[ValueRef] = ~[]; match bcx.ccx().intrinsics.find(&~"llvm.trap") { - Some(x) => { Call(bcx, x, v); }, + Some(&x) => { Call(bcx, x, v); }, _ => bcx.sess().bug(~"unbound llvm.trap in trap") } } @@ -2861,8 +2867,8 @@ pub fn create_module_map(ccx: @CrateContext) -> ValueRef { lib::llvm::SetLinkage(map, lib::llvm::InternalLinkage); } let mut elts: ~[ValueRef] = ~[]; - for ccx.module_data.each |&key, &val| { - let elt = C_struct(~[p2i(ccx, C_cstr(ccx, @/*bad*/ copy key)), + for ccx.module_data.each |&(key, &val)| { + let elt = C_struct(~[p2i(ccx, C_cstr(ccx, @/*bad*/ copy *key)), p2i(ccx, val)]); elts.push(elt); } @@ -3036,9 +3042,9 @@ pub fn trans_crate(sess: session::Session, let targ_cfg = sess.targ_cfg; let td = mk_target_data(sess.targ_cfg.target_strs.data_layout); let tn = mk_type_names(); - let intrinsics = declare_intrinsics(llmod); + let mut intrinsics = declare_intrinsics(llmod); if sess.opts.extra_debuginfo { - declare_dbg_intrinsics(llmod, intrinsics); + declare_dbg_intrinsics(llmod, &mut intrinsics); } let int_type = T_int(targ_cfg); let float_type = T_float(targ_cfg); @@ -3059,36 +3065,36 @@ pub fn trans_crate(sess: session::Session, llmod: llmod, td: td, tn: tn, - externs: HashMap(), + externs: @mut LinearMap::new(), intrinsics: intrinsics, - item_vals: HashMap(), + item_vals: @mut LinearMap::new(), exp_map2: emap2, reachable: reachable, - item_symbols: HashMap(), + item_symbols: @mut LinearMap::new(), link_meta: link_meta, - enum_sizes: ty::new_ty_hash(), - discrims: HashMap(), - discrim_symbols: HashMap(), - tydescs: ty::new_ty_hash(), + enum_sizes: @mut LinearMap::new(), + discrims: @mut LinearMap::new(), + discrim_symbols: @mut LinearMap::new(), + tydescs: @mut LinearMap::new(), finished_tydescs: @mut false, - external: HashMap(), - monomorphized: HashMap(), - monomorphizing: HashMap(), - type_use_cache: HashMap(), - vtables: oldmap::HashMap(), - const_cstr_cache: HashMap(), - const_globals: HashMap(), - const_values: HashMap(), - module_data: HashMap(), - lltypes: ty::new_ty_hash(), - llsizingtypes: ty::new_ty_hash(), + external: @mut LinearMap::new(), + monomorphized: @mut LinearMap::new(), + monomorphizing: @mut LinearMap::new(), + type_use_cache: @mut LinearMap::new(), + vtables: @mut LinearMap::new(), + const_cstr_cache: @mut LinearMap::new(), + const_globals: @mut LinearMap::new(), + const_values: @mut LinearMap::new(), + module_data: @mut LinearMap::new(), + 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(), symbol_hasher: symbol_hasher, - type_hashcodes: ty::new_ty_hash(), - type_short_names: ty::new_ty_hash(), - all_llvm_symbols: HashMap(), + type_hashcodes: @mut LinearMap::new(), + type_short_names: @mut LinearMap::new(), + all_llvm_symbols: @mut LinearSet::new(), tcx: tcx, maps: maps, stats: @mut Stats { @@ -3101,7 +3107,7 @@ pub fn trans_crate(sess: session::Session, n_inlines: 0u, n_closures: 0u, llvm_insn_ctxt: @mut ~[], - llvm_insns: HashMap(), + llvm_insns: @mut LinearMap::new(), fn_times: @mut ~[] }, upcalls: upcall::declare_upcalls(targ_cfg, llmod), @@ -3151,7 +3157,7 @@ pub fn trans_crate(sess: session::Session, } if ccx.sess.count_llvm_insns() { - for ccx.stats.llvm_insns.each |&k, &v| { + for ccx.stats.llvm_insns.each |&(&k, &v)| { io::println(fmt!("%-7u %s", v, k)); } } diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index 5e5cbc9f971..e8b85c54d48 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -18,13 +18,13 @@ use syntax::codemap::span; use core::prelude::*; use core::cast; +use core::hashmap::linear::LinearMap; use core::libc::{c_uint, c_int, c_ulonglong, c_char}; use core::libc; use core::option::Some; use core::ptr; use core::str; use core::vec; -use std::oldmap::HashMap; pub fn terminate(cx: block, _: &str) { unsafe { @@ -55,7 +55,7 @@ pub fn count_insn(cx: block, category: &str) { // Build version of path with cycles removed. // Pass 1: scan table mapping str -> rightmost pos. - let mm = HashMap(); + let mut mm = LinearMap::new(); let len = vec::len(*v); let mut i = 0u; while i < len { @@ -70,7 +70,7 @@ pub fn count_insn(cx: block, category: &str) { let mut s = ~"."; i = 0u; while i < len { - i = mm.get(&v[i]); + i = *mm.get(&v[i]); s += ~"/"; s += v[i]; i += 1u; @@ -80,7 +80,7 @@ pub fn count_insn(cx: block, category: &str) { s += category; let n = match h.find(&s) { - Some(n) => n, + Some(&n) => n, _ => 0u }; h.insert(s, n+1u); diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index 8c5729637ac..7ba0b706e43 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/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 } @@ -265,7 +268,7 @@ pub fn trans_fn_ref_with_vtables( ccx.tcx.items.find(&def_id.node), || fmt!("local item should be in ast map")); - match map_node { + match *map_node { ast_map::node_foreign_item(_, ast::foreign_abi_rust_intrinsic, _, @@ -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, @@ -700,7 +706,7 @@ pub fn trans_arg_expr(bcx: block, match autoref_arg { DoAutorefArg => { fail_unless!(! - bcx.ccx().maps.moves_map.contains_key(&arg_expr.id)); + bcx.ccx().maps.moves_map.contains(&arg_expr.id)); val = arg_datum.to_ref_llval(bcx); } DontAutorefArg => { diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index b7a8e38dbb8..74d338bbbb5 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/src/librustc/middle/trans/closure.rs @@ -411,7 +411,7 @@ pub fn trans_expr_fn(bcx: block, let Result {bcx: bcx, val: closure} = match sigil { ast::BorrowedSigil | ast::ManagedSigil | ast::OwnedSigil => { - let cap_vars = ccx.maps.capture_map.get(&user_id); + let cap_vars = *ccx.maps.capture_map.get(&user_id); let ret_handle = match is_loop_body {Some(x) => x, None => None}; let ClosureResult {llbox, cdata_ty, bcx} diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index bcdfc7cf95b..5805f7fbe3a 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -45,14 +45,13 @@ use util::ppaux::{expr_repr, ty_to_str}; use core::cast; use core::hash; -use core::hashmap::linear::LinearMap; +use core::hashmap::linear::{LinearMap, LinearSet}; use core::libc::{c_uint, c_longlong, c_ulonglong}; use core::ptr; 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; @@ -134,7 +133,7 @@ pub struct Stats { n_inlines: uint, n_closures: uint, llvm_insn_ctxt: @mut ~[~str], - llvm_insns: HashMap<~str, uint>, + llvm_insns: @mut LinearMap<~str, uint>, fn_times: @mut ~[(~str, int)] // (ident, time) } @@ -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 { @@ -165,30 +164,30 @@ pub struct CrateContext { td: TargetData, tn: @TypeNames, externs: ExternMap, - intrinsics: HashMap<~str, ValueRef>, - item_vals: HashMap<ast::node_id, ValueRef>, + intrinsics: LinearMap<~str, ValueRef>, + item_vals: @mut LinearMap<ast::node_id, ValueRef>, exp_map2: resolve::ExportMap2, reachable: reachable::map, - item_symbols: HashMap<ast::node_id, ~str>, + item_symbols: @mut LinearMap<ast::node_id, ~str>, link_meta: LinkMeta, - enum_sizes: HashMap<ty::t, uint>, - discrims: HashMap<ast::def_id, ValueRef>, - discrim_symbols: HashMap<ast::node_id, ~str>, - tydescs: HashMap<ty::t, @mut tydesc_info>, + enum_sizes: @mut LinearMap<ty::t, uint>, + discrims: @mut LinearMap<ast::def_id, ValueRef>, + discrim_symbols: @mut LinearMap<ast::node_id, ~str>, + tydescs: @mut LinearMap<ty::t, @mut tydesc_info>, // Set when running emit_tydescs to enforce that no more tydescs are // created. finished_tydescs: @mut bool, // Track mapping of external ids to local items imported for inlining - external: HashMap<ast::def_id, Option<ast::node_id>>, + external: @mut LinearMap<ast::def_id, Option<ast::node_id>>, // Cache instances of monomorphized functions - monomorphized: HashMap<mono_id, ValueRef>, - monomorphizing: HashMap<ast::def_id, uint>, + monomorphized: @mut LinearMap<mono_id, ValueRef>, + monomorphizing: @mut LinearMap<ast::def_id, uint>, // Cache computed type parameter uses (see type_use.rs) - type_use_cache: HashMap<ast::def_id, ~[type_use::type_uses]>, + type_use_cache: @mut LinearMap<ast::def_id, ~[type_use::type_uses]>, // Cache generated vtables - vtables: HashMap<mono_id, ValueRef>, + vtables: @mut LinearMap<mono_id, ValueRef>, // Cache of constant strings, - const_cstr_cache: HashMap<@~str, ValueRef>, + const_cstr_cache: @mut LinearMap<@~str, ValueRef>, // Reverse-direction for const ptrs cast from globals. // Key is an int, cast from a ValueRef holding a *T, @@ -198,20 +197,20 @@ pub struct CrateContext { // when we ptrcast, and we have to ptrcast during translation // of a [T] const because we form a slice, a [*T,int] pair, not // a pointer to an LLVM array type. - const_globals: HashMap<int, ValueRef>, + const_globals: @mut LinearMap<int, ValueRef>, // Cache of emitted const values - const_values: HashMap<ast::node_id, ValueRef>, - module_data: HashMap<~str, ValueRef>, - lltypes: HashMap<ty::t, TypeRef>, - llsizingtypes: HashMap<ty::t, TypeRef>, + const_values: @mut LinearMap<ast::node_id, ValueRef>, + module_data: @mut LinearMap<~str, ValueRef>, + 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, symbol_hasher: @hash::State, - type_hashcodes: HashMap<ty::t, @str>, - type_short_names: HashMap<ty::t, ~str>, - all_llvm_symbols: Set<~str>, + type_hashcodes: @mut LinearMap<ty::t, @str>, + type_short_names: @mut LinearMap<ty::t, ~str>, + all_llvm_symbols: @mut LinearSet<~str>, tcx: ty::ctxt, maps: astencode::Maps, stats: @mut Stats, @@ -310,12 +309,12 @@ pub struct fn_ctxt_ { loop_ret: Option<(ValueRef, ValueRef)>, // Maps arguments to allocas created for them in llallocas. - llargs: @HashMap<ast::node_id, local_val>, + llargs: @mut LinearMap<ast::node_id, local_val>, // Maps the def_ids for local variables to the allocas created for // them in llallocas. - lllocals: @HashMap<ast::node_id, local_val>, + lllocals: @mut LinearMap<ast::node_id, local_val>, // Same as above, but for closure upvars - llupvars: @HashMap<ast::node_id, ValueRef>, + llupvars: @mut LinearMap<ast::node_id, ValueRef>, // The node_id of the function, or -1 if it doesn't correspond to // a user-defined function. @@ -712,7 +711,7 @@ pub impl block_ { fn def(@mut self, nid: ast::node_id) -> ast::def { match self.tcx().def_map.find(&nid) { - Some(v) => v, + Some(&v) => v, None => { self.tcx().sess.bug(fmt!( "No def associated with node id %?", nid)); @@ -1132,7 +1131,7 @@ pub fn C_u8(i: uint) -> ValueRef { pub fn C_cstr(cx: @CrateContext, s: @~str) -> ValueRef { unsafe { match cx.const_cstr_cache.find(&s) { - Some(llval) => return llval, + Some(&llval) => return llval, None => () } @@ -1400,7 +1399,7 @@ pub fn node_vtables(bcx: block, id: ast::node_id) -> Option<typeck::vtable_res> { let raw_vtables = bcx.ccx().maps.vtable_map.find(&id); raw_vtables.map( - |vts| resolve_vtables_in_fn_ctxt(bcx.fcx, *vts)) + |&vts| resolve_vtables_in_fn_ctxt(bcx.fcx, *vts)) } pub fn resolve_vtables_in_fn_ctxt(fcx: fn_ctxt, vts: typeck::vtable_res) diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index ea34df54462..1362f97c08e 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -110,7 +110,7 @@ fn const_addr_of(cx: @CrateContext, cv: ValueRef) -> ValueRef { fn const_deref_ptr(cx: @CrateContext, v: ValueRef) -> ValueRef { let v = match cx.const_globals.find(&(v as int)) { - Some(v) => v, + Some(&v) => v, None => v }; unsafe { @@ -158,7 +158,7 @@ pub fn get_const_val(cx: @CrateContext, def_id: ast::def_id) -> ValueRef { if !ast_util::is_local(def_id) { def_id = inline::maybe_instantiate_inline(cx, def_id, true); } - match cx.tcx.items.get(&def_id.node) { + match *cx.tcx.items.get(&def_id.node) { ast_map::node_item(@ast::item { node: ast::item_const(_, subexpr), _ }, _) => { @@ -167,7 +167,7 @@ pub fn get_const_val(cx: @CrateContext, def_id: ast::def_id) -> ValueRef { _ => cx.tcx.sess.bug(~"expected a const to be an item") } } - cx.const_values.get(&def_id.node) + *cx.const_values.get(&def_id.node) } pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef { @@ -175,14 +175,14 @@ pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef { let ety = ty::expr_ty(cx.tcx, e); match cx.tcx.adjustments.find(&e.id) { None => { } - Some(@ty::AutoAddEnv(ty::re_static, ast::BorrowedSigil)) => { + Some(&@ty::AutoAddEnv(ty::re_static, ast::BorrowedSigil)) => { llconst = C_struct(~[llconst, C_null(T_opaque_box_ptr(cx))]) } - Some(@ty::AutoAddEnv(ref r, ref s)) => { + Some(&@ty::AutoAddEnv(ref r, ref s)) => { cx.sess.span_bug(e.span, fmt!("unexpected static function: \ region %? sigil %?", *r, *s)) } - Some(@ty::AutoDerefRef(ref adj)) => { + Some(&@ty::AutoDerefRef(ref adj)) => { let mut ty = ety; let mut maybe_ptr = None; for adj.autoderefs.times { @@ -496,7 +496,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef { ast::expr_path(pth) => { fail_unless!(pth.types.len() == 0); match cx.tcx.def_map.find(&e.id) { - Some(ast::def_fn(def_id, _purity)) => { + Some(&ast::def_fn(def_id, _purity)) => { if !ast_util::is_local(def_id) { let ty = csearch::get_type(cx.tcx, def_id).ty; base::trans_external_path(cx, def_id, ty) @@ -505,10 +505,10 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef { base::get_item_val(cx, def_id.node) } } - Some(ast::def_const(def_id)) => { + Some(&ast::def_const(def_id)) => { get_const_val(cx, def_id) } - Some(ast::def_variant(enum_did, variant_did)) => { + Some(&ast::def_variant(enum_did, variant_did)) => { let ety = ty::expr_ty(cx.tcx, e); let repr = adt::represent_type(cx, ety); let vinfo = ty::enum_variant_with_id(cx.tcx, @@ -516,7 +516,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef { variant_did); adt::trans_const(cx, repr, vinfo.disr_val, []) } - Some(ast::def_struct(_)) => { + Some(&ast::def_struct(_)) => { let ety = ty::expr_ty(cx.tcx, e); let llty = type_of::type_of(cx, ety); C_null(llty) @@ -529,13 +529,13 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef { } ast::expr_call(callee, ref args, _) => { match cx.tcx.def_map.find(&callee.id) { - Some(ast::def_struct(_)) => { + Some(&ast::def_struct(_)) => { let ety = ty::expr_ty(cx.tcx, e); let repr = adt::represent_type(cx, ety); adt::trans_const(cx, repr, 0, args.map(|a| const_expr(cx, *a))) } - Some(ast::def_variant(enum_did, variant_did)) => { + Some(&ast::def_variant(enum_did, variant_did)) => { let ety = ty::expr_ty(cx.tcx, e); let repr = adt::represent_type(cx, ety); let vinfo = ty::enum_variant_with_id(cx.tcx, @@ -561,7 +561,7 @@ pub fn trans_const(ccx: @CrateContext, _e: @ast::expr, id: ast::node_id) { let g = base::get_item_val(ccx, id); // At this point, get_item_val has already translated the // constant's initializer to determine its LLVM type. - let v = ccx.const_values.get(&id); + let v = *ccx.const_values.get(&id); llvm::LLVMSetInitializer(g, v); llvm::LLVMSetGlobalConstant(g, True); } diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs index 616a5f99499..1c201d0def6 100644 --- a/src/librustc/middle/trans/controlflow.rs +++ b/src/librustc/middle/trans/controlflow.rs @@ -196,7 +196,7 @@ pub fn trans_log(log_ex: @ast::expr, }; let global = if ccx.module_data.contains_key(&modname) { - ccx.module_data.get(&modname) + *ccx.module_data.get(&modname) } else { let s = link::mangle_internal_name_by_path_and_seq( ccx, modpath, ~"loglevel"); diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 600f637f72b..bb7fae9ae33 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -105,6 +105,7 @@ use util::common::indenter; use util::ppaux::ty_to_str; use core::cmp; +use core::container::Set; // XXX: this should not be necessary use core::to_bytes; use core::uint; use syntax::ast; @@ -230,7 +231,7 @@ pub impl Datum { * `id` is located in the move table, but copies otherwise. */ - if bcx.ccx().maps.moves_map.contains_key(&id) { + if bcx.ccx().maps.moves_map.contains(&id) { self.move_to(bcx, action, dst) } else { self.copy_to(bcx, action, dst) @@ -646,16 +647,15 @@ pub impl Datum { let key = root_map_key { id: expr_id, derefs: derefs }; let bcx = match ccx.maps.root_map.find(&key) { None => bcx, - Some(root_info) => self.root(bcx, root_info) + Some(&root_info) => self.root(bcx, root_info) }; // Perform the write guard, if necessary. // // (Note: write-guarded values are always boxes) - let bcx = match ccx.maps.write_guard_map.find(&key) { - None => bcx, - Some(_) => self.perform_write_guard(bcx) - }; + let bcx = if ccx.maps.write_guard_map.contains(&key) { + self.perform_write_guard(bcx) + } else { bcx }; match ty::get(self.ty).sty { ty::ty_box(_) | ty::ty_uniq(_) => { diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 505c08fc8b8..45884c9c3b4 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -20,11 +20,10 @@ use middle::trans; use middle::ty; use util::ppaux::ty_to_str; +use core::hashmap::linear::LinearMap; use core::libc; use core::option; use core::sys; -use std::oldmap::HashMap; -use std::oldmap; use syntax::codemap::{span, CharPos}; use syntax::parse::token::ident_interner; use syntax::{ast, codemap, ast_util, ast_map}; @@ -107,19 +106,18 @@ pub struct DebugContext { pub fn mk_ctxt(+crate: ~str, intr: @ident_interner) -> DebugContext { DebugContext { - llmetadata: oldmap::HashMap(), + llmetadata: @mut LinearMap::new(), names: new_namegen(intr), crate_file: crate } } fn update_cache(cache: metadata_cache, mdtag: int, val: debug_metadata) { - let existing = if cache.contains_key(&mdtag) { - cache.get(&mdtag) - } else { - ~[] + let mut existing = match cache.pop(&mdtag) { + Some(arr) => arr, None => ~[] }; - cache.insert(mdtag, vec::append_one(existing, val)); + existing.push(val); + cache.insert(mdtag, existing); } struct Metadata<T> { @@ -153,7 +151,7 @@ struct RetvalMetadata { id: ast::node_id } -type metadata_cache = HashMap<int, ~[debug_metadata]>; +type metadata_cache = @mut LinearMap<int, ~[debug_metadata]>; enum debug_metadata { file_metadata(@Metadata<FileMetadata>), @@ -318,7 +316,7 @@ fn create_block(cx: block) -> @Metadata<BlockMetadata> { }; let file_node = create_file(cx.ccx(), fname); let unique_id = match cache.find(&LexicalBlockTag) { - option::Some(v) => vec::len(v) as int, + option::Some(v) => v.len() as int, option::None => 0 }; let lldata = ~[lltag(tg), @@ -746,13 +744,13 @@ pub fn create_local_var(bcx: block, local: @ast::local) update_cache(cache, AutoVariableTag, local_var_metadata(mdval)); let llptr = match bcx.fcx.lllocals.find(&local.node.id) { - option::Some(local_mem(v)) => v, + option::Some(&local_mem(v)) => v, option::Some(_) => { bcx.tcx().sess.span_bug(local.span, ~"local is bound to \ something weird"); } option::None => { - match bcx.fcx.lllocals.get(&local.node.pat.id) { + match *bcx.fcx.lllocals.get(&local.node.pat.id) { local_imm(v) => v, _ => bcx.tcx().sess.span_bug(local.span, ~"local is bound to \ something weird") @@ -760,7 +758,7 @@ pub fn create_local_var(bcx: block, local: @ast::local) } }; let declargs = ~[llmdnode(~[llptr]), mdnode]; - trans::build::Call(bcx, cx.intrinsics.get(&~"llvm.dbg.declare"), + trans::build::Call(bcx, *cx.intrinsics.get(&~"llvm.dbg.declare"), declargs); return mdval; } @@ -807,12 +805,12 @@ pub fn create_arg(bcx: block, arg: ast::arg, sp: span) }; update_cache(cache, tg, argument_metadata(mdval)); - let llptr = match fcx.llargs.get(&arg.id) { + let llptr = match *fcx.llargs.get(&arg.id) { local_mem(v) | local_imm(v) => v, }; let declargs = ~[llmdnode(~[llptr]), mdnode]; trans::build::Call(bcx, - cx.intrinsics.get(&~"llvm.dbg.declare"), + *cx.intrinsics.get(&~"llvm.dbg.declare"), declargs); return Some(mdval); } @@ -851,7 +849,7 @@ pub fn create_function(fcx: fn_ctxt) -> @Metadata<SubProgramMetadata> { let sp = fcx.span.get(); debug!("%s", cx.sess.codemap.span_to_str(sp)); - let (ident, ret_ty, id) = match cx.tcx.items.get(&fcx.id) { + let (ident, ret_ty, id) = match *cx.tcx.items.get(&fcx.id) { ast_map::node_item(item, _) => { match item.node { ast::item_fn(ref decl, _, _, _) => { diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 7cfa1ff4929..33576a682a7 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -150,7 +150,7 @@ use middle::ty::{AutoPtr, AutoBorrowVec, AutoBorrowVecRef, AutoBorrowFn, use util::common::indenter; use util::ppaux::ty_to_str; -use std::oldmap::HashMap; +use core::hashmap::linear::LinearMap; use syntax::print::pprust::{expr_to_str}; use syntax::ast; use syntax::codemap; @@ -198,14 +198,14 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock { None => { trans_to_datum_unadjusted(bcx, expr) } - Some(@AutoAddEnv(*)) => { + Some(&@AutoAddEnv(*)) => { let mut bcx = bcx; let mut datum = unpack_datum!(bcx, { trans_to_datum_unadjusted(bcx, expr) }); add_env(bcx, expr, datum) } - Some(@AutoDerefRef(ref adj)) => { + Some(&@AutoDerefRef(ref adj)) => { let mut bcx = bcx; let mut datum = unpack_datum!(bcx, { trans_to_datum_unadjusted(bcx, expr) @@ -925,7 +925,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock { // at the end of the scope with id `scope_id`: let root_key = root_map_key { id: expr.id, derefs: 0u }; for bcx.ccx().maps.root_map.find(&root_key).each |&root_info| { - bcx = unrooted_datum.root(bcx, root_info); + bcx = unrooted_datum.root(bcx, *root_info); } return DatumBlock {bcx: bcx, datum: unrooted_datum}; @@ -1131,7 +1131,7 @@ pub fn trans_local_var(bcx: block, def: ast::def) -> Datum { // Can't move upvars, so this is never a ZeroMemLastUse. let local_ty = node_id_type(bcx, nid); match bcx.fcx.llupvars.find(&nid) { - Some(val) => { + Some(&val) => { Datum { val: val, ty: local_ty, @@ -1146,10 +1146,10 @@ pub fn trans_local_var(bcx: block, def: ast::def) -> Datum { } } ast::def_arg(nid, _, _) => { - take_local(bcx, *bcx.fcx.llargs, nid) + take_local(bcx, bcx.fcx.llargs, nid) } ast::def_local(nid, _) | ast::def_binding(nid, _) => { - take_local(bcx, *bcx.fcx.lllocals, nid) + take_local(bcx, bcx.fcx.lllocals, nid) } ast::def_self(nid, _) => { let self_info: ValSelfData = match bcx.fcx.llself { @@ -1181,11 +1181,11 @@ pub fn trans_local_var(bcx: block, def: ast::def) -> Datum { }; fn take_local(bcx: block, - table: HashMap<ast::node_id, local_val>, + table: &LinearMap<ast::node_id, local_val>, nid: ast::node_id) -> Datum { let (v, mode) = match table.find(&nid) { - Some(local_mem(v)) => (v, ByRef), - Some(local_imm(v)) => (v, ByValue), + Some(&local_mem(v)) => (v, ByRef), + Some(&local_imm(v)) => (v, ByValue), None => { bcx.sess().bug(fmt!( "trans_local_var: no llval for local/arg %? found", nid)); @@ -1227,7 +1227,7 @@ pub fn with_field_tys<R>(tcx: ty::ctxt, ty_to_str(tcx, ty))); } Some(node_id) => { - match tcx.def_map.get(&node_id) { + match *tcx.def_map.get(&node_id) { ast::def_variant(enum_id, variant_id) => { let variant_info = ty::enum_variant_with_id( tcx, enum_id, variant_id); @@ -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, diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index dadd51b3248..08f86bfb2df 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -567,7 +567,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, let tp_sz = machine::llbitsize_of_real(ccx, lltp_ty), out_sz = machine::llbitsize_of_real(ccx, llout_ty); if tp_sz != out_sz { - let sp = match ccx.tcx.items.get(&ref_id.get()) { + let sp = match *ccx.tcx.items.get(&ref_id.get()) { ast_map::node_expr(e) => e.span, _ => fail!(~"reinterpret_cast or forget has non-expr arg") }; @@ -605,7 +605,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, abi::tydesc_field_visit_glue, None); } ~"frame_address" => { - let frameaddress = ccx.intrinsics.get(&~"llvm.frameaddress"); + let frameaddress = *ccx.intrinsics.get(&~"llvm.frameaddress"); let frameaddress_val = Call(bcx, frameaddress, ~[C_i32(0i32)]); let star_u8 = ty::mk_imm_ptr( bcx.tcx(), @@ -644,7 +644,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, let size = get_param(decl, first_real_arg + 2); let align = C_i32(1); let volatile = C_i1(false); - let llfn = bcx.ccx().intrinsics.get( + let llfn = *bcx.ccx().intrinsics.get( &~"llvm.memmove.p0i8.p0i8.i32"); Call(bcx, llfn, ~[dst_ptr, src_ptr, size, align, volatile]); } @@ -654,249 +654,249 @@ pub fn trans_intrinsic(ccx: @CrateContext, let size = get_param(decl, first_real_arg + 2); let align = C_i32(1); let volatile = C_i1(false); - let llfn = bcx.ccx().intrinsics.get( + let llfn = *bcx.ccx().intrinsics.get( &~"llvm.memmove.p0i8.p0i8.i64"); Call(bcx, llfn, ~[dst_ptr, src_ptr, size, align, volatile]); } ~"sqrtf32" => { let x = get_param(decl, first_real_arg); - let sqrtf = ccx.intrinsics.get(&~"llvm.sqrt.f32"); + let sqrtf = *ccx.intrinsics.get(&~"llvm.sqrt.f32"); Store(bcx, Call(bcx, sqrtf, ~[x]), fcx.llretptr); } ~"sqrtf64" => { let x = get_param(decl, first_real_arg); - let sqrtf = ccx.intrinsics.get(&~"llvm.sqrt.f64"); + let sqrtf = *ccx.intrinsics.get(&~"llvm.sqrt.f64"); Store(bcx, Call(bcx, sqrtf, ~[x]), fcx.llretptr); } ~"powif32" => { let a = get_param(decl, first_real_arg); let x = get_param(decl, first_real_arg + 1u); - let powif = ccx.intrinsics.get(&~"llvm.powi.f32"); + let powif = *ccx.intrinsics.get(&~"llvm.powi.f32"); Store(bcx, Call(bcx, powif, ~[a, x]), fcx.llretptr); } ~"powif64" => { let a = get_param(decl, first_real_arg); let x = get_param(decl, first_real_arg + 1u); - let powif = ccx.intrinsics.get(&~"llvm.powi.f64"); + let powif = *ccx.intrinsics.get(&~"llvm.powi.f64"); Store(bcx, Call(bcx, powif, ~[a, x]), fcx.llretptr); } ~"sinf32" => { let x = get_param(decl, first_real_arg); - let sinf = ccx.intrinsics.get(&~"llvm.sin.f32"); + let sinf = *ccx.intrinsics.get(&~"llvm.sin.f32"); Store(bcx, Call(bcx, sinf, ~[x]), fcx.llretptr); } ~"sinf64" => { let x = get_param(decl, first_real_arg); - let sinf = ccx.intrinsics.get(&~"llvm.sin.f64"); + let sinf = *ccx.intrinsics.get(&~"llvm.sin.f64"); Store(bcx, Call(bcx, sinf, ~[x]), fcx.llretptr); } ~"cosf32" => { let x = get_param(decl, first_real_arg); - let cosf = ccx.intrinsics.get(&~"llvm.cos.f32"); + let cosf = *ccx.intrinsics.get(&~"llvm.cos.f32"); Store(bcx, Call(bcx, cosf, ~[x]), fcx.llretptr); } ~"cosf64" => { let x = get_param(decl, first_real_arg); - let cosf = ccx.intrinsics.get(&~"llvm.cos.f64"); + let cosf = *ccx.intrinsics.get(&~"llvm.cos.f64"); Store(bcx, Call(bcx, cosf, ~[x]), fcx.llretptr); } ~"powf32" => { let a = get_param(decl, first_real_arg); let x = get_param(decl, first_real_arg + 1u); - let powf = ccx.intrinsics.get(&~"llvm.pow.f32"); + let powf = *ccx.intrinsics.get(&~"llvm.pow.f32"); Store(bcx, Call(bcx, powf, ~[a, x]), fcx.llretptr); } ~"powf64" => { let a = get_param(decl, first_real_arg); let x = get_param(decl, first_real_arg + 1u); - let powf = ccx.intrinsics.get(&~"llvm.pow.f64"); + let powf = *ccx.intrinsics.get(&~"llvm.pow.f64"); Store(bcx, Call(bcx, powf, ~[a, x]), fcx.llretptr); } ~"expf32" => { let x = get_param(decl, first_real_arg); - let expf = ccx.intrinsics.get(&~"llvm.exp.f32"); + let expf = *ccx.intrinsics.get(&~"llvm.exp.f32"); Store(bcx, Call(bcx, expf, ~[x]), fcx.llretptr); } ~"expf64" => { let x = get_param(decl, first_real_arg); - let expf = ccx.intrinsics.get(&~"llvm.exp.f64"); + let expf = *ccx.intrinsics.get(&~"llvm.exp.f64"); Store(bcx, Call(bcx, expf, ~[x]), fcx.llretptr); } ~"exp2f32" => { let x = get_param(decl, first_real_arg); - let exp2f = ccx.intrinsics.get(&~"llvm.exp2.f32"); + let exp2f = *ccx.intrinsics.get(&~"llvm.exp2.f32"); Store(bcx, Call(bcx, exp2f, ~[x]), fcx.llretptr); } ~"exp2f64" => { let x = get_param(decl, first_real_arg); - let exp2f = ccx.intrinsics.get(&~"llvm.exp2.f64"); + let exp2f = *ccx.intrinsics.get(&~"llvm.exp2.f64"); Store(bcx, Call(bcx, exp2f, ~[x]), fcx.llretptr); } ~"logf32" => { let x = get_param(decl, first_real_arg); - let logf = ccx.intrinsics.get(&~"llvm.log.f32"); + let logf = *ccx.intrinsics.get(&~"llvm.log.f32"); Store(bcx, Call(bcx, logf, ~[x]), fcx.llretptr); } ~"logf64" => { let x = get_param(decl, first_real_arg); - let logf = ccx.intrinsics.get(&~"llvm.log.f64"); + let logf = *ccx.intrinsics.get(&~"llvm.log.f64"); Store(bcx, Call(bcx, logf, ~[x]), fcx.llretptr); } ~"log10f32" => { let x = get_param(decl, first_real_arg); - let log10f = ccx.intrinsics.get(&~"llvm.log10.f32"); + let log10f = *ccx.intrinsics.get(&~"llvm.log10.f32"); Store(bcx, Call(bcx, log10f, ~[x]), fcx.llretptr); } ~"log10f64" => { let x = get_param(decl, first_real_arg); - let log10f = ccx.intrinsics.get(&~"llvm.log10.f64"); + let log10f = *ccx.intrinsics.get(&~"llvm.log10.f64"); Store(bcx, Call(bcx, log10f, ~[x]), fcx.llretptr); } ~"log2f32" => { let x = get_param(decl, first_real_arg); - let log2f = ccx.intrinsics.get(&~"llvm.log2.f32"); + let log2f = *ccx.intrinsics.get(&~"llvm.log2.f32"); Store(bcx, Call(bcx, log2f, ~[x]), fcx.llretptr); } ~"log2f64" => { let x = get_param(decl, first_real_arg); - let log2f = ccx.intrinsics.get(&~"llvm.log2.f64"); + let log2f = *ccx.intrinsics.get(&~"llvm.log2.f64"); Store(bcx, Call(bcx, log2f, ~[x]), fcx.llretptr); } ~"fmaf32" => { let a = get_param(decl, first_real_arg); let b = get_param(decl, first_real_arg + 1u); let c = get_param(decl, first_real_arg + 2u); - let fmaf = ccx.intrinsics.get(&~"llvm.fma.f32"); + let fmaf = *ccx.intrinsics.get(&~"llvm.fma.f32"); Store(bcx, Call(bcx, fmaf, ~[a, b, c]), fcx.llretptr); } ~"fmaf64" => { let a = get_param(decl, first_real_arg); let b = get_param(decl, first_real_arg + 1u); let c = get_param(decl, first_real_arg + 2u); - let fmaf = ccx.intrinsics.get(&~"llvm.fma.f64"); + let fmaf = *ccx.intrinsics.get(&~"llvm.fma.f64"); Store(bcx, Call(bcx, fmaf, ~[a, b, c]), fcx.llretptr); } ~"fabsf32" => { let x = get_param(decl, first_real_arg); - let fabsf = ccx.intrinsics.get(&~"llvm.fabs.f32"); + let fabsf = *ccx.intrinsics.get(&~"llvm.fabs.f32"); Store(bcx, Call(bcx, fabsf, ~[x]), fcx.llretptr); } ~"fabsf64" => { let x = get_param(decl, first_real_arg); - let fabsf = ccx.intrinsics.get(&~"llvm.fabs.f64"); + let fabsf = *ccx.intrinsics.get(&~"llvm.fabs.f64"); Store(bcx, Call(bcx, fabsf, ~[x]), fcx.llretptr); } ~"floorf32" => { let x = get_param(decl, first_real_arg); - let floorf = ccx.intrinsics.get(&~"llvm.floor.f32"); + let floorf = *ccx.intrinsics.get(&~"llvm.floor.f32"); Store(bcx, Call(bcx, floorf, ~[x]), fcx.llretptr); } ~"floorf64" => { let x = get_param(decl, first_real_arg); - let floorf = ccx.intrinsics.get(&~"llvm.floor.f64"); + let floorf = *ccx.intrinsics.get(&~"llvm.floor.f64"); Store(bcx, Call(bcx, floorf, ~[x]), fcx.llretptr); } ~"ceilf32" => { let x = get_param(decl, first_real_arg); - let ceilf = ccx.intrinsics.get(&~"llvm.ceil.f32"); + let ceilf = *ccx.intrinsics.get(&~"llvm.ceil.f32"); Store(bcx, Call(bcx, ceilf, ~[x]), fcx.llretptr); } ~"ceilf64" => { let x = get_param(decl, first_real_arg); - let ceilf = ccx.intrinsics.get(&~"llvm.ceil.f64"); + let ceilf = *ccx.intrinsics.get(&~"llvm.ceil.f64"); Store(bcx, Call(bcx, ceilf, ~[x]), fcx.llretptr); } ~"truncf32" => { let x = get_param(decl, first_real_arg); - let truncf = ccx.intrinsics.get(&~"llvm.trunc.f32"); + let truncf = *ccx.intrinsics.get(&~"llvm.trunc.f32"); Store(bcx, Call(bcx, truncf, ~[x]), fcx.llretptr); } ~"truncf64" => { let x = get_param(decl, first_real_arg); - let truncf = ccx.intrinsics.get(&~"llvm.trunc.f64"); + let truncf = *ccx.intrinsics.get(&~"llvm.trunc.f64"); Store(bcx, Call(bcx, truncf, ~[x]), fcx.llretptr); } ~"ctpop8" => { let x = get_param(decl, first_real_arg); - let ctpop = ccx.intrinsics.get(&~"llvm.ctpop.i8"); + let ctpop = *ccx.intrinsics.get(&~"llvm.ctpop.i8"); Store(bcx, Call(bcx, ctpop, ~[x]), fcx.llretptr) } ~"ctpop16" => { let x = get_param(decl, first_real_arg); - let ctpop = ccx.intrinsics.get(&~"llvm.ctpop.i16"); + let ctpop = *ccx.intrinsics.get(&~"llvm.ctpop.i16"); Store(bcx, Call(bcx, ctpop, ~[x]), fcx.llretptr) } ~"ctpop32" => { let x = get_param(decl, first_real_arg); - let ctpop = ccx.intrinsics.get(&~"llvm.ctpop.i32"); + let ctpop = *ccx.intrinsics.get(&~"llvm.ctpop.i32"); Store(bcx, Call(bcx, ctpop, ~[x]), fcx.llretptr) } ~"ctpop64" => { let x = get_param(decl, first_real_arg); - let ctpop = ccx.intrinsics.get(&~"llvm.ctpop.i64"); + let ctpop = *ccx.intrinsics.get(&~"llvm.ctpop.i64"); Store(bcx, Call(bcx, ctpop, ~[x]), fcx.llretptr) } ~"ctlz8" => { let x = get_param(decl, first_real_arg); let y = C_i1(false); - let ctlz = ccx.intrinsics.get(&~"llvm.ctlz.i8"); + let ctlz = *ccx.intrinsics.get(&~"llvm.ctlz.i8"); Store(bcx, Call(bcx, ctlz, ~[x, y]), fcx.llretptr) } ~"ctlz16" => { let x = get_param(decl, first_real_arg); let y = C_i1(false); - let ctlz = ccx.intrinsics.get(&~"llvm.ctlz.i16"); + let ctlz = *ccx.intrinsics.get(&~"llvm.ctlz.i16"); Store(bcx, Call(bcx, ctlz, ~[x, y]), fcx.llretptr) } ~"ctlz32" => { let x = get_param(decl, first_real_arg); let y = C_i1(false); - let ctlz = ccx.intrinsics.get(&~"llvm.ctlz.i32"); + let ctlz = *ccx.intrinsics.get(&~"llvm.ctlz.i32"); Store(bcx, Call(bcx, ctlz, ~[x, y]), fcx.llretptr) } ~"ctlz64" => { let x = get_param(decl, first_real_arg); let y = C_i1(false); - let ctlz = ccx.intrinsics.get(&~"llvm.ctlz.i64"); + let ctlz = *ccx.intrinsics.get(&~"llvm.ctlz.i64"); Store(bcx, Call(bcx, ctlz, ~[x, y]), fcx.llretptr) } ~"cttz8" => { let x = get_param(decl, first_real_arg); let y = C_i1(false); - let cttz = ccx.intrinsics.get(&~"llvm.cttz.i8"); + let cttz = *ccx.intrinsics.get(&~"llvm.cttz.i8"); Store(bcx, Call(bcx, cttz, ~[x, y]), fcx.llretptr) } ~"cttz16" => { let x = get_param(decl, first_real_arg); let y = C_i1(false); - let cttz = ccx.intrinsics.get(&~"llvm.cttz.i16"); + let cttz = *ccx.intrinsics.get(&~"llvm.cttz.i16"); Store(bcx, Call(bcx, cttz, ~[x, y]), fcx.llretptr) } ~"cttz32" => { let x = get_param(decl, first_real_arg); let y = C_i1(false); - let cttz = ccx.intrinsics.get(&~"llvm.cttz.i32"); + let cttz = *ccx.intrinsics.get(&~"llvm.cttz.i32"); Store(bcx, Call(bcx, cttz, ~[x, y]), fcx.llretptr) } ~"cttz64" => { let x = get_param(decl, first_real_arg); let y = C_i1(false); - let cttz = ccx.intrinsics.get(&~"llvm.cttz.i64"); + let cttz = *ccx.intrinsics.get(&~"llvm.cttz.i64"); Store(bcx, Call(bcx, cttz, ~[x, y]), fcx.llretptr) } ~"bswap16" => { let x = get_param(decl, first_real_arg); - let cttz = ccx.intrinsics.get(&~"llvm.bswap.i16"); + let cttz = *ccx.intrinsics.get(&~"llvm.bswap.i16"); Store(bcx, Call(bcx, cttz, ~[x]), fcx.llretptr) } ~"bswap32" => { let x = get_param(decl, first_real_arg); - let cttz = ccx.intrinsics.get(&~"llvm.bswap.i32"); + let cttz = *ccx.intrinsics.get(&~"llvm.bswap.i32"); Store(bcx, Call(bcx, cttz, ~[x]), fcx.llretptr) } ~"bswap64" => { let x = get_param(decl, first_real_arg); - let cttz = ccx.intrinsics.get(&~"llvm.bswap.i64"); + let cttz = *ccx.intrinsics.get(&~"llvm.bswap.i64"); Store(bcx, Call(bcx, cttz, ~[x]), fcx.llretptr) } _ => { @@ -1082,7 +1082,7 @@ pub fn register_foreign_fn(ccx: @CrateContext, fn abi_of_foreign_fn(ccx: @CrateContext, i: @ast::foreign_item) -> ast::foreign_abi { match attr::first_attr_value_str_by_name(i.attrs, ~"abi") { - None => match ccx.tcx.items.get(&i.id) { + None => match *ccx.tcx.items.get(&i.id) { ast_map::node_foreign_item(_, abi, _, _) => abi, // ?? _ => fail!(~"abi_of_foreign_fn: not foreign") diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index bf5a699ed82..1639c6b414d 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/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); diff --git a/src/librustc/middle/trans/inline.rs b/src/librustc/middle/trans/inline.rs index afbb5f09da3..906519543d2 100644 --- a/src/librustc/middle/trans/inline.rs +++ b/src/librustc/middle/trans/inline.rs @@ -32,13 +32,13 @@ pub fn maybe_instantiate_inline(ccx: @CrateContext, fn_id: ast::def_id, -> ast::def_id { let _icx = ccx.insn_ctxt("maybe_instantiate_inline"); match ccx.external.find(&fn_id) { - Some(Some(node_id)) => { + Some(&Some(node_id)) => { // Already inline debug!("maybe_instantiate_inline(%s): already inline as node id %d", ty::item_path_str(ccx.tcx, fn_id), node_id); local_def(node_id) } - Some(None) => fn_id, // Not inlinable + Some(&None) => fn_id, // Not inlinable None => { // Not seen yet match csearch::maybe_get_item_ast( ccx.tcx, fn_id, diff --git a/src/librustc/middle/trans/machine.rs b/src/librustc/middle/trans/machine.rs index 434fcd4cf31..047968ed569 100644 --- a/src/librustc/middle/trans/machine.rs +++ b/src/librustc/middle/trans/machine.rs @@ -10,6 +10,7 @@ // Information concerning the machine representation of various types. +use core::prelude::*; use lib::llvm::{ModuleRef, ValueRef, TypeRef, BasicBlockRef, BuilderRef}; use lib::llvm::{True, False, Bool}; @@ -119,7 +120,7 @@ pub fn llalign_of(cx: @CrateContext, t: TypeRef) -> ValueRef { // Computes the size of the data part of an enum. pub fn static_size_of_enum(cx: @CrateContext, t: ty::t) -> uint { if cx.enum_sizes.contains_key(&t) { - return cx.enum_sizes.get(&t); + return *cx.enum_sizes.get(&t); } debug!("static_size_of_enum %s", ty_to_str(cx.tcx, t)); diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index b49bdbba426..1f348bc3e24 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -306,7 +306,7 @@ pub fn trans_static_method_callee(bcx: block, }; let mname = if method_id.crate == ast::local_crate { - match bcx.tcx().items.get(&method_id.node) { + match *bcx.tcx().items.get(&method_id.node) { ast_map::node_trait_method(trait_method, _, _) => { ast_util::trait_method_to_ty_method(trait_method).ident } @@ -323,7 +323,7 @@ pub fn trans_static_method_callee(bcx: block, name=%s", method_id, callee_id, *ccx.sess.str_of(mname)); let vtbls = resolve_vtables_in_fn_ctxt( - bcx.fcx, ccx.maps.vtable_map.get(&callee_id)); + bcx.fcx, *ccx.maps.vtable_map.get(&callee_id)); match vtbls[bound_index] { typeck::vtable_static(impl_did, ref rcvr_substs, rcvr_origins) => { @@ -361,7 +361,7 @@ pub fn method_from_methods(ms: &[@ast::method], name: ast::ident) pub fn method_with_name(ccx: @CrateContext, impl_id: ast::def_id, name: ast::ident) -> ast::def_id { if impl_id.crate == ast::local_crate { - match ccx.tcx.items.get(&impl_id.node) { + match *ccx.tcx.items.get(&impl_id.node) { ast_map::node_item(@ast::item { node: ast::item_impl(_, _, _, ref ms), _ @@ -378,7 +378,7 @@ pub fn method_with_name(ccx: @CrateContext, impl_id: ast::def_id, pub fn method_with_name_or_default(ccx: @CrateContext, impl_id: ast::def_id, name: ast::ident) -> ast::def_id { if impl_id.crate == ast::local_crate { - match ccx.tcx.items.get(&impl_id.node) { + match *ccx.tcx.items.get(&impl_id.node) { ast_map::node_item(@ast::item { node: ast::item_impl(_, _, _, ref ms), _ }, _) => { @@ -414,7 +414,7 @@ pub fn method_ty_param_count(ccx: @CrateContext, m_id: ast::def_id, debug!("method_ty_param_count: m_id: %?, i_id: %?", m_id, i_id); if m_id.crate == ast::local_crate { match ccx.tcx.items.find(&m_id.node) { - Some(ast_map::node_method(m, _, _)) => m.generics.ty_params.len(), + Some(&ast_map::node_method(m, _, _)) => m.generics.ty_params.len(), None => { match ccx.tcx.provided_method_sources.find(&m_id) { Some(source) => { @@ -424,7 +424,7 @@ pub fn method_ty_param_count(ccx: @CrateContext, m_id: ast::def_id, None => fail!() } } - Some(ast_map::node_trait_method(@ast::provided(@ref m), + Some(&ast_map::node_trait_method(@ast::provided(@ref m), _, _)) => { m.generics.ty_params.len() } @@ -764,7 +764,7 @@ pub fn get_vtable(ccx: @CrateContext, // XXX: Bad copy. let hash_id = vtable_id(ccx, copy origin); match ccx.vtables.find(&hash_id) { - Some(val) => val, + Some(&val) => val, None => match origin { typeck::vtable_static(id, substs, sub_vtables) => { make_impl_vtable(ccx, id, substs, sub_vtables) diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index 67bba3e0bd9..659b3f6c7ac 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -77,7 +77,7 @@ pub fn monomorphic_fn(ccx: @CrateContext, substs.map(|s| ty_to_str(ccx.tcx, *s)), hash_id); match ccx.monomorphized.find(&hash_id) { - Some(val) => { + Some(&val) => { debug!("leaving monomorphic fn %s", ty::item_path_str(ccx.tcx, fn_id)); return (val, must_cast); @@ -93,7 +93,7 @@ pub fn monomorphic_fn(ccx: @CrateContext, (may have attempted to monomorphize an item defined in a different \ crate?)", fn_id)); // Get the path so that we can create a symbol - let (pt, name, span) = match map_node { + let (pt, name, span) = match *map_node { ast_map::node_item(i, pt) => (pt, i.ident, i.span), ast_map::node_variant(ref v, enm, pt) => (pt, (*v).node.name, enm.span), ast_map::node_method(m, _, pt) => (pt, m.ident, m.span), @@ -142,7 +142,9 @@ pub fn monomorphic_fn(ccx: @CrateContext, ccx.stats.n_monos += 1; - let depth = option::get_or_default(ccx.monomorphizing.find(&fn_id), 0u); + let depth = match ccx.monomorphizing.find(&fn_id) { + Some(&d) => d, None => 0 + }; // Random cut-off -- code that needs to instantiate the same function // recursively more than thirty times can probably safely be assumed to be // causing an infinite expansion. @@ -170,7 +172,7 @@ pub fn monomorphic_fn(ccx: @CrateContext, self_ty: impl_ty_opt }); - let lldecl = match map_node { + let lldecl = match *map_node { ast_map::node_item(i@@ast::item { // XXX: Bad copy. node: ast::item_fn(ref decl, _, _, ref body), diff --git a/src/librustc/middle/trans/reachable.rs b/src/librustc/middle/trans/reachable.rs index 015fc61a3c8..4ac3ac0555f 100644 --- a/src/librustc/middle/trans/reachable.rs +++ b/src/librustc/middle/trans/reachable.rs @@ -21,7 +21,7 @@ use middle::ty; use middle::typeck; use core::prelude::*; -use std::oldmap::HashMap; +use core::hashmap::linear::LinearSet; use syntax::ast; use syntax::ast::*; use syntax::ast_util::def_id_of_def; @@ -30,27 +30,29 @@ use syntax::codemap; use syntax::print::pprust::expr_to_str; use syntax::{visit, ast_util, ast_map}; -pub type map = HashMap<node_id, ()>; +pub type map = @LinearSet<node_id>; struct ctx { exp_map2: resolve::ExportMap2, tcx: ty::ctxt, method_map: typeck::method_map, - rmap: map + rmap: &'self mut LinearSet<node_id>, } pub fn find_reachable(crate_mod: &_mod, exp_map2: resolve::ExportMap2, tcx: ty::ctxt, method_map: typeck::method_map) -> map { - let rmap = HashMap(); - let cx = ctx { - exp_map2: exp_map2, - tcx: tcx, - method_map: method_map, - rmap: rmap - }; - traverse_public_mod(cx, ast::crate_node_id, crate_mod); - traverse_all_resources_and_impls(cx, crate_mod); - rmap + let mut rmap = LinearSet::new(); + { + let cx = ctx { + exp_map2: exp_map2, + tcx: tcx, + method_map: method_map, + rmap: &mut rmap + }; + traverse_public_mod(cx, ast::crate_node_id, crate_mod); + traverse_all_resources_and_impls(cx, crate_mod); + } + return @rmap; } fn traverse_exports(cx: ctx, mod_id: node_id) -> bool { @@ -69,20 +71,17 @@ fn traverse_exports(cx: ctx, mod_id: node_id) -> bool { fn traverse_def_id(cx: ctx, did: def_id) { if did.crate != local_crate { return; } - let n = match cx.tcx.items.find(&did.node) { - None => return, // This can happen for self, for example - Some(ref n) => (/*bad*/copy *n) - }; - match n { - ast_map::node_item(item, _) => traverse_public_item(cx, item), - ast_map::node_method(_, impl_id, _) => traverse_def_id(cx, impl_id), - ast_map::node_foreign_item(item, _, _, _) => { - cx.rmap.insert(item.id, ()); - } - ast_map::node_variant(ref v, _, _) => { - cx.rmap.insert((*v).node.id, ()); - } - _ => () + match cx.tcx.items.find(&did.node) { + None => (), // This can happen for self, for example + Some(&ast_map::node_item(item, _)) => traverse_public_item(cx, item), + Some(&ast_map::node_method(_, impl_id, _)) => traverse_def_id(cx, impl_id), + Some(&ast_map::node_foreign_item(item, _, _, _)) => { + cx.rmap.insert(item.id); + } + Some(&ast_map::node_variant(ref v, _, _)) => { + cx.rmap.insert(v.node.id); + } + _ => () } } @@ -96,14 +95,16 @@ fn traverse_public_mod(cx: ctx, mod_id: node_id, m: &_mod) { } fn traverse_public_item(cx: ctx, item: @item) { - if cx.rmap.contains_key(&item.id) { return; } - cx.rmap.insert(item.id, ()); + // XXX: it shouldn't be necessary to do this + let rmap: &mut LinearSet<node_id> = cx.rmap; + if rmap.contains(&item.id) { return; } + rmap.insert(item.id); match item.node { item_mod(ref m) => traverse_public_mod(cx, item.id, m), item_foreign_mod(ref nm) => { if !traverse_exports(cx, item.id) { for nm.items.each |item| { - cx.rmap.insert(item.id, ()); + cx.rmap.insert(item.id); } } } @@ -119,17 +120,17 @@ fn traverse_public_item(cx: ctx, item: @item) { m.generics.ty_params.len() > 0u || attr::find_inline_attr(m.attrs) != attr::ia_none { - cx.rmap.insert(m.id, ()); + cx.rmap.insert(m.id); traverse_inline_body(cx, &m.body); } } } item_struct(ref struct_def, ref generics) => { for struct_def.ctor_id.each |&ctor_id| { - cx.rmap.insert(ctor_id, ()); + cx.rmap.insert(ctor_id); } for struct_def.dtor.each |dtor| { - cx.rmap.insert(dtor.node.id, ()); + cx.rmap.insert(dtor.node.id); if generics.ty_params.len() > 0u || attr::find_inline_attr(dtor.node.attrs) != attr::ia_none { @@ -151,17 +152,19 @@ fn mk_ty_visitor() -> visit::vt<ctx> { ..*visit::default_visitor()}) } -fn traverse_ty(ty: @Ty, cx: ctx, v: visit::vt<ctx>) { - if cx.rmap.contains_key(&ty.id) { return; } - cx.rmap.insert(ty.id, ()); +fn traverse_ty(ty: @Ty, cx: ctx<'a>, v: visit::vt<ctx<'a>>) { + // XXX: it shouldn't be necessary to do this + let rmap: &mut LinearSet<node_id> = cx.rmap; + if rmap.contains(&ty.id) { return; } + rmap.insert(ty.id); match ty.node { ty_path(p, p_id) => { match cx.tcx.def_map.find(&p_id) { // Kind of a hack to check this here, but I'm not sure what else // to do - Some(def_prim_ty(_)) => { /* do nothing */ } - Some(d) => traverse_def_id(cx, def_id_of_def(d)), + Some(&def_prim_ty(_)) => { /* do nothing */ } + Some(&d) => traverse_def_id(cx, def_id_of_def(d)), None => { /* do nothing -- but should we fail here? */ } } for p.types.each |t| { @@ -173,11 +176,11 @@ fn traverse_ty(ty: @Ty, cx: ctx, v: visit::vt<ctx>) { } fn traverse_inline_body(cx: ctx, body: &blk) { - fn traverse_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) { + fn traverse_expr(e: @expr, cx: ctx<'a>, v: visit::vt<ctx<'a>>) { match e.node { expr_path(_) => { match cx.tcx.def_map.find(&e.id) { - Some(d) => { + Some(&d) => { traverse_def_id(cx, def_id_of_def(d)); } None => cx.tcx.sess.span_bug(e.span, fmt!("Unbound node \ @@ -187,7 +190,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), _ }) => { @@ -198,7 +201,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), _ }) => { diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index 41e63cc878e..b8145e65326 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/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, diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs index 90f6bf87578..5bb94a18e72 100644 --- a/src/librustc/middle/trans/tvec.rs +++ b/src/librustc/middle/trans/tvec.rs @@ -28,7 +28,6 @@ use util::common::indenter; use util::ppaux::ty_to_str; use core::option::None; -use core::uint; use core::vec; use syntax::ast; use syntax::codemap; diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index a7bec5547c4..8e4719d2ccc 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use core::prelude::*; use lib::llvm::llvm; use lib::llvm::{TypeRef}; @@ -100,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 { @@ -160,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 diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index 45cf790ccee..e19afb0d507 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/src/librustc/middle/trans/type_use.rs @@ -27,6 +27,7 @@ // much information, but have the disadvantage of being very // invasive.) +use core::prelude::*; use middle::freevars; use middle::trans::common::*; @@ -59,7 +60,7 @@ pub struct Context { pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint) -> ~[type_uses] { match ccx.type_use_cache.find(&fn_id) { - Some(uses) => return uses, + Some(uses) => return /*bad*/ copy *uses, None => () } @@ -97,7 +98,7 @@ pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint) return uses; } let map_node = match ccx.tcx.items.find(&fn_id_loc.node) { - Some(ref x) => (/*bad*/copy *x), + Some(x) => (/*bad*/copy *x), None => ccx.sess.bug(fmt!("type_uses_for: unbound item ID %?", fn_id_loc)) }; @@ -249,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) } } @@ -295,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| { - let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get(&e.id)); + // 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) } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 44245e0b4e1..fcbf34dca90 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -37,9 +37,7 @@ use core::result; use core::to_bytes; use core::uint; use core::vec; -use core::hashmap::linear::LinearMap; -use std::oldmap::HashMap; -use std::oldmap; +use core::hashmap::linear::{LinearMap, LinearSet}; use std::smallintmap::SmallIntMap; use syntax::ast::*; use syntax::ast_util::{is_local, local_def}; @@ -118,7 +116,7 @@ pub struct creader_cache_key { len: uint } -type creader_cache = HashMap<creader_cache_key, t>; +type creader_cache = @mut LinearMap<creader_cache_key, t>; impl to_bytes::IterBytes for creader_cache_key { fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { @@ -222,7 +220,7 @@ pub enum AutoRefKind { // This is a map from ID of each implementation to the method info and trait // method ID of each of the default methods belonging to the trait that that // implementation implements. -pub type ProvidedMethodsMap = HashMap<def_id,@mut ~[@ProvidedMethodInfo]>; +pub type ProvidedMethodsMap = @mut LinearMap<def_id,@mut ~[@ProvidedMethodInfo]>; // Stores the method info and definition ID of the associated trait method for // each instantiation of each provided method. @@ -245,7 +243,7 @@ pub type ctxt = @ctxt_; struct ctxt_ { diag: @syntax::diagnostic::span_handler, - interner: HashMap<intern_key, t_box>, + interner: @mut LinearMap<intern_key, t_box>, next_id: @mut uint, vecs_implicitly_copyable: bool, legacy_modes: bool, @@ -265,43 +263,43 @@ struct ctxt_ { // of this node. This only applies to nodes that refer to entities // parameterized by type parameters, such as generic fns, types, or // other items. - node_type_substs: HashMap<node_id, ~[t]>, + node_type_substs: @mut LinearMap<node_id, ~[t]>, items: ast_map::map, - intrinsic_defs: HashMap<ast::ident, (ast::def_id, t)>, + intrinsic_defs: @mut LinearMap<ast::ident, (ast::def_id, t)>, freevars: freevars::freevar_map, tcache: type_cache, rcache: creader_cache, ccache: constness_cache, - short_names_cache: HashMap<t, @~str>, - needs_unwind_cleanup_cache: HashMap<t, bool>, + short_names_cache: @mut LinearMap<t, @~str>, + needs_unwind_cleanup_cache: @mut LinearMap<t, bool>, tc_cache: @mut LinearMap<uint, TypeContents>, - ast_ty_to_ty_cache: HashMap<node_id, ast_ty_to_ty_cache_entry>, - enum_var_cache: HashMap<def_id, @~[VariantInfo]>, - trait_method_cache: HashMap<def_id, @~[method]>, - ty_param_bounds: HashMap<ast::node_id, param_bounds>, - inferred_modes: HashMap<ast::node_id, ast::mode>, - adjustments: HashMap<ast::node_id, @AutoAdjustment>, - normalized_cache: HashMap<t, t>, + ast_ty_to_ty_cache: @mut LinearMap<node_id, ast_ty_to_ty_cache_entry>, + enum_var_cache: @mut LinearMap<def_id, @~[VariantInfo]>, + trait_method_cache: @mut LinearMap<def_id, @~[method]>, + ty_param_bounds: @mut LinearMap<ast::node_id, param_bounds>, + inferred_modes: @mut LinearMap<ast::node_id, ast::mode>, + adjustments: @mut LinearMap<ast::node_id, @AutoAdjustment>, + normalized_cache: @mut LinearMap<t, t>, lang_items: middle::lang_items::LanguageItems, // A mapping from an implementation ID to the method info and trait // method ID of the provided (a.k.a. default) methods in the traits that // that implementation implements. provided_methods: ProvidedMethodsMap, - provided_method_sources: HashMap<ast::def_id, ProvidedMethodSource>, - supertraits: HashMap<ast::def_id, @~[InstantiatedTraitRef]>, + provided_method_sources: @mut LinearMap<ast::def_id, ProvidedMethodSource>, + supertraits: @mut LinearMap<ast::def_id, @~[InstantiatedTraitRef]>, // A mapping from the def ID of an enum or struct type to the def ID // of the method that implements its destructor. If the type is not // present in this map, it does not have a destructor. This map is // populated during the coherence phase of typechecking. - destructor_for_type: HashMap<ast::def_id, ast::def_id>, + destructor_for_type: @mut LinearMap<ast::def_id, ast::def_id>, // A method will be in this list if and only if it is a destructor. - destructors: HashMap<ast::def_id, ()>, + destructors: @mut LinearSet<ast::def_id>, // Maps a trait onto a mapping from self-ty to impl - trait_impls: HashMap<ast::def_id, HashMap<t, @Impl>> + trait_impls: @mut LinearMap<ast::def_id, @mut LinearMap<t, @Impl>> } enum tbox_flag { @@ -778,18 +776,18 @@ pub struct ty_param_substs_and_ty { ty: ty::t } -type type_cache = HashMap<ast::def_id, ty_param_bounds_and_ty>; +type type_cache = @mut LinearMap<ast::def_id, ty_param_bounds_and_ty>; -type constness_cache = HashMap<ast::def_id, const_eval::constness>; +type constness_cache = @mut LinearMap<ast::def_id, const_eval::constness>; pub type node_type_table = @mut SmallIntMap<t>; fn mk_rcache() -> creader_cache { - return oldmap::HashMap(); + return @mut LinearMap::new(); } -pub fn new_ty_hash<V:Copy>() -> oldmap::HashMap<t, V> { - oldmap::HashMap() +pub fn new_ty_hash<V:Copy>() -> @mut LinearMap<t, V> { + @mut LinearMap::new() } pub fn mk_ctxt(s: session::Session, @@ -811,13 +809,12 @@ pub fn mk_ctxt(s: session::Session, } } - let interner = oldmap::HashMap(); let vecs_implicitly_copyable = get_lint_level(s.lint_settings.default_settings, lint::vecs_implicitly_copyable) == allow; @ctxt_ { diag: s.diagnostic(), - interner: interner, + interner: @mut LinearMap::new(), next_id: @mut 0, vecs_implicitly_copyable: vecs_implicitly_copyable, legacy_modes: legacy_modes, @@ -827,30 +824,30 @@ pub fn mk_ctxt(s: session::Session, region_map: region_map, region_paramd_items: region_paramd_items, node_types: @mut SmallIntMap::new(), - node_type_substs: oldmap::HashMap(), + node_type_substs: @mut LinearMap::new(), items: amap, - intrinsic_defs: oldmap::HashMap(), + intrinsic_defs: @mut LinearMap::new(), freevars: freevars, - tcache: HashMap(), + tcache: @mut LinearMap::new(), rcache: mk_rcache(), - ccache: HashMap(), + ccache: @mut LinearMap::new(), short_names_cache: new_ty_hash(), needs_unwind_cleanup_cache: new_ty_hash(), tc_cache: @mut LinearMap::new(), - ast_ty_to_ty_cache: HashMap(), - enum_var_cache: HashMap(), - trait_method_cache: HashMap(), - ty_param_bounds: HashMap(), - inferred_modes: HashMap(), - adjustments: HashMap(), + ast_ty_to_ty_cache: @mut LinearMap::new(), + enum_var_cache: @mut LinearMap::new(), + trait_method_cache: @mut LinearMap::new(), + ty_param_bounds: @mut LinearMap::new(), + inferred_modes: @mut LinearMap::new(), + adjustments: @mut LinearMap::new(), normalized_cache: new_ty_hash(), lang_items: lang_items, - provided_methods: HashMap(), - provided_method_sources: HashMap(), - supertraits: HashMap(), - destructor_for_type: HashMap(), - destructors: HashMap(), - trait_impls: HashMap() + provided_methods: @mut LinearMap::new(), + provided_method_sources: @mut LinearMap::new(), + supertraits: @mut LinearMap::new(), + destructor_for_type: @mut LinearMap::new(), + destructors: @mut LinearSet::new(), + trait_impls: @mut LinearMap::new() } } @@ -863,7 +860,7 @@ fn mk_t(cx: ctxt, +st: sty) -> t { mk_t_with_id(cx, st, None) } fn mk_t_with_id(cx: ctxt, +st: sty, o_def_id: Option<ast::def_id>) -> t { let key = intern_key { sty: to_unsafe_ptr(&st), o_def_id: o_def_id }; match cx.interner.find(&key) { - Some(t) => unsafe { return cast::reinterpret_cast(&t); }, + Some(&t) => unsafe { return cast::reinterpret_cast(&t); }, _ => () } @@ -1161,7 +1158,7 @@ pub fn default_arg_mode_for_ty(tcx: ctxt, ty: ty::t) -> ast::rmode { // with id `id`. pub fn encl_region(cx: ctxt, id: ast::node_id) -> ty::Region { match cx.region_map.find(&id) { - Some(encl_scope) => ty::re_scope(encl_scope), + Some(&encl_scope) => ty::re_scope(encl_scope), None => ty::re_static } } @@ -1622,25 +1619,24 @@ pub fn type_needs_drop(cx: ctxt, ty: t) -> bool { // cleanups. pub fn type_needs_unwind_cleanup(cx: ctxt, ty: t) -> bool { match cx.needs_unwind_cleanup_cache.find(&ty) { - Some(result) => return result, + Some(&result) => return result, None => () } - let tycache = new_ty_hash(); + let mut tycache = LinearSet::new(); let needs_unwind_cleanup = - type_needs_unwind_cleanup_(cx, ty, tycache, false); + type_needs_unwind_cleanup_(cx, ty, &mut tycache, false); cx.needs_unwind_cleanup_cache.insert(ty, needs_unwind_cleanup); return needs_unwind_cleanup; } fn type_needs_unwind_cleanup_(cx: ctxt, ty: t, - tycache: oldmap::HashMap<t, ()>, + tycache: &mut LinearSet<t>, encountered_box: bool) -> bool { // Prevent infinite recursion - match tycache.find(&ty) { - Some(_) => return false, - None => { tycache.insert(ty, ()); } + if !tycache.insert(ty) { + return false; } let mut encountered_box = encountered_box; @@ -2016,7 +2012,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { fail_unless!(p.def_id.crate == ast::local_crate); param_bounds_to_contents( - cx, cx.ty_param_bounds.get(&p.def_id.node)) + cx, *cx.ty_param_bounds.get(&p.def_id.node)) } ty_self(_) => { @@ -2711,10 +2707,6 @@ impl to_bytes::IterBytes for sty { } } -pub fn br_hashmap<V:Copy>() -> HashMap<bound_region, V> { - oldmap::HashMap() -} - pub fn node_id_to_type(cx: ctxt, id: ast::node_id) -> t { //io::println(fmt!("%?/%?", id, cx.node_types.len())); match cx.node_types.find(&(id as uint)) { @@ -2729,7 +2721,7 @@ pub fn node_id_to_type(cx: ctxt, id: ast::node_id) -> t { pub fn node_id_to_type_params(cx: ctxt, id: ast::node_id) -> ~[t] { match cx.node_type_substs.find(&id) { None => return ~[], - Some(ts) => return ts + Some(ts) => return /*bad*/ copy *ts } } @@ -2882,7 +2874,7 @@ pub fn expr_ty_adjusted(cx: ctxt, expr: @ast::expr) -> t { return match cx.adjustments.find(&expr.id) { None => unadjusted_ty, - Some(@AutoAddEnv(r, s)) => { + Some(&@AutoAddEnv(r, s)) => { match ty::get(unadjusted_ty).sty { ty::ty_bare_fn(ref b) => { ty::mk_closure( @@ -2900,7 +2892,7 @@ pub fn expr_ty_adjusted(cx: ctxt, expr: @ast::expr) -> t { } } - Some(@AutoDerefRef(ref adj)) => { + Some(&@AutoDerefRef(ref adj)) => { let mut adjusted_ty = unadjusted_ty; for uint::range(0, adj.autoderefs) |i| { @@ -3037,7 +3029,7 @@ pub fn method_call_bounds(tcx: ctxt, method_map: typeck::method_map, pub fn resolve_expr(tcx: ctxt, expr: @ast::expr) -> ast::def { match tcx.def_map.find(&expr.id) { - Some(def) => def, + Some(&def) => def, None => { tcx.sess.span_bug(expr.span, fmt!( "No def-map entry for expr %?", expr.id)); @@ -3270,19 +3262,20 @@ pub fn occurs_check(tcx: ctxt, sp: span, vid: TyVid, rt: t) { // Maintains a little union-set tree for inferred modes. `canon()` returns // the current head value for `m0`. -fn canon<T:Copy + cmp::Eq>(tbl: HashMap<ast::node_id, ast::inferable<T>>, +fn canon<T:Copy + cmp::Eq>(tbl: &mut LinearMap<ast::node_id, ast::inferable<T>>, +m0: ast::inferable<T>) -> ast::inferable<T> { match m0 { - ast::infer(id) => match tbl.find(&id) { - None => m0, - Some(ref m1) => { - let cm1 = canon(tbl, (*m1)); + ast::infer(id) => { + let m1 = match tbl.find(&id) { + None => return m0, + Some(&m1) => m1 + }; + let cm1 = canon(tbl, m1); // path compression: - if cm1 != (*m1) { tbl.insert(id, cm1); } + if cm1 != m1 { tbl.insert(id, cm1); } cm1 - } - }, - _ => m0 + }, + _ => m0 } } @@ -3545,7 +3538,7 @@ pub fn store_trait_methods(cx: ctxt, id: ast::node_id, ms: @~[method]) { pub fn provided_trait_methods(cx: ctxt, id: ast::def_id) -> ~[ast::ident] { if is_local(id) { match cx.items.find(&id.node) { - Some(ast_map::node_item(@ast::item { + Some(&ast_map::node_item(@ast::item { node: item_trait(_, _, ref ms), _ }, _)) => @@ -3565,7 +3558,7 @@ pub fn trait_supertraits(cx: ctxt, -> @~[InstantiatedTraitRef] { // Check the cache. match cx.supertraits.find(&id) { - Some(instantiated_trait_info) => { return instantiated_trait_info; } + Some(&instantiated_trait_info) => { return instantiated_trait_info; } None => {} // Continue. } @@ -3598,7 +3591,7 @@ pub fn trait_supertraits(cx: ctxt, pub fn trait_methods(cx: ctxt, id: ast::def_id) -> @~[method] { match cx.trait_method_cache.find(&id) { // Local traits are supposed to have been added explicitly. - Some(ms) => ms, + Some(&ms) => ms, _ => { // If the lookup in trait_method_cache fails, assume that the trait // method we're trying to look up is in a different crate, and look @@ -3634,7 +3627,7 @@ pub fn impl_traits(cx: ctxt, id: ast::def_id, store: TraitStore) -> ~[t] { if id.crate == ast::local_crate { debug!("(impl_traits) searching for trait impl %?", id); match cx.items.find(&id.node) { - Some(ast_map::node_item(@ast::item { + Some(&ast_map::node_item(@ast::item { node: ast::item_impl(_, opt_trait, _, _), _}, _)) => { @@ -3670,7 +3663,7 @@ fn struct_ctor_id(cx: ctxt, struct_did: ast::def_id) -> Option<ast::def_id> { } match cx.items.find(&struct_did.node) { - Some(ast_map::node_item(item, _)) => { + Some(&ast_map::node_item(item, _)) => { match item.node { ast::item_struct(struct_def, _) => { struct_def.ctor_id.map(|ctor_id| @@ -3736,13 +3729,13 @@ pub impl DtorKind { Otherwise return none. */ pub fn ty_dtor(cx: ctxt, struct_id: def_id) -> DtorKind { match cx.destructor_for_type.find(&struct_id) { - Some(method_def_id) => return TraitDtor(method_def_id), + Some(&method_def_id) => return TraitDtor(method_def_id), None => {} // Continue. } if is_local(struct_id) { match cx.items.find(&struct_id.node) { - Some(ast_map::node_item(@ast::item { + Some(&ast_map::node_item(@ast::item { node: ast::item_struct(@ast::struct_def { dtor: Some(ref dtor), _ }, _), @@ -3769,8 +3762,12 @@ pub fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path { if id.crate != ast::local_crate { csearch::get_item_path(cx, id) } else { - let node = cx.items.get(&id.node); - match node { + // FIXME (#5521): uncomment this code and don't have a catch-all at the + // end of the match statement. Favor explicitly listing + // each variant. + // let node = cx.items.get(&id.node); + // match *node { + match *cx.items.get(&id.node) { ast_map::node_item(item, path) => { let item_elt = match item.node { item_mod(_) | item_foreign_mod(_) => { @@ -3812,9 +3809,7 @@ pub fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path { vec::append_one(/*bad*/copy *path, ast_map::path_name(item.ident)) } - ast_map::node_stmt(*) | ast_map::node_expr(*) | - ast_map::node_arg(*) | ast_map::node_local(*) | - ast_map::node_block(*) => { + ref node => { cx.sess.bug(fmt!("cannot find item_path for node %?", node)); } } @@ -3834,7 +3829,7 @@ pub fn type_is_empty(cx: ctxt, t: t) -> bool { pub fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[VariantInfo] { match cx.enum_var_cache.find(&id) { - Some(variants) => return variants, + Some(&variants) => return variants, _ => { /* fallthrough */ } } @@ -3846,7 +3841,7 @@ pub fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[VariantInfo] { call eval_const_expr, it should never get called twice for the same expr, since check_enum_variants also updates the enum_var_cache */ - match cx.items.get(&id.node) { + match *cx.items.get(&id.node) { ast_map::node_item(@ast::item { node: ast::item_enum(ref enum_definition, _), _ @@ -3920,7 +3915,7 @@ pub fn lookup_item_type(cx: ctxt, did: ast::def_id) -> ty_param_bounds_and_ty { match cx.tcache.find(&did) { - Some(tpt) => { + Some(&tpt) => { // The item is in this crate. The caller should have added it to the // type cache already return tpt; @@ -3962,7 +3957,7 @@ pub fn lookup_field_type(tcx: ctxt, pub fn lookup_struct_fields(cx: ctxt, did: ast::def_id) -> ~[field_ty] { if did.crate == ast::local_crate { match cx.items.find(&did.node) { - Some(ast_map::node_item(i,_)) => { + Some(&ast_map::node_item(i,_)) => { match i.node { ast::item_struct(struct_def, _) => { struct_field_tys(struct_def.fields) @@ -3970,7 +3965,7 @@ pub fn lookup_struct_fields(cx: ctxt, did: ast::def_id) -> ~[field_ty] { _ => cx.sess.bug(~"struct ID bound to non-struct") } } - Some(ast_map::node_variant(ref variant, _, _)) => { + Some(&ast_map::node_variant(ref variant, _, _)) => { match (*variant).node.kind { ast::struct_variant_kind(struct_def) => { struct_field_tys(struct_def.fields) @@ -4168,7 +4163,7 @@ pub fn normalize_ty(cx: ctxt, t: t) -> t { } match cx.normalized_cache.find(&t) { - Some(t) => return t, + Some(&t) => return t, None => () } @@ -4299,7 +4294,7 @@ pub fn iter_bound_traits_and_supertraits(tcx: ctxt, } }; - let mut supertrait_map = HashMap(); + let mut supertrait_map = LinearMap::new(); let mut seen_def_ids = ~[]; let mut i = 0; let trait_ty_id = ty_to_def_id(bound_trait_ty).expect( diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 5d69ab5766d..4f8f600485e 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -60,7 +60,6 @@ use middle::ty::{ty_param_substs_and_ty}; use middle::ty; use middle::typeck::rscope::{in_binding_rscope}; use middle::typeck::rscope::{region_scope, type_rscope, RegionError}; -use middle::typeck::{CrateCtxt}; use core::result; use core::vec; @@ -236,11 +235,11 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>( } ast::ty_path(path, id) if a_seq_ty.mutbl == ast::m_imm => { match tcx.def_map.find(&id) { - Some(ast::def_prim_ty(ast::ty_str)) => { + Some(&ast::def_prim_ty(ast::ty_str)) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); return ty::mk_estr(tcx, vst); } - Some(ast::def_ty(type_def_id)) => { + Some(&ast::def_ty(type_def_id)) => { let result = ast_path_to_substs_and_ty( self, rscope, type_def_id, path); @@ -304,8 +303,8 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>( let tcx = self.tcx(); match tcx.ast_ty_to_ty_cache.find(&ast_ty.id) { - Some(ty::atttce_resolved(ty)) => return ty, - Some(ty::atttce_unresolved) => { + Some(&ty::atttce_resolved(ty)) => return ty, + Some(&ty::atttce_unresolved) => { tcx.sess.span_fatal(ast_ty.span, ~"illegal recursive type; \ insert an enum in the cycle, \ if this is desired"); @@ -360,7 +359,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>( None => tcx.sess.span_fatal( ast_ty.span, fmt!("unbound path %s", path_to_str(path, tcx.sess.intr()))), - Some(d) => d + Some(&d) => d }; match a_def { ast::def_ty(did) | ast::def_struct(did) => { diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs index 4ffcd440bcf..cc2cf7a23c5 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -18,8 +18,8 @@ use middle::typeck::check::{instantiate_path, lookup_def}; use middle::typeck::check::{structure_of, valid_range_bounds}; use middle::typeck::require_same_types; +use core::hashmap::linear::{LinearMap, LinearSet}; use core::vec; -use std::oldmap::HashMap; use syntax::ast; use syntax::ast_util; use syntax::codemap::span; @@ -228,7 +228,7 @@ pub fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path, /// `class_fields` describes the type of each field of the struct. /// `class_id` is the ID of the struct. /// `substitutions` are the type substitutions applied to this struct type -/// (e.g. K,V in HashMap<K,V>). +/// (e.g. K,V in LinearMap<K,V>). /// `etc` is true if the pattern said '...' and false otherwise. pub fn check_struct_pat_fields(pcx: pat_ctxt, span: span, @@ -241,23 +241,23 @@ pub fn check_struct_pat_fields(pcx: pat_ctxt, let tcx = pcx.fcx.ccx.tcx; // Index the class fields. - let field_map = HashMap(); + let mut field_map = LinearMap::new(); for class_fields.eachi |i, class_field| { field_map.insert(class_field.ident, i); } // Typecheck each field. - let found_fields = HashMap(); + let mut found_fields = LinearSet::new(); for fields.each |field| { match field_map.find(&field.ident) { - Some(index) => { + Some(&index) => { let class_field = class_fields[index]; let field_type = ty::lookup_field_type(tcx, class_id, class_field.id, substitutions); check_pat(pcx, field.pat, field_type); - found_fields.insert(index, ()); + found_fields.insert(index); } None => { let name = pprust::path_to_str(path, tcx.sess.intr()); @@ -272,7 +272,7 @@ pub fn check_struct_pat_fields(pcx: pat_ctxt, // Report an error if not all the fields were specified. if !etc { for class_fields.eachi |i, field| { - if found_fields.contains_key(&i) { + if found_fields.contains(&i) { loop; } tcx.sess.span_err(span, @@ -293,11 +293,11 @@ pub fn check_struct_pat(pcx: pat_ctxt, pat_id: ast::node_id, span: span, // Check to ensure that the struct is the one specified. match tcx.def_map.find(&pat_id) { - Some(ast::def_struct(supplied_def_id)) + Some(&ast::def_struct(supplied_def_id)) if supplied_def_id == class_id => { // OK. } - Some(ast::def_struct(*)) | Some(ast::def_variant(*)) => { + Some(&ast::def_struct(*)) | Some(&ast::def_variant(*)) => { let name = pprust::path_to_str(path, tcx.sess.intr()); tcx.sess.span_err(span, fmt!("mismatched types: expected `%s` but \ @@ -334,7 +334,7 @@ pub fn check_struct_like_enum_variant_pat(pcx: pat_ctxt, // Find the variant that was specified. match tcx.def_map.find(&pat_id) { - Some(ast::def_variant(found_enum_id, variant_id)) + Some(&ast::def_variant(found_enum_id, variant_id)) if found_enum_id == enum_id => { // Get the struct fields from this struct-like enum variant. let class_fields = ty::lookup_struct_fields(tcx, variant_id); @@ -342,7 +342,7 @@ pub fn check_struct_like_enum_variant_pat(pcx: pat_ctxt, check_struct_pat_fields(pcx, span, path, fields, class_fields, variant_id, substitutions, etc); } - Some(ast::def_struct(*)) | Some(ast::def_variant(*)) => { + Some(&ast::def_struct(*)) | Some(&ast::def_variant(*)) => { let name = pprust::path_to_str(path, tcx.sess.intr()); tcx.sess.span_err(span, fmt!("mismatched types: expected `%s` but \ @@ -394,7 +394,7 @@ pub fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { } ast::pat_enum(*) | ast::pat_ident(*) if pat_is_const(tcx.def_map, pat) => { - let const_did = ast_util::def_id_of_def(tcx.def_map.get(&pat.id)); + let const_did = ast_util::def_id_of_def(*tcx.def_map.get(&pat.id)); let const_tpt = ty::lookup_item_type(tcx, const_did); demand::suptype(fcx, pat.span, expected, const_tpt.ty); fcx.write_ty(pat.id, const_tpt.ty); @@ -421,7 +421,7 @@ pub fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) { } } - let canon_id = pcx.map.get(&ast_util::path_to_ident(name)); + let canon_id = *pcx.map.get(&ast_util::path_to_ident(name)); if canon_id != pat.id { let ct = fcx.local_ty(pat.span, canon_id); demand::eqtype(fcx, pat.span, ct, typ); diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index c550e5c71e4..fcaf1c08342 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -95,10 +95,10 @@ use middle::typeck::{method_self, method_static, method_trait, method_super}; use util::common::indenter; use util::ppaux::expr_repr; +use core::hashmap::linear::LinearSet; use core::result; use core::uint; use core::vec; -use std::oldmap::HashMap; use syntax::ast::{def_id, sty_by_ref, sty_value, sty_region, sty_box}; use syntax::ast::{sty_uniq, sty_static, node_id, by_copy, by_ref}; use syntax::ast::{m_const, m_mutbl, m_imm}; @@ -131,6 +131,7 @@ pub fn lookup( check_traits: CheckTraitsFlag, // Whether we check traits only. autoderef_receiver: AutoderefReceiverFlag) -> Option<method_map_entry> { + let mut impl_dups = LinearSet::new(); let lcx = LookupContext { fcx: fcx, expr: expr, @@ -138,7 +139,7 @@ pub fn lookup( callee_id: callee_id, m_name: m_name, supplied_tps: supplied_tps, - impl_dups: HashMap(), + impl_dups: &mut impl_dups, inherent_candidates: @mut ~[], extension_candidates: @mut ~[], deref_args: deref_args, @@ -158,7 +159,7 @@ pub struct LookupContext { callee_id: node_id, m_name: ast::ident, supplied_tps: &'self [ty::t], - impl_dups: HashMap<def_id, ()>, + impl_dups: &'self mut LinearSet<def_id>, inherent_candidates: @mut ~[Candidate], extension_candidates: @mut ~[Candidate], deref_args: check::DerefArgs, @@ -344,8 +345,8 @@ pub impl<'self> LookupContext<'self> { // If the method being called is associated with a trait, then // find all the impls of that trait. Each of those are // candidates. - let opt_applicable_traits = self.fcx.ccx.trait_map.find( - &self.expr.id); + let trait_map: &mut resolve::TraitMap = &mut self.fcx.ccx.trait_map; + let opt_applicable_traits = trait_map.find(&self.expr.id); for opt_applicable_traits.each |applicable_traits| { for applicable_traits.each |trait_did| { let coherence_info = self.fcx.ccx.coherence_info; @@ -362,7 +363,7 @@ pub impl<'self> LookupContext<'self> { // Look for default methods. match self.tcx().provided_methods.find(trait_did) { - Some(methods) => { + Some(&methods) => { self.push_candidates_from_provided_methods( self.extension_candidates, self_ty, *trait_did, methods); @@ -384,7 +385,7 @@ pub impl<'self> LookupContext<'self> { let mut next_bound_idx = 0; // count only trait bounds let bounds = tcx.ty_param_bounds.get(¶m_ty.def_id.node); - for vec::each(*bounds) |bound| { + for bounds.each |bound| { let bound_trait_ty = match *bound { ty::bound_trait(bound_t) => bound_t, @@ -639,7 +640,7 @@ pub impl<'self> LookupContext<'self> { fn push_candidates_from_impl(&self, candidates: &mut ~[Candidate], impl_info: &resolve::Impl) { - if !self.impl_dups.insert(impl_info.did, ()) { + if !self.impl_dups.insert(impl_info.did) { return; // already visited } @@ -1195,7 +1196,7 @@ pub impl<'self> LookupContext<'self> { match candidate.origin { method_static(method_id) | method_self(method_id, _) | method_super(method_id, _) => { - bad = self.tcx().destructors.contains_key(&method_id); + bad = self.tcx().destructors.contains(&method_id); } method_param(method_param { trait_id: trait_id, _ }) | method_trait(trait_id, _, _) => { @@ -1256,7 +1257,7 @@ pub impl<'self> LookupContext<'self> { fn report_static_candidate(&self, idx: uint, did: def_id) { let span = if did.crate == ast::local_crate { match self.tcx().items.find(&did.node) { - Some(ast_map::node_method(m, _, _)) => m.span, + Some(&ast_map::node_method(m, _, _)) => m.span, _ => fail!(fmt!("report_static_candidate: bad item %?", did)) } } else { diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index e216f9266e9..005b5377b62 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -112,6 +112,7 @@ use util::ppaux::{bound_region_to_str, expr_repr, pat_repr}; use util::ppaux; use core::either; +use core::hashmap::linear::LinearMap; use core::option; use core::ptr; use core::result::{Result, Ok, Err}; @@ -119,8 +120,6 @@ use core::result; use core::str; use core::vec; use std::list::Nil; -use std::oldmap::HashMap; -use std::oldmap; use syntax::ast::{provided, required, ty_i}; use syntax::ast; use syntax::ast_map; @@ -160,12 +159,12 @@ pub struct SelfInfo { /// share the inherited fields. pub struct inherited { infcx: @mut infer::InferCtxt, - locals: HashMap<ast::node_id, ty::t>, + locals: @mut LinearMap<ast::node_id, ty::t>, // Temporary tables: - node_types: HashMap<ast::node_id, ty::t>, - node_type_substs: HashMap<ast::node_id, ty::substs>, - adjustments: HashMap<ast::node_id, @ty::AutoAdjustment>, + node_types: @mut LinearMap<ast::node_id, ty::t>, + node_type_substs: @mut LinearMap<ast::node_id, ty::substs>, + adjustments: @mut LinearMap<ast::node_id, @ty::AutoAdjustment>, method_map: method_map, vtable_map: vtable_map, } @@ -222,12 +221,12 @@ pub struct FnCtxt { pub fn blank_inherited(ccx: @mut CrateCtxt) -> @inherited { @inherited { infcx: infer::new_infer_ctxt(ccx.tcx), - locals: HashMap(), - node_types: oldmap::HashMap(), - node_type_substs: oldmap::HashMap(), - adjustments: oldmap::HashMap(), - method_map: oldmap::HashMap(), - vtable_map: oldmap::HashMap(), + locals: @mut LinearMap::new(), + node_types: @mut LinearMap::new(), + node_type_substs: @mut LinearMap::new(), + adjustments: @mut LinearMap::new(), + method_map: @mut LinearMap::new(), + vtable_map: @mut LinearMap::new(), } } @@ -399,7 +398,7 @@ pub fn check_fn(ccx: @mut CrateCtxt, assign(self_info.self_id, Some(self_info.self_ty)); debug!("self is assigned to %s", fcx.infcx().ty_to_str( - fcx.inh.locals.get(&self_info.self_id))); + *fcx.inh.locals.get(&self_info.self_id))); } // Add formal parameters. @@ -432,7 +431,7 @@ pub fn check_fn(ccx: @mut CrateCtxt, debug!("Local variable %s is assigned type %s", fcx.pat_to_str(local.node.pat), fcx.infcx().ty_to_str( - fcx.inh.locals.get(&local.node.id))); + *fcx.inh.locals.get(&local.node.id))); visit::visit_local(local, e, v); }; @@ -445,7 +444,7 @@ pub fn check_fn(ccx: @mut CrateCtxt, debug!("Pattern binding %s is assigned to %s", *tcx.sess.str_of(path.idents[0]), fcx.infcx().ty_to_str( - fcx.inh.locals.get(&p.id))); + *fcx.inh.locals.get(&p.id))); } _ => {} } @@ -506,11 +505,12 @@ pub fn check_method(ccx: @mut CrateCtxt, pub fn check_no_duplicate_fields(tcx: ty::ctxt, fields: ~[(ast::ident, span)]) { - let field_names = HashMap(); + let mut field_names = LinearMap::new(); for fields.each |p| { let (id, sp) = *p; - match field_names.find(&id) { + let orig_sp = field_names.find(&id).map_consume(|x| *x); + match orig_sp { Some(orig_sp) => { tcx.sess.span_err(sp, fmt!("Duplicate field \ name %s in record type declaration", @@ -572,7 +572,7 @@ pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) { check_bare_fn(ccx, decl, body, it.id, None); } ast::item_impl(_, _, ty, ref ms) => { - let rp = ccx.tcx.region_paramd_items.find(&it.id); + let rp = ccx.tcx.region_paramd_items.find(&it.id).map_consume(|x| *x); debug!("item_impl %s with id %d rp %?", *ccx.tcx.sess.str_of(it.ident), it.id, rp); let self_ty = ccx.to_ty(&rscope::type_rscope(rp), ty); @@ -679,7 +679,7 @@ pub impl FnCtxt { fn local_ty(&self, span: span, nid: ast::node_id) -> ty::t { match self.inh.locals.find(&nid) { - Some(t) => t, + Some(&t) => t, None => { self.tcx().sess.span_bug( span, @@ -766,7 +766,7 @@ pub impl FnCtxt { fn expr_ty(&self, ex: @ast::expr) -> ty::t { match self.inh.node_types.find(&ex.id) { - Some(t) => t, + Some(&t) => t, None => { self.tcx().sess.bug( fmt!("no type for %s in fcx %s", @@ -776,7 +776,7 @@ pub impl FnCtxt { } fn node_ty(&self, id: ast::node_id) -> ty::t { match self.inh.node_types.find(&id) { - Some(t) => t, + Some(&t) => t, None => { self.tcx().sess.bug( fmt!("no type for node %d: %s in fcx %s", @@ -789,7 +789,7 @@ pub impl FnCtxt { } fn node_ty_substs(&self, id: ast::node_id) -> ty::substs { match self.inh.node_type_substs.find(&id) { - Some(ref ts) => (/*bad*/copy *ts), + Some(ts) => (/*bad*/copy *ts), None => { self.tcx().sess.bug( fmt!("no type substs for node %d: %s in fcx %s", @@ -800,10 +800,14 @@ pub impl FnCtxt { } } } - fn opt_node_ty_substs(&self, id: ast::node_id) -> Option<ty::substs> { - self.inh.node_type_substs.find(&id) - } + fn opt_node_ty_substs(&self, id: ast::node_id, + f: &fn(&ty::substs) -> bool) { + match self.inh.node_type_substs.find(&id) { + Some(s) => { f(s); } + None => () + } + } fn mk_subty(&self, a_is_expected: bool, @@ -1059,9 +1063,10 @@ pub fn impl_self_ty(vcx: &VtableContext, let tcx = vcx.tcx(); let (n_tps, region_param, raw_ty) = if did.crate == ast::local_crate { - let region_param = tcx.region_paramd_items.find(&did.node); + let region_param = tcx.region_paramd_items.find(&did.node). + map_consume(|x| *x); match tcx.items.find(&did.node) { - Some(ast_map::node_item(@ast::item { + Some(&ast_map::node_item(@ast::item { node: ast::item_impl(ref ts, _, st, _), _ }, _)) => { @@ -1069,7 +1074,7 @@ pub fn impl_self_ty(vcx: &VtableContext, region_param, vcx.ccx.to_ty(&rscope::type_rscope(region_param), st)) } - Some(ast_map::node_item(@ast::item { + Some(&ast_map::node_item(@ast::item { node: ast::item_struct(_, ref ts), id: class_id, _ @@ -1328,7 +1333,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, sugar: ast::CallSugar) { // Index expressions need to be handled separately, to inform them // that they appear in call position. - let mut bot = check_expr(fcx, f); + let mut _bot = check_expr(fcx, f); check_call_or_method(fcx, sp, call_expr_id, @@ -1769,7 +1774,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, check_completeness: bool) { let tcx = fcx.ccx.tcx; - let class_field_map = HashMap(); + let mut class_field_map = LinearMap::new(); let mut fields_found = 0; for field_types.each |field| { // XXX: Check visibility here. @@ -1782,7 +1787,9 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, for ast_fields.each |field| { let mut expected_field_type = ty::mk_err(tcx); - match class_field_map.find(&field.node.ident) { + let pair = class_field_map.find(&field.node.ident). + map_consume(|x| *x); + match pair { None => { tcx.sess.span_err( field.span, @@ -1825,7 +1832,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, let mut missing_fields = ~[]; for field_types.each |class_field| { let name = class_field.ident; - let (_, seen) = class_field_map.get(&name); + let (_, seen) = *class_field_map.get(&name); if !seen { missing_fields.push( ~"`" + *tcx.sess.str_of(name) + ~"`"); @@ -1862,9 +1869,10 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, let type_parameter_count, region_parameterized, raw_type; if class_id.crate == ast::local_crate { region_parameterized = - tcx.region_paramd_items.find(&class_id.node); + tcx.region_paramd_items.find(&class_id.node). + map_consume(|x| *x); match tcx.items.find(&class_id.node) { - Some(ast_map::node_item(@ast::item { + Some(&ast_map::node_item(@ast::item { node: ast::item_struct(_, ref generics), _ }, _)) => { @@ -1950,9 +1958,9 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, let type_parameter_count, region_parameterized, raw_type; if enum_id.crate == ast::local_crate { region_parameterized = - tcx.region_paramd_items.find(&enum_id.node); + tcx.region_paramd_items.find(&enum_id.node).map_consume(|x| *x); match tcx.items.find(&enum_id.node) { - Some(ast_map::node_item(@ast::item { + Some(&ast_map::node_item(@ast::item { node: ast::item_enum(_, ref generics), _ }, _)) => { @@ -2730,11 +2738,11 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, ast::expr_struct(path, ref fields, base_expr) => { // Resolve the path. match tcx.def_map.find(&id) { - Some(ast::def_struct(type_def_id)) => { + Some(&ast::def_struct(type_def_id)) => { check_struct_constructor(fcx, id, expr.span, type_def_id, *fields, base_expr); } - Some(ast::def_variant(enum_id, variant_id)) => { + Some(&ast::def_variant(enum_id, variant_id)) => { check_struct_enum_variant(fcx, id, expr.span, enum_id, variant_id, *fields); } @@ -2834,7 +2842,7 @@ pub fn check_decl_local(fcx: @mut FnCtxt, local: @ast::local) { } let region = - ty::re_scope(tcx.region_map.get(&local.node.id)); + ty::re_scope(*tcx.region_map.get(&local.node.id)); let pcx = pat_ctxt { fcx: fcx, map: pat_id_map(tcx.def_map, local.node.pat), @@ -3350,7 +3358,7 @@ pub fn may_break(cx: ty::ctxt, id: ast::node_id, b: &ast::blk) -> bool { match e.node { ast::expr_break(Some(_)) => match cx.def_map.find(&e.id) { - Some(ast::def_label(loop_id)) if id == loop_id => true, + Some(&ast::def_label(loop_id)) if id == loop_id => true, _ => false, }, _ => false @@ -3445,8 +3453,8 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) { let ty_visitor_name = tcx.sess.ident_of(~"TyVisitor"); fail_unless!(tcx.intrinsic_defs.contains_key(&tydesc_name)); fail_unless!(ccx.tcx.intrinsic_defs.contains_key(&ty_visitor_name)); - let (_, tydesc_ty) = tcx.intrinsic_defs.get(&tydesc_name); - let (_, visitor_trait) = tcx.intrinsic_defs.get(&ty_visitor_name); + let (_, tydesc_ty) = *tcx.intrinsic_defs.get(&tydesc_name); + let (_, visitor_trait) = *tcx.intrinsic_defs.get(&ty_visitor_name); let visitor_trait = match ty::get(visitor_trait).sty { ty::ty_trait(trait_def_id, ref trait_substs, _) => { diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index fa0d9e81c2d..02102110d9b 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -180,7 +180,7 @@ pub fn visit_block(b: &ast::blk, &&rcx: @mut Rcx, v: rvt) { pub fn visit_expr(expr: @ast::expr, &&rcx: @mut Rcx, v: rvt) { debug!("visit_expr(e=%s)", rcx.fcx.expr_to_str(expr)); - for rcx.fcx.inh.adjustments.find(&expr.id).each |adjustment| { + for rcx.fcx.inh.adjustments.find(&expr.id).each |&adjustment| { match *adjustment { @ty::AutoDerefRef( ty::AutoDerefRef { @@ -331,7 +331,7 @@ pub fn constrain_auto_ref(rcx: @mut Rcx, expr: @ast::expr) { let adjustment = rcx.fcx.inh.adjustments.find(&expr.id); let region = match adjustment { - Some(@ty::AutoDerefRef( + Some(&@ty::AutoDerefRef( ty::AutoDerefRef { autoref: Some(ref auto_ref), _})) => { auto_ref.region @@ -727,7 +727,7 @@ pub mod guarantor { debug!("before adjustments, cat=%?", expr_ct.cat); match rcx.fcx.inh.adjustments.find(&expr.id) { - Some(@ty::AutoAddEnv(*)) => { + Some(&@ty::AutoAddEnv(*)) => { // This is basically an rvalue, not a pointer, no regions // involved. expr_ct.cat = ExprCategorization { @@ -736,7 +736,7 @@ pub mod guarantor { }; } - Some(@ty::AutoDerefRef(ref adjustment)) => { + Some(&@ty::AutoDerefRef(ref adjustment)) => { debug!("adjustment=%?", adjustment); expr_ct = apply_autoderefs( diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs index 6dfe34191d3..8146213d3be 100644 --- a/src/librustc/middle/typeck/check/vtable.rs +++ b/src/librustc/middle/typeck/check/vtable.rs @@ -192,7 +192,7 @@ pub fn lookup_vtable(vcx: &VtableContext, match ty::get(ty).sty { ty::ty_param(param_ty {idx: n, def_id: did}) => { let mut n_bound = 0; - let bounds = tcx.ty_param_bounds.get(&did.node); + let bounds = *tcx.ty_param_bounds.get(&did.node); for ty::iter_bound_traits_and_supertraits( tcx, bounds) |ity| { debug!("checking bounds trait %?", @@ -511,9 +511,8 @@ pub fn early_resolve_expr(ex: @ast::expr, let cx = fcx.ccx; match ex.node { ast::expr_path(*) => { - match fcx.opt_node_ty_substs(ex.id) { - Some(ref substs) => { - let def = cx.tcx.def_map.get(&ex.id); + for fcx.opt_node_ty_substs(ex.id) |substs| { + let def = *cx.tcx.def_map.get(&ex.id); let did = ast_util::def_id_of_def(def); let item_ty = ty::lookup_item_type(cx.tcx, did); debug!("early resolve expr: def %? %?, %?, %?", ex.id, did, def, @@ -531,8 +530,6 @@ pub fn early_resolve_expr(ex: @ast::expr, insert_vtables(fcx, ex.id, vtbls); } } - } - _ => () } } diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index 53b0275f95d..9ba98a4d27f 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -66,7 +66,7 @@ fn resolve_method_map_entry(fcx: @mut FnCtxt, sp: span, id: ast::node_id) { // Resolve any method map entry match fcx.inh.method_map.find(&id) { None => {} - Some(ref mme) => { + Some(mme) => { for resolve_type_vars_in_type(fcx, sp, mme.self_arg.ty).each |t| { let method_map = fcx.ccx.method_map; let new_entry = method_map_entry { @@ -119,7 +119,7 @@ fn resolve_type_vars_for_node(wbcx: @mut WbCtxt, sp: span, id: ast::node_id) match fcx.inh.adjustments.find(&id) { None => (), - Some(@ty::AutoAddEnv(r, s)) => { + Some(&@ty::AutoAddEnv(r, s)) => { match resolve_region(fcx.infcx(), r, resolve_all | force_all) { Err(e) => { // This should not, I think, happen: @@ -135,7 +135,7 @@ fn resolve_type_vars_for_node(wbcx: @mut WbCtxt, sp: span, id: ast::node_id) } } - Some(@ty::AutoDerefRef(adj)) => { + Some(&@ty::AutoDerefRef(adj)) => { let resolved_autoref = match adj.autoref { Some(ref autoref) => { match resolve_region(fcx.infcx(), autoref.region, @@ -176,18 +176,15 @@ fn resolve_type_vars_for_node(wbcx: @mut WbCtxt, sp: span, id: ast::node_id) debug!("resolve_type_vars_for_node(id=%d, n_ty=%s, t=%s)", id, ppaux::ty_to_str(tcx, n_ty), ppaux::ty_to_str(tcx, t)); write_ty_to_tcx(tcx, id, t); - match fcx.opt_node_ty_substs(id) { - Some(ref substs) => { - let mut new_tps = ~[]; - for (*substs).tps.each |subst| { - match resolve_type_vars_in_type(fcx, sp, *subst) { - Some(t) => new_tps.push(t), - None => { wbcx.success = false; return None; } - } - } - write_substs_to_tcx(tcx, id, new_tps); + for fcx.opt_node_ty_substs(id) |substs| { + let mut new_tps = ~[]; + for substs.tps.each |subst| { + match resolve_type_vars_in_type(fcx, sp, *subst) { + Some(t) => new_tps.push(t), + None => { wbcx.success = false; return None; } + } } - None => () + write_substs_to_tcx(tcx, id, new_tps); } return Some(t); } diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index 0b3eca7c07d..7e97edf8f8a 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -58,7 +58,6 @@ use util::ppaux::ty_to_str; use core::result::Ok; use core::hashmap::linear::{LinearMap, LinearSet}; use core::uint; -use std::oldmap::HashMap; pub struct UniversalQuantificationResult { monotype: t, @@ -187,7 +186,7 @@ pub fn CoherenceChecker(crate_context: @mut CrateCtxt) -> CoherenceChecker { crate_context: crate_context, inference_context: new_infer_ctxt(crate_context.tcx), - base_type_def_ids: HashMap() + base_type_def_ids: @mut LinearMap::new(), } } @@ -198,7 +197,7 @@ pub struct CoherenceChecker { // A mapping from implementations to the corresponding base type // definition ID. - base_type_def_ids: HashMap<def_id,def_id>, + base_type_def_ids: @mut LinearMap<def_id,def_id>, } pub impl CoherenceChecker { @@ -475,7 +474,7 @@ pub impl CoherenceChecker { ty_to_str(self.crate_context.tcx, self_t)); match self.crate_context.tcx.trait_impls.find(&trait_t) { None => { - let m = HashMap(); + let m = @mut LinearMap::new(); m.insert(self_t, the_impl); self.crate_context.tcx.trait_impls.insert(trait_t, m); } @@ -505,14 +504,14 @@ pub impl CoherenceChecker { f: &fn(x: &ty::method) -> bool) { // Make a list of all the names of the provided methods. // XXX: This is horrible. - let provided_method_idents = HashMap(); + let mut provided_method_idents = LinearSet::new(); let tcx = self.crate_context.tcx; for ty::provided_trait_methods(tcx, trait_did).each |ident| { - provided_method_idents.insert(*ident, ()); + provided_method_idents.insert(*ident); } for ty::trait_methods(tcx, trait_did).each |method| { - if provided_method_idents.contains_key(&method.ident) { + if provided_method_idents.contains(&method.ident) { if !f(method) { break; } @@ -622,7 +621,7 @@ pub impl CoherenceChecker { fn get_self_type_for_implementation(&self, implementation: @Impl) -> ty_param_bounds_and_ty { - return self.crate_context.tcx.tcache.get(&implementation.did); + return *self.crate_context.tcx.tcache.get(&implementation.did); } // Privileged scope checking @@ -694,7 +693,7 @@ pub impl CoherenceChecker { fn trait_ref_to_trait_def_id(&self, trait_ref: @trait_ref) -> def_id { let def_map = self.crate_context.tcx.def_map; - let trait_def = def_map.get(&trait_ref.ref_id); + let trait_def = *def_map.get(&trait_ref.ref_id); let trait_id = def_id_of_def(trait_def); return trait_id; } @@ -773,7 +772,7 @@ pub impl CoherenceChecker { has no provided methods", trait_did.node); /* fall through */ } - Some(all_provided) => { + Some(&all_provided) => { debug!("(creating impl) trait with node_id `%d` \ has provided methods", trait_did.node); // Add all provided methods. @@ -802,7 +801,7 @@ pub impl CoherenceChecker { fn span_of_impl(&self, implementation: @Impl) -> span { fail_unless!(implementation.did.crate == local_crate); match self.crate_context.tcx.items.find(&implementation.did.node) { - Some(node_item(item, _)) => { + Some(&node_item(item, _)) => { return item.span; } _ => { @@ -815,7 +814,7 @@ pub impl CoherenceChecker { // External crate handling - fn add_impls_for_module(&self, impls_seen: HashMap<def_id,()>, + fn add_impls_for_module(&self, impls_seen: &mut LinearSet<def_id>, crate_store: @mut CStore, module_def_id: def_id) { let implementations = get_impls_for_mod(crate_store, @@ -828,16 +827,11 @@ pub impl CoherenceChecker { // Make sure we don't visit the same implementation // multiple times. - match impls_seen.find(&implementation.did) { - None => { - // Good. Continue. - impls_seen.insert(implementation.did, ()); - } - Some(_) => { - // Skip this one. - loop; - } + if !impls_seen.insert(implementation.did) { + // Skip this one. + loop; } + // Good. Continue. let self_type = lookup_item_type(self.crate_context.tcx, implementation.did); @@ -939,11 +933,11 @@ pub impl CoherenceChecker { // Adds implementations and traits from external crates to the coherence // info. fn add_external_crates(&self) { - let impls_seen = HashMap(); + let mut impls_seen = LinearSet::new(); let crate_store = self.crate_context.tcx.sess.cstore; do iter_crate_data(crate_store) |crate_number, _crate_metadata| { - self.add_impls_for_module(impls_seen, + self.add_impls_for_module(&mut impls_seen, crate_store, def_id { crate: crate_number, node: 0 }); @@ -951,7 +945,7 @@ pub impl CoherenceChecker { for each_path(crate_store, crate_number) |_p, def_like| { match def_like { dl_def(def_mod(def_id)) => { - self.add_impls_for_module(impls_seen, + self.add_impls_for_module(&mut impls_seen, crate_store, def_id); } @@ -1003,13 +997,13 @@ pub impl CoherenceChecker { ty::ty_struct(type_def_id, _) => { tcx.destructor_for_type.insert(type_def_id, method_def_id); - tcx.destructors.insert(method_def_id, ()); + tcx.destructors.insert(method_def_id); } _ => { // Destructors only work on nominal types. if impl_info.did.crate == ast::local_crate { match tcx.items.find(&impl_info.did.node) { - Some(ast_map::node_item(@ref item, _)) => { + Some(&ast_map::node_item(@ref item, _)) => { tcx.sess.span_err((*item).span, ~"the Drop trait may only \ be implemented on \ diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index a74ea5dff8b..a1fcf102988 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -137,10 +137,10 @@ impl AstConv for CrateCtxt { csearch::get_type(self.tcx, id) } else { match self.tcx.items.find(&id.node) { - Some(ast_map::node_item(item, _)) => { + Some(&ast_map::node_item(item, _)) => { ty_of_item(self, item) } - Some(ast_map::node_foreign_item(foreign_item, _, _, _)) => { + Some(&ast_map::node_foreign_item(foreign_item, _, _, _)) => { ty_of_foreign_item(self, foreign_item) } ref x => { @@ -280,8 +280,8 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, let tcx = ccx.tcx; - let region_paramd = tcx.region_paramd_items.find(&id); - match tcx.items.get(&id) { + let region_paramd = tcx.region_paramd_items.find(&id).map_consume(|x| *x); + match *tcx.items.get(&id) { ast_map::node_item(@ast::item { node: ast::item_trait(ref generics, _, ref ms), _ @@ -516,7 +516,7 @@ pub fn check_methods_against_trait(ccx: &CrateCtxt, // the methods within the trait with bogus results. (See issue #3903.) match tcx.items.find(&did.node) { - Some(ast_map::node_item(item, _)) => { + Some(&ast_map::node_item(item, _)) => { let tpt = ty_of_item(ccx, item); ensure_trait_methods(ccx, did.node, tpt.ty); } @@ -615,7 +615,7 @@ pub fn ensure_no_ty_param_bounds(ccx: &CrateCtxt, pub fn convert(ccx: &CrateCtxt, it: @ast::item) { let tcx = ccx.tcx; - let rp = tcx.region_paramd_items.find(&it.id); + let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x); debug!("convert: item %s with id %d rp %?", *tcx.sess.str_of(it.ident), it.id, rp); match it.node { @@ -828,10 +828,10 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: @ast::item) let def_id = local_def(it.id); let tcx = ccx.tcx; match tcx.tcache.find(&def_id) { - Some(tpt) => return tpt, + Some(&tpt) => return tpt, _ => {} } - let rp = tcx.region_paramd_items.find(&it.id); + let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x); match it.node { ast::item_const(t, _) => { let typ = ccx.to_ty(&empty_rscope, t); @@ -857,11 +857,11 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: @ast::item) } ast::item_ty(t, ref generics) => { match tcx.tcache.find(&local_def(it.id)) { - Some(tpt) => return tpt, + Some(&tpt) => return tpt, None => { } } - let rp = tcx.region_paramd_items.find(&it.id); + let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x); let tpt = { let ty = { let t0 = ccx.to_ty(&type_rscope(rp), t); @@ -991,7 +991,7 @@ pub fn ty_param_bounds(ccx: &CrateCtxt, -> @~[ty::param_bounds] { @do generics.ty_params.map_to_vec |param| { match ccx.tcx.ty_param_bounds.find(¶m.id) { - Some(bs) => bs, + Some(&bs) => bs, None => { let bounds = compute_bounds(ccx, param.bounds); ccx.tcx.ty_param_bounds.insert(param.id, bounds); diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs index f0b5ce9ff60..45c7ad2f8f8 100644 --- a/src/librustc/middle/typeck/infer/region_inference.rs +++ b/src/librustc/middle/typeck/infer/region_inference.rs @@ -549,11 +549,11 @@ use util::ppaux::note_and_explain_region; use core::cell::{Cell, empty_cell}; use core::cmp; +use core::hashmap::linear::{LinearMap, LinearSet}; use core::result::{Err, Ok, Result}; use core::to_bytes; use core::uint; use core::vec; -use std::oldmap::HashMap; use syntax::codemap::span; enum Constraint { @@ -619,15 +619,19 @@ enum UndoLogEntry { Snapshot, AddVar(RegionVid), AddConstraint(Constraint), - AddCombination(CombineMap, TwoRegions) + AddCombination(CombineMapType, TwoRegions) } -type CombineMap = HashMap<TwoRegions, RegionVid>; +enum CombineMapType { + Lub, Glb +} + +type CombineMap = LinearMap<TwoRegions, RegionVid>; pub struct RegionVarBindings { tcx: ty::ctxt, var_spans: ~[span], - constraints: HashMap<Constraint, span>, + constraints: LinearMap<Constraint, span>, lubs: CombineMap, glbs: CombineMap, skolemization_count: uint, @@ -654,22 +658,15 @@ pub fn RegionVarBindings(tcx: ty::ctxt) -> RegionVarBindings { tcx: tcx, var_spans: ~[], values: empty_cell(), - constraints: HashMap(), - lubs: CombineMap(), - glbs: CombineMap(), + constraints: LinearMap::new(), + lubs: LinearMap::new(), + glbs: LinearMap::new(), skolemization_count: 0, bound_count: 0, undo_log: ~[] } } -// Note: takes two regions but doesn't care which is `a` and which is -// `b`! Not obvious that this is the most efficient way to go about -// it. -fn CombineMap() -> CombineMap { - return HashMap(); -} - pub impl RegionVarBindings { fn in_snapshot(&mut self) -> bool { self.undo_log.len() > 0 @@ -706,8 +703,11 @@ pub impl RegionVarBindings { AddConstraint(ref constraint) => { self.constraints.remove(constraint); } - AddCombination(map, ref regions) => { - map.remove(regions); + AddCombination(Glb, ref regions) => { + self.glbs.remove(regions); + } + AddCombination(Lub, ref regions) => { + self.lubs.remove(regions); } } } @@ -825,7 +825,7 @@ pub impl RegionVarBindings { (re_infer(ReVar(*)), _) | (_, re_infer(ReVar(*))) => { self.combine_vars( - self.lubs, a, b, span, + Lub, a, b, span, |this, old_r, new_r| this.make_subregion(span, old_r, new_r)) } @@ -852,7 +852,7 @@ pub impl RegionVarBindings { (re_infer(ReVar(*)), _) | (_, re_infer(ReVar(*))) => { self.combine_vars( - self.glbs, a, b, span, + Glb, a, b, span, |this, old_r, new_r| this.make_subregion(span, new_r, old_r)) } @@ -905,7 +905,7 @@ pub impl RegionVarBindings { } fn combine_vars(&mut self, - combines: CombineMap, + t: CombineMapType, a: Region, b: Region, span: span, @@ -914,21 +914,35 @@ pub impl RegionVarBindings { new_r: Region) -> cres<()>) -> cres<Region> { let vars = TwoRegions { a: a, b: b }; - match combines.find(&vars) { - Some(c) => Ok(re_infer(ReVar(c))), - None => { - let c = self.new_region_var(span); - combines.insert(vars, c); - if self.in_snapshot() { - self.undo_log.push(AddCombination(combines, vars)); - } - do relate(self, a, re_infer(ReVar(c))).then { - do relate(self, b, re_infer(ReVar(c))).then { - debug!("combine_vars() c=%?", c); - Ok(re_infer(ReVar(c))) + let c; + { + // FIXME (#3850): shouldn't need a scope, nor should this need to be + // done twice to get the maps out + { + let combines = match t { + Glb => &self.glbs, Lub => &self.lubs + }; + match combines.find(&vars) { + Some(&c) => return Ok(re_infer(ReVar(c))), + None => () } } - } + c = self.new_region_var(span); + { + let combines = match t { + Glb => &mut self.glbs, Lub => &mut self.lubs + }; + combines.insert(vars, c); + } + } + if self.in_snapshot() { + self.undo_log.push(AddCombination(t, vars)); + } + do relate(self, a, re_infer(ReVar(c))).then { + do relate(self, b, re_infer(ReVar(c))).then { + debug!("combine_vars() c=%?", c); + Ok(re_infer(ReVar(c))) + } } } @@ -1206,11 +1220,7 @@ struct SpannedRegion { span: span, } -type TwoRegionsMap = HashMap<TwoRegions, ()>; - -fn TwoRegionsMap() -> TwoRegionsMap { - return HashMap(); -} +type TwoRegionsMap = LinearSet<TwoRegions>; pub impl RegionVarBindings { fn infer_variable_values(&mut self) -> ~[GraphNodeValue] { @@ -1239,7 +1249,7 @@ pub impl RegionVarBindings { // It would be nice to write this using map(): let mut edges = vec::with_capacity(num_edges); - for self.constraints.each |constraint, span| { + for self.constraints.each |&(constraint, span)| { edges.push(GraphEdge { next_edge: [uint::max_value, uint::max_value], constraint: *constraint, @@ -1439,7 +1449,7 @@ pub impl RegionVarBindings { &mut self, graph: &Graph) -> ~[GraphNodeValue] { - let dup_map = TwoRegionsMap(); + let mut dup_map = LinearSet::new(); graph.nodes.mapi(|idx, node| { match node.value { Value(_) => { @@ -1478,11 +1488,11 @@ pub impl RegionVarBindings { match node.classification { Expanding => { self.report_error_for_expanding_node( - graph, dup_map, node_vid); + graph, &mut dup_map, node_vid); } Contracting => { self.report_error_for_contracting_node( - graph, dup_map, node_vid); + graph, &mut dup_map, node_vid); } } } @@ -1494,17 +1504,17 @@ pub impl RegionVarBindings { // Used to suppress reporting the same basic error over and over fn is_reported(&mut self, - dup_map: TwoRegionsMap, + dup_map: &mut TwoRegionsMap, r_a: Region, r_b: Region) -> bool { let key = TwoRegions { a: r_a, b: r_b }; - !dup_map.insert(key, ()) + !dup_map.insert(key) } fn report_error_for_expanding_node(&mut self, graph: &Graph, - dup_map: TwoRegionsMap, + dup_map: &mut TwoRegionsMap, node_idx: RegionVid) { // Errors in expanding nodes result from a lower-bound that is // not contained by an upper-bound. @@ -1557,7 +1567,7 @@ pub impl RegionVarBindings { fn report_error_for_contracting_node(&mut self, graph: &Graph, - dup_map: TwoRegionsMap, + dup_map: &mut TwoRegionsMap, node_idx: RegionVid) { // Errors in contracting nodes result from two upper-bounds // that have no intersection. @@ -1614,9 +1624,9 @@ pub impl RegionVarBindings { orig_node_idx: RegionVid, dir: Direction) -> ~[SpannedRegion] { - let set = HashMap(); + let mut set = LinearSet::new(); let mut stack = ~[orig_node_idx]; - set.insert(orig_node_idx.to_uint(), ()); + set.insert(orig_node_idx.to_uint()); let mut result = ~[]; while !vec::is_empty(stack) { let node_idx = stack.pop(); @@ -1627,7 +1637,7 @@ pub impl RegionVarBindings { Incoming => from_vid, Outgoing => to_vid }; - if set.insert(vid.to_uint(), ()) { + if set.insert(vid.to_uint()) { stack.push(vid); } } diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index a5265deafdd..77022b80feb 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -55,12 +55,11 @@ use middle::ty; use util::common::time; use util::ppaux; +use core::hashmap::linear::LinearMap; use core::result; use core::vec; use std::list::{List, Nil, Cons}; use std::list; -use std::oldmap::HashMap; -use std::oldmap; use syntax::codemap::{span, spanned, respan}; use syntax::print::pprust::*; use syntax::{ast, ast_util, ast_map}; @@ -130,7 +129,7 @@ pub struct method_map_entry { // maps from an expression id that corresponds to a method call to the details // of the method to be invoked -pub type method_map = HashMap<ast::node_id, method_map_entry>; +pub type method_map = @mut LinearMap<ast::node_id, method_map_entry>; // Resolutions for bounds of all parameters, left to right, for a given path. pub type vtable_res = @~[vtable_origin]; @@ -171,7 +170,7 @@ pub impl vtable_origin { } } -pub type vtable_map = HashMap<ast::node_id, vtable_res>; +pub type vtable_map = @mut LinearMap<ast::node_id, vtable_res>; pub struct CrateCtxt { // A mapping from method call sites to traits that have that method. @@ -209,7 +208,7 @@ pub fn write_tpt_to_tcx(tcx: ty::ctxt, pub fn lookup_def_tcx(tcx: ty::ctxt, sp: span, id: ast::node_id) -> ast::def { match tcx.def_map.find(&id) { - Some(x) => x, + Some(&x) => x, _ => { tcx.sess.span_fatal(sp, ~"internal error looking up a definition") } @@ -292,7 +291,7 @@ fn check_main_fn_ty(ccx: @mut CrateCtxt, match ty::get(main_t).sty { ty::ty_bare_fn(ref fn_ty) => { match tcx.items.find(&main_id) { - Some(ast_map::node_item(it,_)) => { + Some(&ast_map::node_item(it,_)) => { match it.node { ast::item_fn(_, _, ref ps, _) if ps.is_parameterized() => { @@ -337,14 +336,14 @@ fn check_for_main_fn(ccx: @mut CrateCtxt) { } pub fn check_crate(tcx: ty::ctxt, - trait_map: resolve::TraitMap, + +trait_map: resolve::TraitMap, crate: @ast::crate) -> (method_map, vtable_map) { let time_passes = tcx.sess.time_passes(); let ccx = @mut CrateCtxt { trait_map: trait_map, - method_map: oldmap::HashMap(), - vtable_map: oldmap::HashMap(), + method_map: @mut LinearMap::new(), + vtable_map: @mut LinearMap::new(), coherence_info: @coherence::CoherenceInfo(), tcx: tcx }; diff --git a/src/librustc/rustc.rc b/src/librustc/rustc.rc index 6a778a83361..f26a97b48a1 100644 --- a/src/librustc/rustc.rc +++ b/src/librustc/rustc.rc @@ -123,6 +123,8 @@ pub mod lib { pub mod llvm; } +use core::prelude::*; + use driver::driver::{host_triple, optgroups, early_error}; use driver::driver::{str_input, file_input, build_session_options}; use driver::driver::{build_session, build_configuration, parse_pretty}; @@ -166,7 +168,7 @@ Available lint options: let lint_dict = lint::get_lint_dict(); let mut max_key = 0; - for lint_dict.each_key |&k| { max_key = uint::max(k.len(), max_key); } + for lint_dict.each_key |k| { max_key = uint::max(k.len(), max_key); } fn padded(max: uint, s: &str) -> ~str { str::from_bytes(vec::from_elem(max - s.len(), ' ' as u8)) + s } @@ -175,7 +177,7 @@ Available lint options: padded(max_key, ~"name"), ~"default", ~"meaning")); io::println(fmt!(" %s %7.7s %s\n", padded(max_key, ~"----"), ~"-------", ~"-------")); - for lint_dict.each |&k, &v| { + for lint_dict.each |&(k, v)| { let k = str::replace(*k, ~"_", ~"-"); io::println(fmt!(" %s %7.7s %s", padded(max_key, k), diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index 1cd3982c7e8..2a2d921ba86 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -14,8 +14,8 @@ use syntax::ast; use syntax::codemap::{span}; use syntax::visit; +use core::hashmap::linear::LinearSet; use core::str; -use std::oldmap::HashMap; use std; pub fn time<T>(do_it: bool, what: ~str, thunk: &fn() -> T) -> T { @@ -55,8 +55,6 @@ pub fn indenter() -> _indenter { _indenter(()) } -pub type flag = HashMap<~str, ()>; - pub fn field_expr(f: ast::field) -> @ast::expr { return f.node.expr; } pub fn field_exprs(fields: ~[ast::field]) -> ~[@ast::expr] { @@ -116,7 +114,7 @@ pub fn pluralize(n: uint, +s: ~str) -> ~str { } // A set of node IDs (used to keep track of which node IDs are for statements) -pub type stmt_set = HashMap<ast::node_id, ()>; +pub type stmt_set = @mut LinearSet<ast::node_id>; // // Local Variables: diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index eb63d675d80..bf2a35dbf7c 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -64,10 +64,10 @@ pub fn explain_region_and_span(cx: ctxt, region: ty::Region) return match region { re_scope(node_id) => { match cx.items.find(&node_id) { - Some(ast_map::node_block(ref blk)) => { + Some(&ast_map::node_block(ref blk)) => { explain_span(cx, "block", blk.span) } - Some(ast_map::node_expr(expr)) => { + Some(&ast_map::node_expr(expr)) => { match expr.node { ast::expr_call(*) => explain_span(cx, "call", expr.span), ast::expr_method_call(*) => { @@ -77,10 +77,10 @@ pub fn explain_region_and_span(cx: ctxt, region: ty::Region) _ => explain_span(cx, "expression", expr.span) } } - Some(ast_map::node_stmt(stmt)) => { + Some(&ast_map::node_stmt(stmt)) => { explain_span(cx, "statement", stmt.span) } - Some(ast_map::node_item(it, _)) if (match it.node { + Some(&ast_map::node_item(it, _)) if (match it.node { ast::item_fn(*) => true, _ => false}) => { explain_span(cx, "function body", it.span) } @@ -102,7 +102,7 @@ pub fn explain_region_and_span(cx: ctxt, region: ty::Region) }; match cx.items.find(&id) { - Some(ast_map::node_block(ref blk)) => { + Some(&ast_map::node_block(ref blk)) => { let (msg, opt_span) = explain_span(cx, "block", blk.span); (fmt!("%s %s", prefix, msg), opt_span) } @@ -152,11 +152,11 @@ pub fn bound_region_to_str_space(cx: ctxt, pub fn re_scope_id_to_str(cx: ctxt, node_id: ast::node_id) -> ~str { match cx.items.find(&node_id) { - Some(ast_map::node_block(ref blk)) => { + Some(&ast_map::node_block(ref blk)) => { fmt!("<block at %s>", cx.sess.codemap.span_to_str(blk.span)) } - Some(ast_map::node_expr(expr)) => { + Some(&ast_map::node_expr(expr)) => { match expr.node { ast::expr_call(*) => { fmt!("<call at %s>", diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs index 0bf2f50e63f..30c8ff6964e 100644 --- a/src/librustdoc/attr_pass.rs +++ b/src/librustdoc/attr_pass.rs @@ -114,7 +114,7 @@ fn parse_item_attrs<T:Owned>( id: doc::AstId, parse_attrs: ~fn(a: ~[ast::attribute]) -> T) -> T { do astsrv::exec(srv) |ctxt| { - let attrs = match ctxt.ast_map.get(&id) { + let attrs = match *ctxt.ast_map.get(&id) { ast_map::node_item(item, _) => copy item.attrs, ast_map::node_foreign_item(item, _, _, _) => copy item.attrs, _ => fail!(~"parse_item_attrs: not an item") @@ -162,7 +162,7 @@ fn fold_enum( let desc = { let variant = copy variant; do astsrv::exec(srv.clone()) |ctxt| { - match ctxt.ast_map.get(&doc_id) { + match *ctxt.ast_map.get(&doc_id) { ast_map::node_item(@ast::item { node: ast::item_enum(ref enum_definition, _), _ }, _) => { @@ -226,7 +226,7 @@ fn merge_method_attrs( // Create an assoc list from method name to attributes let attrs: ~[(~str, Option<~str>)] = do astsrv::exec(srv) |ctxt| { - match ctxt.ast_map.get(&item_id) { + match *ctxt.ast_map.get(&item_id) { ast_map::node_item(@ast::item { node: ast::item_trait(_, _, ref methods), _ }, _) => { diff --git a/src/librustdoc/prune_hidden_pass.rs b/src/librustdoc/prune_hidden_pass.rs index bbd975dd55a..3c069e59e7a 100644 --- a/src/librustdoc/prune_hidden_pass.rs +++ b/src/librustdoc/prune_hidden_pass.rs @@ -53,7 +53,7 @@ fn is_hidden(srv: astsrv::Srv, doc: doc::ItemDoc) -> bool { let id = doc.id; do astsrv::exec(srv) |ctxt| { - let attrs = match ctxt.ast_map.get(&id) { + let attrs = match *ctxt.ast_map.get(&id) { ast_map::node_item(item, _) => copy item.attrs, _ => ~[] }; diff --git a/src/librustdoc/prune_private_pass.rs b/src/librustdoc/prune_private_pass.rs index b6aebf8b14f..e6f21b5df54 100644 --- a/src/librustdoc/prune_private_pass.rs +++ b/src/librustdoc/prune_private_pass.rs @@ -57,7 +57,7 @@ fn fold_impl( let doc = fold::default_seq_fold_impl(fold, doc); do astsrv::exec(fold.ctxt.clone()) |ctxt| { - match ctxt.ast_map.get(&doc.item.id) { + match *ctxt.ast_map.get(&doc.item.id) { ast_map::node_item(item, _) => { match item.node { ast::item_impl(_, None, _, ref methods) => { @@ -136,7 +136,7 @@ fn is_visible(srv: astsrv::Srv, doc: doc::ItemDoc) -> bool { let id = doc.id; do astsrv::exec(srv) |ctxt| { - match ctxt.ast_map.get(&id) { + match *ctxt.ast_map.get(&id) { ast_map::node_item(item, _) => { match &item.node { &ast::item_impl(*) => { diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs index 50ec41e80bc..229a0a3ff0f 100644 --- a/src/librustdoc/tystr_pass.rs +++ b/src/librustdoc/tystr_pass.rs @@ -66,7 +66,7 @@ fn fold_fn( fn get_fn_sig(srv: astsrv::Srv, fn_id: doc::AstId) -> Option<~str> { do astsrv::exec(srv) |ctxt| { - match ctxt.ast_map.get(&fn_id) { + match *ctxt.ast_map.get(&fn_id) { ast_map::node_item(@ast::item { ident: ident, node: ast::item_fn(ref decl, purity, ref tys, _), _ @@ -106,7 +106,7 @@ fn fold_const( sig: Some({ let doc = copy doc; do astsrv::exec(srv) |ctxt| { - match ctxt.ast_map.get(&doc.id()) { + match *ctxt.ast_map.get(&doc.id()) { ast_map::node_item(@ast::item { node: ast::item_const(ty, _), _ }, _) => { @@ -137,7 +137,7 @@ fn fold_enum( let sig = { let variant = copy *variant; do astsrv::exec(srv.clone()) |ctxt| { - match ctxt.ast_map.get(&doc_id) { + match *ctxt.ast_map.get(&doc_id) { ast_map::node_item(@ast::item { node: ast::item_enum(ref enum_definition, _), _ }, _) => { @@ -199,7 +199,7 @@ fn get_method_sig( method_name: ~str ) -> Option<~str> { do astsrv::exec(srv) |ctxt| { - match ctxt.ast_map.get(&item_id) { + match *ctxt.ast_map.get(&item_id) { ast_map::node_item(@ast::item { node: ast::item_trait(_, _, ref methods), _ }, _) => { @@ -277,7 +277,7 @@ fn fold_impl( let (bounds, trait_types, self_ty) = { let doc = copy doc; do astsrv::exec(srv) |ctxt| { - match ctxt.ast_map.get(&doc.id()) { + match *ctxt.ast_map.get(&doc.id()) { ast_map::node_item(@ast::item { node: ast::item_impl(ref generics, opt_trait_type, self_ty, _), _ }, _) => { @@ -347,7 +347,7 @@ fn fold_type( sig: { let doc = copy doc; do astsrv::exec(srv) |ctxt| { - match ctxt.ast_map.get(&doc.id()) { + match *ctxt.ast_map.get(&doc.id()) { ast_map::node_item(@ast::item { ident: ident, node: ast::item_ty(ty, ref params), _ @@ -385,7 +385,7 @@ fn fold_struct( sig: { let doc = copy doc; do astsrv::exec(srv) |ctxt| { - match ctxt.ast_map.get(&doc.id()) { + match *ctxt.ast_map.get(&doc.id()) { ast_map::node_item(item, _) => { let item = strip_struct_extra_stuff(item); Some(pprust::item_to_str(item, diff --git a/src/libstd/json.rs b/src/libstd/json.rs index f39e406bc00..8b8771e989a 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -1202,7 +1202,6 @@ mod tests { use core::result; use core::hashmap::linear::LinearMap; - use core::cmp; fn mk_object(items: &[(~str, Json)]) -> Json { diff --git a/src/libstd/oldmap.rs b/src/libstd/oldmap.rs deleted file mode 100644 index b40237cf584..00000000000 --- a/src/libstd/oldmap.rs +++ /dev/null @@ -1,388 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! A deprecated compatibility layer on top of `core::hashmap` - -use core::prelude::*; -use core::hash::Hash; -use core::prelude::*; -use core::to_bytes::IterBytes; -use core::vec; - -/// A convenience type to treat a hashmap as a set -pub type Set<K> = HashMap<K, ()>; - -pub type HashMap<K, V> = chained::T<K, V>; - -pub mod chained { - use core::ops; - use core::prelude::*; - use core::hashmap::linear::LinearMap; - - struct HashMap_<K, V> { - priv map: LinearMap<K, V> - } - - pub type T<K, V> = @mut HashMap_<K, V>; - - pub impl<K:Eq + IterBytes + Hash,V> HashMap_<K, V> { - fn clear(&mut self) { - self.map.clear() - } - } - - impl<K:Eq + IterBytes + Hash,V> Container for HashMap_<K, V> { - fn len(&const self) -> uint { self.map.len() } - fn is_empty(&const self) -> bool { self.map.is_empty() } - } - - pub impl<K:Eq + IterBytes + Hash,V> HashMap_<K, V> { - fn contains_key(&self, k: &K) -> bool { - self.map.contains_key(k) - } - - fn insert(&mut self, k: K, v: V) -> bool { - self.map.insert(k, v) - } - - fn remove(&mut self, k: &K) -> bool { - self.map.remove(k) - } - - fn each(&self, blk: &fn(key: &K, value: &V) -> bool) { - do self.map.each |&(k, v)| { blk(k, v) } - } - - fn each_key(&self, blk: &fn(key: &K) -> bool) { - self.map.each_key(blk) - } - - fn each_value(&self, blk: &fn(value: &V) -> bool) { - self.map.each_value(blk) - } - } - - pub impl<K:Eq + IterBytes + Hash + Copy,V:Copy> HashMap_<K, V> { - fn find(&self, k: &K) -> Option<V> { - self.map.find(k).map(|&x| copy *x) - } - - fn update(&mut self, key: K, newval: V, ff: &fn(V, V) -> V) -> bool { - match self.find(&key) { - None => self.insert(key, newval), - Some(orig) => self.insert(key, ff(orig, newval)) - } - } - - fn get(&self, k: &K) -> V { - copy *self.map.get(k) - } - } - - impl<K:Eq + IterBytes + Hash + Copy,V:Copy> ops::Index<K, V> - for HashMap_<K, V> { - fn index(&self, k: K) -> V { - self.get(&k) - } - } - - pub fn mk<K:Eq + IterBytes + Hash,V:Copy>() -> T<K,V> { - @mut HashMap_{map: LinearMap::new()} - } -} - -/* -Function: hashmap - -Construct a hashmap. -*/ -pub fn HashMap<K:Eq + IterBytes + Hash + Const,V:Copy>() - -> HashMap<K, V> { - chained::mk() -} - -/// Convenience function for adding keys to a hashmap with nil type keys -pub fn set_add<K:Eq + IterBytes + Hash + Const + Copy>(set: Set<K>, key: K) - -> bool { - set.insert(key, ()) -} - -/// Convert a set into a vector. -pub fn vec_from_set<T:Eq + IterBytes + Hash + Copy>(s: Set<T>) -> ~[T] { - do vec::build_sized(s.len()) |push| { - for s.each_key() |&k| { - push(k); - } - } -} - -/// Construct a hashmap from a vector -pub fn hash_from_vec<K:Eq + IterBytes + Hash + Const + Copy,V:Copy>( - items: &[(K, V)]) -> HashMap<K, V> { - let map = HashMap(); - for vec::each(items) |item| { - match *item { - (copy key, copy value) => { - map.insert(key, value); - } - } - } - map -} - -#[cfg(test)] -mod tests { - use core::uint; - - use super::*; - - #[test] - fn test_simple() { - debug!("*** starting test_simple"); - fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y } - fn uint_id(x: &uint) -> uint { *x } - debug!("uint -> uint"); - let hm_uu: HashMap<uint, uint> = - HashMap::<uint, uint>(); - fail_unless!((hm_uu.insert(10u, 12u))); - fail_unless!((hm_uu.insert(11u, 13u))); - fail_unless!((hm_uu.insert(12u, 14u))); - fail_unless!((hm_uu.get(&11) == 13u)); - fail_unless!((hm_uu.get(&12) == 14u)); - fail_unless!((hm_uu.get(&10) == 12u)); - fail_unless!((!hm_uu.insert(12u, 14u))); - fail_unless!((hm_uu.get(&12) == 14u)); - fail_unless!((!hm_uu.insert(12u, 12u))); - fail_unless!((hm_uu.get(&12) == 12u)); - let ten: ~str = ~"ten"; - let eleven: ~str = ~"eleven"; - let twelve: ~str = ~"twelve"; - debug!("str -> uint"); - let hm_su: HashMap<~str, uint> = - HashMap::<~str, uint>(); - fail_unless!((hm_su.insert(~"ten", 12u))); - fail_unless!((hm_su.insert(eleven, 13u))); - fail_unless!((hm_su.insert(~"twelve", 14u))); - fail_unless!((hm_su.get(&eleven) == 13u)); - fail_unless!((hm_su.get(&~"eleven") == 13u)); - fail_unless!((hm_su.get(&~"twelve") == 14u)); - fail_unless!((hm_su.get(&~"ten") == 12u)); - fail_unless!((!hm_su.insert(~"twelve", 14u))); - fail_unless!((hm_su.get(&~"twelve") == 14u)); - fail_unless!((!hm_su.insert(~"twelve", 12u))); - fail_unless!((hm_su.get(&~"twelve") == 12u)); - debug!("uint -> str"); - let hm_us: HashMap<uint, ~str> = - HashMap::<uint, ~str>(); - fail_unless!((hm_us.insert(10u, ~"twelve"))); - fail_unless!((hm_us.insert(11u, ~"thirteen"))); - fail_unless!((hm_us.insert(12u, ~"fourteen"))); - fail_unless!(hm_us.get(&11) == ~"thirteen"); - fail_unless!(hm_us.get(&12) == ~"fourteen"); - fail_unless!(hm_us.get(&10) == ~"twelve"); - fail_unless!((!hm_us.insert(12u, ~"fourteen"))); - fail_unless!(hm_us.get(&12) == ~"fourteen"); - fail_unless!((!hm_us.insert(12u, ~"twelve"))); - fail_unless!(hm_us.get(&12) == ~"twelve"); - debug!("str -> str"); - let hm_ss: HashMap<~str, ~str> = - HashMap::<~str, ~str>(); - fail_unless!((hm_ss.insert(ten, ~"twelve"))); - fail_unless!((hm_ss.insert(eleven, ~"thirteen"))); - fail_unless!((hm_ss.insert(twelve, ~"fourteen"))); - fail_unless!(hm_ss.get(&~"eleven") == ~"thirteen"); - fail_unless!(hm_ss.get(&~"twelve") == ~"fourteen"); - fail_unless!(hm_ss.get(&~"ten") == ~"twelve"); - fail_unless!((!hm_ss.insert(~"twelve", ~"fourteen"))); - fail_unless!(hm_ss.get(&~"twelve") == ~"fourteen"); - fail_unless!((!hm_ss.insert(~"twelve", ~"twelve"))); - fail_unless!(hm_ss.get(&~"twelve") == ~"twelve"); - debug!("*** finished test_simple"); - } - - - /** - * Force map growth - */ - #[test] - fn test_growth() { - debug!("*** starting test_growth"); - let num_to_insert: uint = 64u; - fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y } - fn uint_id(x: &uint) -> uint { *x } - debug!("uint -> uint"); - let hm_uu: HashMap<uint, uint> = - HashMap::<uint, uint>(); - let mut i: uint = 0u; - while i < num_to_insert { - fail_unless!((hm_uu.insert(i, i * i))); - debug!("inserting %u -> %u", i, i*i); - i += 1u; - } - debug!("-----"); - i = 0u; - while i < num_to_insert { - debug!("get(%u) = %u", i, hm_uu.get(&i)); - fail_unless!((hm_uu.get(&i) == i * i)); - i += 1u; - } - fail_unless!((hm_uu.insert(num_to_insert, 17u))); - fail_unless!((hm_uu.get(&num_to_insert) == 17u)); - debug!("-----"); - i = 0u; - while i < num_to_insert { - debug!("get(%u) = %u", i, hm_uu.get(&i)); - fail_unless!((hm_uu.get(&i) == i * i)); - i += 1u; - } - debug!("str -> str"); - let hm_ss: HashMap<~str, ~str> = - HashMap::<~str, ~str>(); - i = 0u; - while i < num_to_insert { - fail_unless!(hm_ss.insert(uint::to_str_radix(i, 2u), - uint::to_str_radix(i * i, 2u))); - debug!("inserting \"%s\" -> \"%s\"", - uint::to_str_radix(i, 2u), - uint::to_str_radix(i*i, 2u)); - i += 1u; - } - debug!("-----"); - i = 0u; - while i < num_to_insert { - debug!("get(\"%s\") = \"%s\"", - uint::to_str_radix(i, 2u), - hm_ss.get(&uint::to_str_radix(i, 2u))); - fail_unless!(hm_ss.get(&uint::to_str_radix(i, 2u)) == - uint::to_str_radix(i * i, 2u)); - i += 1u; - } - fail_unless!(hm_ss.insert(uint::to_str_radix(num_to_insert, 2u), - uint::to_str_radix(17u, 2u))); - fail_unless!(hm_ss.get(&uint::to_str_radix(num_to_insert, 2u)) == - uint::to_str_radix(17u, 2u)); - debug!("-----"); - i = 0u; - while i < num_to_insert { - debug!("get(\"%s\") = \"%s\"", - uint::to_str_radix(i, 2u), - hm_ss.get(&uint::to_str_radix(i, 2u))); - fail_unless!(hm_ss.get(&uint::to_str_radix(i, 2u)) == - uint::to_str_radix(i * i, 2u)); - i += 1u; - } - debug!("*** finished test_growth"); - } - - #[test] - fn test_removal() { - debug!("*** starting test_removal"); - let num_to_insert: uint = 64u; - let hm: HashMap<uint, uint> = - HashMap::<uint, uint>(); - let mut i: uint = 0u; - while i < num_to_insert { - fail_unless!((hm.insert(i, i * i))); - debug!("inserting %u -> %u", i, i*i); - i += 1u; - } - fail_unless!((hm.len() == num_to_insert)); - debug!("-----"); - debug!("removing evens"); - i = 0u; - while i < num_to_insert { - let v = hm.remove(&i); - fail_unless!(v); - i += 2u; - } - fail_unless!((hm.len() == num_to_insert / 2u)); - debug!("-----"); - i = 1u; - while i < num_to_insert { - debug!("get(%u) = %u", i, hm.get(&i)); - fail_unless!((hm.get(&i) == i * i)); - i += 2u; - } - debug!("-----"); - i = 1u; - while i < num_to_insert { - debug!("get(%u) = %u", i, hm.get(&i)); - fail_unless!((hm.get(&i) == i * i)); - i += 2u; - } - debug!("-----"); - i = 0u; - while i < num_to_insert { - fail_unless!((hm.insert(i, i * i))); - debug!("inserting %u -> %u", i, i*i); - i += 2u; - } - fail_unless!((hm.len() == num_to_insert)); - debug!("-----"); - i = 0u; - while i < num_to_insert { - debug!("get(%u) = %u", i, hm.get(&i)); - fail_unless!((hm.get(&i) == i * i)); - i += 1u; - } - debug!("-----"); - fail_unless!((hm.len() == num_to_insert)); - i = 0u; - while i < num_to_insert { - debug!("get(%u) = %u", i, hm.get(&i)); - fail_unless!((hm.get(&i) == i * i)); - i += 1u; - } - debug!("*** finished test_removal"); - } - - #[test] - fn test_contains_key() { - let key = ~"k"; - let map = HashMap::<~str, ~str>(); - fail_unless!((!map.contains_key(&key))); - map.insert(key, ~"val"); - fail_unless!((map.contains_key(&key))); - } - - #[test] - fn test_find() { - let key = ~"k"; - let map = HashMap::<~str, ~str>(); - fail_unless!(map.find(&key).is_none()); - map.insert(key, ~"val"); - fail_unless!(map.find(&key).get() == ~"val"); - } - - #[test] - fn test_clear() { - let key = ~"k"; - let mut map = HashMap::<~str, ~str>(); - map.insert(key, ~"val"); - fail_unless!((map.len() == 1)); - fail_unless!((map.contains_key(&key))); - map.clear(); - fail_unless!((map.len() == 0)); - fail_unless!((!map.contains_key(&key))); - } - - #[test] - fn test_hash_from_vec() { - let map = hash_from_vec(~[ - (~"a", 1), - (~"b", 2), - (~"c", 3) - ]); - fail_unless!(map.len() == 3u); - fail_unless!(map.get(&~"a") == 1); - fail_unless!(map.get(&~"b") == 2); - fail_unless!(map.get(&~"c") == 3); - } -} diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs index 1dc990526f0..8a239e8b6d8 100644 --- a/src/libstd/sort.rs +++ b/src/libstd/sort.rs @@ -725,8 +725,6 @@ fn copy_vec<T:Copy>(dest: &mut [T], s1: uint, #[cfg(test)] mod test_qsort3 { - use core::prelude::*; - use sort::*; use core::vec; @@ -770,8 +768,6 @@ mod test_qsort3 { #[cfg(test)] mod test_qsort { - use core::prelude::*; - use sort::*; use core::int; diff --git a/src/libstd/std.rc b/src/libstd/std.rc index aa5371671c1..7d46e73a697 100644 --- a/src/libstd/std.rc +++ b/src/libstd/std.rc @@ -71,7 +71,6 @@ pub mod bitv; pub mod deque; pub mod fun_treemap; pub mod list; -pub mod oldmap; pub mod priority_queue; pub mod rope; pub mod smallintmap; diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 8989bb88cd7..eef14ac8b7a 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -23,9 +23,9 @@ use print::pprust; use visit; use core::cmp; +use core::hashmap::linear::LinearMap; use core::str; use core::vec; -use std; pub enum path_elt { path_mod(ident), @@ -104,10 +104,10 @@ pub enum ast_node { node_struct_ctor(@struct_def, @item, @path), } -pub type map = std::oldmap::HashMap<node_id, ast_node>; +pub type map = @mut LinearMap<node_id, ast_node>; pub struct Ctx { - map: @map, + map: map, path: path, local_id: uint, diag: @span_handler, @@ -134,13 +134,13 @@ pub fn mk_ast_map_visitor() -> vt { pub fn map_crate(diag: @span_handler, c: crate) -> map { let cx = @mut Ctx { - map: @std::oldmap::HashMap(), + map: @mut LinearMap::new(), path: ~[], local_id: 0u, diag: diag, }; visit::visit_crate(c, cx, mk_ast_map_visitor()); - *cx.map + cx.map } // Used for items loaded from external crate that are being inlined into this @@ -157,7 +157,7 @@ pub fn map_decoded_item(diag: @span_handler, // even if we did I think it only needs an ordering between local // variables that are simultaneously in scope). let cx = @mut Ctx { - map: @map, + map: map, path: copy path, local_id: 0, diag: diag, @@ -374,7 +374,7 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str { None => { fmt!("unknown node (id=%d)", id) } - Some(node_item(item, path)) => { + Some(&node_item(item, path)) => { let path_str = path_ident_to_str(*path, item.ident, itr); let item_str = match item.node { item_const(*) => ~"const", @@ -390,43 +390,43 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str { }; fmt!("%s %s (id=%?)", item_str, path_str, id) } - Some(node_foreign_item(item, abi, _, path)) => { + Some(&node_foreign_item(item, abi, _, path)) => { fmt!("foreign item %s with abi %? (id=%?)", path_ident_to_str(*path, item.ident, itr), abi, id) } - Some(node_method(m, _, path)) => { + Some(&node_method(m, _, path)) => { fmt!("method %s in %s (id=%?)", *itr.get(m.ident), path_to_str(*path, itr), id) } - Some(node_trait_method(ref tm, _, path)) => { + Some(&node_trait_method(ref tm, _, path)) => { let m = ast_util::trait_method_to_ty_method(&**tm); fmt!("method %s in %s (id=%?)", *itr.get(m.ident), path_to_str(*path, itr), id) } - Some(node_variant(ref variant, _, path)) => { + Some(&node_variant(ref variant, _, path)) => { fmt!("variant %s in %s (id=%?)", *itr.get(variant.node.name), path_to_str(*path, itr), id) } - Some(node_expr(expr)) => { + Some(&node_expr(expr)) => { fmt!("expr %s (id=%?)", pprust::expr_to_str(expr, itr), id) } - Some(node_stmt(stmt)) => { + Some(&node_stmt(stmt)) => { fmt!("stmt %s (id=%?)", pprust::stmt_to_str(*stmt, itr), id) } - Some(node_arg(_, _)) => { // add more info here + Some(&node_arg(_, _)) => { // add more info here fmt!("arg (id=%?)", id) } - Some(node_local(_)) => { // add more info here + Some(&node_local(_)) => { // add more info here fmt!("local (id=%?)", id) } - Some(node_dtor(*)) => { // add more info here + Some(&node_dtor(*)) => { // add more info here fmt!("node_dtor (id=%?)", id) } - Some(node_block(_)) => { + Some(&node_block(_)) => { fmt!("block") } - Some(node_struct_ctor(*)) => { + Some(&node_struct_ctor(*)) => { fmt!("struct_ctor") } } @@ -436,7 +436,7 @@ pub fn node_item_query<Result>(items: map, id: node_id, query: &fn(@item) -> Result, +error_msg: ~str) -> Result { match items.find(&id) { - Some(node_item(it, _)) => query(it), + Some(&node_item(it, _)) => query(it), _ => fail!(error_msg) } } diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 688d7a57d91..b7ba9c5c6c0 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -19,11 +19,8 @@ use parse::parser::Parser; use parse::token::{Token, EOF, to_str, nonterminal}; use parse::token; -use core::option::{Option, Some, None}; -use core::str; -use core::uint; -use core::vec; -use std::oldmap::HashMap; +use core::hashmap::linear::LinearMap; +use core::prelude::*; /* 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 @@ -189,9 +186,9 @@ pub enum named_match { pub type earley_item = ~MatcherPos; pub fn nameize(p_s: @mut ParseSess, ms: ~[matcher], res: ~[@named_match]) - -> HashMap<ident,@named_match> { + -> LinearMap<ident,@named_match> { fn n_rec(p_s: @mut ParseSess, m: matcher, res: ~[@named_match], - ret_val: HashMap<ident, @named_match>) { + ret_val: &mut LinearMap<ident, @named_match>) { match m { codemap::spanned {node: match_tok(_), _} => (), codemap::spanned {node: match_seq(ref more_ms, _, _, _, _), _} => { @@ -210,13 +207,13 @@ pub fn nameize(p_s: @mut ParseSess, ms: ~[matcher], res: ~[@named_match]) } } } - let ret_val = HashMap(); - for ms.each() |m| { n_rec(p_s, *m, res, ret_val) } + let mut ret_val = LinearMap::new(); + for ms.each() |m| { n_rec(p_s, *m, res, &mut ret_val) } return ret_val; } pub enum parse_result { - success(HashMap<ident, @named_match>), + success(LinearMap<ident, @named_match>), failure(codemap::span, ~str), error(codemap::span, ~str) } @@ -226,11 +223,11 @@ pub fn parse_or_else( +cfg: ast::crate_cfg, rdr: @reader, ms: ~[matcher] -) -> HashMap<ident, @named_match> { +) -> LinearMap<ident, @named_match> { match parse(sess, cfg, rdr, ms) { success(m) => m, - failure(sp, ref str) => sess.span_diagnostic.span_fatal(sp, (*str)), - error(sp, ref str) => sess.span_diagnostic.span_fatal(sp, (*str)) + failure(sp, str) => sess.span_diagnostic.span_fatal(sp, str), + error(sp, str) => sess.span_diagnostic.span_fatal(sp, str) } } diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 5a6fd6fec58..6bd72b95109 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -63,12 +63,12 @@ pub fn add_new_extension(cx: @ext_ctxt, argument_gram); // Extract the arguments: - let lhses = match argument_map.get(&lhs_nm) { + let lhses = match *argument_map.get(&lhs_nm) { @matched_seq(ref s, _) => /* FIXME (#2543) */ copy *s, _ => cx.span_bug(sp, ~"wrong-structured lhs") }; - let rhses = match argument_map.get(&rhs_nm) { + let rhses = match *argument_map.get(&rhs_nm) { @matched_seq(ref s, _) => /* FIXME (#2543) */ copy *s, _ => cx.span_bug(sp, ~"wrong-structured rhs") }; diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 49076c74972..67c2f438269 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -18,9 +18,9 @@ use ext::tt::macro_parser::{named_match, matched_seq, matched_nonterminal}; use parse::token::{EOF, INTERPOLATED, IDENT, Token, nt_ident, ident_interner}; use parse::lexer::TokenAndSpan; +use core::hashmap::linear::LinearMap; use core::option; use core::vec; -use std; /* FIXME #2811: figure out how to have a uniquely linked stack, and change to `~` */ @@ -39,7 +39,7 @@ pub struct TtReader { // the unzipped tree: cur: @mut TtFrame, /* for MBE-style macro transcription */ - interpolations: std::oldmap::HashMap<ident, @named_match>, + interpolations: LinearMap<ident, @named_match>, repeat_idx: ~[uint], repeat_len: ~[uint], /* cached: */ @@ -52,7 +52,7 @@ pub struct TtReader { * should) be none. */ pub fn new_tt_reader(sp_diag: @span_handler, itr: @ident_interner, - interp: Option<std::oldmap::HashMap<ident,@named_match>>, + interp: Option<LinearMap<ident,@named_match>>, +src: ~[ast::token_tree]) -> @mut TtReader { let r = @mut TtReader { @@ -66,7 +66,7 @@ pub fn new_tt_reader(sp_diag: @span_handler, up: option::None }, interpolations: match interp { /* just a convienience */ - None => std::oldmap::HashMap(), + None => LinearMap::new(), Some(x) => x }, repeat_idx: ~[], @@ -124,7 +124,10 @@ fn lookup_cur_matched_by_matched(r: &mut TtReader, } fn lookup_cur_matched(r: &mut TtReader, name: ident) -> @named_match { - lookup_cur_matched_by_matched(r, r.interpolations.get(&name)) + // FIXME (#3850): this looks a bit silly with an extra scope. + let start; + { start = *r.interpolations.get(&name); } + return lookup_cur_matched_by_matched(r, start); } enum lis { lis_unconstrained, lis_constraint(uint, ident), lis_contradiction(~str) diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs index ea599e8290a..c14c7bed139 100644 --- a/src/libsyntax/parse/common.rs +++ b/src/libsyntax/parse/common.rs @@ -129,7 +129,7 @@ pub impl Parser { // A sanity check that the word we are asking for is a known keyword fn require_keyword(&self, word: &~str) { - if !self.keywords.contains_key(word) { + if !self.keywords.contains(word) { self.bug(fmt!("unknown keyword: %s", *word)); } } @@ -153,7 +153,7 @@ pub impl Parser { fn is_any_keyword(&self, tok: &token::Token) -> bool { match *tok { token::IDENT(sid, false) => { - self.keywords.contains_key(self.id_to_str(sid)) + self.keywords.contains(self.id_to_str(sid)) } _ => false } @@ -183,7 +183,7 @@ pub impl Parser { } fn is_strict_keyword(&self, word: &~str) -> bool { - self.strict_keywords.contains_key(word) + self.strict_keywords.contains(word) } fn check_strict_keywords(&self) { @@ -203,7 +203,7 @@ pub impl Parser { } fn is_reserved_keyword(&self, word: &~str) -> bool { - self.reserved_keywords.contains_key(word) + self.reserved_keywords.contains(word) } fn check_reserved_keywords(&self) { diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 0f4de9257c9..32c8b88aed8 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -225,9 +225,9 @@ pub impl Parser { desc: &str) { self.span_err(sp, fmt!("obsolete syntax: %s", kind_str)); - if !self.obsolete_set.contains_key(&kind) { + if !self.obsolete_set.contains(&kind) { self.sess.span_diagnostic.handler().note(fmt!("%s", desc)); - self.obsolete_set.insert(kind, ()); + self.obsolete_set.insert(kind); } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index af64bf07b7c..171cd90bcd2 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -92,8 +92,8 @@ use opt_vec::OptVec; use core::either::{Either, Left, Right}; use core::either; +use core::hashmap::linear::LinearSet; use core::vec; -use std::oldmap::HashMap; #[deriving(Eq)] enum restriction { @@ -240,7 +240,7 @@ pub fn Parser(sess: @mut ParseSess, keywords: token::keyword_table(), strict_keywords: token::strict_keyword_table(), reserved_keywords: token::reserved_keyword_table(), - obsolete_set: HashMap(), + obsolete_set: @mut LinearSet::new(), mod_path_stack: @mut ~[], } } @@ -259,12 +259,12 @@ pub struct Parser { quote_depth: @mut uint, // not (yet) related to the quasiquoter reader: @reader, interner: @token::ident_interner, - keywords: HashMap<~str, ()>, - strict_keywords: HashMap<~str, ()>, - reserved_keywords: HashMap<~str, ()>, + keywords: LinearSet<~str>, + strict_keywords: LinearSet<~str>, + reserved_keywords: LinearSet<~str>, /// The set of seen errors about obsolete syntax. Used to suppress /// extra detail when the same error is seen twice - obsolete_set: HashMap<ObsoleteSyntax, ()>, + obsolete_set: @mut LinearSet<ObsoleteSyntax>, /// Used to determine the path to externally loaded source files mod_path_stack: @mut ~[~str], diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 074bb13e199..5fdf6f7620c 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -18,9 +18,9 @@ use util::interner; use core::cast; use core::char; +use core::hashmap::linear::LinearSet; use core::str; use core::task; -use std::oldmap::HashMap; #[auto_encode] #[auto_decode] @@ -458,35 +458,33 @@ pub fn mk_fake_ident_interner() -> @ident_interner { * appear as identifiers at all. Reserved keywords are not used anywhere in * the language and may not appear as identifiers. */ -pub fn keyword_table() -> HashMap<~str, ()> { - let keywords = HashMap(); - for temporary_keyword_table().each_key |&word| { - keywords.insert(word, ()); - } - for strict_keyword_table().each_key |&word| { - keywords.insert(word, ()); - } - for reserved_keyword_table().each_key |&word| { - keywords.insert(word, ()); - } - keywords +pub fn keyword_table() -> LinearSet<~str> { + let mut keywords = LinearSet::new(); + let mut tmp = temporary_keyword_table(); + let mut strict = strict_keyword_table(); + let mut reserved = reserved_keyword_table(); + + do tmp.consume |word| { keywords.insert(word); } + do strict.consume |word| { keywords.insert(word); } + do reserved.consume |word| { keywords.insert(word); } + return keywords; } /// Keywords that may be used as identifiers -pub fn temporary_keyword_table() -> HashMap<~str, ()> { - let words = HashMap(); +pub fn temporary_keyword_table() -> LinearSet<~str> { + let mut words = LinearSet::new(); let keys = ~[ ~"self", ~"static", ]; - for keys.each |word| { - words.insert(copy *word, ()); + do vec::consume(keys) |_, s| { + words.insert(s); } - words + return words; } /// Full keywords. May not appear anywhere else. -pub fn strict_keyword_table() -> HashMap<~str, ()> { - let words = HashMap(); +pub fn strict_keyword_table() -> LinearSet<~str> { + let mut words = LinearSet::new(); let keys = ~[ ~"as", ~"break", @@ -505,21 +503,21 @@ pub fn strict_keyword_table() -> HashMap<~str, ()> { ~"unsafe", ~"use", ~"while" ]; - for keys.each |word| { - words.insert(copy *word, ()); + do vec::consume(keys) |_, w| { + words.insert(w); } - words + return words; } -pub fn reserved_keyword_table() -> HashMap<~str, ()> { - let words = HashMap(); +pub fn reserved_keyword_table() -> LinearSet<~str> { + let mut words = LinearSet::new(); let keys = ~[ ~"be" ]; - for keys.each |word| { - words.insert(copy *word, ()); + do vec::consume(keys) |_, s| { + words.insert(s); } - words + return words; } diff --git a/src/test/auxiliary/issue-2631-a.rs b/src/test/auxiliary/issue-2631-a.rs index f7788c7d57a..fad72ee4eb3 100644 --- a/src/test/auxiliary/issue-2631-a.rs +++ b/src/test/auxiliary/issue-2631-a.rs @@ -13,11 +13,11 @@ extern mod std; -use std::oldmap::HashMap; +use core::hashmap::linear::LinearMap; -pub type header_map = HashMap<~str, @mut ~[@~str]>; +pub type header_map = LinearMap<~str, @mut ~[@~str]>; // the unused ty param is necessary so this gets monomorphized -pub fn request<T:Copy>(req: header_map) { - let _x = copy *(copy *req.get(&~"METHOD"))[0u]; +pub fn request<T:Copy>(req: &header_map) { + let _x = copy *(copy **req.get(&~"METHOD"))[0u]; } diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index eecf509998b..0a68d29ac56 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -13,8 +13,6 @@ extern mod std; use std::time::precise_time_s; -use std::oldmap; -use std::oldmap::{Map, HashMap}; use core::io::{Reader, ReaderUtil}; use core::rand::RngUtil; @@ -29,7 +27,6 @@ fn main() { bench!(shift_push); bench!(read_line); - bench!(str_set); bench!(vec_plus); bench!(vec_append); bench!(vec_push_all); @@ -73,24 +70,6 @@ fn read_line() { } } -fn str_set() { - let r = rand::Rng(); - - let s = oldmap::HashMap(); - - for int::range(0, 1000) |_i| { - oldmap::set_add(s, r.gen_str(10)); - } - - let mut found = 0; - for int::range(0, 1000) |_i| { - match s.find(&r.gen_str(10)) { - Some(_) => { found += 1; } - None => { } - } - } -} - fn vec_plus() { let r = rand::Rng(); diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index b99dfa8bacb..899b86b5cfb 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -22,11 +22,9 @@ An implementation of the Graph500 Breadth First Search problem in Rust. extern mod std; use std::arc; use std::time; -use std::oldmap; -use std::oldmap::Map; -use std::oldmap::HashMap; use std::deque::Deque; use std::par; +use core::hashmap::linear::{LinearMap, LinearSet}; use core::io::WriterUtil; use core::int::abs; use core::rand::RngUtil; @@ -82,27 +80,31 @@ fn make_edges(scale: uint, edgefactor: uint) -> ~[(node_id, node_id)] { } fn make_graph(N: uint, edges: ~[(node_id, node_id)]) -> graph { - let graph = do vec::from_fn(N) |_i| { - oldmap::HashMap::<node_id, ()>() + let mut graph = do vec::from_fn(N) |_i| { + LinearSet::new() }; do vec::each(edges) |e| { match *e { (i, j) => { - oldmap::set_add(graph[i], j); - oldmap::set_add(graph[j], i); + graph[i].insert(j); + graph[j].insert(i); } } true } - do graph.map() |v| { - oldmap::vec_from_set(*v) + do vec::map_consume(graph) |mut v| { + let mut vec = ~[]; + do v.consume |i| { + vec.push(i); + } + vec } } fn gen_search_keys(graph: &[~[node_id]], n: uint) -> ~[node_id] { - let keys = oldmap::HashMap::<node_id, ()>(); + let mut keys = LinearSet::new(); let r = rand::Rng(); while keys.len() < n { @@ -111,10 +113,14 @@ fn gen_search_keys(graph: &[~[node_id]], n: uint) -> ~[node_id] { if graph[k].len() > 0u && vec::any(graph[k], |i| { *i != k as node_id }) { - oldmap::set_add(keys, k as node_id); + keys.insert(k as node_id); } } - oldmap::vec_from_set(keys) + let mut vec = ~[]; + do keys.consume |i| { + vec.push(i); + } + return vec; } /** diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index 111219974d0..a81f7fd76e7 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -11,8 +11,6 @@ // chameneos extern mod std; -use std::oldmap; -use std::oldmap::HashMap; use std::sort; use core::cell::Cell; use core::comm::*; diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index f0847b635b4..f4ae799aace 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -14,15 +14,14 @@ #[legacy_modes]; extern mod std; -use std::oldmap; -use std::oldmap::HashMap; use std::sort; +use core::hashmap::linear::LinearMap; use core::io::ReaderUtil; use core::comm::{stream, Port, Chan}; use core::cmp::Ord; // given a map, print a sorted version of it -fn sort_and_fmt(mm: HashMap<~[u8], uint>, total: uint) -> ~str { +fn sort_and_fmt(mm: &LinearMap<~[u8], uint>, total: uint) -> ~str { fn pct(xx: uint, yy: uint) -> float { return (xx as float) * 100f / (yy as float); } @@ -49,7 +48,7 @@ fn sort_and_fmt(mm: HashMap<~[u8], uint>, total: uint) -> ~str { let mut pairs = ~[]; // map -> [(k,%)] - for mm.each |&key, &val| { + for mm.each |&(&key, &val)| { pairs.push((key, pct(val, total))); } @@ -68,17 +67,21 @@ fn sort_and_fmt(mm: HashMap<~[u8], uint>, total: uint) -> ~str { } // given a map, search for the frequency of a pattern -fn find(mm: HashMap<~[u8], uint>, key: ~str) -> uint { +fn find(mm: &LinearMap<~[u8], uint>, key: ~str) -> uint { match mm.find(&str::to_bytes(str::to_lower(key))) { option::None => { return 0u; } - option::Some(num) => { return num; } + option::Some(&num) => { return num; } } } // given a map, increment the counter for a key -fn update_freq(mm: HashMap<~[u8], uint>, key: &[u8]) { +fn update_freq(mm: &mut LinearMap<~[u8], uint>, key: &[u8]) { let key = vec::slice(key, 0, key.len()).to_vec(); - mm.update(key, 1, |v,v1| { v+v1 }); + let newval = match mm.pop(&key) { + Some(v) => v + 1, + None => 1 + }; + mm.insert(key, newval); } // given a ~[u8], for each window call a function @@ -100,7 +103,7 @@ fn windows_with_carry(bb: &[u8], nn: uint, fn make_sequence_processor(sz: uint, from_parent: comm::Port<~[u8]>, to_parent: comm::Chan<~str>) { - let freqs: HashMap<~[u8], uint> = oldmap::HashMap(); + let mut freqs: LinearMap<~[u8], uint> = LinearMap::new(); let mut carry: ~[u8] = ~[]; let mut total: uint = 0u; @@ -112,19 +115,19 @@ fn make_sequence_processor(sz: uint, from_parent: comm::Port<~[u8]>, if line == ~[] { break; } carry = windows_with_carry(carry + line, sz, |window| { - update_freq(freqs, window); + update_freq(&mut freqs, window); total += 1u; }); } let buffer = match sz { - 1u => { sort_and_fmt(freqs, total) } - 2u => { sort_and_fmt(freqs, total) } - 3u => { fmt!("%u\t%s", find(freqs, ~"GGT"), ~"GGT") } - 4u => { fmt!("%u\t%s", find(freqs, ~"GGTA"), ~"GGTA") } - 6u => { fmt!("%u\t%s", find(freqs, ~"GGTATT"), ~"GGTATT") } - 12u => { fmt!("%u\t%s", find(freqs, ~"GGTATTTTAATT"), ~"GGTATTTTAATT") } - 18u => { fmt!("%u\t%s", find(freqs, ~"GGTATTTTAATTTATAGT"), ~"GGTATTTTAATTTATAGT") } + 1u => { sort_and_fmt(&freqs, total) } + 2u => { sort_and_fmt(&freqs, total) } + 3u => { fmt!("%u\t%s", find(&freqs, ~"GGT"), ~"GGT") } + 4u => { fmt!("%u\t%s", find(&freqs, ~"GGTA"), ~"GGTA") } + 6u => { fmt!("%u\t%s", find(&freqs, ~"GGTATT"), ~"GGTATT") } + 12u => { fmt!("%u\t%s", find(&freqs, ~"GGTATTTTAATT"), ~"GGTATTTTAATT") } + 18u => { fmt!("%u\t%s", find(&freqs, ~"GGTATTTTAATTTATAGT"), ~"GGTATTTTAATTTATAGT") } _ => { ~"" } }; diff --git a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs index 07a68bfb068..6dbfa5dd538 100644 --- a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs +++ b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs @@ -9,12 +9,12 @@ // except according to those terms. //buggy.rs -extern mod std; -use std::oldmap::HashMap; + +use core::hashmap::linear::LinearMap; fn main() { - let buggy_map :HashMap<uint, &uint> = - HashMap::<uint, &uint>(); + let mut buggy_map :LinearMap<uint, &uint> = + LinearMap::new::<uint, &uint>(); buggy_map.insert(42, &*~1); //~ ERROR illegal borrow // but it is ok if we use a temporary diff --git a/src/test/compile-fail/for-loop-decl.rs b/src/test/compile-fail/for-loop-decl.rs index 952bf8c060a..918d8f00d78 100644 --- a/src/test/compile-fail/for-loop-decl.rs +++ b/src/test/compile-fail/for-loop-decl.rs @@ -10,11 +10,11 @@ // error-pattern: mismatched types extern mod std; -use std::oldmap::HashMap; use std::bitv; +use core::hashmap::linear::LinearMap; struct FnInfo { - vars: HashMap<uint, VarInfo> + vars: LinearMap<uint, VarInfo> } struct VarInfo { @@ -27,7 +27,7 @@ fn bitv_to_str(enclosing: FnInfo, v: ~bitv::Bitv) -> str { // error is that the value type in the hash map is var_info, not a box for enclosing.vars.each_value |val| { - if v.get(val) { s += "foo"; } + if *v.get(val) { s += "foo"; } } return s; } diff --git a/src/test/run-pass/extern-mod-syntax.rs b/src/test/run-pass/extern-mod-syntax.rs index 2a7843bdccd..b6b2e004263 100644 --- a/src/test/run-pass/extern-mod-syntax.rs +++ b/src/test/run-pass/extern-mod-syntax.rs @@ -11,7 +11,7 @@ // except according to those terms. extern mod std; -use std::oldmap::HashMap; +use std::json::Object; pub fn main() { io::println("Hello world!"); diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index 5d8ac2f1ab5..4234c064e8d 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -16,17 +16,10 @@ This originally came from the word-count benchmark. */ -extern mod std; - -use std::oldmap; -use std::oldmap::HashMap; -use core::comm::*; - pub fn map(filename: ~str, emit: map_reduce::putter) { emit(filename, ~"1"); } mod map_reduce { - use std::oldmap; - use std::oldmap::HashMap; + use core::hashmap::linear::LinearMap; use core::comm::*; pub type putter = @fn(~str, ~str); @@ -44,23 +37,20 @@ mod map_reduce { } fn map_task(ctrl: SharedChan<ctrl_proto>, input: ~str) { - let intermediates = oldmap::HashMap(); - - fn emit(im: oldmap::HashMap<~str, int>, ctrl: SharedChan<ctrl_proto>, key: ~str, - val: ~str) { - let mut c; - match im.find(&key) { - Some(_c) => { c = _c } - None => { - let (pp, cc) = stream(); - error!("sending find_reducer"); - ctrl.send(find_reducer(str::to_bytes(key), cc)); - error!("receiving"); - c = pp.recv(); - error!(c); - im.insert(key, c); - } + let intermediates = @mut LinearMap::new(); + + fn emit(im: &mut LinearMap<~str, int>, ctrl: SharedChan<ctrl_proto>, key: ~str, + _val: ~str) { + if im.contains_key(&key) { + return; } + let (pp, cc) = stream(); + error!("sending find_reducer"); + ctrl.send(find_reducer(str::to_bytes(key), cc)); + error!("receiving"); + let c = pp.recv(); + error!(c); + im.insert(key, c); } let ctrl_clone = ctrl.clone(); @@ -75,9 +65,9 @@ mod map_reduce { // This task becomes the master control task. It spawns others // to do the rest. - let mut reducers: oldmap::HashMap<~str, int>; + let mut reducers: LinearMap<~str, int>; - reducers = oldmap::HashMap(); + reducers = LinearMap::new(); start_mappers(ctrl_chan, inputs.clone()); @@ -89,7 +79,7 @@ mod map_reduce { find_reducer(k, cc) => { let mut c; match reducers.find(&str::from_bytes(k)) { - Some(_c) => { c = _c; } + Some(&_c) => { c = _c; } None => { c = 0; } } cc.send(c); diff --git a/src/test/run-pass/issue-1696.rs b/src/test/run-pass/issue-1696.rs index 8697e5c8c3c..5f8b8d29830 100644 --- a/src/test/run-pass/issue-1696.rs +++ b/src/test/run-pass/issue-1696.rs @@ -10,11 +10,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod std; -use std::oldmap::HashMap; +use core::hashmap::linear::LinearMap; pub fn main() { - let m = HashMap(); + let mut m = LinearMap::new(); m.insert(str::to_bytes(~"foo"), str::to_bytes(~"bar")); error!(m); } diff --git a/src/test/run-pass/issue-2631-b.rs b/src/test/run-pass/issue-2631-b.rs index 5f5e2f9fc30..b22c423ed04 100644 --- a/src/test/run-pass/issue-2631-b.rs +++ b/src/test/run-pass/issue-2631-b.rs @@ -12,14 +12,13 @@ // aux-build:issue-2631-a.rs extern mod req; -extern mod std; use req::*; -use std::oldmap::HashMap; +use core::hashmap::linear::LinearMap; pub fn main() { let v = ~[@~"hi"]; - let m: req::header_map = HashMap(); + let mut m: req::header_map = LinearMap::new(); m.insert(~"METHOD", @mut v); - request::<int>(m); + request::<int>(&m); } diff --git a/src/test/run-pass/issue-2804-2.rs b/src/test/run-pass/issue-2804-2.rs index 9fe88227c44..8934c3935c0 100644 --- a/src/test/run-pass/issue-2804-2.rs +++ b/src/test/run-pass/issue-2804-2.rs @@ -12,11 +12,11 @@ // Minimized version of issue-2804.rs. Both check that callee IDs don't // clobber the previous node ID in a macro expr -extern mod std; -use std::oldmap::HashMap; -fn add_interfaces(managed_ip: ~str, device: std::oldmap::HashMap<~str, int>) { - error!("%s, %?", managed_ip, device[~"interfaces"]); +use core::hashmap::linear::LinearMap; + +fn add_interfaces(managed_ip: ~str, device: LinearMap<~str, int>) { + error!("%s, %?", managed_ip, device.get(&~"interfaces")); } pub fn main() {} diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs index 2b4acc34f46..3d1a2c3df5d 100644 --- a/src/test/run-pass/issue-2804.rs +++ b/src/test/run-pass/issue-2804.rs @@ -11,8 +11,7 @@ // except according to those terms. extern mod std; -use core::io::WriterUtil; -use std::oldmap::HashMap; +use core::hashmap::linear::LinearMap; use std::json; enum object { @@ -59,19 +58,20 @@ fn add_interface(store: int, managed_ip: ~str, data: std::json::Json) -> (~str, } } -fn add_interfaces(store: int, managed_ip: ~str, device: std::oldmap::HashMap<~str, std::json::Json>) -> ~[(~str, object)] +fn add_interfaces(store: int, managed_ip: ~str, device: LinearMap<~str, std::json::Json>) -> ~[(~str, object)] { - match device[~"interfaces"] + match device.get(&~"interfaces") { - std::json::List(interfaces) => + &std::json::List(ref interfaces) => { - do vec::map(interfaces) |interface| { + do interfaces.map |interface| { add_interface(store, copy managed_ip, copy *interface) } } _ => { - error!("Expected list for %s interfaces but found %?", managed_ip, device[~"interfaces"]); + error!("Expected list for %s interfaces but found %?", managed_ip, + device.get(&~"interfaces")); ~[] } } diff --git a/src/test/run-pass/issue-3026.rs b/src/test/run-pass/issue-3026.rs index 32f7d2ee07c..022d3f6fceb 100644 --- a/src/test/run-pass/issue-3026.rs +++ b/src/test/run-pass/issue-3026.rs @@ -10,12 +10,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod std; -use std::oldmap::HashMap; -use std::oldmap; +use core::hashmap::linear::LinearMap; pub fn main() { - let buggy_map :HashMap<uint, &uint> = HashMap::<uint, &uint>(); + let mut buggy_map: LinearMap<uint, &uint> = LinearMap::new::<uint, &uint>(); let x = ~1; buggy_map.insert(42, &*x); } diff --git a/src/test/run-pass/issue-3559.rs b/src/test/run-pass/issue-3559.rs index 0486357dc69..46a02ff1592 100644 --- a/src/test/run-pass/issue-3559.rs +++ b/src/test/run-pass/issue-3559.rs @@ -14,7 +14,6 @@ extern mod std; use core::io::{WriterUtil}; -use std::oldmap::*; #[cfg(test)] fn check_strs(actual: &str, expected: &str) -> bool @@ -30,7 +29,7 @@ fn check_strs(actual: &str, expected: &str) -> bool #[test] fn tester() { - let table = HashMap(); + let mut table = core::hashmap::linear::LinearMap(); table.insert(@~"one", 1); table.insert(@~"two", 2); fail_unless!(check_strs(table.to_str(), ~"xxx")); // not sure what expected should be diff --git a/src/test/run-pass/issue-4092.rs b/src/test/run-pass/issue-4092.rs index 5cfb5809feb..85cb3e3207e 100644 --- a/src/test/run-pass/issue-4092.rs +++ b/src/test/run-pass/issue-4092.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod std; +use core::hashmap::linear::LinearMap; pub fn main() { - let x = std::oldmap::HashMap(); + let mut x = LinearMap::new(); x.insert((@"abc", 0), 0); } |