Fallout from the libcollections movement

Author: alexcrichton

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

@@ -19,7 +19,6 @@ use core::ops;
 use core::slice;
 use core::uint;
 
-use string::String;
 use vec::Vec;
 
 #[deriving(Clone)]
@@ -980,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]
@@ -1022,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]
@@ -1333,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]
@@ -1350,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

@@ -777,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

@@ -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

@@ -610,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

@@ -138,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/libcollections/hash/mod.rs

@@ -68,6 +68,7 @@ use core::prelude::*;
 use alloc::owned::Box;
 use alloc::rc::Rc;
 use core::intrinsics::TypeId;
+use core::mem;
 
 use vec::Vec;
 
@@ -97,14 +98,16 @@ pub trait Writer {
 
 //////////////////////////////////////////////////////////////////////////////
 
+fn id<T>(t: T) -> T { t }
+
 macro_rules! impl_hash(
-    ( $($ty:ident)* ) => (
+    ( $($ty:ident, $uty:ident, $f:path;)* ) => (
         $(
             impl<S: Writer> Hash<S> for $ty {
                 #[inline]
                 fn hash(&self, state: &mut S) {
                     let a: [u8, ..::core::$ty::BYTES] = unsafe {
-                        ::core::mem::transmute(*self)
+                        mem::transmute($f(*self as $uty) as $ty)
                     };
                     state.write(a.as_slice())
                 }
@@ -113,7 +116,28 @@ macro_rules! impl_hash(
     )
 )
 
-impl_hash!( u8 u16 u32 u64 uint i8 i16 i32 i64 int )
+impl_hash!(
+    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 {
     #[inline]
@@ -292,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;
 
@@ -317,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(())
         }
     }
 

src/libcollections/hash/sip.rs

@@ -269,16 +269,15 @@ pub fn hash_with_keys<T: Hash<SipState>>(k0: u64, k1: u64, value: &T) -> u64 {
 
 #[cfg(test)]
 mod tests {
-    extern crate test;
-    use prelude::*;
-    use num::ToStrRadix;
-    use option::{Some, None};
+    use test::Bencher;
+    use std::prelude::*;
+    use std::num::ToStrRadix;
+
     use str::Str;
     use string::String;
     use slice::{Vector, ImmutableVector};
-    use self::test::Bencher;
 
-    use super::super::Hash;
+    use super::super::{Hash, Writer};
     use super::{SipState, hash, hash_with_keys};
 
     // Hash just the bytes of the slice, without length prefix
@@ -399,7 +398,7 @@ mod tests {
         }
 
         while t < 64 {
-            debug!("siphash test {}", t);
+            debug!("siphash test {}: {}", t, buf);
             let vec = u8to64_le!(vecs[t], 0);
             let out = hash_with_keys(k0, k1, &Bytes(buf.as_slice()));
             debug!("got {:?}, expected {:?}", out, vec);
@@ -412,10 +411,14 @@ mod tests {
             let v = to_hex_str(&vecs[t]);
             debug!("{}: ({}) => inc={} full={}", t, v, i, f);
 
-            assert!(f == i && f == v);
+            debug!("full state {:?}", state_full);
+            debug!("inc  state {:?}", state_inc);
+
+            assert_eq!(f, i);
+            assert_eq!(f, v);
 
             buf.push(t as u8);
-            state_inc.write_u8(t as u8);
+            state_inc.write([t as u8]);
 
             t += 1;
         }
@@ -542,21 +545,4 @@ officia deserunt mollit anim id est laborum.";
             assert_eq!(hash(&u), 5254097107239593357);
         })
     }
-
-    #[deriving(Hash)]
-    struct Compound {
-        x: u8,
-        y: u64,
-    }
-
-    #[bench]
-    fn bench_compound_1(b: &mut Bencher) {
-        let compound = Compound {
-            x: 1,
-            y: 2,
-        };
-        b.iter(|| {
-            assert_eq!(hash(&compound), 12506681940457338191);
-        })
-    }
 }

src/libcollections/lib.rs

@@ -26,8 +26,9 @@
 extern crate alloc;
 
 #[cfg(test)] extern crate native;
-#[cfg(test)] extern crate std;
 #[cfg(test)] extern crate test;
+#[cfg(test)] extern crate debug;
+#[cfg(test)] #[phase(syntax, link)] extern crate std;
 #[cfg(test)] #[phase(syntax, link)] extern crate log;
 
 pub use bitv::{Bitv, BitvSet};
@@ -66,10 +67,11 @@ mod unicode;
 fn expect<T>(a: core::option::Option<T>, b: &str) -> T {
     match a {
         core::option::Some(a) => a,
-        core::option::None => fail!(b),
+        core::option::None => fail!("{}", b),
     }
 }
 
+#[cfg(not(test))]
 mod std {
     pub use core::fmt;      // necessary for fail!()
     pub use core::option;   // necessary for fail!()