librustc: Make unqualified identifier searches terminate at the nearest module scope. r=tjc

36 files changed, 198 insertions, 30 deletions

diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs
index b38f756a2b5..3463b31c55c 100644
--- a/src/libstd/arc.rs
+++ b/src/libstd/arc.rs
@@ -20,6 +20,7 @@ use sync::{Mutex, mutex_with_condvars, RWlock, rwlock_with_condvars};
 
 use core::cast;
 use core::pipes;
+use core::prelude::*;
 use core::private::{SharedMutableState, shared_mutable_state};
 use core::private::{clone_shared_mutable_state, unwrap_shared_mutable_state};
 use core::private::{get_shared_mutable_state, get_shared_immutable_state};
@@ -470,6 +471,9 @@ impl<T: Const Owned> &RWReadMode<T> {
 mod tests {
     #[legacy_exports];
 
+    use core::prelude::*;
+
+    use arc::*;
     use arc;
 
     use core::oldcomm::*;
diff --git a/src/libstd/arena.rs b/src/libstd/arena.rs
index e817e6e160f..6fee82521e8 100644
--- a/src/libstd/arena.rs
+++ b/src/libstd/arena.rs
@@ -42,6 +42,7 @@ use core::at_vec;
 use core::cast::reinterpret_cast;
 use core::cast;
 use core::libc::size_t;
+use core::prelude::*;
 use core::ptr;
 use core::sys::TypeDesc;
 use core::sys;
diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index 38ebe67898d..834edc3f464 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -11,6 +11,7 @@
 #[forbid(deprecated_mode)];
 
 use core::ops;
+use core::prelude::*;
 use core::uint;
 use core::vec::{to_mut, from_elem};
 use core::vec;
@@ -578,6 +579,9 @@ impl Bitv: ops::Index<uint,bool> {
 mod tests {
     #[legacy_exports];
 
+    use core::prelude::*;
+
+    use bitv::*;
     use bitv;
 
     use core::uint;
diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index aa9e864adfd..fe1bfa62fb1 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -40,6 +40,7 @@
 use core::libc;
 use core::oldcomm;
 use core::option;
+use core::prelude::*;
 use core::ptr;
 use core::task;
 
@@ -152,6 +153,10 @@ pub unsafe fn ptr<T>(t: CVec<T>) -> *mut T {
 
 #[cfg(test)]
 mod tests {
+    use core::prelude::*;
+
+    use c_vec::*;
+
     use core::libc::*;
     use core::libc;
 
diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs
index 29c75e629e9..d4077e94617 100644
--- a/src/libstd/cell.rs
+++ b/src/libstd/cell.rs
@@ -11,6 +11,7 @@
 #[forbid(deprecated_mode)];
 
 use core::option;
+use core::prelude::*;
 
 /// A dynamic, mutable location.
 ///
diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs
index 850e53c2d48..3118a0c1ba5 100644
--- a/src/libstd/comm.rs
+++ b/src/libstd/comm.rs
@@ -20,6 +20,7 @@ Higher level communication abstractions.
 use core::pipes::{GenericChan, GenericSmartChan, GenericPort};
 use core::pipes::{Chan, Port, Selectable, Peekable};
 use core::pipes;
+use core::prelude::*;
 
 /// An extension of `pipes::stream` that allows both sending and receiving.
 pub struct DuplexStream<T: Owned, U: Owned> {
@@ -80,6 +81,8 @@ pub fn DuplexStream<T: Owned, U: Owned>()
 #[cfg(test)]
 mod test {
     #[legacy_exports];
+    use comm::DuplexStream;
+
     #[test]
     fn DuplexStream1() {
         let (left, right) = DuplexStream();
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index e7042ffa89f..71d8743a361 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -15,6 +15,7 @@
 use core::cmp::Eq;
 use core::dvec::DVec;
 use core::dvec;
+use core::prelude::*;
 use core::uint;
 use core::vec;
 
@@ -131,6 +132,9 @@ pub fn create<T: Copy>() -> Deque<T> {
 
 #[cfg(test)]
 mod tests {
+    use core::prelude::*;
+
+    use deque::*;
     use deque;
 
     #[test]
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 0f49507cea4..5a2fc2298ae 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -14,6 +14,7 @@ use serialize;
 
 use core::io;
 use core::ops;
+use core::prelude::*;
 use core::str;
 use core::vec;
 
@@ -33,18 +34,18 @@ struct EbmlState {
     data_pos: uint,
 }
 
-struct Doc {
+pub struct Doc {
     data: @~[u8],
     start: uint,
     end: uint,
 }
 
-struct TaggedDoc {
+pub struct TaggedDoc {
     tag: uint,
     doc: Doc,
 }
 
-enum EbmlEncoderTag {
+pub enum EbmlEncoderTag {
     EsUint, EsU64, EsU32, EsU16, EsU8,
     EsInt, EsI64, EsI32, EsI16, EsI8,
     EsBool,
@@ -60,11 +61,16 @@ enum EbmlEncoderTag {
 // --------------------------------------
 
 pub mod reader {
+    use ebml::{Doc, EbmlEncoderTag, EsBool, EsEnum, EsEnumBody, EsEnumVid};
+    use ebml::{EsF32, EsF64, EsFloat, EsI16, EsI32, EsI64, EsI8, EsInt};
+    use ebml::{EsLabel, EsOpaque, EsStr, EsU16, EsU32, EsU64, EsU8, EsUint};
+    use ebml::{EsVec, EsVecElt, EsVecLen, TaggedDoc};
     use serialize;
 
     use core::int;
     use core::io;
     use core::ops;
+    use core::prelude::*;
     use core::str;
     use core::vec;
 
@@ -398,6 +404,11 @@ pub mod reader {
 }
 
 pub mod writer {
+    use ebml::{Doc, EbmlEncoderTag, EsBool, EsEnum, EsEnumBody, EsEnumVid};
+    use ebml::{EsF32, EsF64, EsFloat, EsI16, EsI32, EsI64, EsI8, EsInt};
+    use ebml::{EsLabel, EsOpaque, EsStr, EsU16, EsU32, EsU64, EsU8, EsUint};
+    use ebml::{EsVec, EsVecElt, EsVecLen, TaggedDoc};
+
     use core::io;
     use core::str;
     use core::vec;
@@ -668,6 +679,7 @@ mod tests {
     use serialize;
 
     use core::io;
+    use core::option::{None, Option, Some};
 
     #[test]
     fn test_option_int() {
diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs
index 8f239b2a130..07201a1180d 100644
--- a/src/libstd/flatpipes.rs
+++ b/src/libstd/flatpipes.rs
@@ -42,6 +42,7 @@ use core::io;
 use core::pipes::GenericChan;
 use core::pipes::GenericPort;
 use core::pipes;
+use core::prelude::*;
 use core::sys::size_of;
 use core::uint;
 use core::vec;
@@ -160,15 +161,16 @@ POD are not equivelant.
 
 */
 pub mod pod {
-
-    use core::io::{Reader, Writer};
-    use core::pipes::{Port, Chan};
-    use core::pipes;
     use flatpipes::flatteners::{PodUnflattener, PodFlattener};
     use flatpipes::bytepipes::{ReaderBytePort, WriterByteChan};
     use flatpipes::bytepipes::{PipeBytePort, PipeByteChan};
     use flatpipes::{FlatPort, FlatChan};
 
+    use core::io::{Reader, Writer};
+    use core::pipes::{Port, Chan};
+    use core::pipes;
+    use core::prelude::*;
+
     pub type ReaderPort<T: Copy Owned, R> =
         FlatPort<T, PodUnflattener<T>, ReaderBytePort<R>>;
     pub type WriterChan<T: Copy Owned, W> =
@@ -326,12 +328,14 @@ pub impl<T,F:Flattener<T>,C:ByteChan> FlatChan<T, F, C> {
 
 pub mod flatteners {
     use ebml;
+    use flatpipes::{ByteChan, BytePort, Flattener, Unflattener};
     use flatpipes::util::BufReader;
     use json;
     use serialize::{Encoder, Decoder, Encodable, Decodable};
 
     use core::cast;
     use core::io::{Writer, Reader, BytesWriter, ReaderUtil};
+    use core::prelude::*;
     use core::ptr;
     use core::sys::size_of;
     use core::vec;
@@ -496,9 +500,12 @@ pub mod flatteners {
 }
 
 pub mod bytepipes {
+    use flatpipes::{ByteChan, BytePort};
+
     use core::io::{Writer, Reader, ReaderUtil};
     use core::pipes::{Port, Chan};
     use core::pipes;
+    use core::prelude::*;
 
     pub struct ReaderBytePort<R: Reader> {
         reader: R
@@ -622,6 +629,7 @@ pub mod bytepipes {
 mod util {
     use core::io::{Reader, BytesReader};
     use core::io;
+    use core::prelude::*;
 
     pub struct BufReader {
         buf: ~[u8],
@@ -675,6 +683,7 @@ mod util {
 
 #[cfg(test)]
 mod test {
+    use core::prelude::*;
 
     // XXX: json::Decoder doesn't work because of problems related to
     // its interior pointers
@@ -688,6 +697,7 @@ mod test {
     use flatpipes::pod;
     use flatpipes::serial;
     use flatpipes::util::BufReader;
+    use flatpipes::{BytePort, FlatChan, FlatPort};
     use net::ip;
     use net::tcp::TcpSocketBuf;
 
@@ -695,6 +705,7 @@ mod test {
     use core::int;
     use core::io::BytesReader;
     use core::io;
+    use core::prelude::*;
     use core::result;
     use core::sys;
     use core::task;
@@ -918,6 +929,10 @@ mod test {
     // Tests that the different backends behave the same when the
     // binary streaming protocol is broken
     mod broken_protocol {
+        use core::prelude::*;
+
+        use flatpipes::{BytePort, FlatPort};
+        use flatpipes::flatteners::PodUnflattener;
         use flatpipes::pod;
         use flatpipes::util::BufReader;
 
diff --git a/src/libstd/fun_treemap.rs b/src/libstd/fun_treemap.rs
index 6a24e1e5817..e0d4b95a7e4 100644
--- a/src/libstd/fun_treemap.rs
+++ b/src/libstd/fun_treemap.rs
@@ -23,6 +23,7 @@
 
 use core::cmp::{Eq, Ord};
 use core::option::{Some, None};
+use core::prelude::*;
 
 pub type Treemap<K, V> = @TreeNode<K, V>;
 
diff --git a/src/libstd/future.rs b/src/libstd/future.rs
index 7cbd42f217d..6a34c29b516 100644
--- a/src/libstd/future.rs
+++ b/src/libstd/future.rs
@@ -26,6 +26,7 @@ use core::cast;
 use core::either::Either;
 use core::option;
 use core::pipes::{recv, oneshot, ChanOne, PortOne, send_one, recv_one};
+use core::prelude::*;
 use core::task;
 
 #[doc = "The future type"]
@@ -145,6 +146,10 @@ pub fn spawn<A:Owned>(blk: fn~() -> A) -> Future<A> {
 
 #[allow(non_implicitly_copyable_typarams)]
 pub mod test {
+    use core::prelude::*;
+
+    use future::*;
+
     use core::pipes::oneshot;
     use core::task;
 
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 3d9ee0d3d12..93eb2095c5e 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -75,6 +75,7 @@
 #[forbid(deprecated_mode)];
 
 use core::cmp::Eq;
+use core::prelude::*;
 use core::result::{Err, Ok};
 use core::result;
 use core::option;
@@ -83,16 +84,16 @@ use core::str;
 use core::vec;
 
 #[deriving_eq]
-enum Name {
+pub enum Name {
     Long(~str),
     Short(char),
 }
 
 #[deriving_eq]
-enum HasArg { Yes, No, Maybe, }
+pub enum HasArg { Yes, No, Maybe, }
 
 #[deriving_eq]
-enum Occur { Req, Optional, Multi, }
+pub enum Occur { Req, Optional, Multi, }
 
 /// A description of a possible option
 #[deriving_eq]
@@ -453,8 +454,10 @@ enum FailType {
  *  groups of short and long option names, together.
  */
 pub mod groups {
-    use getopts::Result;
+    use getopts::{HasArg, Long, Maybe, Multi, No, Occur, Opt, Optional, Req};
+    use getopts::{Result, Short, Yes};
 
+    use core::prelude::*;
     use core::str;
     use core::vec;
 
@@ -569,7 +572,7 @@ pub mod groups {
     /*
      * Parse command line args with the provided long format options
      */
-    pub fn getopts(args: &[~str], opts: &[OptGroup]) -> Result {
+    pub fn getopts(args: &[~str], opts: &[OptGroup]) -> ::getopts::Result {
         ::getopts::getopts(args, vec::flat_map(opts, long_to_short))
     }
 
@@ -633,9 +636,11 @@ pub mod groups {
 #[cfg(test)]
 mod tests {
     #[legacy_exports];
+    use core::prelude::*;
+
     use opt = getopts;
     use getopts::groups::OptGroup;
-    use getopts::groups;
+    use getopts::*;
 
     use core::result::{Err, Ok};
     use core::result;
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 44cd4fe4449..f29e2b5e2ca 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -23,6 +23,7 @@ use core::cmp::{Eq, Ord};
 use core::float;
 use core::io::{WriterUtil, ReaderUtil};
 use core::io;
+use core::prelude::*;
 use core::send_map::linear;
 use core::str;
 use core::to_str;
@@ -1193,6 +1194,10 @@ impl Error: to_str::ToStr {
 
 #[cfg(test)]
 mod tests {
+    use core::prelude::*;
+
+    use json::*;
+
     use core::result;
     use core::send_map::linear;
 
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index 4a7574afd9f..2d9c96b28a9 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -14,6 +14,7 @@
 use core::cmp::Eq;
 use core::option;
 use core::option::*;
+use core::prelude::*;
 use core::vec;
 
 #[deriving_eq]
@@ -162,6 +163,7 @@ pub pure fn each<T>(l: @List<T>, f: fn(&T) -> bool) {
 mod tests {
     #[legacy_exports];
 
+    use list::*;
     use list;
 
     use core::option;
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index e4f38496f1d..c7d59aa18cb 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -18,6 +18,7 @@ use core::io;
 use core::ops;
 use core::to_str::ToStr;
 use core::mutable::Mut;
+use core::prelude::*;
 use core::send_map::linear::LinearMap;
 use core::to_bytes::IterBytes;
 use core::uint;
@@ -120,11 +121,12 @@ pub mod util {
 // FIXME (#2344): package this up and export it as a datatype usable for
 // external code that doesn't want to pay the cost of a box.
 pub mod chained {
-    use map::util;
+    use map::{Map, util};
 
     use core::io;
     use core::ops;
     use core::option;
+    use core::prelude::*;
     use core::uint;
     use core::vec;
 
@@ -615,6 +617,7 @@ impl<K: Eq IterBytes Hash Copy, V: Copy> @Mut<LinearMap<K, V>>:
 mod tests {
     use map;
 
+    use core::option::None;
     use core::option;
     use core::uint;
 
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 96bd6367e56..fad583a668b 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -13,6 +13,7 @@
 
 use core::libc;
 use core::oldcomm;
+use core::prelude::*;
 use core::ptr;
 use core::result;
 use core::str;
@@ -47,7 +48,7 @@ pub enum IpAddr {
 }
 
 /// Human-friendly feedback on why a parse_addr attempt failed
-type ParseAddrErr = {
+pub type ParseAddrErr = {
     err_msg: ~str
 };
 
@@ -147,8 +148,12 @@ pub fn get_addr(node: &str, iotask: iotask)
 }
 
 pub mod v4 {
+    use net::ip::{IpAddr, Ipv4, Ipv6, ParseAddrErr};
     use uv::ll;
+    use uv_ip4_addr = uv::ll::ip4_addr;
+    use uv_ip4_name = uv::ll::ip4_name;
 
+    use core::prelude::*;
     use core::ptr;
     use core::result;
     use core::str;
@@ -241,6 +246,11 @@ pub mod v4 {
     }
 }
 pub mod v6 {
+    use net::ip::{IpAddr, Ipv6, ParseAddrErr};
+    use uv_ip6_addr = uv::ll::ip6_addr;
+    use uv_ip6_name = uv::ll::ip6_name;
+
+    use core::prelude::*;
     use core::result;
     use core::str;
 
@@ -350,6 +360,9 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
 
 #[cfg(test)]
 mod test {
+    use core::prelude::*;
+
+    use net_ip::*;
     use net_ip::v4;
     use net_ip::v6;
     use uv;
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index ca365e2a7d3..64e779fb996 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -24,6 +24,7 @@ use core::io;
 use core::libc::size_t;
 use core::libc;
 use core::oldcomm;
+use core::prelude::*;
 use core::ptr;
 use core::result::{Result};
 use core::result;
@@ -86,7 +87,7 @@ pub type TcpErrData = {
     err_msg: ~str
 };
 /// Details returned as part of a `result::err` result from `tcp::listen`
-enum TcpListenErrData {
+pub enum TcpListenErrData {
     /**
      * Some unplanned-for error. The first and second fields correspond
      * to libuv's `err_name` and `err_msg` fields, respectively.
@@ -374,7 +375,7 @@ pub fn read_stop(sock: &TcpSocket,
  * * `timeout_msecs` - a `uint` value, in msecs, to wait before dropping the
  * read attempt. Pass `0u` to wait indefinitely
  */
-fn read(sock: &TcpSocket, timeout_msecs: uint)
+pub fn read(sock: &TcpSocket, timeout_msecs: uint)
     -> result::Result<~[u8],TcpErrData> {
     let socket_data = ptr::addr_of(&(*(sock.socket_data)));
     read_common_impl(socket_data, timeout_msecs)
@@ -1270,12 +1271,16 @@ type TcpBufferedSocketData = {
 
 //#[cfg(test)]
 mod test {
-    use net;
     use net::ip;
+    use net::tcp::{GenericListenErr, TcpConnectErrData, TcpListenErrData};
+    use net::tcp::{TcpSocket, accept, connect, listen, read, socket_buf};
+    use net;
+    use uv::iotask::IoTask;
     use uv;
 
     use core::io;
     use core::oldcomm;
+    use core::prelude::*;
     use core::result;
     use core::str;
     use core::task;
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 5fc20351793..cd683dcf8d0 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -19,6 +19,7 @@ use core::dvec::DVec;
 use core::from_str::FromStr;
 use core::io::{Reader, ReaderUtil};
 use core::io;
+use core::prelude::*;
 use core::send_map::linear::LinearMap;
 use core::send_map;
 use core::str;
@@ -735,6 +736,10 @@ impl Url: to_bytes::IterBytes {
 #[cfg(test)]
 mod tests {
     #[legacy_exports];
+
+    use core::prelude::*;
+
+    use net_url::*;
     use net_url::UserInfo;
 
     use core::result;
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index d88d298ef18..04d88af1100 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -11,6 +11,7 @@
 #[forbid(deprecated_mode)];
 
 use core::cast;
+use core::prelude::*;
 use core::ptr;
 use core::sys;
 use core::uint;
diff --git a/src/libstd/priority_queue.rs b/src/libstd/priority_queue.rs
index 42818676359..4d341d737f6 100644
--- a/src/libstd/priority_queue.rs
+++ b/src/libstd/priority_queue.rs
@@ -2,6 +2,7 @@
 //! A priority queue implemented with a binary heap
 
 use core::cmp::Ord;
+use core::prelude::*;
 use core::ptr::addr_of;
 use core::vec;
 
diff --git a/src/libstd/rl.rs b/src/libstd/rl.rs
index f384cceb41b..f0168607adb 100644
--- a/src/libstd/rl.rs
+++ b/src/libstd/rl.rs
@@ -12,6 +12,7 @@
 // state without mutexes.
 
 use core::libc::{c_char, c_int};
+use core::prelude::*;
 use core::str;
 use core::task;
 
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 1513e621fcb..153f3956884 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -38,6 +38,7 @@
 use core::cast;
 use core::char;
 use core::option;
+use core::prelude::*;
 use core::str;
 use core::uint;
 use core::vec;
@@ -448,7 +449,9 @@ pub fn loop_leaves(rope: Rope, it: fn(node::Leaf) -> bool) -> bool{
 
 pub mod iterator {
     pub mod leaf {
-        use rope::node;
+        use rope::{Rope, node};
+
+        use core::prelude::*;
 
         pub fn start(rope: Rope) -> node::leaf_iterator::T {
             match (rope) {
@@ -461,7 +464,9 @@ pub mod iterator {
         }
     }
     pub mod char {
-        use rope::node;
+        use rope::{Rope, node};
+
+        use core::prelude::*;
 
         pub fn start(rope: Rope) -> node::char_iterator::T {
             match (rope) {
@@ -560,6 +565,7 @@ pub mod node {
     use core::cast;
     use core::char;
     use core::option;
+    use core::prelude::*;
     use core::str;
     use core::uint;
     use core::vec;
@@ -1135,7 +1141,10 @@ pub mod node {
     }
 
     pub mod leaf_iterator {
+        use rope::node::{Concat, Leaf, Node, height};
+
         use core::option;
+        use core::prelude::*;
         use core::vec;
 
         pub type T = {
@@ -1175,9 +1184,11 @@ pub mod node {
     }
 
     pub mod char_iterator {
+        use rope::node::{Leaf, Node};
         use rope::node::leaf_iterator;
 
         use core::option;
+        use core::prelude::*;
         use core::str;
 
         pub type T = {
@@ -1259,8 +1270,7 @@ pub mod node {
 
 #[cfg(test)]
 mod tests {
-    use rope::iterator;
-    use rope::node;
+    use rope::*;
 
     use core::option;
     use core::str;
diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs
index 97d5ad18780..aa4ed82bbe9 100644
--- a/src/libstd/serialize.rs
+++ b/src/libstd/serialize.rs
@@ -18,6 +18,7 @@ Core encoding and decoding interfaces.
 #[forbid(non_camel_case_types)];
 
 use core::at_vec;
+use core::prelude::*;
 use core::vec;
 
 pub trait Encoder {
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index a6c14516af2..dbcb0c6aeec 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -21,6 +21,7 @@ use core::dvec::DVec;
 use core::ops;
 use core::option::{Some, None};
 use core::option;
+use core::prelude::*;
 
 // FIXME (#2347): Should not be @; there's a bug somewhere in rustc that
 // requires this to be.
@@ -168,6 +169,8 @@ pub fn as_map<V: Copy>(s: SmallIntMap<V>) -> map::Map<uint, V> {
 
 #[cfg(test)]
 mod tests {
+    use smallintmap::{mk, SmallIntMap};
+
     use core::option::None;
     use core::option;
 
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 505b2526741..d83568ddd94 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -13,6 +13,7 @@
 
 use core::cmp::{Eq, Ord};
 use core::dvec::DVec;
+use core::prelude::*;
 use core::util;
 use core::vec::{len, push};
 use core::vec;
@@ -715,6 +716,10 @@ fn copy_vec<T: Copy>(dest: &[mut T], s1: uint,
 mod test_qsort3 {
     #[legacy_exports];
 
+    use core::prelude::*;
+
+    use sort::*;
+
     use core::vec;
 
     fn check_sort(v1: &[mut int], v2: &[mut int]) {
@@ -758,6 +763,10 @@ mod test_qsort3 {
 mod test_qsort {
     #[legacy_exports];
 
+    use core::prelude::*;
+
+    use sort::*;
+
     use core::int;
     use core::vec;
 
@@ -822,6 +831,10 @@ mod test_qsort {
 mod tests {
     #[legacy_exports];
 
+    use core::prelude::*;
+
+    use sort::*;
+
     use core::vec;
 
     fn check_sort(v1: &[int], v2: &[int]) {
@@ -887,6 +900,10 @@ mod tests {
 
 #[cfg(test)]
 mod test_tim_sort {
+    use core::prelude::*;
+
+    use sort::tim_sort;
+
     use core::rand;
     use core::vec;
 
@@ -980,6 +997,10 @@ mod test_tim_sort {
 
 #[cfg(test)]
 mod big_tests {
+    use core::prelude::*;
+
+    use sort::*;
+
     use core::rand;
     use core::task;
     use core::uint;
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index d957a7ee2ab..a883062c4b9 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -19,6 +19,7 @@
 
 use core::option;
 use core::pipes;
+use core::prelude::*;
 use core::private::{Exclusive, exclusive};
 use core::ptr;
 use core::task;
@@ -709,6 +710,10 @@ impl &RWlockReadMode {
 mod tests {
     #[legacy_exports];
 
+    use core::prelude::*;
+
+    use sync::*;
+
     use core::cast;
     use core::option;
     use core::pipes;
diff --git a/src/libstd/task_pool.rs b/src/libstd/task_pool.rs
index 68bf2612f9a..5ed2195d2d2 100644
--- a/src/libstd/task_pool.rs
+++ b/src/libstd/task_pool.rs
@@ -14,6 +14,7 @@
 use core::io;
 use core::pipes::{Chan, Port};
 use core::pipes;
+use core::prelude::*;
 use core::task::{SchedMode, SingleThreaded};
 use core::task;
 use core::vec;
diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs
index afb9290f6cf..bbe1e5c7ccd 100644
--- a/src/libstd/tempfile.rs
+++ b/src/libstd/tempfile.rs
@@ -13,6 +13,7 @@
 #[forbid(deprecated_mode)];
 
 use core::os;
+use core::prelude::*;
 use core::rand;
 use core::str;
 
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 176953663eb..8b4c53604bc 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -29,6 +29,7 @@ use core::io;
 use core::libc::size_t;
 use core::oldcomm;
 use core::option;
+use core::prelude::*;
 use core::result;
 use core::str;
 use core::task::TaskBuilder;
@@ -79,7 +80,7 @@ pub type TestOpts = {filter: Option<~str>, run_ignored: bool,
 type OptRes = Either<TestOpts, ~str>;
 
 // Parses command line arguments into test options
-fn parse_opts(args: &[~str]) -> OptRes {
+pub fn parse_opts(args: &[~str]) -> OptRes {
     let args_ = vec::tail(args);
     let opts = ~[getopts::optflag(~"ignored"), getopts::optopt(~"logfile")];
     let matches =
@@ -283,9 +284,9 @@ enum TestEvent {
 
 type MonitorMsg = (TestDesc, TestResult);
 
-fn run_tests(opts: &TestOpts, tests: &[TestDesc],
+fn run_tests(opts: &TestOpts,
+             tests: &[TestDesc],
              callback: fn@(e: TestEvent)) {
-
     let mut filtered_tests = filter_tests(opts, tests);
     callback(TeFiltered(copy filtered_tests));
 
@@ -340,8 +341,9 @@ fn get_concurrency() -> uint {
 }
 
 #[allow(non_implicitly_copyable_typarams)]
-fn filter_tests(opts: &TestOpts,
-                tests: &[TestDesc]) -> ~[TestDesc] {
+pub fn filter_tests(opts: &TestOpts,
+                    tests: &[TestDesc])
+                 -> ~[TestDesc] {
     let mut filtered = vec::slice(tests, 0, tests.len());
 
     // Remove tests that don't match the test filter
@@ -393,7 +395,7 @@ fn filter_tests(opts: &TestOpts,
 
 type TestFuture = {test: TestDesc, wait: fn@() -> TestResult};
 
-fn run_test(test: TestDesc, monitor_ch: oldcomm::Chan<MonitorMsg>) {
+pub fn run_test(test: TestDesc, monitor_ch: oldcomm::Chan<MonitorMsg>) {
     if test.ignore {
         oldcomm::send(monitor_ch, (copy test, TrIgnored));
         return;
@@ -425,6 +427,8 @@ fn calc_result(test: &TestDesc, task_succeeded: bool) -> TestResult {
 mod tests {
     #[legacy_exports];
 
+    use test::{TrFailed, TrIgnored, TrOk, filter_tests, parse_opts, run_test};
+
     use core::either;
     use core::oldcomm;
     use core::option;
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 7c586c3fd4e..575f49c73fb 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -16,6 +16,7 @@ use core::libc::{c_char, c_int, c_long, size_t, time_t};
 use core::i32;
 use core::io::{Reader, ReaderUtil};
 use core::io;
+use core::prelude::*;
 use core::result::{Result, Ok, Err};
 use core::str;
 
@@ -857,6 +858,8 @@ priv fn do_strftime(format: &str, tm: &Tm) -> ~str {
 mod tests {
     #[legacy_exports];
 
+    use time::*;
+
     use core::float;
     use core::os;
     use core::result;
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index 038486f2b90..18c623c2bd8 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -19,6 +19,7 @@ use uv::iotask::IoTask;
 use core::either;
 use core::libc;
 use core::oldcomm;
+use core::prelude::*;
 use core::ptr;
 use core;
 
@@ -164,6 +165,9 @@ extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) unsafe {
 mod test {
     #[legacy_exports];
 
+    use core::prelude::*;
+
+    use timer::*;
     use uv;
 
     use core::iter;
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index caccb763ee9..af3ab4b88eb 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -18,8 +18,8 @@
 #[forbid(deprecated_mode)];
 
 use core::cmp::{Eq, Ord};
-use core::option::{Some, None};
-use Option = core::Option;
+use core::option::{Option, Some, None};
+use core::prelude::*;
 
 pub type TreeMap<K: Copy Eq Ord, V: Copy> = @mut TreeEdge<K, V>;
 
@@ -107,6 +107,9 @@ pub fn equals<K: Copy Eq Ord, V: Copy Eq>(t1: &const TreeEdge<K, V>,
 mod tests {
     #[legacy_exports];
 
+    use treemap::*;
+
+    use core::option::{None, Option, Some};
     use core::str;
 
     #[test]
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index 43ed58aa0c1..f65c8ce3875 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -123,8 +123,11 @@ fn spawn_loop() -> IoTask {
 
 #[cfg(test)]
 mod test {
+    use core::prelude::*;
+
     use uv::iotask;
     use uv::ll;
+    use uv_global_loop::*;
 
     use core::iter;
     use core::libc;
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index 7853f1cd9f7..409d73c2539 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -21,6 +21,7 @@ use ll = uv_ll;
 use core::libc::c_void;
 use core::libc;
 use core::oldcomm::{Port, Chan, listen};
+use core::prelude::*;
 use core::ptr::addr_of;
 use core::task::TaskBuilder;
 use core::task;
@@ -176,7 +177,10 @@ extern fn tear_down_close_cb(handle: *ll::uv_async_t) unsafe {
 
 #[cfg(test)]
 mod test {
+    use core::prelude::*;
+
     use uv::ll;
+    use uv_iotask::*;
 
     use core::iter;
     use core::libc;
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index 46574ced2e5..4446e1388e6 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -34,6 +34,7 @@
 
 use core::libc::size_t;
 use core::libc;
+use core::prelude::*;
 use core::ptr::to_unsafe_ptr;
 use core::ptr;
 use core::str;
@@ -319,6 +320,9 @@ pub type uv_getaddrinfo_t = {
 };
 
 pub mod uv_ll_struct_stubgen {
+    use uv_ll::{uv_async_t, uv_connect_t, uv_getaddrinfo_t, uv_tcp_t};
+    use uv_ll::{uv_timer_t, uv_write_t};
+
     use core::ptr;
 
     pub fn gen_stub_uv_tcp_t() -> uv_tcp_t {
@@ -1040,6 +1044,10 @@ pub unsafe fn addrinfo_as_sockaddr_in6(input: *addrinfo) -> *sockaddr_in6 {
 
 #[cfg(test)]
 pub mod test {
+    use core::prelude::*;
+
+    use uv_ll::*;
+
     use core::libc;
     use core::oldcomm;
     use core::ptr;
diff --git a/src/libstd/workcache.rs b/src/libstd/workcache.rs
index 3631556c2ba..c8898ccd9c7 100644
--- a/src/libstd/workcache.rs
+++ b/src/libstd/workcache.rs
@@ -16,6 +16,7 @@ use core::either::{Either, Left, Right};
 use core::io;
 use core::option;
 use core::pipes::{recv, oneshot, PortOne, send_one};
+use core::prelude::*;
 use core::result;
 use core::run;
 use core::send_map::linear::LinearMap;