librustc: Stop reexporting the standard modules from prelude.

29 files changed, 162 insertions, 111 deletions

diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index 7a41c278fa3..e3d3642d6c7 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -282,6 +282,8 @@ mod test {
     use super::*;
     use prelude::*;
 
+    use uint;
+
     #[test]
     fn test() {
         // Some code that could use that, then:
diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs
index d1fa9e697bf..b80d3ae68f8 100644
--- a/src/libstd/cell.rs
+++ b/src/libstd/cell.rs
@@ -11,6 +11,7 @@
 //! A mutable, nullable memory location
 
 use cast::transmute_mut;
+use cmp;
 use prelude::*;
 use util::replace;
 
diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs
index baa6722b193..94b32b6af4c 100644
--- a/src/libstd/condition.rs
+++ b/src/libstd/condition.rs
@@ -10,8 +10,9 @@
 
 /*! Condition handling */
 
-use prelude::*;
 use local_data::{local_data_pop, local_data_set};
+use local_data;
+use prelude::*;
 
 // helper for transmutation, shown below.
 type RustClosure = (int, int);
diff --git a/src/libstd/core.rc b/src/libstd/core.rc
index 3d5f0fb8493..85397cbe777 100644
--- a/src/libstd/core.rc
+++ b/src/libstd/core.rc
@@ -224,5 +224,8 @@ mod std {
     pub use kinds;
     pub use sys;
     pub use pipes;
+    pub use unstable;
+    pub use str;
+    pub use os;
 }
 
diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs
index 7eb2054a35d..9828ff4e317 100644
--- a/src/libstd/hash.rs
+++ b/src/libstd/hash.rs
@@ -387,6 +387,8 @@ mod tests {
     use super::*;
     use prelude::*;
 
+    use uint;
+
     #[test]
     fn test_siphash() {
         let vecs : [[u8, ..8], ..64] = [
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index 800ce9f05dc..5847034d026 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -257,6 +257,9 @@ mod tests {
     use super::*;
     use prelude::*;
 
+    use int;
+    use uint;
+
     #[test]
     fn test_to_vec() {
         let xs = ~[1, 2, 3];
diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index a5679e6dbff..69bb1b0b766 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -17,8 +17,11 @@ implementing the `Iterator` trait.
 
 */
 
-use prelude::*;
+use cmp;
+use iter;
 use num::{Zero, One};
+use num;
+use prelude::*;
 
 pub trait Iterator<A> {
     /// Advance the iterator and return the next value. Return `None` when the end is reached.
@@ -506,6 +509,9 @@ mod tests {
     use super::*;
     use prelude::*;
 
+    use iter;
+    use uint;
+
     #[test]
     fn test_counter_to_vec() {
         let mut it = Counter::new(0, 5).take(10);
diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index 2cbf8b9f05e..6227f9ad388 100644
--- a/src/libstd/local_data.rs
+++ b/src/libstd/local_data.rs
@@ -27,7 +27,9 @@ magic.
 */
 
 use prelude::*;
+
 use task::local_data_priv::{local_get, local_pop, local_modify, local_set, Handle};
+use task;
 
 /**
  * Indexes a task-local data slot. The function's code pointer is used for
diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs
index b578084268a..64737c47f29 100644
--- a/src/libstd/num/f32.rs
+++ b/src/libstd/num/f32.rs
@@ -13,7 +13,9 @@
 use libc::c_int;
 use num::{Zero, One, strconv};
 use num::{FPCategory, FPNaN, FPInfinite , FPZero, FPSubnormal, FPNormal};
+use num;
 use prelude::*;
+use to_str;
 
 pub use cmath::c_float_targ_consts::*;
 
@@ -958,9 +960,12 @@ impl num::FromStrRadix for f32 {
 #[cfg(test)]
 mod tests {
     use f32::*;
-    use num::*;
     use prelude::*;
 
+    use num::*;
+    use num;
+    use sys;
+
     #[test]
     fn test_num() {
         num::test_num(10f32, 2f32);
diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs
index bca730c5748..f01d45bbd1d 100644
--- a/src/libstd/num/f64.rs
+++ b/src/libstd/num/f64.rs
@@ -13,7 +13,9 @@
 use libc::c_int;
 use num::{Zero, One, strconv};
 use num::{FPCategory, FPNaN, FPInfinite , FPZero, FPSubnormal, FPNormal};
+use num;
 use prelude::*;
+use to_str;
 
 pub use cmath::c_double_targ_consts::*;
 pub use cmp::{min, max};
@@ -999,9 +1001,12 @@ impl num::FromStrRadix for f64 {
 #[cfg(test)]
 mod tests {
     use f64::*;
-    use num::*;
     use prelude::*;
 
+    use num::*;
+    use num;
+    use sys;
+
     #[test]
     fn test_num() {
         num::test_num(10f64, 2f64);
diff --git a/src/libstd/num/float.rs b/src/libstd/num/float.rs
index acc5e5a6f39..30de95b4846 100644
--- a/src/libstd/num/float.rs
+++ b/src/libstd/num/float.rs
@@ -20,10 +20,13 @@
 
 // PORT this must match in width according to architecture
 
+use f64;
 use libc::c_int;
 use num::{Zero, One, strconv};
 use num::FPCategory;
+use num;
 use prelude::*;
+use to_str;
 
 pub use f64::{add, sub, mul, div, rem, lt, le, eq, ne, ge, gt};
 pub use f64::{acos, asin, atan2, cbrt, ceil, copysign, cosh, floor};
@@ -43,7 +46,7 @@ pub static neg_infinity: float = -1.0/0.0;
 pub mod consts {
     // FIXME (requires Issue #1433 to fix): replace with mathematical
     // staticants from cmath.
-    /// Archimedes' staticant
+    /// Archimedes' constant
     pub static pi: float = 3.14159265358979323846264338327950288;
 
     /// pi/2.0
@@ -945,10 +948,13 @@ impl Float for float {
 
 #[cfg(test)]
 mod tests {
-    use num::*;
     use super::*;
     use prelude::*;
 
+    use num::*;
+    use num;
+    use sys;
+
     #[test]
     fn test_num() {
         num::test_num(10f, 2f);
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index 27e872003ec..778e741ff3b 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -557,6 +557,13 @@ mod tests {
     use super::*;
     use prelude::*;
 
+    use i16;
+    use i32;
+    use i64;
+    use i8;
+    use num;
+    use sys;
+
     #[test]
     fn test_num() {
         num::test_num(10 as $T, 2 as $T);
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index e6267bfe9e1..f16b4f4a740 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -402,6 +402,14 @@ mod tests {
     use super::*;
     use prelude::*;
 
+    use num;
+    use sys;
+    use u16;
+    use u32;
+    use u64;
+    use u8;
+    use uint;
+
     #[test]
     fn test_num() {
         num::test_num(10 as $T, 2 as $T);
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 9c8c2dbe4d7..c1b5c159a24 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -31,8 +31,10 @@ use io;
 use libc;
 use libc::{c_char, c_void, c_int, size_t};
 use libc::{mode_t, FILE};
+use local_data;
 use option;
 use option::{Some, None};
+use os;
 use prelude::*;
 use ptr;
 use str;
diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index 58d0c40efa0..07864ce419e 100644
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -10,8 +10,7 @@
 
 //! The Rust prelude. Imported into every module by default.
 
-/* Reexported core operators */
-
+// Reexported core operators
 pub use either::{Either, Left, Right};
 pub use kinds::{Const, Copy, Owned};
 pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
@@ -21,12 +20,10 @@ pub use ops::{Shl, Shr, Index};
 pub use option::{Option, Some, None};
 pub use result::{Result, Ok, Err};
 
-/* Reexported functions */
-
+// Reexported functions
 pub use io::{print, println};
 
-/* Reexported types and traits */
-
+// Reexported types and traits
 pub use clone::{Clone, DeepClone};
 pub use cmp::{Eq, ApproxEq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater, Equiv};
 pub use char::Char;
@@ -64,48 +61,7 @@ pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector, MutableVector};
 pub use io::{Reader, ReaderUtil, Writer, WriterUtil};
 
-/* Reexported runtime types */
+// Reexported runtime types
 pub use comm::{stream, Port, Chan, GenericChan, GenericSmartChan, GenericPort, Peekable};
 pub use task::spawn;
 
-/* Reexported modules */
-
-pub use at_vec;
-pub use bool;
-pub use cast;
-pub use char;
-pub use cmp;
-pub use either;
-pub use f32;
-pub use f64;
-pub use float;
-pub use i16;
-pub use i32;
-pub use i64;
-pub use i8;
-pub use int;
-pub use io;
-pub use iter;
-pub use old_iter;
-pub use libc;
-pub use local_data;
-pub use num;
-pub use ops;
-pub use option;
-pub use os;
-pub use path;
-pub use comm;
-pub use unstable;
-pub use ptr;
-pub use rand;
-pub use result;
-pub use str;
-pub use sys;
-pub use task;
-pub use to_str;
-pub use u16;
-pub use u32;
-pub use u64;
-pub use u8;
-pub use uint;
-pub use vec;
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
index 38d7095a366..65375e410a6 100644
--- a/src/libstd/ptr.rs
+++ b/src/libstd/ptr.rs
@@ -430,6 +430,11 @@ pub mod ptr_tests {
     use super::*;
     use prelude::*;
 
+    use cast;
+    use libc;
+    use str;
+    use vec;
+
     #[test]
     fn test() {
         unsafe {
@@ -522,18 +527,19 @@ pub mod ptr_tests {
 
     #[test]
     fn test_to_option() {
-        let p: *int = null();
-        // FIXME (#6641): Usage of unsafe methods in safe code doesn't cause an error.
-        assert_eq!(p.to_option(), None);
+        unsafe {
+            let p: *int = null();
+            assert_eq!(p.to_option(), None);
 
-        let q: *int = &2;
-        assert_eq!(q.to_option().unwrap(), &2);     // FIXME (#6641)
+            let q: *int = &2;
+            assert_eq!(q.to_option().unwrap(), &2);
 
-        let p: *mut int = mut_null();
-        assert_eq!(p.to_option(), None);            // FIXME (#6641)
+            let p: *mut int = mut_null();
+            assert_eq!(p.to_option(), None);
 
-        let q: *mut int = &mut 2;
-        assert_eq!(q.to_option().unwrap(), &2);     // FIXME (#6641)
+            let q: *mut int = &mut 2;
+            assert_eq!(q.to_option().unwrap(), &2);
+        }
     }
 
     #[test]
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 2bcc9c8bba2..2c8681ef288 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -40,10 +40,13 @@ fn main () {
 ~~~
 */
 
-
+use cast;
+use cmp;
 use int;
+use local_data;
 use prelude::*;
 use str;
+use sys;
 use u32;
 use uint;
 use util;
diff --git a/src/libstd/rand/distributions.rs b/src/libstd/rand/distributions.rs
index 72cff5111e7..a66e35f68df 100644
--- a/src/libstd/rand/distributions.rs
+++ b/src/libstd/rand/distributions.rs
@@ -20,6 +20,7 @@
 // Generating Random Variables"], but more robust. If one wanted, one
 // could implement VIZIGNOR the ZIGNOR paper for more speed.
 
+use f64;
 use prelude::*;
 use rand::{Rng,Rand};
 
diff --git a/src/libstd/rt/io/flate.rs b/src/libstd/rt/io/flate.rs
index db2683dc85d..0a9e0b1e38f 100644
--- a/src/libstd/rt/io/flate.rs
+++ b/src/libstd/rt/io/flate.rs
@@ -100,6 +100,8 @@ mod test {
     use super::super::mem::*;
     use super::super::Decorator;
 
+    use str;
+
     #[test]
     #[ignore]
     fn smoke_test() {
diff --git a/src/libstd/rt/io/mem.rs b/src/libstd/rt/io/mem.rs
index b2701c1fdc3..bd9cff76e57 100644
--- a/src/libstd/rt/io/mem.rs
+++ b/src/libstd/rt/io/mem.rs
@@ -15,9 +15,10 @@
 //! * Should probably have something like this for strings.
 //! * Should they implement Closable? Would take extra state.
 
+use cmp::min;
 use prelude::*;
 use super::*;
-use cmp::min;
+use vec;
 
 /// Writes to an owned, growable byte vector
 pub struct MemWriter {
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index cf4967b12b3..12c683120c8 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -13,12 +13,14 @@
 //! local storage, and logging. Even a 'freestanding' Rust would likely want
 //! to implement this.
 
-use prelude::*;
-use libc::{c_void, uintptr_t};
 use cast::transmute;
+use libc::{c_void, uintptr_t};
+use ptr;
+use prelude::*;
 use rt::local::Local;
-use super::local_heap::LocalHeap;
 use rt::logging::StdErrLogger;
+use super::local_heap::LocalHeap;
+use super::sched::Scheduler;
 
 pub struct Task {
     heap: LocalHeap,
diff --git a/src/libstd/rt/uv/uvll.rs b/src/libstd/rt/uv/uvll.rs
index ddc9040d730..6263fd47df6 100644
--- a/src/libstd/rt/uv/uvll.rs
+++ b/src/libstd/rt/uv/uvll.rs
@@ -31,7 +31,11 @@
 
 use libc::{size_t, c_int, c_uint, c_void, c_char, uintptr_t};
 use libc::{malloc, free};
+use libc;
 use prelude::*;
+use ptr;
+use str;
+use vec;
 
 pub static UNKNOWN: c_int = -1;
 pub static OK: c_int = 0;
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index 3cdc5dcca07..7c73aca3af9 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -11,10 +11,11 @@
 //! Process spawning.
 
 use cast;
+use comm::{stream, SharedChan, GenericChan, GenericPort};
+use int;
 use io;
-use libc;
 use libc::{pid_t, c_void, c_int};
-use comm::{stream, SharedChan, GenericChan, GenericPort};
+use libc;
 use option::{Some, None};
 use os;
 use prelude::*;
@@ -463,6 +464,9 @@ fn spawn_process_os(prog: &str, args: &[~str],
     };
     use libc::funcs::extra::msvcrt::get_osfhandle;
 
+    use sys;
+    use uint;
+
     unsafe {
 
         let mut si = zeroed_startupinfo();
@@ -574,6 +578,8 @@ fn zeroed_process_information() -> libc::types::os::arch::extra::PROCESS_INFORMA
 #[cfg(windows)]
 pub fn make_command_line(prog: &str, args: &[~str]) -> ~str {
 
+    use uint;
+
     let mut cmd = ~"";
     append_arg(&mut cmd, prog);
     for args.each |arg| {
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index f24d2327358..9c9a91f9548 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -33,17 +33,22 @@
  * ~~~
  */
 
+use prelude::*;
+
+use cast;
 use cell::Cell;
 use cmp::Eq;
-use result::Result;
 use comm::{stream, Chan, GenericChan, GenericPort, Port};
-use prelude::*;
+use comm;
+use ptr;
+use result::Result;
 use result;
+use rt::{context, OldTaskContext};
 use task::rt::{task_id, sched_id};
-use util;
-use util::replace;
+use task;
 use unstable::finally::Finally;
-use rt::{context, OldTaskContext};
+use util::replace;
+use util;
 
 #[cfg(test)] use comm::SharedChan;
 
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
index 56b1fb43ff1..0b345b88d62 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -72,12 +72,14 @@
 
 #[doc(hidden)];
 
+use prelude::*;
+
 use cast::transmute;
 use cast;
 use cell::Cell;
 use container::Map;
 use comm::{Chan, GenericChan};
-use prelude::*;
+use comm;
 use ptr;
 use hashmap::HashSet;
 use task::local_data_priv::{local_get, local_set, OldHandle};
@@ -87,6 +89,7 @@ use task::{Failure, ManualThreads, PlatformThread, SchedOpts, SingleThreaded};
 use task::{Success, TaskOpts, TaskResult, ThreadPerCore, ThreadPerTask};
 use task::{ExistingScheduler, SchedulerHandle};
 use task::unkillable;
+use task;
 use uint;
 use util;
 use unstable::sync::{Exclusive, exclusive};
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index 13b892e700e..1490841b7e6 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -10,8 +10,12 @@
 
 //! An ordered map and set for integer keys implemented as a radix trie
 
+use local_data;
+use os;
 use prelude::*;
+use uint;
 use util::{swap, replace};
+use vec;
 
 // FIXME: #5244: need to manually update the TrieNode constructor
 static SHIFT: uint = 4;
diff --git a/src/libstd/unstable/mod.rs b/src/libstd/unstable/mod.rs
index afdc22a1c63..1f73aa02b01 100644
--- a/src/libstd/unstable/mod.rs
+++ b/src/libstd/unstable/mod.rs
@@ -10,9 +10,11 @@
 
 #[doc(hidden)];
 
-use libc;
 use comm::{GenericChan, GenericPort};
+use comm;
+use libc;
 use prelude::*;
+use ptr;
 use task;
 
 pub mod at_exit;
diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs
index 734368c70c4..bee317a0b93 100644
--- a/src/libstd/unstable/sync.rs
+++ b/src/libstd/unstable/sync.rs
@@ -214,48 +214,52 @@ mod tests {
 
     #[test]
     fn exclusive_arc() {
-        let mut futures = ~[];
+        unsafe {
+            let mut futures = ~[];
 
-        let num_tasks = 10;
-        let count = 10;
+            let num_tasks = 10;
+            let count = 10;
 
-        let total = exclusive(~0);
+            let total = exclusive(~0);
 
-        for uint::range(0, num_tasks) |_i| {
-            let total = total.clone();
-            let (port, chan) = comm::stream();
-            futures.push(port);
+            for uint::range(0, num_tasks) |_i| {
+                let total = total.clone();
+                let (port, chan) = comm::stream();
+                futures.push(port);
 
-            do task::spawn || {
-                for uint::range(0, count) |_i| {
-                    do total.with |count| {
-                        **count += 1;
+                do task::spawn || {
+                    for uint::range(0, count) |_i| {
+                        do total.with |count| {
+                            **count += 1;
+                        }
                     }
+                    chan.send(());
                 }
-                chan.send(());
-            }
-        };
+            };
 
-        for futures.each |f| { f.recv() }
+            for futures.each |f| { f.recv() }
 
-        do total.with |total| {
-            assert!(**total == num_tasks * count)
-        };
+            do total.with |total| {
+                assert!(**total == num_tasks * count)
+            };
+        }
     }
 
     #[test] #[should_fail] #[ignore(cfg(windows))]
     fn exclusive_poison() {
-        // Tests that if one task fails inside of an exclusive, subsequent
-        // accesses will also fail.
-        let x = exclusive(1);
-        let x2 = x.clone();
-        do task::try || {
-            do x2.with |one| {
-                assert_eq!(*one, 2);
+        unsafe {
+            // Tests that if one task fails inside of an exclusive, subsequent
+            // accesses will also fail.
+            let x = exclusive(1);
+            let x2 = x.clone();
+            do task::try || {
+                do x2.with |one| {
+                    assert_eq!(*one, 2);
+                }
+            };
+            do x.with |one| {
+                assert_eq!(*one, 1);
             }
-        };
-        do x.with |one| {
-            assert_eq!(*one, 1);
         }
     }
 }
diff --git a/src/libstd/util.rs b/src/libstd/util.rs
index 9e7f18f446d..5539881a648 100644
--- a/src/libstd/util.rs
+++ b/src/libstd/util.rs
@@ -8,12 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*!
-
-Miscellaneous helpers for common patterns.
-
-*/
+//! Miscellaneous helpers for common patterns.
 
+use cast;
+use local_data;
+use ptr;
 use prelude::*;
 use unstable::intrinsics;