auto merge of #14538 : alexcrichton/rust/libcollections, r=brson

As with the previous commit with `librand`, this commit shuffles around some
`collections` code. The new state of the world is similar to that of librand:

* The libcollections crate now only depends on libcore and liballoc.
* The standard library has a new module, `std::collections`. All functionality
  of libcollections is reexported through this module.

I would like to stress that this change is purely cosmetic. There are very few
alterations to these primitives.

There are a number of notable points about the new organization:

* std::{str, slice, string, vec} all moved to libcollections. There is no reason
  that these primitives shouldn't be necessarily usable in a freestanding
  context that has allocation. These are all reexported in their usual places in
  the standard library.

* The `hashmap`, and transitively the `lru_cache`, modules no longer reside in
  `libcollections`, but rather in libstd. The reason for this is because the
  `HashMap::new` contructor requires access to the OSRng for initially seeding
  the hash map. Beyond this requirement, there is no reason that the hashmap
  could not move to libcollections.

  I do, however, have a plan to move the hash map to the collections module. The
  `HashMap::new` function could be altered to require that the `H` hasher
  parameter ascribe to the `Default` trait, allowing the entire `hashmap` module
  to live in libcollections. The key idea would be that the default hasher would
  be different in libstd. Something along the lines of:

      // src/libstd/collections/mod.rs

      pub type HashMap<K, V, H = RandomizedSipHasher> =
            core_collections::HashMap<K, V, H>;

  This is not possible today because you cannot invoke static methods through
  type aliases. If we modified the compiler, however, to allow invocation of
  static methods through type aliases, then this type definition would
  essentially be switching the default hasher from `SipHasher` in libcollections
  to a libstd-defined `RandomizedSipHasher` type. This type's `Default`
  implementation would randomly seed the `SipHasher` instance, and otherwise
  perform the same as `SipHasher`.

  This future state doesn't seem incredibly far off, but until that time comes,
  the hashmap module will live in libstd to not compromise on functionality.

* In preparation for the hashmap moving to libcollections, the `hash` module has
  moved from libstd to libcollections. A previously snapshotted commit enables a
  distinct `Writer` trait to live in the `hash` module which `Hash`
  implementations are now parameterized over.

  Due to using a custom trait, the `SipHasher` implementation has lost its
  specialized methods for writing integers. These can be re-added
  backwards-compatibly in the future via default methods if necessary, but the
  FNV hashing should satisfy much of the need for speedier hashing.

A list of breaking changes:

* HashMap::{get, get_mut} no longer fails with the key formatted into the error
  message with `{:?}`, instead, a generic message is printed. With backtraces,
  it should still be not-too-hard to track down errors.

* The HashMap, HashSet, and LruCache types are now available through
  std::collections instead of the collections crate.

* Manual implementations of hash should be parameterized over `hash::Writer`
  instead of just `Writer`.

[breaking-change]

Author: bors

mk/crates.mk

@@ -60,36 +60,36 @@ DEPS_core :=
 DEPS_rlibc :=
 DEPS_alloc := core libc native:jemalloc
 DEPS_debug := std
-DEPS_std := core rand libc alloc native:rustrt native:backtrace
+DEPS_std := core rand libc alloc collections native:rustrt native:backtrace
 DEPS_graphviz := std
 DEPS_green := std native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
-DEPS_syntax := std term serialize collections log fmt_macros debug
+DEPS_syntax := std term serialize log fmt_macros debug
 DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
-              collections time log graphviz debug
-DEPS_rustdoc := rustc native:hoedown serialize sync getopts collections \
+              time log graphviz debug
+DEPS_rustdoc := rustc native:hoedown serialize sync getopts \
                 test time debug
 DEPS_flate := std native:miniz
-DEPS_arena := std collections
+DEPS_arena := std
 DEPS_graphviz := std
 DEPS_glob := std
-DEPS_serialize := std collections log
-DEPS_term := std collections log
+DEPS_serialize := std log
+DEPS_term := std log
 DEPS_semver := std
 DEPS_uuid := std serialize
 DEPS_sync := std alloc
 DEPS_getopts := std
-DEPS_collections := std debug
+DEPS_collections := core alloc
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
 DEPS_num := std
-DEPS_test := std collections getopts serialize term time regex
+DEPS_test := std getopts serialize term time regex
 DEPS_time := std serialize sync
 DEPS_rand := core
-DEPS_url := std collections
+DEPS_url := std
 DEPS_log := std sync
-DEPS_regex := std collections
+DEPS_regex := std
 DEPS_regex_macros = syntax std regex
 DEPS_fmt_macros = std
 
@@ -105,6 +105,7 @@ ONLY_RLIB_libc := 1
 ONLY_RLIB_rlibc := 1
 ONLY_RLIB_alloc := 1
 ONLY_RLIB_rand := 1
+ONLY_RLIB_collections := 1
 
 ################################################################################
 # You should not need to edit below this line

src/doc/tutorial.md

@@ -2058,8 +2058,7 @@ illegal to copy and pass by value.
 Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 
 ~~~~
-extern crate collections;
-type Set<T> = collections::HashMap<T, ()>;
+type Set<T> = std::collections::HashMap<T, ()>;
 
 struct Stack<T> {
     elements: Vec<T>

src/libarena/lib.rs

@@ -28,8 +28,6 @@
        html_root_url = "http://doc.rust-lang.org/")]
 #![allow(missing_doc)]
 
-extern crate collections;
-
 use std::cell::{Cell, RefCell};
 use std::cmp;
 use std::intrinsics::{TyDesc, get_tydesc};

src/libcollections/bitv.rs

@@ -10,14 +10,16 @@
 
 #![allow(missing_doc)]
 
+use core::prelude::*;
 
-use std::cmp;
-use std::fmt;
-use std::iter::RandomAccessIterator;
-use std::iter::{Enumerate, Repeat, Map, Zip};
-use std::ops;
-use std::slice;
-use std::uint;
+use core::cmp;
+use core::fmt;
+use core::iter::{Enumerate, Repeat, Map, Zip};
+use core::ops;
+use core::slice;
+use core::uint;
+
+use vec::Vec;
 
 #[deriving(Clone)]
 struct SmallBitv {
@@ -977,26 +979,26 @@ impl<'a> Iterator<uint> for BitPositions<'a> {
 
 #[cfg(test)]
 mod tests {
-    extern crate test;
-    use self::test::Bencher;
+    use std::prelude::*;
+    use std::uint;
+    use std::rand;
+    use std::rand::Rng;
+    use test::Bencher;
 
     use bitv::{Bitv, SmallBitv, BigBitv, BitvSet, from_bools, from_fn,
                from_bytes};
     use bitv;
-
-    use std::uint;
-    use std::rand;
-    use std::rand::Rng;
+    use vec::Vec;
 
     static BENCH_BITS : uint = 1 << 14;
 
     #[test]
     fn test_to_str() {
         let zerolen = Bitv::new(0u, false);
-        assert_eq!(zerolen.to_str(), "".to_string());
+        assert_eq!(zerolen.to_str().as_slice(), "");
 
         let eightbits = Bitv::new(8u, false);
-        assert_eq!(eightbits.to_str(), "00000000".to_string());
+        assert_eq!(eightbits.to_str().as_slice(), "00000000")
     }
 
     #[test]
@@ -1019,7 +1021,7 @@ mod tests {
         let mut b = bitv::Bitv::new(2, false);
         b.set(0, true);
         b.set(1, false);
-        assert_eq!(b.to_str(), "10".to_string());
+        assert_eq!(b.to_str().as_slice(), "10");
     }
 
     #[test]
@@ -1330,7 +1332,7 @@ mod tests {
     fn test_from_bytes() {
         let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
         let str = format!("{}{}{}", "10110110", "00000000", "11111111");
-        assert_eq!(bitv.to_str(), str);
+        assert_eq!(bitv.to_str().as_slice(), str.as_slice());
     }
 
     #[test]
@@ -1347,8 +1349,8 @@ mod tests {
 
     #[test]
     fn test_from_bools() {
-        assert!(from_bools([true, false, true, true]).to_str() ==
-            "1011".to_string());
+        assert!(from_bools([true, false, true, true]).to_str().as_slice() ==
+                "1011");
     }
 
     #[test]

src/libcollections/btree.rs

@@ -18,8 +18,13 @@
 ///a length (the height of the tree), and lower and upper bounds on the
 ///number of elements that a given node can contain.
 
-use std::fmt;
-use std::fmt::Show;
+use core::prelude::*;
+
+use alloc::owned::Box;
+use core::fmt;
+use core::fmt::Show;
+
+use vec::Vec;
 
 #[allow(missing_doc)]
 pub struct BTree<K, V> {
@@ -772,6 +777,7 @@ impl<K: fmt::Show + Ord, V: fmt::Show> fmt::Show for BranchElt<K, V> {
 
 #[cfg(test)]
 mod test_btree {
+    use std::prelude::*;
 
     use super::{BTree, Node, LeafElt};
 

src/libcollections/deque.rs

@@ -10,7 +10,7 @@
 
 //! Container traits for collections
 
-use std::container::Mutable;
+use core::prelude::*;
 
 /// A double-ended sequence that allows querying, insertion and deletion at both ends.
 pub trait Deque<T> : Mutable {
@@ -41,11 +41,10 @@ pub trait Deque<T> : Mutable {
 
 #[cfg(test)]
 pub mod bench {
-    extern crate test;
-    use self::test::Bencher;
-    use std::container::MutableMap;
+    use std::prelude::*;
     use std::rand;
     use std::rand::Rng;
+    use test::Bencher;
 
     pub fn insert_rand_n<M:MutableMap<uint,uint>>(n: uint,
                                                   map: &mut M,

src/libcollections/dlist.rs

@@ -21,9 +21,12 @@
 // Backlinks over DList::prev are raw pointers that form a full chain in
 // the reverse direction.
 
-use std::iter;
-use std::mem;
-use std::ptr;
+use core::prelude::*;
+
+use alloc::owned::Box;
+use core::iter;
+use core::mem;
+use core::ptr;
 
 use deque::Deque;
 
@@ -607,11 +610,14 @@ impl<A: Clone> Clone for DList<A> {
 
 #[cfg(test)]
 mod tests {
-    extern crate test;
-    use self::test::Bencher;
-    use deque::Deque;
+    use std::prelude::*;
     use std::rand;
+    use test::Bencher;
+    use test;
+
+    use deque::Deque;
     use super::{DList, Node, ListInsertion};
+    use vec::Vec;
 
     pub fn check_links<T>(list: &DList<T>) {
         let mut len = 0u;

src/libcollections/enum_set.rs

@@ -13,7 +13,9 @@
 //! This module defines a container which uses an efficient bit mask
 //! representation to hold C-like enum variants.
 
-use std::num::Bitwise;
+use core::prelude::*;
+
+use core::num::Bitwise;
 
 #[deriving(Clone, PartialEq, Eq, Hash, Show)]
 /// A specialized Set implementation to use enum types.
@@ -136,7 +138,7 @@ impl<E:CLike> Iterator<E> for Items<E> {
 
 #[cfg(test)]
 mod test {
-
+    use std::prelude::*;
     use std::mem;
 
     use enum_set::{EnumSet, CLike};

src/libstd/hash/mod.rs src/libcollections/hash/mod.rs

@@ -63,22 +63,18 @@
 
 #![allow(unused_must_use)]
 
-use container::Container;
-use intrinsics::TypeId;
-use iter::Iterator;
-use option::{Option, Some, None};
-use owned::Box;
-use rc::Rc;
-use result::{Result, Ok, Err};
-use slice::{Vector, ImmutableVector};
-use str::{Str, StrSlice};
+use core::prelude::*;
+
+use alloc::owned::Box;
+use alloc::rc::Rc;
+use core::intrinsics::TypeId;
+use core::mem;
+
 use vec::Vec;
 
 /// Reexport the `sip::hash` function as our default hasher.
 pub use hash = self::sip::hash;
 
-pub use Writer = io::Writer;
-
 pub mod sip;
 
 /// A trait that represents a hashable type. The `S` type parameter is an
@@ -96,32 +92,51 @@ pub trait Hasher<S> {
     fn hash<T: Hash<S>>(&self, value: &T) -> u64;
 }
 
+pub trait Writer {
+    fn write(&mut self, bytes: &[u8]);
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
+fn id<T>(t: T) -> T { t }
+
 macro_rules! impl_hash(
-    ( $( $ty:ty => $method:ident;)* ) => (
+    ( $($ty:ident, $uty:ident, $f:path;)* ) => (
         $(
             impl<S: Writer> Hash<S> for $ty {
                 #[inline]
                 fn hash(&self, state: &mut S) {
-                    state.$method(*self);
+                    let a: [u8, ..::core::$ty::BYTES] = unsafe {
+                        mem::transmute($f(*self as $uty) as $ty)
+                    };
+                    state.write(a.as_slice())
                 }
             }
         )*
     )
 )
 
 impl_hash!(
-    u8 => write_u8;
-    u16 => write_le_u16;
-    u32 => write_le_u32;
-    u64 => write_le_u64;
-    uint => write_le_uint;
-    i8 => write_i8;
-    i16 => write_le_i16;
-    i32 => write_le_i32;
-    i64 => write_le_i64;
-    int => write_le_int;
+    u8, u8, id;
+    u16, u16, mem::to_le16;
+    u32, u32, mem::to_le32;
+    u64, u64, mem::to_le64;
+    i8, u8, id;
+    i16, u16, mem::to_le16;
+    i32, u32, mem::to_le32;
+    i64, u64, mem::to_le64;
+)
+
+#[cfg(target_word_size = "32")]
+impl_hash!(
+    uint, u32, mem::to_le32;
+    int, u32, mem::to_le32;
+)
+
+#[cfg(target_word_size = "64")]
+impl_hash!(
+    uint, u64, mem::to_le64;
+    int, u64, mem::to_le64;
 )
 
 impl<S: Writer> Hash<S> for bool {
@@ -142,7 +157,7 @@ impl<'a, S: Writer> Hash<S> for &'a str {
     #[inline]
     fn hash(&self, state: &mut S) {
         state.write(self.as_bytes());
-        state.write_u8(0xFF);
+        0xffu8.hash(state)
     }
 }
 
@@ -301,14 +316,11 @@ impl<S: Writer, T: Hash<S>, U: Hash<S>> Hash<S> for Result<T, U> {
 
 #[cfg(test)]
 mod tests {
-    use mem;
-    use io::{IoResult, Writer};
-    use iter::{Iterator};
-    use option::{Some, None};
-    use result::Ok;
-    use slice::ImmutableVector;
+    use std::prelude::*;
+    use std::mem;
 
-    use super::{Hash, Hasher};
+    use slice::ImmutableVector;
+    use super::{Hash, Hasher, Writer};
 
     struct MyWriterHasher;
 
@@ -326,11 +338,10 @@ mod tests {
 
     impl Writer for MyWriter {
         // Most things we'll just add up the bytes.
-        fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+        fn write(&mut self, buf: &[u8]) {
             for byte in buf.iter() {
                 self.hash += *byte as u64;
             }
-            Ok(())
         }
     }