From fa7772893a63e6ac83ab461f80fb1f35c8633325 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 22 Mar 2013 22:26:32 -0400 Subject: [PATCH 1/8] Remove unused imports throughout --- src/libcore/flate.rs | 2 +- src/libcore/logging.rs | 3 +-- src/libcore/rt/io/mod.rs | 3 --- src/libcore/rt/uv/mod.rs | 1 - src/libcore/rt/uvll.rs | 1 - src/librustc/middle/trans/tvec.rs | 1 - src/librustc/middle/typeck/astconv.rs | 1 - src/librustc/middle/typeck/check/mod.rs | 2 +- src/libstd/json.rs | 1 - src/libstd/sort.rs | 4 ---- src/libsyntax/ext/tt/macro_parser.rs | 7 ++----- src/libsyntax/ext/tt/transcribe.rs | 1 - 12 files changed, 5 insertions(+), 22 deletions(-) diff --git a/src/libcore/flate.rs b/src/libcore/flate.rs index d9dc89097d03d..2ddf927709693 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/logging.rs b/src/libcore/logging.rs index be6469abc9244..ba976de50ab48 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(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 f82092b829c9b..1634e7443b479 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 28d695273e7c7..94a3b562fd875 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 5111b2bdc1d22..4eaf9dcf40a76 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/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs index 90f6bf8757865..5bb94a18e7227 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/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 5d69ab5766d7d..a4a5c6ddd2176 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; diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index e216f9266e910..c07dd563cac1c 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -1328,7 +1328,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, diff --git a/src/libstd/json.rs b/src/libstd/json.rs index f39e406bc0060..8b8771e989a06 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/sort.rs b/src/libstd/sort.rs index 1dc990526f0b6..8a239e8b6d8ed 100644 --- a/src/libstd/sort.rs +++ b/src/libstd/sort.rs @@ -725,8 +725,6 @@ fn copy_vec(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/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 688d7a57d91a5..70b639d6648b8 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 diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 49076c74972f6..a0d90a0c70b4d 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -20,7 +20,6 @@ use parse::lexer::TokenAndSpan; use core::option; use core::vec; -use std; /* FIXME #2811: figure out how to have a uniquely linked stack, and change to `~` */ From e4c3d805a4d8151158abbddf990a5430529b829f Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 21 Mar 2013 15:41:37 -0400 Subject: [PATCH 2/8] syntax: Removing uses of HashMap --- src/libcore/hashmap.rs | 5 +++ src/libsyntax/ext/tt/macro_parser.rs | 16 ++++----- src/libsyntax/ext/tt/macro_rules.rs | 4 +-- src/libsyntax/ext/tt/transcribe.rs | 12 ++++--- src/libsyntax/parse/common.rs | 8 ++--- src/libsyntax/parse/obsolete.rs | 4 +-- src/libsyntax/parse/parser.rs | 12 +++---- src/libsyntax/parse/token.rs | 54 ++++++++++++++-------------- 8 files changed, 61 insertions(+), 54 deletions(-) diff --git a/src/libcore/hashmap.rs b/src/libcore/hashmap.rs index 8c290553a4599..6f97bf6dde231 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/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 70b639d6648b8..b7ba9c5c6c042 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -186,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 { + -> LinearMap { fn n_rec(p_s: @mut ParseSess, m: matcher, res: ~[@named_match], - ret_val: HashMap) { + ret_val: &mut LinearMap) { match m { codemap::spanned {node: match_tok(_), _} => (), codemap::spanned {node: match_seq(ref more_ms, _, _, _, _), _} => { @@ -207,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), + success(LinearMap), failure(codemap::span, ~str), error(codemap::span, ~str) } @@ -223,11 +223,11 @@ pub fn parse_or_else( +cfg: ast::crate_cfg, rdr: @reader, ms: ~[matcher] -) -> HashMap { +) -> LinearMap { 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 5a6fd6fec5894..6bd72b95109d7 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 a0d90a0c70b4d..67c2f438269d8 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -18,6 +18,7 @@ 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; @@ -38,7 +39,7 @@ pub struct TtReader { // the unzipped tree: cur: @mut TtFrame, /* for MBE-style macro transcription */ - interpolations: std::oldmap::HashMap, + interpolations: LinearMap, repeat_idx: ~[uint], repeat_len: ~[uint], /* cached: */ @@ -51,7 +52,7 @@ pub struct TtReader { * should) be none. */ pub fn new_tt_reader(sp_diag: @span_handler, itr: @ident_interner, - interp: Option>, + interp: Option>, +src: ~[ast::token_tree]) -> @mut TtReader { let r = @mut TtReader { @@ -65,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: ~[], @@ -123,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 ea599e8290a27..c14c7bed1399f 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 0f4de9257c99c..32c8b88aed8bd 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 af64bf07b7c3e..171cd90bcd2b3 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, + obsolete_set: @mut LinearSet, /// 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 074bb13e19908..5fdf6f7620cc1 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; } From 31f6e6432485cfb880af0c8d98dc0cbdaec74383 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 21 Mar 2013 15:57:33 -0400 Subject: [PATCH 3/8] doc: Remove mentions of oldmap::HashMap --- doc/rust.md | 6 +++--- doc/tutorial.md | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/doc/rust.md b/doc/rust.md index 3847b0b975583..287dcb950f772 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: T) -> T { t } -type t = oldmap::HashMap; // Type arguments used in a type expression -let x = id::(10); // Type arguments used in a call expression +type t = LinearMap; // Type arguments used in a type expression +let x = id::(10); // Type arguments used in a call expression # } ~~~~ diff --git a/doc/tutorial.md b/doc/tutorial.md index 30e230b67b0d3..8c0f5f1ebdf6a 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 = HashMap; +# use core::hashmap::linear::LinearMap; +type Set = LinearMap; struct Stack { elements: ~[T] From 6f812fef1bde4a23ccfd7e1526a4c5087cc9e31b Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 22 Mar 2013 22:26:41 -0400 Subject: [PATCH 4/8] rustc: Remove uses of oldmap::HashMap --- src/librustc/back/link.rs | 2 +- src/librustc/driver/driver.rs | 6 +- src/librustc/lib/llvm.rs | 14 +- src/librustc/metadata/creader.rs | 6 +- src/librustc/metadata/cstore.rs | 63 ++++----- src/librustc/metadata/decoder.rs | 2 +- src/librustc/metadata/encoder.rs | 53 ++++---- src/librustc/metadata/tydecode.rs | 2 +- src/librustc/metadata/tyencode.rs | 4 +- src/librustc/middle/astencode.rs | 20 +-- src/librustc/middle/borrowck/check_loans.rs | 81 ++++++----- src/librustc/middle/borrowck/gather_loans.rs | 25 ++-- src/librustc/middle/borrowck/loan.rs | 2 +- src/librustc/middle/borrowck/mod.rs | 22 +-- src/librustc/middle/borrowck/preserve.rs | 12 +- src/librustc/middle/check_const.rs | 16 +-- src/librustc/middle/check_match.rs | 28 ++-- src/librustc/middle/const_eval.rs | 48 ++++--- src/librustc/middle/freevars.rs | 17 ++- src/librustc/middle/kind.rs | 15 +-- src/librustc/middle/lang_items.rs | 10 +- src/librustc/middle/lint.rs | 101 +++++++------- src/librustc/middle/liveness.rs | 53 ++++---- src/librustc/middle/mem_categorization.rs | 16 +-- src/librustc/middle/moves.rs | 24 ++-- src/librustc/middle/pat_util.rs | 10 +- src/librustc/middle/privacy.rs | 6 +- src/librustc/middle/region.rs | 41 +++--- src/librustc/middle/resolve.rs | 127 +++++++++--------- src/librustc/middle/trans/_match.rs | 34 ++--- src/librustc/middle/trans/base.rs | 88 ++++++------ src/librustc/middle/trans/build.rs | 8 +- src/librustc/middle/trans/callee.rs | 2 +- src/librustc/middle/trans/closure.rs | 2 +- src/librustc/middle/trans/common.rs | 54 ++++---- src/librustc/middle/trans/consts.rs | 24 ++-- src/librustc/middle/trans/controlflow.rs | 2 +- src/librustc/middle/trans/datum.rs | 12 +- src/librustc/middle/trans/debuginfo.rs | 28 ++-- src/librustc/middle/trans/expr.rs | 22 +-- src/librustc/middle/trans/foreign.rs | 96 ++++++------- src/librustc/middle/trans/inline.rs | 4 +- src/librustc/middle/trans/machine.rs | 3 +- src/librustc/middle/trans/meth.rs | 4 +- src/librustc/middle/trans/monomorphize.rs | 6 +- src/librustc/middle/trans/reachable.rs | 62 +++++---- src/librustc/middle/trans/type_of.rs | 1 + src/librustc/middle/trans/type_use.rs | 5 +- src/librustc/middle/ty.rs | 114 ++++++++-------- src/librustc/middle/typeck/astconv.rs | 10 +- src/librustc/middle/typeck/check/_match.rs | 26 ++-- src/librustc/middle/typeck/check/method.rs | 19 +-- src/librustc/middle/typeck/check/mod.rs | 78 ++++++----- src/librustc/middle/typeck/check/regionck.rs | 8 +- src/librustc/middle/typeck/check/vtable.rs | 9 +- src/librustc/middle/typeck/check/writeback.rs | 23 ++-- src/librustc/middle/typeck/coherence.rs | 42 +++--- src/librustc/middle/typeck/collect.rs | 14 +- .../middle/typeck/infer/region_inference.rs | 106 ++++++++------- src/librustc/middle/typeck/mod.rs | 12 +- src/librustc/rustc.rc | 6 +- src/librustc/util/common.rs | 6 +- 62 files changed, 877 insertions(+), 879 deletions(-) diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 5f9a3e606f201..d0c318d16a2b5 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 360a5ddccfd2a..1de69ed85a840 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 e01c4ae7d727d..e97252c5341db 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, - named_types: HashMap<@str, TypeRef> + type_names: @mut LinearMap, + 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 { - 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 21b035f2242f6..ce37054cba244 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 018a365f37f52..d4360a7d49160 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; +pub type cnum_map = @mut LinearMap; pub struct crate_metadata { name: @~str, @@ -37,7 +37,7 @@ pub struct crate_metadata { } pub struct CStore { - priv metas: oldmap::HashMap, + priv metas: LinearMap , 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; +type extern_mod_crate_map = LinearMap; 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 { - 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 b952aff9e1ce1..0e9246eedbc87 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 ccc29fbbccb26..675a7837173a5 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; +type abbrev_map = @mut LinearMap; 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, + reachable: reachable::map, reexports2: middle::resolve::ExportMap2, - item_symbols: HashMap, - discrim_symbols: HashMap, + item_symbols: @mut LinearMap, + discrim_symbols: @mut LinearMap, 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, + reachable: reachable::map, reexports2: middle::resolve::ExportMap2, - item_symbols: HashMap, - discrim_symbols: HashMap, + item_symbols: @mut LinearMap, + discrim_symbols: @mut LinearMap, 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) { 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(); } @@ -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 f12cc140d8ab9..1eb82c6277eb5 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 880d01d1cdb50..021d472fa0ef0 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), + ac_use_abbrevs(@mut LinearMap), } fn cx_uses_abbrevs(cx: @ctxt) -> bool { diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 853bb8df3a4c0..e1863a9f40023 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -861,7 +861,7 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext, } } - 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 +873,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 +882,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 +905,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,7 +915,7 @@ 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); } } @@ -931,7 +931,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 +949,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 +1097,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 6dfcf6ddf9168..045a3b2b67719 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, + reported: LinearSet, 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 { + fn purity(&mut self, scope_id: ast::node_id) -> Option { 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 bab652a3d1e2f..bd6a9ab30976d 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 e095c97093131..c0551436edef9 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 d5c4b27e6cbb8..cdec64b7b4c98 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; +pub type root_map = @mut LinearMap; // 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; +pub type mutbl_map = @mut LinearSet; // A set containing IDs of expressions of gc'd type that need to have a write // guard. -pub type write_guard_map = HashMap; +pub type write_guard_map = @mut LinearSet; // 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, - pure_map: HashMap + req_loan_map: LinearMap, + pure_map: LinearMap } pub fn save_and_restore(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 0440f4525ff36..2ce47d8d0a17c 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 7d228f7687147..5a5ba6918d718 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,7 +238,7 @@ 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) { ast_map::node_item(it, _) => { diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index ddc00000c6b4f..3f3ffe1598ae7 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 { 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 { } 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 7e0a36be0a020..8cf6e931c92cb 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -12,16 +12,16 @@ use core::prelude::*; use metadata::csearch; use middle::astencode; -use middle::resolve; use middle::ty; use middle; use core::float; use core::vec; +use std::oldmap::HashMap; 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 +77,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 +96,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 +123,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 +133,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 +144,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 +172,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 } } @@ -192,14 +191,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(), + mutbl_map: @mut LinearSet::new(), + root_map: @mut LinearMap::new(), + last_use_map: @mut LinearMap::new(), method_map: HashMap(), - vtable_map: HashMap(), - write_guard_map: HashMap(), - moves_map: HashMap(), - capture_map: HashMap() + 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 +226,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 e4ea2333d2763..19d3e1f431db2 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; +pub type freevar_map = @mut LinearMap; // 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; // 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) { } @@ -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 0861e57c9b423..ab3dc75c79f17 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; - 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) { 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); @@ -281,7 +276,7 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt) { for cx.tcx.node_type_substs.find(&type_parameter_id).each |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 } _ => { @@ -340,7 +335,7 @@ fn check_ty(aty: @Ty, cx: Context, v: visit::vt) { 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)); + 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| { check_bounds(cx, aty.id, aty.span, *ty, *bound) @@ -405,7 +400,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 669587205d546..9de7b5088f3a0 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 2b16ccdd1d220..a75ade0c585d3 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; -type LintModeMap = HashMap; +type LintModeMap = @mut LinearMap; // 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 e3a595a855211..a92234ba1298e 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; +pub type last_use_map = @mut LinearMap; 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, - variable_map: HashMap, - capture_info_map: HashMap, + live_node_map: LinearMap, + variable_map: LinearMap, + capture_info_map: LinearMap, 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; +type LiveNodeMap = @mut LinearMap; 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 { 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 { 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 e767b0ff812f4..b7ec6208d5607 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 9848c65ac4372..16f133b8794d8 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; +pub type CaptureMap = @mut LinearMap; -pub type MovesMap = HashMap; +pub type MovesMap = @mut LinearSet; /** * For each variable which will be moved, links to the * expression */ -pub type VariableMovesMap = HashMap; +pub type VariableMovesMap = @mut LinearMap; /** 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, + 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 a25fddcad88c8..6bf75b50cb48b 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; +pub type PatIdMap = LinearMap; // 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 c3a65a4f256f4..4e349d1506d4d 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -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 10838a7a8dc2c..f49a37d73018f 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; +pub type region_map = @mut LinearMap; 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, + root_exprs: @mut LinearSet, // 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) { 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) { 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; +pub type region_paramd_items = @mut LinearMap; #[deriving(Eq)] pub struct region_dep { @@ -395,7 +395,7 @@ pub struct region_dep { id: ast::node_id } -pub type dep_map = HashMap; +pub type dep_map = @mut LinearMap; 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 079110e67f511..f956c8cb10c12 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; +pub type DefMap = @mut LinearMap; 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; +pub type BindingMap = LinearMap; // Implementation resolution // @@ -110,11 +109,11 @@ pub struct Impl { } // Trait method resolution -pub type TraitMap = @HashMap; +pub type TraitMap = LinearMap; // This is the replacement export map. It maps a module to all of the exports // within. -pub type ExportMap2 = HashMap; +pub type ExportMap2 = @mut LinearMap; 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, + bindings: @mut LinearMap, 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, + anonymous_children: @mut LinearMap, // The status of resolving each import in this module. import_resolutions: @mut LinearMap, @@ -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, + primitive_types: LinearMap, } 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>, - structs: @HashMap, + trait_info: LinearMap>, + structs: LinearSet, // 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, + modules: &mut LinearMap, 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>, + bindings_list: Option<@mut LinearMap>, 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 = &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 = &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 7529b2132fd9e..d4081352468da 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; +pub type BindingsMap = LinearMap; 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 1a5b01feb0aff..a4f0c7c73cd4e 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -67,7 +67,7 @@ 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}; @@ -383,7 +383,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 +467,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 +1102,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 +1455,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 +1504,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 +1603,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 +1907,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 +1971,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 \ @@ -2347,7 +2349,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,7 +2384,7 @@ 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; @@ -2538,7 +2540,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 +2619,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 +2752,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 +2813,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 +2828,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 +2863,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 +3038,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); @@ -3061,34 +3063,34 @@ pub fn trans_crate(sess: session::Session, tn: tn, externs: HashMap(), 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(), + 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: ty::new_ty_hash(), llsizingtypes: ty::new_ty_hash(), 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 +3103,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 +3153,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 5e5cbc9f97191..e8b85c54d4879 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 8c5729637ac59..e2a5b5f500976 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -700,7 +700,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 b7a8e38dbb873..74d338bbbb5ed 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 bcdfc7cf95b49..437562e3a1344 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -45,7 +45,7 @@ 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; @@ -134,7 +134,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) } @@ -165,30 +165,30 @@ pub struct CrateContext { td: TargetData, tn: @TypeNames, externs: ExternMap, - intrinsics: HashMap<~str, ValueRef>, - item_vals: HashMap, + intrinsics: LinearMap<~str, ValueRef>, + item_vals: @mut LinearMap, exp_map2: resolve::ExportMap2, reachable: reachable::map, - item_symbols: HashMap, + item_symbols: @mut LinearMap, link_meta: LinkMeta, - enum_sizes: HashMap, - discrims: HashMap, - discrim_symbols: HashMap, - tydescs: HashMap, + enum_sizes: @mut LinearMap, + discrims: @mut LinearMap, + discrim_symbols: @mut LinearMap, + tydescs: @mut LinearMap, // 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>, + external: @mut LinearMap>, // Cache instances of monomorphized functions - monomorphized: HashMap, - monomorphizing: HashMap, + monomorphized: @mut LinearMap, + monomorphizing: @mut LinearMap, // Cache computed type parameter uses (see type_use.rs) - type_use_cache: HashMap, + type_use_cache: @mut LinearMap, // Cache generated vtables - vtables: HashMap, + vtables: @mut LinearMap, // 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 +198,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, + const_globals: @mut LinearMap, // Cache of emitted const values - const_values: HashMap, - module_data: HashMap<~str, ValueRef>, + const_values: @mut LinearMap, + module_data: @mut LinearMap<~str, ValueRef>, lltypes: HashMap, llsizingtypes: HashMap, adt_reprs: @mut LinearMap, names: namegen, next_addrspace: addrspace_gen, symbol_hasher: @hash::State, - type_hashcodes: HashMap, - type_short_names: HashMap, - all_llvm_symbols: Set<~str>, + type_hashcodes: @mut LinearMap, + type_short_names: @mut LinearMap, + all_llvm_symbols: @mut LinearSet<~str>, tcx: ty::ctxt, maps: astencode::Maps, stats: @mut Stats, @@ -310,12 +310,12 @@ pub struct fn_ctxt_ { loop_ret: Option<(ValueRef, ValueRef)>, // Maps arguments to allocas created for them in llallocas. - llargs: @HashMap, + llargs: @mut LinearMap, // Maps the def_ids for local variables to the allocas created for // them in llallocas. - lllocals: @HashMap, + lllocals: @mut LinearMap, // Same as above, but for closure upvars - llupvars: @HashMap, + llupvars: @mut LinearMap, // The node_id of the function, or -1 if it doesn't correspond to // a user-defined function. @@ -712,7 +712,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 +1132,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 +1400,7 @@ pub fn node_vtables(bcx: block, id: ast::node_id) -> Option { 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 ea34df54462b7..a929a53a769b9 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 { @@ -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 616a5f994992b..1c201d0def69b 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 600f637f72b59..bb7fae9ae33aa 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 505c08fc8b8c1..50c7017029be6 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 { @@ -153,7 +151,7 @@ struct RetvalMetadata { id: ast::node_id } -type metadata_cache = HashMap; +type metadata_cache = @mut LinearMap; enum debug_metadata { file_metadata(@Metadata), @@ -318,7 +316,7 @@ fn create_block(cx: block) -> @Metadata { }; 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); } diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 7cfa1ff49292a..2fad2bd9b606d 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, + table: &LinearMap, 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(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); diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index dadd51b324847..05acdae1bb017 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -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) } _ => { diff --git a/src/librustc/middle/trans/inline.rs b/src/librustc/middle/trans/inline.rs index afbb5f09da3c6..906519543d2ea 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 434fcd4cf31ef..047968ed56979 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 b49bdbba42637..66a28a03bd845 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -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) => { @@ -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 67bba3e0bd989..77e521b4af06b 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); @@ -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. diff --git a/src/librustc/middle/trans/reachable.rs b/src/librustc/middle/trans/reachable.rs index 015fc61a3c880..c025d970db70f 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; +pub type map = @LinearSet; struct ctx { exp_map2: resolve::ExportMap2, tcx: ty::ctxt, method_map: typeck::method_map, - rmap: map + rmap: &'self mut LinearSet, } 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 { @@ -77,10 +79,10 @@ fn traverse_def_id(cx: ctx, did: def_id) { 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, ()); + cx.rmap.insert(item.id); } ast_map::node_variant(ref v, _, _) => { - cx.rmap.insert((*v).node.id, ()); + cx.rmap.insert(v.node.id); } _ => () } @@ -96,14 +98,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 = 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 +123,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 +155,19 @@ fn mk_ty_visitor() -> visit::vt { ..*visit::default_visitor()}) } -fn traverse_ty(ty: @Ty, cx: ctx, v: visit::vt) { - if cx.rmap.contains_key(&ty.id) { return; } - cx.rmap.insert(ty.id, ()); +fn traverse_ty(ty: @Ty, cx: ctx<'a>, v: visit::vt>) { + // XXX: it shouldn't be necessary to do this + let rmap: &mut LinearSet = 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 +179,11 @@ fn traverse_ty(ty: @Ty, cx: ctx, v: visit::vt) { } fn traverse_inline_body(cx: ctx, body: &blk) { - fn traverse_expr(e: @expr, cx: ctx, v: visit::vt) { + fn traverse_expr(e: @expr, cx: ctx<'a>, v: visit::vt>) { 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 \ diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index a7bec5547c4a3..ab8d03014d62f 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}; diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index 45cf790ccee20..ba05d5bca21de 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 => () } @@ -295,7 +296,7 @@ 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)); + 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| { type_needs(cx, *uses, *subst) diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 44245e0b4e1f8..a6b6c71f387a8 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -37,7 +37,7 @@ use core::result; use core::to_bytes; use core::uint; use core::vec; -use core::hashmap::linear::LinearMap; +use core::hashmap::linear::{LinearMap, LinearSet}; use std::oldmap::HashMap; use std::oldmap; use std::smallintmap::SmallIntMap; @@ -118,7 +118,7 @@ pub struct creader_cache_key { len: uint } -type creader_cache = HashMap; +type creader_cache = @mut LinearMap; impl to_bytes::IterBytes for creader_cache_key { fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { @@ -222,7 +222,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; +pub type ProvidedMethodsMap = @mut LinearMap; // Stores the method info and definition ID of the associated trait method for // each instantiation of each provided method. @@ -245,7 +245,7 @@ pub type ctxt = @ctxt_; struct ctxt_ { diag: @syntax::diagnostic::span_handler, - interner: HashMap, + interner: @mut LinearMap, next_id: @mut uint, vecs_implicitly_copyable: bool, legacy_modes: bool, @@ -276,32 +276,32 @@ struct ctxt_ { short_names_cache: HashMap, needs_unwind_cleanup_cache: HashMap, tc_cache: @mut LinearMap, - 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, + enum_var_cache: @mut LinearMap, + trait_method_cache: @mut LinearMap, + ty_param_bounds: @mut LinearMap, + inferred_modes: @mut LinearMap, + adjustments: @mut LinearMap, normalized_cache: HashMap, 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, - supertraits: HashMap, + provided_method_sources: @mut LinearMap, + supertraits: @mut LinearMap, // 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, + destructor_for_type: @mut LinearMap, // A method will be in this list if and only if it is a destructor. - destructors: HashMap, + destructors: @mut LinearSet, // Maps a trait onto a mapping from self-ty to impl - trait_impls: HashMap> + trait_impls: @mut LinearMap> } enum tbox_flag { @@ -778,14 +778,14 @@ pub struct ty_param_substs_and_ty { ty: ty::t } -type type_cache = HashMap; +type type_cache = @mut LinearMap; -type constness_cache = HashMap; +type constness_cache = @mut LinearMap; pub type node_type_table = @mut SmallIntMap; fn mk_rcache() -> creader_cache { - return oldmap::HashMap(); + return @mut LinearMap::new(); } pub fn new_ty_hash() -> oldmap::HashMap { @@ -811,13 +811,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, @@ -831,26 +830,26 @@ pub fn mk_ctxt(s: session::Session, items: amap, intrinsic_defs: oldmap::HashMap(), 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 +862,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) -> 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 +1160,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 } } @@ -2016,7 +2015,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 +2710,6 @@ impl to_bytes::IterBytes for sty { } } -pub fn br_hashmap() -> HashMap { - 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)) { @@ -2882,7 +2877,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 +2895,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 +3032,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 +3265,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(tbl: HashMap>, +fn canon(tbl: &mut LinearMap>, +m0: ast::inferable) -> ast::inferable { 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 } } @@ -3565,7 +3561,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 +3594,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 @@ -3736,7 +3732,7 @@ 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. } @@ -3834,7 +3830,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 */ } } @@ -3920,7 +3916,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; @@ -4299,7 +4295,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 a4a5c6ddd2176..4f8f600485e54 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -235,11 +235,11 @@ pub fn ast_ty_to_ty( } 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); @@ -303,8 +303,8 @@ pub fn ast_ty_to_ty( 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"); @@ -359,7 +359,7 @@ pub fn ast_ty_to_ty( 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 4ffcd440bcf4a..cc2cf7a23c598 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). +/// (e.g. K,V in LinearMap). /// `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 c550e5c71e491..3c436ffdf878e 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 { + 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, + impl_dups: &'self mut LinearSet, 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, _, _) => { diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index c07dd563cac1c..f534519d1474e 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, + locals: @mut LinearMap, // Temporary tables: - node_types: HashMap, - node_type_substs: HashMap, - adjustments: HashMap, + node_types: @mut LinearMap, + node_type_substs: @mut LinearMap, + adjustments: @mut LinearMap, 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 { - 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,7 +1063,8 @@ 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 { node: ast::item_impl(ref ts, _, st, _), @@ -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,7 +1869,8 @@ 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 { node: ast::item_struct(_, ref generics), @@ -1950,7 +1958,7 @@ 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 { 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 diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index fa0d9e81c2deb..02102110d9bc3 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 6dfe34191d3c5..8146213d3be6e 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 53b0275f95deb..1d6c74fd899b7 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -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 0b3eca7c07df0..e1d22f4e13d32 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, + base_type_def_ids: @mut LinearMap, } 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. @@ -815,7 +814,7 @@ pub impl CoherenceChecker { // External crate handling - fn add_impls_for_module(&self, impls_seen: HashMap, + fn add_impls_for_module(&self, impls_seen: &mut LinearSet, 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,7 +997,7 @@ 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. diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index a74ea5dff8ba0..cc40a65ff2c28 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -280,7 +280,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, let tcx = ccx.tcx; - let region_paramd = tcx.region_paramd_items.find(&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), @@ -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 f0b5ce9ff60a5..45c7ad2f8f81d 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; +enum CombineMapType { + Lub, Glb +} + +type CombineMap = LinearMap; pub struct RegionVarBindings { tcx: ty::ctxt, var_spans: ~[span], - constraints: HashMap, + constraints: LinearMap, 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 { 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; - -fn TwoRegionsMap() -> TwoRegionsMap { - return HashMap(); -} +type TwoRegionsMap = LinearSet; 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 a5265deafdde9..817aafc2b199b 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -55,12 +55,12 @@ 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}; @@ -171,7 +171,7 @@ pub impl vtable_origin { } } -pub type vtable_map = HashMap; +pub type vtable_map = @mut LinearMap; pub struct CrateCtxt { // A mapping from method call sites to traits that have that method. @@ -209,7 +209,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") } @@ -337,14 +337,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: HashMap(), + vtable_map: @mut LinearMap::new(), coherence_info: @coherence::CoherenceInfo(), tcx: tcx }; diff --git a/src/librustc/rustc.rc b/src/librustc/rustc.rc index 6a778a8336190..f26a97b48a1ff 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 1cd3982c7e84b..2a2d921ba8636 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(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; +pub type stmt_set = @mut LinearSet; // // Local Variables: From 17459d0bd355e550a06ee044de077bcd552e9cc5 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sat, 23 Mar 2013 18:55:58 -0400 Subject: [PATCH 5/8] rustc: Purge of HashMap, fixing segfaulting cases Various FIXME comments added around to denote copies which when removed cause the compiler to segfault at some point before stage2. None of these copies should even be necessary. --- src/librustc/metadata/tyencode.rs | 2 +- src/librustc/middle/astencode.rs | 6 ++- src/librustc/middle/const_eval.rs | 3 +- src/librustc/middle/kind.rs | 14 ++++--- src/librustc/middle/trans/base.rs | 19 ++++++---- src/librustc/middle/trans/callee.rs | 14 +++++-- src/librustc/middle/trans/common.rs | 7 ++-- src/librustc/middle/trans/expr.rs | 2 +- src/librustc/middle/trans/glue.rs | 2 +- src/librustc/middle/trans/reachable.rs | 4 +- src/librustc/middle/trans/reflect.rs | 2 +- src/librustc/middle/trans/type_of.rs | 12 ++++-- src/librustc/middle/trans/type_use.rs | 9 ++++- src/librustc/middle/ty.rs | 37 +++++++++---------- src/librustc/middle/typeck/check/mod.rs | 4 +- src/librustc/middle/typeck/check/writeback.rs | 2 +- src/librustc/middle/typeck/mod.rs | 5 +-- 17 files changed, 83 insertions(+), 61 deletions(-) diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 021d472fa0ef0..6734abb7e8075 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -61,7 +61,7 @@ pub fn enc_ty(w: @io::Writer, cx: @ctxt, t: ty::t) { match cx.abbrevs { ac_no_abbrevs => { let result_str = match cx.tcx.short_names_cache.find(&t) { - Some(s) => /*bad*/copy *s, + Some(&s) => /*bad*/copy *s, None => { let s = do io::with_str_writer |wr| { enc_sty(wr, cx, /*bad*/copy ty::get(t).sty); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index e1863a9f40023..1e1dde3303788 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -856,7 +856,9 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext, do ebml_w.tag(c::tag_table_node_type_subst) { ebml_w.id(id); do ebml_w.tag(c::tag_table_val) { - ebml_w.emit_tys(ecx, /*bad*/copy *tys) + // FIXME(#5562): removing this copy causes a segfault + // before stage2 + ebml_w.emit_tys(ecx, /*bad*/copy **tys) } } } @@ -922,7 +924,7 @@ fn encode_side_tables_for_id(ecx: @e::EncodeContext, } } - for maps.method_map.find(&id).each |mme| { + for maps.method_map.find(&id).each |&mme| { do ebml_w.tag(c::tag_table_method_map) { ebml_w.id(id); do ebml_w.tag(c::tag_table_val) { diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 8cf6e931c92cb..a6c954b385190 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -17,7 +17,6 @@ use middle; use core::float; use core::vec; -use std::oldmap::HashMap; use syntax::{ast, ast_map, ast_util, visit}; use syntax::ast::*; @@ -194,7 +193,7 @@ pub fn lookup_const_by_id(tcx: ty::ctxt, mutbl_map: @mut LinearSet::new(), root_map: @mut LinearMap::new(), last_use_map: @mut LinearMap::new(), - method_map: HashMap(), + method_map: @mut LinearMap::new(), vtable_map: @mut LinearMap::new(), write_guard_map: @mut LinearSet::new(), moves_map: @mut LinearSet::new(), diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index ab3dc75c79f17..ca301182e6f32 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -274,6 +274,8 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt) { _ => e.id }; for cx.tcx.node_type_substs.find(&type_parameter_id).each |ts| { + // FIXME(#5562): removing this copy causes a segfault before stage2 + let ts = /*bad*/ copy **ts; let bounds = match e.node { expr_path(_) => { let did = ast_util::def_id_of_def(*cx.tcx.def_map.get(&e.id)); @@ -289,15 +291,15 @@ pub fn check_expr(e: @expr, cx: Context, v: visit::vt) { ~"non path/method call expr has type substs??") } }; - if vec::len(*ts) != vec::len(*bounds) { + if ts.len() != bounds.len() { // Fail earlier to make debugging easier fail!(fmt!("internal error: in kind::check_expr, length \ mismatch between actual and declared bounds: actual = \ %s (%u tys), declared = %? (%u tys)", - tys_to_str(cx.tcx, *ts), ts.len(), - *bounds, (*bounds).len())); + tys_to_str(cx.tcx, ts), ts.len(), + *bounds, bounds.len())); } - for vec::each2(*ts, *bounds) |ty, bound| { + for vec::each2(ts, *bounds) |ty, bound| { check_bounds(cx, type_parameter_id, e.span, *ty, *bound) } } @@ -335,9 +337,11 @@ fn check_ty(aty: @Ty, cx: Context, v: visit::vt) { match aty.node { ty_path(_, id) => { for cx.tcx.node_type_substs.find(&id).each |ts| { + // FIXME(#5562): removing this copy causes a segfault before stage2 + let ts = /*bad*/ copy **ts; let did = ast_util::def_id_of_def(*cx.tcx.def_map.get(&id)); let bounds = ty::lookup_item_type(cx.tcx, did).bounds; - for vec::each2(*ts, *bounds) |ty, bound| { + for vec::each2(ts, *bounds) |ty, bound| { check_bounds(cx, aty.id, aty.span, *ty, *bound) } } diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index a4f0c7c73cd4e..680e9c7053dcf 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -72,8 +72,7 @@ use core::int; use core::io; use core::libc::{c_uint, c_ulonglong}; use core::uint; -use std::oldmap::HashMap; -use std::{oldmap, time, list}; +use std::{time, list}; use syntax::ast::ident; use syntax::ast_map::{path, path_elt_to_str, path_mod, path_name}; use syntax::ast_util::{def_id_of_def, local_def, path_to_ident}; @@ -170,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) }); @@ -3061,7 +3066,7 @@ pub fn trans_crate(sess: session::Session, llmod: llmod, td: td, tn: tn, - externs: HashMap(), + externs: @mut LinearMap::new(), intrinsics: intrinsics, item_vals: @mut LinearMap::new(), exp_map2: emap2, @@ -3082,8 +3087,8 @@ pub fn trans_crate(sess: session::Session, const_globals: @mut LinearMap::new(), const_values: @mut LinearMap::new(), module_data: @mut LinearMap::new(), - lltypes: ty::new_ty_hash(), - llsizingtypes: ty::new_ty_hash(), + lltypes: @mut LinearMap::new(), + llsizingtypes: @mut LinearMap::new(), adt_reprs: @mut LinearMap::new(), names: new_namegen(sess.parse_sess.interner), next_addrspace: new_addrspace_gen(), diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index e2a5b5f500976..dd882087d384c 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 } @@ -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, diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 437562e3a1344..5805f7fbe3a06 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -52,7 +52,6 @@ use core::str; use core::to_bytes; use core::vec::raw::to_ptr; use core::vec; -use std::oldmap::{HashMap, Set}; use syntax::ast::ident; use syntax::ast_map::{path, path_elt}; use syntax::codemap::span; @@ -156,7 +155,7 @@ pub fn BuilderRef_res(B: BuilderRef) -> BuilderRef_res { } } -pub type ExternMap = HashMap<@str, ValueRef>; +pub type ExternMap = @mut LinearMap<@str, ValueRef>; // Crate context. Every crate we compile has one of these. pub struct CrateContext { @@ -203,8 +202,8 @@ pub struct CrateContext { // Cache of emitted const values const_values: @mut LinearMap, module_data: @mut LinearMap<~str, ValueRef>, - lltypes: HashMap, - llsizingtypes: HashMap, + lltypes: @mut LinearMap, + llsizingtypes: @mut LinearMap, adt_reprs: @mut LinearMap, names: namegen, next_addrspace: addrspace_gen, diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 2fad2bd9b606d..33576a682a7f1 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -1647,7 +1647,7 @@ fn trans_overloaded_op(bcx: block, dest: Dest, +autoref_arg: AutorefArg) -> block { - let origin = bcx.ccx().maps.method_map.get(&expr.id); + let origin = *bcx.ccx().maps.method_map.get(&expr.id); let fty = node_id_type(bcx, expr.callee_id); return callee::trans_call_inner( bcx, expr.info(), fty, diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index bf5a699ed8237..1639c6b414d19 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/reachable.rs b/src/librustc/middle/trans/reachable.rs index c025d970db70f..026a27dce2c7d 100644 --- a/src/librustc/middle/trans/reachable.rs +++ b/src/librustc/middle/trans/reachable.rs @@ -193,7 +193,7 @@ fn traverse_inline_body(cx: ctx, body: &blk) { } expr_field(_, _, _) => { match cx.method_map.find(&e.id) { - Some(typeck::method_map_entry { + Some(&typeck::method_map_entry { origin: typeck::method_static(did), _ }) => { @@ -204,7 +204,7 @@ fn traverse_inline_body(cx: ctx, body: &blk) { } expr_method_call(*) => { match cx.method_map.find(&e.id) { - Some(typeck::method_map_entry { + Some(&typeck::method_map_entry { origin: typeck::method_static(did), _ }) => { diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index 41e63cc878e13..b8145e6532602 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/type_of.rs b/src/librustc/middle/trans/type_of.rs index ab8d03014d62f..8e4719d2ccc7d 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -101,8 +101,10 @@ pub fn type_of_non_gc_box(cx: @CrateContext, t: ty::t) -> TypeRef { // behavior. pub fn sizing_type_of(cx: @CrateContext, t: ty::t) -> TypeRef { - if cx.llsizingtypes.contains_key(&t) { - return cx.llsizingtypes.get(&t); + match cx.llsizingtypes.find(&t) { + // FIXME(#5562): removing this copy causes a segfault in stage1 core + Some(t) => return /*bad*/ copy *t, + None => () } let llsizingty = match ty::get(t).sty { @@ -161,7 +163,11 @@ pub fn type_of(cx: @CrateContext, t: ty::t) -> TypeRef { debug!("type_of %?: %?", t, ty::get(t)); // Check the cache. - if cx.lltypes.contains_key(&t) { return cx.lltypes.get(&t); } + match cx.lltypes.find(&t) { + // FIXME(#5562): removing this copy causes a segfault in stage1 core + Some(t) => return /*bad*/ copy *t, + None => () + } // Replace any typedef'd types with their equivalent non-typedef // type. This ensures that all LLVM nominal types that contain diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index ba05d5bca21de..62cde5999e8d4 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/src/librustc/middle/trans/type_use.rs @@ -250,8 +250,11 @@ pub fn mark_for_method_call(cx: Context, e_id: node_id, callee_id: node_id) { match mth.origin { typeck::method_static(did) => { for cx.ccx.tcx.node_type_substs.find(&callee_id).each |ts| { + // FIXME(#5562): removing this copy causes a segfault + // before stage2 + let ts = /*bad*/ copy **ts; let type_uses = type_uses_for(cx.ccx, did, ts.len()); - for vec::each2(type_uses, *ts) |uses, subst| { + for vec::each2(type_uses, ts) |uses, subst| { type_needs(cx, *uses, *subst) } } @@ -296,9 +299,11 @@ pub fn mark_for_expr(cx: Context, e: @expr) { } expr_path(_) => { for cx.ccx.tcx.node_type_substs.find(&e.id).each |ts| { + // FIXME(#5562): removing this copy causes a segfault before stage2 + let ts = copy **ts; let id = ast_util::def_id_of_def(*cx.ccx.tcx.def_map.get(&e.id)); let uses_for_ts = type_uses_for(cx.ccx, id, ts.len()); - for vec::each2(uses_for_ts, *ts) |uses, subst| { + for vec::each2(uses_for_ts, ts) |uses, subst| { type_needs(cx, *uses, *subst) } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index a6b6c71f387a8..74146e56da29e 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -38,8 +38,6 @@ use core::to_bytes; use core::uint; use core::vec; use core::hashmap::linear::{LinearMap, LinearSet}; -use std::oldmap::HashMap; -use std::oldmap; use std::smallintmap::SmallIntMap; use syntax::ast::*; use syntax::ast_util::{is_local, local_def}; @@ -265,16 +263,16 @@ 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_type_substs: @mut LinearMap, items: ast_map::map, - intrinsic_defs: HashMap, + intrinsic_defs: @mut LinearMap, freevars: freevars::freevar_map, tcache: type_cache, rcache: creader_cache, ccache: constness_cache, - short_names_cache: HashMap, - needs_unwind_cleanup_cache: HashMap, + short_names_cache: @mut LinearMap, + needs_unwind_cleanup_cache: @mut LinearMap, tc_cache: @mut LinearMap, ast_ty_to_ty_cache: @mut LinearMap, enum_var_cache: @mut LinearMap, @@ -282,7 +280,7 @@ struct ctxt_ { ty_param_bounds: @mut LinearMap, inferred_modes: @mut LinearMap, adjustments: @mut LinearMap, - normalized_cache: HashMap, + normalized_cache: @mut LinearMap, 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 @@ -788,8 +786,8 @@ fn mk_rcache() -> creader_cache { return @mut LinearMap::new(); } -pub fn new_ty_hash() -> oldmap::HashMap { - oldmap::HashMap() +pub fn new_ty_hash() -> @mut LinearMap { + @mut LinearMap::new() } pub fn mk_ctxt(s: session::Session, @@ -826,9 +824,9 @@ 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: @mut LinearMap::new(), rcache: mk_rcache(), @@ -1621,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, + tycache: &mut LinearSet, 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; @@ -2724,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 } } @@ -4164,7 +4161,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 => () } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index f534519d1474e..3af23bb20ac7d 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -3453,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/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index 1d6c74fd899b7..9ba98a4d27f10 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 { diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index 817aafc2b199b..b783a099e160f 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -60,7 +60,6 @@ use core::result; use core::vec; use std::list::{List, Nil, Cons}; use std::list; -use std::oldmap::HashMap; 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; +pub type method_map = @mut LinearMap; // Resolutions for bounds of all parameters, left to right, for a given path. pub type vtable_res = @~[vtable_origin]; @@ -343,7 +342,7 @@ pub fn check_crate(tcx: ty::ctxt, let time_passes = tcx.sess.time_passes(); let ccx = @mut CrateCtxt { trait_map: trait_map, - method_map: HashMap(), + method_map: @mut LinearMap::new(), vtable_map: @mut LinearMap::new(), coherence_info: @coherence::CoherenceInfo(), tcx: tcx From b53057f49d7f3994fa394df493f22d9bfdf2df8f Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sat, 23 Mar 2013 21:22:00 -0400 Subject: [PATCH 6/8] test: Remove uses of oldmap::HashMap --- src/test/auxiliary/issue-2631-a.rs | 8 ++-- src/test/bench/core-std.rs | 20 --------- src/test/bench/graph500-bfs.rs | 30 ++++++++----- src/test/bench/shootout-chameneos-redux.rs | 2 - src/test/bench/shootout-k-nucleotide-pipes.rs | 37 +++++++++------- .../borrowck-borrowed-uniq-rvalue.rs | 8 ++-- src/test/compile-fail/for-loop-decl.rs | 6 +-- src/test/run-pass/extern-mod-syntax.rs | 2 +- src/test/run-pass/hashmap-memory.rs | 44 +++++++------------ src/test/run-pass/issue-1696.rs | 5 +-- src/test/run-pass/issue-2631-b.rs | 7 ++- src/test/run-pass/issue-2804-2.rs | 8 ++-- src/test/run-pass/issue-2804.rs | 14 +++--- src/test/run-pass/issue-3026.rs | 6 +-- src/test/run-pass/issue-3559.rs | 3 +- src/test/run-pass/issue-4092.rs | 4 +- 16 files changed, 88 insertions(+), 116 deletions(-) diff --git a/src/test/auxiliary/issue-2631-a.rs b/src/test/auxiliary/issue-2631-a.rs index f7788c7d57aeb..fad72ee4eb360 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(req: header_map) { - let _x = copy *(copy *req.get(&~"METHOD"))[0u]; +pub fn request(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 eecf509998b58..42c79f3af7168 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -14,7 +14,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 +28,6 @@ fn main() { bench!(shift_push); bench!(read_line); - bench!(str_set); bench!(vec_plus); bench!(vec_append); bench!(vec_push_all); @@ -73,24 +71,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 b99dfa8bacbc4..899b86b5cfb03 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::() + 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::(); + 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 111219974d098..a81f7fd76e77b 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 f0847b635b4bd..f4ae799aace70 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 07a68bfb06818..6dbfa5dd53847 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 = - HashMap::(); + let mut buggy_map :LinearMap = + LinearMap::new::(); 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 952bf8c060a8a..918d8f00d7842 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 + vars: LinearMap } 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 2a7843bdccd22..b6b2e0042633d 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 5d8ac2f1ab5fa..4234c064e8d38 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, input: ~str) { - let intermediates = oldmap::HashMap(); - - fn emit(im: oldmap::HashMap<~str, int>, ctrl: SharedChan, 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, 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 8697e5c8c3cf6..5f8b8d2983072 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 5f5e2f9fc3084..b22c423ed0412 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::(m); + request::(&m); } diff --git a/src/test/run-pass/issue-2804-2.rs b/src/test/run-pass/issue-2804-2.rs index 9fe88227c4435..8934c3935c087 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 2b4acc34f4659..3d1a2c3df5d3b 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 32f7d2ee07cee..022d3f6fceb05 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 = HashMap::(); + let mut buggy_map: LinearMap = LinearMap::new::(); 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 0486357dc6968..46a02ff15929c 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 5cfb5809feb71..85cb3e3207ee7 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); } From dbe1354321e6d8aa5bfe09ac33d780a97d3f7788 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sat, 23 Mar 2013 21:45:27 -0400 Subject: [PATCH 7/8] Move ast_map::map to LinearMap --- src/librustc/metadata/encoder.rs | 4 +-- src/librustc/middle/check_const.rs | 2 +- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/privacy.rs | 20 ++++++------ src/librustc/middle/trans/base.rs | 17 +++++----- src/librustc/middle/trans/callee.rs | 2 +- src/librustc/middle/trans/consts.rs | 2 +- src/librustc/middle/trans/debuginfo.rs | 2 +- src/librustc/middle/trans/foreign.rs | 4 +-- src/librustc/middle/trans/meth.rs | 10 +++--- src/librustc/middle/trans/monomorphize.rs | 4 +-- src/librustc/middle/trans/reachable.rs | 25 +++++++------- src/librustc/middle/trans/type_use.rs | 2 +- src/librustc/middle/ty.rs | 26 ++++++++------- src/librustc/middle/typeck/check/method.rs | 2 +- src/librustc/middle/typeck/check/mod.rs | 8 ++--- src/librustc/middle/typeck/coherence.rs | 4 +-- src/librustc/middle/typeck/collect.rs | 8 ++--- src/librustc/middle/typeck/mod.rs | 2 +- src/librustc/util/ppaux.rs | 14 ++++---- src/librustdoc/attr_pass.rs | 6 ++-- src/librustdoc/prune_hidden_pass.rs | 2 +- src/librustdoc/prune_private_pass.rs | 4 +-- src/librustdoc/tystr_pass.rs | 14 ++++---- src/libsyntax/ast_map.rs | 38 +++++++++++----------- 25 files changed, 111 insertions(+), 113 deletions(-) diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 675a7837173a5..490fa357bb537 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -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, diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 5a5ba6918d718..f9212d1ff7b55 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -240,7 +240,7 @@ pub fn check_item_recursion(sess: Session, match env.def_map.find(&e.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/const_eval.rs b/src/librustc/middle/const_eval.rs index a6c954b385190..a25d873af41ba 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -182,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 }, diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 4e349d1506d4d..50e8ed23446de 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() { diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 680e9c7053dcf..fb05cf0b73989 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -2065,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"), @@ -2336,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 and substs , @@ -2393,7 +2392,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef { 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)]); diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index dd882087d384c..7ba0b706e436e 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -268,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, _, diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index a929a53a769b9..1362f97c08e85 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -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), _ }, _) => { diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 50c7017029be6..45884c9c3b424 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -849,7 +849,7 @@ pub fn create_function(fcx: fn_ctxt) -> @Metadata { 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/foreign.rs b/src/librustc/middle/trans/foreign.rs index 05acdae1bb017..08f86bfb2dff5 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") }; @@ -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/meth.rs b/src/librustc/middle/trans/meth.rs index 66a28a03bd845..1f348bc3e24df 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 } @@ -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() } diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index 77e521b4af06b..659b3f6c7acc3 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -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), @@ -172,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 026a27dce2c7d..4ac3ac0555f5e 100644 --- a/src/librustc/middle/trans/reachable.rs +++ b/src/librustc/middle/trans/reachable.rs @@ -71,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); + } + _ => () } } diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index 62cde5999e8d4..e19afb0d5077d 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/src/librustc/middle/trans/type_use.rs @@ -98,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)) }; diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 74146e56da29e..fcbf34dca9054 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -3538,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), _ }, _)) => @@ -3627,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, _, _), _}, _)) => { @@ -3663,7 +3663,7 @@ fn struct_ctor_id(cx: ctxt, struct_did: ast::def_id) -> Option { } 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| @@ -3735,7 +3735,7 @@ pub fn ty_dtor(cx: ctxt, struct_id: def_id) -> DtorKind { 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), _ }, _), @@ -3762,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(_) => { @@ -3805,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)); } } @@ -3839,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, _), _ @@ -3955,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) @@ -3963,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) diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 3c436ffdf878e..fcaf1c08342be 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -1257,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 3af23bb20ac7d..005b5377b629e 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -1066,7 +1066,7 @@ pub fn impl_self_ty(vcx: &VtableContext, 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, _), _ }, _)) => { @@ -1074,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, _ @@ -1872,7 +1872,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, 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), _ }, _)) => { @@ -1960,7 +1960,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, region_parameterized = 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), _ }, _)) => { diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index e1d22f4e13d32..7e97edf8f8aa6 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -801,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; } _ => { @@ -1003,7 +1003,7 @@ pub impl CoherenceChecker { // 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 cc40a65ff2c28..a1fcf1029880b 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 => { @@ -281,7 +281,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, let tcx = ccx.tcx; let region_paramd = tcx.region_paramd_items.find(&id).map_consume(|x| *x); - match tcx.items.get(&id) { + 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); } diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index b783a099e160f..77022b80feba0 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -291,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() => { diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index eb63d675d80af..bf2a35dbf7cb3 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!("", 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!("", diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs index 0bf2f50e63fc5..30c8ff6964ef8 100644 --- a/src/librustdoc/attr_pass.rs +++ b/src/librustdoc/attr_pass.rs @@ -114,7 +114,7 @@ fn parse_item_attrs( 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 bbd975dd55ace..3c069e59e7ae3 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 b6aebf8b14fe6..e6f21b5df5457 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 50ec41e80bc09..229a0a3ff0f3d 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/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 8989bb88cd7f4..eef14ac8b7a5c 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; +pub type map = @mut LinearMap; 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(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) } } From d69108d8f78a9b5a8669606b62fe6df6409d17e7 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sun, 24 Mar 2013 01:11:42 -0400 Subject: [PATCH 8/8] std: Remove the oldmap module --- src/libstd/oldmap.rs | 388 ------------------------------------- src/libstd/std.rc | 1 - src/test/bench/core-std.rs | 1 - 3 files changed, 390 deletions(-) delete mode 100644 src/libstd/oldmap.rs diff --git a/src/libstd/oldmap.rs b/src/libstd/oldmap.rs deleted file mode 100644 index b40237cf5848f..0000000000000 --- 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 or the MIT license -// , 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 = HashMap; - -pub type HashMap = chained::T; - -pub mod chained { - use core::ops; - use core::prelude::*; - use core::hashmap::linear::LinearMap; - - struct HashMap_ { - priv map: LinearMap - } - - pub type T = @mut HashMap_; - - pub impl HashMap_ { - fn clear(&mut self) { - self.map.clear() - } - } - - impl Container for HashMap_ { - fn len(&const self) -> uint { self.map.len() } - fn is_empty(&const self) -> bool { self.map.is_empty() } - } - - pub impl HashMap_ { - 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 HashMap_ { - fn find(&self, k: &K) -> Option { - 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 ops::Index - for HashMap_ { - fn index(&self, k: K) -> V { - self.get(&k) - } - } - - pub fn mk() -> T { - @mut HashMap_{map: LinearMap::new()} - } -} - -/* -Function: hashmap - -Construct a hashmap. -*/ -pub fn HashMap() - -> HashMap { - chained::mk() -} - -/// Convenience function for adding keys to a hashmap with nil type keys -pub fn set_add(set: Set, key: K) - -> bool { - set.insert(key, ()) -} - -/// Convert a set into a vector. -pub fn vec_from_set(s: Set) -> ~[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( - items: &[(K, V)]) -> HashMap { - 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 = - HashMap::(); - 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 = - HashMap::(); - 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 = - HashMap::(); - 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 = - HashMap::(); - 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/std.rc b/src/libstd/std.rc index aa5371671c194..7d46e73a697f8 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/test/bench/core-std.rs b/src/test/bench/core-std.rs index 42c79f3af7168..0a68d29ac560e 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -13,7 +13,6 @@ extern mod std; use std::time::precise_time_s; -use std::oldmap; use core::io::{Reader, ReaderUtil}; use core::rand::RngUtil;