---

yaml
---
r: 103547
b: refs/heads/auto
c: 42389b7
h: refs/heads/master
i:
  103545: 4095ce4
  103543: 18a4f15
v: v3

Author: alexcrichton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 5862c0c28b7d25f1a1f8fd9165eff1f6f3d191d8
+refs/heads/auto: 42389b7069a21679d6b92229d825b860121125d9
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libcollections/hashmap.rs

@@ -358,13 +358,13 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
     pub fn with_capacity(capacity: uint) -> HashMap<K, V> {
         let mut r = rand::task_rng();
         let hasher = SipHasher::new_with_keys(r.gen(), r.gen());
-        HashMap::with_capacity_and_hasher(hasher, capacity)
+        HashMap::with_capacity_and_hasher(capacity, hasher)
     }
 }
 
 impl<K: Hash<S> + Eq, V, S, H: Hasher<S>> HashMap<K, V, H> {
     pub fn with_hasher(hasher: H) -> HashMap<K, V, H> {
-        HashMap::with_capacity_and_hasher(hasher, INITIAL_CAPACITY)
+        HashMap::with_capacity_and_hasher(INITIAL_CAPACITY, hasher)
     }
 
     /// Create an empty HashMap with space for at least `capacity`
@@ -374,7 +374,7 @@ impl<K: Hash<S> + Eq, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// is designed to allow HashMaps to be resistant to attacks that
     /// cause many collisions and very poor performance. Setting it
     /// manually using this function can expose a DoS attack vector.
-    pub fn with_capacity_and_hasher(hasher: H, capacity: uint) -> HashMap<K, V, H> {
+    pub fn with_capacity_and_hasher(capacity: uint, hasher: H) -> HashMap<K, V, H> {
         let cap = max(INITIAL_CAPACITY, capacity);
         HashMap {
             hasher: hasher,
@@ -587,7 +587,8 @@ impl<K: Hash<S> + Eq, V: Eq, S, H: Hasher<S>> Eq for HashMap<K, V, H> {
 
 impl<K: Hash<S> + Eq + Clone, V:Clone, S, H: Hasher<S> + Clone> Clone for HashMap<K, V, H> {
     fn clone(&self) -> HashMap<K, V, H> {
-        let mut new_map = HashMap::with_capacity_and_hasher(self.hasher.clone(), self.len());
+        let mut new_map = HashMap::with_capacity_and_hasher(self.len(),
+                                                            self.hasher.clone());
         for (key, value) in self.iter() {
             new_map.insert((*key).clone(), (*value).clone());
         }
@@ -714,7 +715,7 @@ impl<K> Iterator<K> for SetMoveItems<K> {
 impl<K: Hash<S> + Eq, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> {
     fn from_iterator<T: Iterator<(K, V)>>(iter: &mut T) -> HashMap<K, V, H> {
         let (lower, _) = iter.size_hint();
-        let mut map = HashMap::with_capacity_and_hasher(Default::default(), lower);
+        let mut map = HashMap::with_capacity_and_hasher(lower, Default::default());
         map.extend(iter);
         map
     }
@@ -730,7 +731,7 @@ impl<K: Hash<S> + Eq, V, S, H: Hasher<S> + Default> Extendable<(K, V)> for HashM
 
 impl<K: Hash<S> + Eq, V, S, H: Hasher<S> + Default> Default for HashMap<K, V, H> {
     fn default() -> HashMap<K, V, H> {
-        HashMap::with_capacity_and_hasher(Default::default(), INITIAL_CAPACITY)
+        HashMap::with_capacity_and_hasher(INITIAL_CAPACITY, Default::default())
     }
 }
 
@@ -802,7 +803,7 @@ impl<T: Hash<SipState> + Eq> HashSet<T, SipHasher> {
 
 impl<T: Hash<S> + Eq, S, H: Hasher<S>> HashSet<T, H> {
     pub fn with_hasher(hasher: H) -> HashSet<T, H> {
-        HashSet::with_capacity_and_hasher(hasher, INITIAL_CAPACITY)
+        HashSet::with_capacity_and_hasher(INITIAL_CAPACITY, hasher)
     }
 
     /// Create an empty HashSet with space for at least `capacity`
@@ -812,9 +813,9 @@ impl<T: Hash<S> + Eq, S, H: Hasher<S>> HashSet<T, H> {
     /// are designed to allow HashSets to be resistant to attacks that
     /// cause many collisions and very poor performance. Setting them
     /// manually using this function can expose a DoS attack vector.
-    pub fn with_capacity_and_hasher(hasher: H, capacity: uint) -> HashSet<T, H> {
+    pub fn with_capacity_and_hasher(capacity: uint, hasher: H) -> HashSet<T, H> {
         HashSet {
-            map: HashMap::with_capacity_and_hasher(hasher, capacity)
+            map: HashMap::with_capacity_and_hasher(capacity, hasher)
         }
     }
 
@@ -902,7 +903,7 @@ impl<T: fmt::Show + Hash<S> + Eq, S, H: Hasher<S>> fmt::Show for HashSet<T, H> {
 impl<T: Hash<S> + Eq, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T, H> {
     fn from_iterator<Iter: Iterator<T>>(iter: &mut Iter) -> HashSet<T, H> {
         let (lower, _) = iter.size_hint();
-        let mut set = HashSet::with_capacity_and_hasher(Default::default(), lower);
+        let mut set = HashSet::with_capacity_and_hasher(lower, Default::default());
         set.extend(iter);
         set
     }

branches/auto/src/librustc/driver/driver.rs

@@ -27,7 +27,6 @@ use middle::{trans, freevars, kind, ty, typeck, lint, astencode, reachable};
 use middle;
 use util::common::time;
 use util::ppaux;
-use util::nodemap::NodeSet;
 
 use serialize::{json, Encodable};
 
@@ -39,7 +38,7 @@ use std::os;
 use std::vec;
 use std::vec_ng::Vec;
 use std::vec_ng;
-use collections::HashMap;
+use collections::{HashMap, HashSet};
 use getopts::{optopt, optmulti, optflag, optflagopt, opt};
 use MaybeHasArg = getopts::Maybe;
 use OccurOptional = getopts::Optional;
@@ -224,12 +223,8 @@ pub fn phase_2_configure_and_expand(sess: Session,
                  front::config::strip_unconfigured_items(krate));
 
     krate = time(time_passes, "expansion", krate, |krate| {
-        let cfg = syntax::ext::expand::ExpansionConfig {
-            loader: loader,
-            deriving_hash_type_parameter: sess.features.default_type_params.get()
-        };
         syntax::ext::expand::expand_crate(sess.parse_sess,
-                                          cfg,
+                                          loader,
                                           krate)
     });
     // dump the syntax-time crates
@@ -263,7 +258,7 @@ pub struct CrateAnalysis {
     public_items: middle::privacy::PublicItems,
     ty_cx: ty::ctxt,
     maps: astencode::Maps,
-    reachable: @RefCell<NodeSet>,
+    reachable: @RefCell<HashSet<ast::NodeId>>
 }
 
 /// Run the resolution, typechecking, region checking and other

branches/auto/src/librustc/front/test.rs

@@ -28,7 +28,6 @@ use syntax::attr;
 use syntax::codemap::{DUMMY_SP, Span, ExpnInfo, NameAndSpan, MacroAttribute};
 use syntax::codemap;
 use syntax::ext::base::ExtCtxt;
-use syntax::ext::expand::ExpansionConfig;
 use syntax::fold::Folder;
 use syntax::fold;
 use syntax::opt_vec;
@@ -166,11 +165,7 @@ fn generate_test_harness(sess: session::Session, krate: ast::Crate)
     let loader = &mut Loader::new(sess);
     let mut cx: TestCtxt = TestCtxt {
         sess: sess,
-        ext_cx: ExtCtxt::new(sess.parse_sess, sess.opts.cfg.clone(),
-                             ExpansionConfig {
-                                 loader: loader,
-                                 deriving_hash_type_parameter: false,
-                             }),
+        ext_cx: ExtCtxt::new(sess.parse_sess, sess.opts.cfg.clone(), loader),
         path: RefCell::new(~[]),
         testfns: RefCell::new(~[]),
         is_test_crate: is_test_crate(&krate),

branches/auto/src/librustc/lib.rs

@@ -29,7 +29,7 @@ This API is completely unstable and subject to change.
 
 #[allow(deprecated)];
 #[feature(macro_rules, globs, struct_variant, managed_boxes)];
-#[feature(quote, default_type_params)];
+#[feature(quote)];
 
 extern crate extra;
 extern crate flate;
@@ -125,7 +125,6 @@ pub mod util {
     pub mod common;
     pub mod ppaux;
     pub mod sha2;
-    pub mod nodemap;
 }
 
 pub mod lib {

branches/auto/src/librustc/metadata/encoder.rs

@@ -23,7 +23,6 @@ use middle::astencode;
 use middle::ty;
 use middle::typeck;
 use middle;
-use util::nodemap::{NodeMap, NodeSet};
 
 use serialize::Encodable;
 use std::cast;
@@ -32,7 +31,7 @@ use std::hash;
 use std::hash::Hash;
 use std::io::MemWriter;
 use std::str;
-use collections::HashMap;
+use collections::{HashMap, HashSet};
 use syntax::abi::AbiSet;
 use syntax::ast::*;
 use syntax::ast;
@@ -70,8 +69,8 @@ pub struct EncodeParams<'a> {
     diag: @SpanHandler,
     tcx: ty::ctxt,
     reexports2: middle::resolve::ExportMap2,
-    item_symbols: &'a RefCell<NodeMap<~str>>,
-    non_inlineable_statics: &'a RefCell<NodeSet>,
+    item_symbols: &'a RefCell<HashMap<ast::NodeId, ~str>>,
+    non_inlineable_statics: &'a RefCell<HashSet<ast::NodeId>>,
     link_meta: &'a LinkMeta,
     cstore: @cstore::CStore,
     encode_inlined_item: EncodeInlinedItem<'a>,
@@ -98,8 +97,8 @@ pub struct EncodeContext<'a> {
     tcx: ty::ctxt,
     stats: @Stats,
     reexports2: middle::resolve::ExportMap2,
-    item_symbols: &'a RefCell<NodeMap<~str>>,
-    non_inlineable_statics: &'a RefCell<NodeSet>,
+    item_symbols: &'a RefCell<HashMap<ast::NodeId, ~str>>,
+    non_inlineable_statics: &'a RefCell<HashSet<ast::NodeId>>,
     link_meta: &'a LinkMeta,
     cstore: &'a cstore::CStore,
     encode_inlined_item: EncodeInlinedItem<'a>,

branches/auto/src/librustc/middle/cfg/construct.rs

@@ -12,15 +12,15 @@ use middle::cfg::*;
 use middle::graph;
 use middle::typeck;
 use middle::ty;
+use collections::HashMap;
 use syntax::ast;
 use syntax::ast_util;
 use syntax::opt_vec;
-use util::nodemap::NodeMap;
 
 struct CFGBuilder {
     tcx: ty::ctxt,
     method_map: typeck::MethodMap,
-    exit_map: NodeMap<CFGIndex>,
+    exit_map: HashMap<ast::NodeId, CFGIndex>,
     graph: CFGGraph,
     loop_scopes: ~[LoopScope],
 }
@@ -35,7 +35,7 @@ pub fn construct(tcx: ty::ctxt,
                  method_map: typeck::MethodMap,
                  blk: &ast::Block) -> CFG {
     let mut cfg_builder = CFGBuilder {
-        exit_map: NodeMap::new(),
+        exit_map: HashMap::new(),
         graph: graph::Graph::new(),
         tcx: tcx,
         method_map: method_map,

branches/auto/src/librustc/middle/cfg/mod.rs

@@ -18,14 +18,14 @@ Uses `Graph` as the underlying representation.
 use middle::graph;
 use middle::ty;
 use middle::typeck;
+use collections::HashMap;
 use syntax::ast;
 use syntax::opt_vec::OptVec;
-use util::nodemap::NodeMap;
 
 mod construct;
 
 pub struct CFG {
-    exit_map: NodeMap<CFGIndex>,
+    exit_map: HashMap<ast::NodeId, CFGIndex>,
     graph: CFGGraph,
     entry: CFGIndex,
     exit: CFGIndex,

branches/auto/src/librustc/middle/const_eval.rs

@@ -16,7 +16,6 @@ use middle::astencode;
 use middle::ty;
 use middle::typeck::astconv;
 use middle;
-use util::nodemap::{DefIdMap, NodeMap};
 
 use syntax::ast::*;
 use syntax::parse::token::InternedString;
@@ -67,7 +66,7 @@ pub enum constness {
     non_const
 }
 
-type constness_cache = DefIdMap<constness>;
+type constness_cache = HashMap<ast::DefId, constness>;
 
 pub fn join(a: constness, b: constness) -> constness {
     match (a, b) {
@@ -135,9 +134,9 @@ pub fn lookup_variant_by_id(tcx: ty::ctxt,
         }
         let maps = astencode::Maps {
             root_map: @RefCell::new(HashMap::new()),
-            method_map: @RefCell::new(NodeMap::new()),
-            vtable_map: @RefCell::new(NodeMap::new()),
-            capture_map: @RefCell::new(NodeMap::new())
+            method_map: @RefCell::new(HashMap::new()),
+            vtable_map: @RefCell::new(HashMap::new()),
+            capture_map: @RefCell::new(HashMap::new())
         };
         let e = match csearch::maybe_get_item_ast(tcx, enum_def,
             |a, b, c, d| astencode::decode_inlined_item(a, b,
@@ -185,9 +184,9 @@ pub fn lookup_const_by_id(tcx: ty::ctxt, def_id: ast::DefId)
         }
         let maps = astencode::Maps {
             root_map: @RefCell::new(HashMap::new()),
-            method_map: @RefCell::new(NodeMap::new()),
-            vtable_map: @RefCell::new(NodeMap::new()),
-            capture_map: @RefCell::new(NodeMap::new())
+            method_map: @RefCell::new(HashMap::new()),
+            vtable_map: @RefCell::new(HashMap::new()),
+            capture_map: @RefCell::new(HashMap::new())
         };
         let e = match csearch::maybe_get_item_ast(tcx, def_id,
             |a, b, c, d| astencode::decode_inlined_item(a, b, maps, c, d)) {
@@ -306,7 +305,7 @@ pub fn process_crate(krate: &ast::Crate,
                      tcx: ty::ctxt) {
     let mut v = ConstEvalVisitor {
         tcx: tcx,
-        ccache: DefIdMap::new(),
+        ccache: HashMap::new(),
     };
     visit::walk_crate(&mut v, krate, ());
     tcx.sess.abort_if_errors();

branches/auto/src/librustc/middle/dataflow.rs

@@ -20,14 +20,14 @@
 use std::io;
 use std::uint;
 use std::vec;
+use collections::HashMap;
 use syntax::ast;
 use syntax::ast_util;
 use syntax::ast_util::IdRange;
 use syntax::print::{pp, pprust};
 use middle::ty;
 use middle::typeck;
 use util::ppaux::Repr;
-use util::nodemap::NodeMap;
 
 #[deriving(Clone)]
 pub struct DataFlowContext<O> {
@@ -45,7 +45,7 @@ pub struct DataFlowContext<O> {
     priv words_per_id: uint,
 
     // mapping from node to bitset index.
-    priv nodeid_to_bitset: NodeMap<uint>,
+    priv nodeid_to_bitset: HashMap<ast::NodeId,uint>,
 
     // Bit sets per id.  The following three fields (`gens`, `kills`,
     // and `on_entry`) all have the same structure. For each id in
@@ -139,7 +139,7 @@ impl<O:DataFlowOperator> DataFlowContext<O> {
             tcx: tcx,
             method_map: method_map,
             words_per_id: words_per_id,
-            nodeid_to_bitset: NodeMap::new(),
+            nodeid_to_bitset: HashMap::new(),
             bits_per_id: bits_per_id,
             oper: oper,
             gens: gens,

branches/auto/src/librustc/middle/dead.rs

@@ -16,7 +16,6 @@ use middle::lint::{allow, contains_lint, DeadCode};
 use middle::privacy;
 use middle::ty;
 use middle::typeck;
-use util::nodemap::NodeSet;
 
 use collections::HashSet;
 use syntax::ast;
@@ -253,7 +252,7 @@ impl Visitor<()> for LifeSeeder {
 
 fn create_and_seed_worklist(tcx: ty::ctxt,
                             exported_items: &privacy::ExportedItems,
-                            reachable_symbols: &NodeSet,
+                            reachable_symbols: &HashSet<ast::NodeId>,
                             krate: &ast::Crate) -> ~[ast::NodeId] {
     let mut worklist = ~[];
 
@@ -287,7 +286,7 @@ fn create_and_seed_worklist(tcx: ty::ctxt,
 fn find_live(tcx: ty::ctxt,
              method_map: typeck::MethodMap,
              exported_items: &privacy::ExportedItems,
-             reachable_symbols: &NodeSet,
+             reachable_symbols: &HashSet<ast::NodeId>,
              krate: &ast::Crate)
              -> ~HashSet<ast::NodeId> {
     let worklist = create_and_seed_worklist(tcx, exported_items,
@@ -410,7 +409,7 @@ impl Visitor<()> for DeadVisitor {
 pub fn check_crate(tcx: ty::ctxt,
                    method_map: typeck::MethodMap,
                    exported_items: &privacy::ExportedItems,
-                   reachable_symbols: &NodeSet,
+                   reachable_symbols: &HashSet<ast::NodeId>,
                    krate: &ast::Crate) {
     let live_symbols = find_live(tcx, method_map, exported_items,
                                  reachable_symbols, krate);