cleanup warnings from libextra

Author: erickt

src/libextra/base64.rs

@@ -12,10 +12,6 @@
 
 use core::prelude::*;
 
-use core::old_iter;
-use core::str;
-use core::vec;
-
 pub trait ToBase64 {
     fn to_base64(&self) -> ~str;
 }
@@ -242,12 +238,12 @@ mod tests {
 
     #[test]
     fn test_from_base64() {
-        assert_eq!((~"").from_base64(), str::to_bytes(~""));
-        assert!((~"Zg==").from_base64() == str::to_bytes(~"f"));
-        assert_eq!((~"Zm8=").from_base64(), str::to_bytes(~"fo"));
-        assert_eq!((~"Zm9v").from_base64(), str::to_bytes(~"foo"));
-        assert!((~"Zm9vYg==").from_base64() == str::to_bytes(~"foob"));
-        assert_eq!((~"Zm9vYmE=").from_base64(), str::to_bytes(~"fooba"))
-        assert_eq!((~"Zm9vYmFy").from_base64(), str::to_bytes(~"foobar"));
+        assert_eq!((~"").from_base64(), str::to_bytes(""));
+        assert!((~"Zg==").from_base64() == str::to_bytes("f"));
+        assert_eq!((~"Zm8=").from_base64(), str::to_bytes("fo"));
+        assert_eq!((~"Zm9v").from_base64(), str::to_bytes("foo"));
+        assert!((~"Zm9vYg==").from_base64() == str::to_bytes("foob"));
+        assert_eq!((~"Zm9vYmE=").from_base64(), str::to_bytes("fooba"))
+        assert_eq!((~"Zm9vYmFy").from_base64(), str::to_bytes("foobar"));
     }
 }

src/libextra/bitv.rs

@@ -10,8 +10,6 @@
 
 use core::prelude::*;
 
-use core::vec::from_elem;
-
 struct SmallBitv {
     /// only the lowest nbits of this value are used. the rest is undefined.
     bits: uint
@@ -257,7 +255,7 @@ pub impl Bitv {
             let nelems = nbits/uint::bits +
                          if nbits % uint::bits == 0 {0} else {1};
             let elem = if init {!0} else {0};
-            let s = from_elem(nelems, elem);
+            let s = vec::from_elem(nelems, elem);
             Big(~BigBitv::new(s))
         };
         Bitv {rep: rep, nbits: nbits}
@@ -502,7 +500,7 @@ impl Clone for Bitv {
             Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
           }
           Big(ref b) => {
-            let mut st = from_elem(self.nbits / uint::bits + 1, 0);
+            let mut st = vec::from_elem(self.nbits / uint::bits + 1, 0);
             let len = st.len();
             for uint::range(0, len) |i| { st[i] = b.storage[i]; };
             Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: st})}
@@ -872,17 +870,14 @@ mod tests {
 
     #[test]
     fn test_0_elements() {
-        let mut act;
-        let exp;
-        act = Bitv::new(0u, false);
-        exp = vec::from_elem::<uint>(0u, 0u);
+        let act = Bitv::new(0u, false);
+        let exp = vec::from_elem::<uint>(0u, 0u);
         assert!(act.eq_vec(exp));
     }
 
     #[test]
     fn test_1_element() {
-        let mut act;
-        act = Bitv::new(1u, false);
+        let mut act = Bitv::new(1u, false);
         assert!(act.eq_vec(~[0u]));
         act = Bitv::new(1u, true);
         assert!(act.eq_vec(~[1u]));
@@ -1488,7 +1483,7 @@ mod tests {
     #[bench]
     fn bench_bitv_big_union(b: &mut BenchHarness) {
         let mut b1 = Bitv::new(bench_bits, false);
-        let mut b2 = Bitv::new(bench_bits, false);
+        let b2 = Bitv::new(bench_bits, false);
         do b.iter {
             b1.union(&b2);
         }

src/libextra/dlist.rs

@@ -540,13 +540,13 @@ mod tests {
 
     #[test]
     fn test_dlist_concat() {
-        let a = from_vec(~[1,2]);
-        let b = from_vec(~[3,4]);
-        let c = from_vec(~[5,6]);
-        let d = from_vec(~[7,8]);
-        let ab = from_vec(~[a,b]);
-        let cd = from_vec(~[c,d]);
-        let abcd = concat(concat(from_vec(~[ab,cd])));
+        let a = from_vec([1,2]);
+        let b = from_vec([3,4]);
+        let c = from_vec([5,6]);
+        let d = from_vec([7,8]);
+        let ab = from_vec([a,b]);
+        let cd = from_vec([c,d]);
+        let abcd = concat(concat(from_vec([ab,cd])));
         abcd.assert_consistent(); assert_eq!(abcd.len(), 8);
         abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 1);
         abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 2);
@@ -560,8 +560,8 @@ mod tests {
     }
     #[test]
     fn test_dlist_append() {
-        let a = from_vec(~[1,2,3]);
-        let b = from_vec(~[4,5,6]);
+        let a = from_vec([1,2,3]);
+        let b = from_vec([4,5,6]);
         a.append(b);
         assert_eq!(a.len(), 6);
         assert_eq!(b.len(), 0);
@@ -576,7 +576,7 @@ mod tests {
     }
     #[test]
     fn test_dlist_append_empty() {
-        let a = from_vec(~[1,2,3]);
+        let a = from_vec([1,2,3]);
         let b = DList::<int>();
         a.append(b);
         assert_eq!(a.len(), 3);
@@ -590,7 +590,7 @@ mod tests {
     #[test]
     fn test_dlist_append_to_empty() {
         let a = DList::<int>();
-        let b = from_vec(~[4,5,6]);
+        let b = from_vec([4,5,6]);
         a.append(b);
         assert_eq!(a.len(), 3);
         assert_eq!(b.len(), 0);
@@ -626,8 +626,8 @@ mod tests {
     }
     #[test]
     fn test_dlist_prepend() {
-        let a = from_vec(~[1,2,3]);
-        let b = from_vec(~[4,5,6]);
+        let a = from_vec([1,2,3]);
+        let b = from_vec([4,5,6]);
         b.prepend(a);
         assert_eq!(a.len(), 0);
         assert_eq!(b.len(), 6);
@@ -642,7 +642,7 @@ mod tests {
     }
     #[test]
     fn test_dlist_reverse() {
-        let a = from_vec(~[5,4,3,2,1]);
+        let a = from_vec([5,4,3,2,1]);
         a.reverse();
         assert_eq!(a.len(), 5);
         a.assert_consistent(); assert_eq!(a.pop().get(), 1);
@@ -661,7 +661,7 @@ mod tests {
     }
     #[test]
     fn test_dlist_each_node() {
-        let a = from_vec(~[1,2,4,5]);
+        let a = from_vec([1,2,4,5]);
         for a.each_node |nobe| {
             if nobe.data > 3 {
                 a.insert_before(3, nobe);
@@ -678,28 +678,28 @@ mod tests {
     }
     #[test]
     fn test_dlist_clear() {
-        let a = from_vec(~[5,4,3,2,1]);
+        let a = from_vec([5,4,3,2,1]);
         a.clear();
         assert_eq!(a.len(), 0);
         a.assert_consistent();
     }
     #[test]
     fn test_dlist_is_empty() {
         let empty = DList::<int>();
-        let full1 = from_vec(~[1,2,3]);
+        let full1 = from_vec([1,2,3]);
         assert!(empty.is_empty());
         assert!(!full1.is_empty());
     }
     #[test]
     fn test_dlist_head_tail() {
-        let l = from_vec(~[1,2,3]);
+        let l = from_vec([1,2,3]);
         assert_eq!(l.head(), 1);
         assert_eq!(l.tail(), 3);
         assert_eq!(l.len(), 3);
     }
     #[test]
     fn test_dlist_pop() {
-        let l = from_vec(~[1,2,3]);
+        let l = from_vec([1,2,3]);
         assert_eq!(l.pop().get(), 1);
         assert_eq!(l.tail(), 3);
         assert_eq!(l.head(), 2);
@@ -712,7 +712,7 @@ mod tests {
     }
     #[test]
     fn test_dlist_pop_tail() {
-        let l = from_vec(~[1,2,3]);
+        let l = from_vec([1,2,3]);
         assert_eq!(l.pop_tail().get(), 3);
         assert_eq!(l.tail(), 2);
         assert_eq!(l.head(), 1);
@@ -758,7 +758,7 @@ mod tests {
     }
     #[test]
     fn test_dlist_break_early() {
-        let l = from_vec(~[1,2,3,4,5]);
+        let l = from_vec([1,2,3,4,5]);
         let mut x = 0;
         for l.each |i| {
             x += 1;

src/libextra/fileinput.rs

@@ -96,8 +96,6 @@ total line count).
 
 use core::prelude::*;
 
-use core::io::ReaderUtil;
-
 /**
 A summary of the internal state of a `FileInput` object. `line_num`
 and `line_num_file` represent the number of lines read in total and in
@@ -407,7 +405,6 @@ pub fn input_vec_state(files: ~[Option<Path>],
 mod test {
     use core::prelude::*;
 
-    use core::io::WriterUtil;
     use super::{FileInput, pathify, input_vec, input_vec_state};
 
     fn make_file(path : &Path, contents: &[~str]) {
@@ -441,7 +438,7 @@ mod test {
 
         // 3 files containing 0\n, 1\n, and 2\n respectively
         for filenames.eachi |i, &filename| {
-            make_file(filename.get_ref(), ~[fmt!("%u", i)]);
+            make_file(filename.get_ref(), [fmt!("%u", i)]);
         }
 
         let fi = FileInput::from_vec(copy filenames);
@@ -471,7 +468,7 @@ mod test {
 
         // 3 files containing 1\n, 2\n, and 3\n respectively
         for filenames.eachi |i, &filename| {
-            make_file(filename.get_ref(), ~[fmt!("%u", i)]);
+            make_file(filename.get_ref(), [fmt!("%u", i)]);
         }
 
         let fi = FileInput::from_vec(filenames);
@@ -533,9 +530,9 @@ mod test {
             3,
             |i| fmt!("tmp/lib-fileinput-test-empty-files-%u.tmp", i)),true);
 
-        make_file(filenames[0].get_ref(), ~[~"1", ~"2"]);
-        make_file(filenames[1].get_ref(), ~[]);
-        make_file(filenames[2].get_ref(), ~[~"3", ~"4"]);
+        make_file(filenames[0].get_ref(), [~"1", ~"2"]);
+        make_file(filenames[1].get_ref(), []);
+        make_file(filenames[2].get_ref(), [~"3", ~"4"]);
 
         let mut count = 0;
         for input_vec_state(copy filenames) |line, state| {
@@ -580,7 +577,7 @@ mod test {
             make_file(&filename.get(), contents);
         }
 
-        let mut in = FileInput::from_vec(filenames);
+        let in = FileInput::from_vec(filenames);
 
         // read once from 0
         assert_eq!(in.read_line(), ~"0 1");

src/libextra/flate.rs

@@ -16,12 +16,8 @@ Simple compression
 
 use core::prelude::*;
 
-use core::libc::{c_void, size_t, c_int};
 use core::libc;
-use core::vec;
-
-#[cfg(test)] use core::rand;
-#[cfg(test)] use core::rand::RngUtil;
+use core::libc::{c_void, size_t, c_int};
 
 pub mod rustrt {
     use core::libc::{c_int, c_void, size_t};
@@ -83,27 +79,34 @@ pub fn inflate_bytes(bytes: &const [u8]) -> ~[u8] {
     }
 }
 
-#[test]
-#[allow(non_implicitly_copyable_typarams)]
-fn test_flate_round_trip() {
-    let mut r = rand::rng();
-    let mut words = ~[];
-    for 20.times {
-        let range = r.gen_uint_range(1, 10);
-        words.push(r.gen_bytes(range));
-    }
-    for 20.times {
-        let mut in = ~[];
-        for 2000.times {
-            in.push_all(r.choose(words));
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use core::rand;
+    use core::rand::RngUtil;
+
+    #[test]
+    #[allow(non_implicitly_copyable_typarams)]
+    fn test_flate_round_trip() {
+        let mut r = rand::rng();
+        let mut words = ~[];
+        for 20.times {
+            let range = r.gen_uint_range(1, 10);
+            words.push(r.gen_bytes(range));
+        }
+        for 20.times {
+            let mut in = ~[];
+            for 2000.times {
+                in.push_all(r.choose(words));
+            }
+            debug!("de/inflate of %u bytes of random word-sequences",
+                   in.len());
+            let cmp = deflate_bytes(in);
+            let out = inflate_bytes(cmp);
+            debug!("%u bytes deflated to %u (%.1f%% size)",
+                   in.len(), cmp.len(),
+                   100.0 * ((cmp.len() as float) / (in.len() as float)));
+            assert_eq!(in, out);
         }
-        debug!("de/inflate of %u bytes of random word-sequences",
-               in.len());
-        let cmp = deflate_bytes(in);
-        let out = inflate_bytes(cmp);
-        debug!("%u bytes deflated to %u (%.1f%% size)",
-               in.len(), cmp.len(),
-               100.0 * ((cmp.len() as float) / (in.len() as float)));
-        assert_eq!(in, out);
     }
 }