Great renaming: propagate throughout the rest of the codebase

src/libextra/arc.rs

@@ -39,15 +39,14 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use sync;
 use sync::{Mutex, mutex_with_condvars, RWlock, rwlock_with_condvars};
 
-use core::cast;
-use core::unstable::sync::UnsafeAtomicRcBox;
-use core::task;
-use core::borrow;
+use std::cast;
+use std::unstable::sync::UnsafeAtomicRcBox;
+use std::task;
+use std::borrow;
 
 /// As sync::condvar, a mechanism for unlock-and-descheduling and signaling.
 pub struct Condvar<'self> {
@@ -514,14 +513,13 @@ impl<'self, T:Freeze + Send> RWReadMode<'self, T> {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use arc::*;
 
-    use core::cell::Cell;
-    use core::comm;
-    use core::task;
-    use core::uint;
+    use std::cell::Cell;
+    use std::comm;
+    use std::task;
+    use std::uint;
 
     #[test]
     fn manually_share_arc() {

src/libextra/arena.rs

@@ -34,22 +34,21 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use list::{MutList, MutCons, MutNil};
 
-use core::at_vec;
-use core::cast::{transmute, transmute_mut, transmute_mut_region};
-use core::cast;
-use core::ptr;
-use core::sys;
-use core::uint;
-use core::vec;
-use core::unstable::intrinsics;
-use core::unstable::intrinsics::{TyDesc};
+use std::at_vec;
+use std::cast::{transmute, transmute_mut, transmute_mut_region};
+use std::cast;
+use std::ptr;
+use std::sys;
+use std::uint;
+use std::vec;
+use std::unstable::intrinsics;
+use std::unstable::intrinsics::{TyDesc};
 
 #[cfg(not(stage0))]
-use core::unstable::intrinsics::{get_tydesc};
+use std::unstable::intrinsics::{get_tydesc};
 
 #[cfg(stage0)]
 unsafe fn get_tydesc<T>() -> *TyDesc {

src/libextra/base64.rs

@@ -10,9 +10,8 @@
 
 //! Base64 binary-to-text encoding
 
-use core::prelude::*;
 
-use core::vec;
+use std::vec;
 
 /// A trait for converting a value to base64 encoding.
 pub trait ToBase64 {
@@ -199,7 +198,7 @@ impl<'self> FromBase64 for &'self str {
      * Convert any base64 encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
      *
-     * You can use the `from_bytes` function in `core::str`
+     * You can use the `from_bytes` function in `std::str`
      * to turn a `[u8]` into a string with characters corresponding to those values.
      *
      * # Example
@@ -210,7 +209,7 @@ impl<'self> FromBase64 for &'self str {
      * extern mod extra;
      * use extra::base64::ToBase64;
      * use extra::base64::FromBase64;
-     * use core::str;
+     * use std::str;
      *
      * fn main () {
      *     let hello_str = "Hello, World".to_base64();

src/libextra/bitv.rs

@@ -10,12 +10,11 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cmp;
-use core::ops;
-use core::uint;
-use core::vec;
+use std::cmp;
+use std::ops;
+use std::uint;
+use std::vec;
 
 struct SmallBitv {
     /// only the lowest nbits of this value are used. the rest is undefined.
@@ -868,10 +867,10 @@ mod tests {
     use bitv::*;
     use bitv;
 
-    use core::uint;
-    use core::vec;
-    use core::rand;
-    use core::rand::Rng;
+    use std::uint;
+    use std::vec;
+    use std::rand;
+    use std::rand::Rng;
 
     static bench_bits : uint = 1 << 14;
 

src/libextra/c_vec.rs

@@ -36,10 +36,9 @@
  * still held if needed.
  */
 
-use core::prelude::*;
 
-use core::option;
-use core::ptr;
+use std::option;
+use std::ptr;
 
 /**
  * The type representing a foreign chunk of memory
@@ -150,8 +149,8 @@ mod tests {
 
     use c_vec::*;
 
-    use core::libc::*;
-    use core::libc;
+    use std::libc::*;
+    use std::libc;
 
     fn malloc(n: size_t) -> CVec<u8> {
         unsafe {

src/libextra/comm.rs

@@ -16,12 +16,11 @@ Higher level communication abstractions.
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::comm::{GenericChan, GenericSmartChan, GenericPort};
-use core::comm::{Chan, Port, Selectable, Peekable};
-use core::comm;
-use core::pipes;
+use std::comm::{GenericChan, GenericSmartChan, GenericPort};
+use std::comm::{Chan, Port, Selectable, Peekable};
+use std::comm;
+use std::pipes;
 
 /// An extension of `pipes::stream` that allows both sending and receiving.
 pub struct DuplexStream<T, U> {

src/libextra/crypto/digest.rs

@@ -8,10 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::uint;
-use core::vec;
+use std::uint;
+use std::vec;
 
 /**
  * The Digest trait specifies an interface common to digest functions, such as SHA-1 and the SHA-2

src/libextra/crypto/sha1.rs

@@ -22,7 +22,6 @@
  * the `reset` method.
  */
 
-use core::prelude::*;
 
 use digest::Digest;
 
@@ -241,7 +240,7 @@ impl Digest for Sha1 {
 
 #[cfg(test)]
 mod tests {
-    use core::vec;
+    use std::vec;
 
     use digest::{Digest, DigestUtil};
     use sha1::Sha1;

src/libextra/crypto/sha2.rs

@@ -8,9 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::uint;
+use std::uint;
 
 use digest::Digest;
 

src/libextra/dbg.rs

@@ -12,17 +12,17 @@
 
 #[allow(missing_doc)];
 
-use core::cast::transmute;
+use std::cast::transmute;
 #[cfg(stage0)]
 use intrinsic::{get_tydesc};
 #[cfg(not(stage0))]
-use core::unstable::intrinsics::{get_tydesc};
+use std::unstable::intrinsics::{get_tydesc};
 
 pub mod rustrt {
     #[cfg(stage0)]
     use intrinsic::{TyDesc};
     #[cfg(not(stage0))]
-    use core::unstable::intrinsics::{TyDesc};
+    use std::unstable::intrinsics::{TyDesc};
 
     #[abi = "cdecl"]
     pub extern {

src/libextra/deque.rs

@@ -9,12 +9,11 @@
 // except according to those terms.
 
 //! A double-ended queue implemented as a circular buffer
-use core::prelude::*;
 
-use core::uint;
-use core::util::replace;
-use core::vec;
-use core::cast::transmute;
+use std::uint;
+use std::util::replace;
+use std::vec;
+use std::cast::transmute;
 
 static initial_capacity: uint = 32u; // 2^5
 
@@ -254,8 +253,8 @@ fn get<'r, T>(elts: &'r [Option<T>], i: uint) -> &'r T {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use core::cmp::Eq;
-    use core::kinds::Copy;
+    use std::cmp::Eq;
+    use std::kinds::Copy;
     use core;
 
     #[test]
@@ -463,12 +462,12 @@ mod tests {
     #[test]
     fn test_iter() {
         let mut d = Deque::new();
-        for core::int::range(0,5) |i| {
+        for std::int::range(0,5) |i| {
             d.add_back(i);
         }
         assert_eq!(d.iter().collect::<~[&int]>(), ~[&0,&1,&2,&3,&4]);
 
-        for core::int::range(6,9) |i| {
+        for std::int::range(6,9) |i| {
             d.add_front(i);
         }
         assert_eq!(d.iter().collect::<~[&int]>(), ~[&8,&7,&6,&0,&1,&2,&3,&4]);
@@ -477,12 +476,12 @@ mod tests {
     #[test]
     fn test_rev_iter() {
         let mut d = Deque::new();
-        for core::int::range(0,5) |i| {
+        for std::int::range(0,5) |i| {
             d.add_back(i);
         }
         assert_eq!(d.rev_iter().collect::<~[&int]>(), ~[&4,&3,&2,&1,&0]);
 
-        for core::int::range(6,9) |i| {
+        for std::int::range(6,9) |i| {
             d.add_front(i);
         }
         assert_eq!(d.rev_iter().collect::<~[&int]>(), ~[&4,&3,&2,&1,&0,&6,&7,&8]);

src/libextra/dlist.rs

@@ -18,9 +18,8 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
 
 */
 
-use core::prelude::*;
 
-use core::managed;
+use std::managed;
 
 pub type DListLink<T> = Option<@mut DListNode<T>>;
 
@@ -522,7 +521,6 @@ impl<T:Copy> DList<T> {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use super::*;
 

src/libextra/ebml.rs

@@ -10,9 +10,8 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::str;
+use std::str;
 
 // Simple Extensible Binary Markup Language (ebml) reader and writer on a
 // cursor model. See the specification here:
@@ -94,18 +93,18 @@ pub mod reader {
 
     use serialize;
 
-    use core::cast::transmute;
-    use core::int;
-    use core::io;
-    use core::option::{None, Option, Some};
+    use std::cast::transmute;
+    use std::int;
+    use std::io;
+    use std::option::{None, Option, Some};
 
     #[cfg(target_arch = "x86")]
     #[cfg(target_arch = "x86_64")]
-    use core::ptr::offset;
+    use std::ptr::offset;
 
     #[cfg(target_arch = "x86")]
     #[cfg(target_arch = "x86_64")]
-    use core::unstable::intrinsics::bswap32;
+    use std::unstable::intrinsics::bswap32;
 
     // ebml reading
 
@@ -378,7 +377,7 @@ pub mod reader {
         fn read_u8 (&mut self) -> u8  { doc_as_u8 (self.next_doc(EsU8 )) }
         fn read_uint(&mut self) -> uint {
             let v = doc_as_u64(self.next_doc(EsUint));
-            if v > (::core::uint::max_value as u64) {
+            if v > (::std::uint::max_value as u64) {
                 fail!("uint %? too large for this architecture", v);
             }
             v as uint
@@ -611,8 +610,8 @@ pub mod reader {
 pub mod writer {
     use super::*;
 
-    use core::cast;
-    use core::io;
+    use std::cast;
+    use std::io;
 
     // ebml writing
     pub struct Encoder {
@@ -957,8 +956,8 @@ mod tests {
     use serialize::Encodable;
     use serialize;
 
-    use core::io;
-    use core::option::{None, Option, Some};
+    use std::io;
+    use std::option::{None, Option, Some};
 
     #[test]
     fn test_option_int() {

src/libextra/extra.rs

@@ -32,13 +32,9 @@ Rust extras are part of the standard Rust distribution.
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
 
-#[no_std];
+use std::str::{StrSlice, OwnedStr};
 
-extern mod core(name = "std", vers = "0.7-pre");
-
-use core::str::{StrSlice, OwnedStr};
-
-pub use core::os;
+pub use std::os;
 
 pub mod uv_ll;
 
@@ -135,21 +131,16 @@ pub mod serialize;
 // 'extra' so that macro-expanded references to extra::serialize and such
 // can be resolved within libextra.
 #[doc(hidden)]
-pub mod std {
+pub mod extra {
     pub use serialize;
     pub use test;
 
     // For bootstrapping.
-    pub use core::clone;
-    pub use core::condition;
-    pub use core::cmp;
-    pub use core::sys;
-    pub use core::unstable;
-    pub use core::str;
-    pub use core::os;
-}
-#[doc(hidden)]
-pub mod extra {
-    pub use serialize;
-    pub use test;
+    pub use std::clone;
+    pub use std::condition;
+    pub use std::cmp;
+    pub use std::sys;
+    pub use std::unstable;
+    pub use std::str;
+    pub use std::os;
 }

src/libextra/fileinput.rs

@@ -57,14 +57,14 @@ For more complicated uses (e.g. if one needs to pause iteration and
 resume it later), a `FileInput` instance can be constructed via the
 `from_vec`, `from_vec_raw` and `from_args` functions.
 
-Once created, the `each_line` (from the `core::io::ReaderUtil` trait)
+Once created, the `each_line` (from the `std::io::ReaderUtil` trait)
 and `each_line_state` methods allow one to iterate on the lines; the
 latter provides more information about the position within the
 iteration to the caller.
 
 It is possible (and safe) to skip lines and files using the
 `read_line` and `next_file` methods. Also, `FileInput` implements
-`core::io::Reader`, and the state will be updated correctly while
+`std::io::Reader`, and the state will be updated correctly while
 using any of those methods.
 
 E.g. the following program reads until an empty line, pauses for user
@@ -96,12 +96,11 @@ total line count).
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::io::ReaderUtil;
-use core::io;
-use core::os;
-use core::vec;
+use std::io::ReaderUtil;
+use std::io;
+use std::os;
+use std::vec;
 
 /**
 A summary of the internal state of a `FileInput` object. `line_num`
@@ -410,13 +409,12 @@ pub fn input_vec_state(files: ~[Option<Path>],
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use super::{FileInput, pathify, input_vec, input_vec_state};
 
-    use core::io;
-    use core::uint;
-    use core::vec;
+    use std::io;
+    use std::uint;
+    use std::vec;
 
     fn make_file(path : &Path, contents: &[~str]) {
         let file = io::file_writer(path, [io::Create, io::Truncate]).get();

src/libextra/flate.rs

@@ -16,12 +16,12 @@ Simple compression
 
 #[allow(missing_doc)];
 
-use core::libc::{c_void, size_t, c_int};
-use core::libc;
-use core::vec;
+use std::libc::{c_void, size_t, c_int};
+use std::libc;
+use std::vec;
 
 pub mod rustrt {
-    use core::libc::{c_int, c_void, size_t};
+    use std::libc::{c_int, c_void, size_t};
 
     #[link_name = "rustrt"]
     pub extern {
@@ -83,9 +83,8 @@ pub fn inflate_bytes(bytes: &const [u8]) -> ~[u8] {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use core::rand;
-    use core::rand::RngUtil;
-    use core::prelude::*;
+    use std::rand;
+    use std::rand::RngUtil;
 
     #[test]
     #[allow(non_implicitly_copyable_typarams)]

src/libextra/flatpipes.rs

@@ -49,14 +49,13 @@ block the scheduler thread, so will their pipes.
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 // The basic send/recv interface FlatChan and PortChan will implement
-use core::io;
-use core::comm::GenericChan;
-use core::comm::GenericPort;
-use core::sys::size_of;
-use core::vec;
+use std::io;
+use std::comm::GenericChan;
+use std::comm::GenericPort;
+use std::sys::size_of;
+use std::vec;
 
 /**
 A FlatPort, consisting of a `BytePort` that receives byte vectors,
@@ -95,9 +94,9 @@ pub mod serial {
     use flatpipes::bytepipes::{PipeBytePort, PipeByteChan};
     use flatpipes::{FlatPort, FlatChan};
 
-    use core::io::{Reader, Writer};
-    use core::comm::{Port, Chan};
-    use core::comm;
+    use std::io::{Reader, Writer};
+    use std::comm::{Port, Chan};
+    use std::comm;
 
     pub type ReaderPort<T, R> = FlatPort<
         T, DeserializingUnflattener<DefaultDecoder, T>,
@@ -172,16 +171,15 @@ POD are not equivelant.
 
 */
 pub mod pod {
-    use core::prelude::*;
 
     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::comm::{Port, Chan};
-    use core::comm;
+    use std::io::{Reader, Writer};
+    use std::comm::{Port, Chan};
+    use std::comm;
 
     pub type ReaderPort<T, R> =
         FlatPort<T, PodUnflattener<T>, ReaderBytePort<R>>;
@@ -337,7 +335,6 @@ impl<T,F:Flattener<T>,C:ByteChan> FlatChan<T, F, C> {
 
 
 pub mod flatteners {
-    use core::prelude::*;
 
     use ebml;
     use flatpipes::{Flattener, Unflattener};
@@ -345,12 +342,12 @@ pub mod flatteners {
     use json;
     use serialize::{Encoder, Decoder, Encodable, Decodable};
 
-    use core::cast;
-    use core::io::{Writer, Reader, ReaderUtil};
-    use core::io;
-    use core::ptr;
-    use core::sys::size_of;
-    use core::vec;
+    use std::cast;
+    use std::io::{Writer, Reader, ReaderUtil};
+    use std::io;
+    use std::ptr;
+    use std::sys::size_of;
+    use std::vec;
 
     // FIXME #4074: Copy + Send != POD
     pub struct PodUnflattener<T> {
@@ -509,13 +506,12 @@ pub mod flatteners {
 }
 
 pub mod bytepipes {
-    use core::prelude::*;
 
     use flatpipes::{ByteChan, BytePort};
 
-    use core::comm::{Port, Chan};
-    use core::comm;
-    use core::io::{Writer, Reader, ReaderUtil};
+    use std::comm::{Port, Chan};
+    use std::comm;
+    use std::io::{Writer, Reader, ReaderUtil};
 
     pub struct ReaderBytePort<R> {
         reader: R
@@ -583,12 +579,12 @@ pub mod bytepipes {
     impl BytePort for PipeBytePort {
         fn try_recv(&self, count: uint) -> Option<~[u8]> {
             if self.buf.len() >= count {
-                let mut bytes = ::core::util::replace(&mut *self.buf, ~[]);
+                let mut bytes = ::std::util::replace(&mut *self.buf, ~[]);
                 *self.buf = bytes.slice(count, bytes.len()).to_owned();
                 bytes.truncate(count);
                 return Some(bytes);
             } else if !self.buf.is_empty() {
-                let mut bytes = ::core::util::replace(&mut *self.buf, ~[]);
+                let mut bytes = ::std::util::replace(&mut *self.buf, ~[]);
                 assert!(count > bytes.len());
                 match self.try_recv(count - bytes.len()) {
                     Some(rest) => {
@@ -637,7 +633,6 @@ pub mod bytepipes {
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use flatpipes::{Flattener, Unflattener};
     use flatpipes::bytepipes::*;
@@ -647,11 +642,11 @@ mod test {
     use flatpipes::{BytePort, FlatChan, FlatPort};
     use net::tcp::TcpSocketBuf;
 
-    use core::comm;
-    use core::int;
-    use core::io::BytesWriter;
-    use core::result;
-    use core::task;
+    use std::comm;
+    use std::int;
+    use std::io::BytesWriter;
+    use std::result;
+    use std::task;
 
     #[test]
     #[ignore(reason = "ebml failure")]
@@ -772,7 +767,7 @@ mod test {
         writer_chan: WriterChanFactory<F>,
         port: uint) {
 
-        use core::cell::Cell;
+        use std::cell::Cell;
         use net::ip;
         use net::tcp;
         use uv;
@@ -871,17 +866,16 @@ 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 io_util::BufReader;
 
-        use core::comm;
-        use core::io;
-        use core::sys;
-        use core::task;
+        use std::comm;
+        use std::io;
+        use std::sys;
+        use std::task;
 
         type PortLoader<P> =
             ~fn(~[u8]) -> FlatPort<int, PodUnflattener<int>, P>;

src/libextra/fun_treemap.rs

@@ -19,10 +19,9 @@
  * of features.
  */
 
-use core::prelude::*;
 
-use core::cmp::{Eq, Ord};
-use core::option::{Some, None};
+use std::cmp::{Eq, Ord};
+use std::option::{Some, None};
 
 pub type Treemap<K, V> = @TreeNode<K, V>;
 

src/libextra/future.rs

@@ -25,13 +25,12 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cast;
-use core::cell::Cell;
-use core::comm::{PortOne, oneshot, send_one, recv_one};
-use core::task;
-use core::util::replace;
+use std::cast;
+use std::cell::Cell;
+use std::comm::{PortOne, oneshot, send_one, recv_one};
+use std::task;
+use std::util::replace;
 
 #[doc = "The future type"]
 pub struct Future<A> {
@@ -151,9 +150,9 @@ pub fn spawn<A:Send>(blk: ~fn() -> A) -> Future<A> {
 mod test {
     use future::*;
 
-    use core::cell::Cell;
-    use core::comm::{oneshot, send_one};
-    use core::task;
+    use std::cell::Cell;
+    use std::comm::{oneshot, send_one};
+    use std::task;
 
     #[test]
     fn test_from_value() {

src/libextra/getopts.rs

@@ -81,14 +81,13 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cmp::Eq;
-use core::result::{Err, Ok};
-use core::result;
-use core::option::{Some, None};
-use core::str;
-use core::vec;
+use std::cmp::Eq;
+use std::result::{Err, Ok};
+use std::result;
+use std::option::{Some, None};
+use std::str;
+use std::vec;
 
 #[deriving(Eq)]
 pub enum Name {
@@ -466,8 +465,8 @@ pub mod groups {
     use getopts::{HasArg, Long, Maybe, Multi, No, Occur, Opt, Optional, Req};
     use getopts::{Short, Yes};
 
-    use core::str;
-    use core::vec;
+    use std::str;
+    use std::vec;
 
     /** one group of options, e.g., both -h and --help, along with
      * their shared description and properties
@@ -681,8 +680,8 @@ mod tests {
     use getopts::groups::OptGroup;
     use getopts::*;
 
-    use core::result::{Err, Ok};
-    use core::result;
+    use std::result::{Err, Ok};
+    use std::result;
 
     fn check_fail_type(f: Fail_, ft: FailType) {
         match f {

src/libextra/io_util.rs

@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::io::{Reader, BytesReader};
-use core::io;
-use core::cast;
+use std::io::{Reader, BytesReader};
+use std::io;
+use std::cast;
 
 /// An implementation of the io::Reader interface which reads a buffer of bytes
 pub struct BufReader {
@@ -31,7 +31,7 @@ impl BufReader {
 
     fn as_bytes_reader<A>(&self, f: &fn(&BytesReader) -> A) -> A {
         // XXX FIXME(#5723)
-        let bytes = ::core::util::id::<&[u8]>(self.buf);
+        let bytes = ::std::util::id::<&[u8]>(self.buf);
         let bytes: &'static [u8] = unsafe { cast::transmute(bytes) };
         // Recreating the BytesReader state every call since
         // I can't get the borrowing to work correctly

src/libextra/json.rs

@@ -16,16 +16,15 @@
 
 //! json serialization
 
-use core::prelude::*;
 
-use core::char;
-use core::float;
-use core::hashmap::HashMap;
-use core::io::{WriterUtil, ReaderUtil};
-use core::io;
-use core::str;
-use core::to_str;
-use core::vec;
+use std::char;
+use std::float;
+use std::hashmap::HashMap;
+use std::io::{WriterUtil, ReaderUtil};
+use std::io;
+use std::str;
+use std::to_str;
+use std::vec;
 
 use serialize::Encodable;
 use serialize;
@@ -1356,13 +1355,12 @@ impl to_str::ToStr for Error {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::hashmap::HashMap;
-    use core::io;
-    use core::result;
+    use std::hashmap::HashMap;
+    use std::io;
+    use std::result;
 
     use std::serialize::Decodable;
 

src/libextra/list.rs

@@ -10,7 +10,6 @@
 
 //! A standard, garbage-collected linked list.
 
-use core::prelude::*;
 
 
 #[deriving(Eq)]
@@ -181,7 +180,7 @@ mod tests {
     use list::*;
     use list;
 
-    use core::option;
+    use std::option;
 
     #[test]
     fn test_is_empty() {

src/libextra/md4.rs

@@ -8,10 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::uint;
-use core::vec;
+use std::uint;
+use std::vec;
 
 struct Quad {
     a: u32,

src/libextra/net_ip.rs

@@ -12,13 +12,12 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::libc;
-use core::comm::{stream, SharedChan};
-use core::ptr;
-use core::result;
-use core::str;
+use std::libc;
+use std::comm::{stream, SharedChan};
+use std::ptr;
+use std::result;
+use std::str;
 
 use iotask = uv::iotask::IoTask;
 use interact = uv::iotask::interact;
@@ -149,16 +148,15 @@ pub fn get_addr(node: &str, iotask: &iotask)
 }
 
 pub mod v4 {
-    use core::prelude::*;
 
     use net::ip::{IpAddr, Ipv4, ParseAddrErr};
     use uv::ll;
     use uv_ip4_addr = uv::ll::ip4_addr;
     use uv_ip4_name = uv::ll::ip4_name;
 
-    use core::cast::transmute;
-    use core::result;
-    use core::uint;
+    use std::cast::transmute;
+    use std::result;
+    use std::uint;
 
     /**
      * Convert a str to `ip_addr`
@@ -248,13 +246,12 @@ pub mod v4 {
     }
 }
 pub mod v6 {
-    use core::prelude::*;
 
     use net::ip::{IpAddr, Ipv6, ParseAddrErr};
     use uv_ip6_addr = uv::ll::ip6_addr;
     use uv_ip6_name = uv::ll::ip6_name;
 
-    use core::result;
+    use std::result;
 
     /**
      * Convert a str to `ip_addr`
@@ -371,7 +368,7 @@ mod test {
     use net_ip::v6;
     use uv;
 
-    use core::result;
+    use std::result;
 
     #[test]
     fn test_ip_ipv4_parse_and_format_ip() {

src/libextra/net_tcp.rs

@@ -13,7 +13,6 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use future;
 use future_spawn = future::spawn;
@@ -22,18 +21,18 @@ use uv;
 use uv::iotask;
 use uv::iotask::IoTask;
 
-use core::io;
-use core::libc::size_t;
-use core::libc;
-use core::comm::{stream, Port, SharedChan};
-use core::ptr;
-use core::result::{Result};
-use core::result;
-use core::uint;
-use core::vec;
+use std::io;
+use std::libc::size_t;
+use std::libc;
+use std::comm::{stream, Port, SharedChan};
+use std::ptr;
+use std::result::{Result};
+use std::result;
+use std::uint;
+use std::vec;
 
 pub mod rustrt {
-    use core::libc;
+    use std::libc;
 
     #[nolink]
     pub extern {
@@ -360,7 +359,7 @@ pub fn write_future(sock: &TcpSocket, raw_write_data: ~[u8])
  * # Returns
  *
  * * A `Result` instance that will either contain a
- * `core::comm::Port<Result<~[u8], TcpErrData>>` that the user can read
+ * `std::comm::Port<Result<~[u8], TcpErrData>>` that the user can read
  * (and * optionally, loop on) from until `read_stop` is called, or a
  * `TcpErrData` record
  */
@@ -619,7 +618,7 @@ pub fn accept(new_conn: TcpNewConnection)
  * callback's arguments are:
  *     * `new_conn` - an opaque type that can be passed to
  *     `net::tcp::accept` in order to be converted to a `TcpSocket`.
- *     * `kill_ch` - channel of type `core::comm::Chan<Option<tcp_err_data>>`.
+ *     * `kill_ch` - channel of type `std::comm::Chan<Option<tcp_err_data>>`.
  *     this channel can be used to send a message to cause `listen` to begin
  *     closing the underlying libuv data structures.
  *
@@ -683,7 +682,7 @@ fn listen_common(host_ip: ip::IpAddr,
     // will defeat a move sigil, as is done to the host_ip
     // arg above.. this same pattern works w/o complaint in
     // tcp::connect (because the iotask::interact cb isn't
-    // nested within a core::comm::listen block)
+    // nested within a std::comm::listen block)
     let loc_ip = copy(host_ip);
     do iotask::interact(iotask) |loop_ptr| {
         unsafe {
@@ -1429,7 +1428,6 @@ struct TcpBufferedSocketData {
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use net::ip;
     use net::tcp::{GenericListenErr, TcpConnectErrData, TcpListenErrData};
@@ -1438,12 +1436,12 @@ mod test {
     use uv::iotask::IoTask;
     use uv;
 
-    use core::cell::Cell;
-    use core::comm::{stream, SharedChan};
-    use core::io;
-    use core::result;
-    use core::str;
-    use core::task;
+    use std::cell::Cell;
+    use std::comm::{stream, SharedChan};
+    use std::io;
+    use std::result;
+    use std::str;
+    use std::task;
 
     // FIXME don't run on fbsd or linux 32 bit (#2064)
     #[cfg(target_os="win32")]
@@ -1745,7 +1743,7 @@ mod test {
     }
 
     pub fn impl_tcp_socket_impl_reader_handles_eof() {
-        use core::io::{Reader,ReaderUtil};
+        use std::io::{Reader,ReaderUtil};
 
         let hl_loop = &uv::global_loop::get();
         let server_ip = "127.0.0.1";

src/libextra/net_url.rs

@@ -12,14 +12,13 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cmp::Eq;
-use core::io::{Reader, ReaderUtil};
-use core::io;
-use core::hashmap::HashMap;
-use core::to_bytes;
-use core::uint;
+use std::cmp::Eq;
+use std::io::{Reader, ReaderUtil};
+use std::io;
+use std::hashmap::HashMap;
+use std::to_bytes;
+use std::uint;
 
 #[deriving(Clone, Eq)]
 struct Url {
@@ -803,7 +802,7 @@ mod tests {
 
     use net_url::*;
 
-    use core::hashmap::HashMap;
+    use std::hashmap::HashMap;
 
     #[test]
     fn test_url_parse() {

src/libextra/num/bigint.rs

@@ -18,13 +18,12 @@ A BigInt is a combination of BigUint and Sign.
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
-use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
-use core::int;
-use core::num::{IntConvertible, Zero, One, ToStrRadix, FromStrRadix, Orderable};
-use core::str;
-use core::uint;
-use core::vec;
+use std::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
+use std::int;
+use std::num::{IntConvertible, Zero, One, ToStrRadix, FromStrRadix, Orderable};
+use std::str;
+use std::uint;
+use std::vec;
 
 /**
 A BigDigit is a BigUint's composing element.
@@ -1148,16 +1147,15 @@ impl BigInt {
 
 #[cfg(test)]
 mod biguint_tests {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::cmp::{Less, Equal, Greater};
-    use core::int;
-    use core::num::{IntConvertible, Zero, One, FromStrRadix};
-    use core::str;
-    use core::uint;
-    use core::vec;
+    use std::cmp::{Less, Equal, Greater};
+    use std::int;
+    use std::num::{IntConvertible, Zero, One, FromStrRadix};
+    use std::str;
+    use std::uint;
+    use std::vec;
 
     #[test]
     fn test_from_slice() {
@@ -1623,15 +1621,14 @@ mod biguint_tests {
 
 #[cfg(test)]
 mod bigint_tests {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::cmp::{Less, Equal, Greater};
-    use core::int;
-    use core::num::{IntConvertible, Zero, One, FromStrRadix};
-    use core::uint;
-    use core::vec;
+    use std::cmp::{Less, Equal, Greater};
+    use std::int;
+    use std::num::{IntConvertible, Zero, One, FromStrRadix};
+    use std::uint;
+    use std::vec;
 
     #[test]
     fn test_from_biguint() {

src/libextra/num/complex.rs

@@ -11,9 +11,8 @@
 
 //! Complex numbers.
 
-use core::prelude::*;
 
-use core::num::{Zero,One,ToStrRadix};
+use std::num::{Zero,One,ToStrRadix};
 
 // FIXME #1284: handle complex NaN & infinity etc. This
 // probably doesn't map to C's _Complex correctly.
@@ -193,7 +192,7 @@ impl<T: ToStrRadix + Num + Ord> ToStrRadix for Cmplx<T> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use core::num::{Zero,One,Real};
+    use std::num::{Zero,One,Real};
 
     pub static _0_0i : Complex = Cmplx { re: 0f, im: 0f };
     pub static _1_0i : Complex = Cmplx { re: 1f, im: 0f };
@@ -287,7 +286,7 @@ mod test {
 
     mod arith {
         use super::*;
-        use core::num::Zero;
+        use std::num::Zero;
 
         #[test]
         fn test_add() {

src/libextra/num/rational.rs

@@ -10,11 +10,10 @@
 
 //! Rational numbers
 
-use core::prelude::*;
 
-use core::cmp;
-use core::from_str::FromStr;
-use core::num::{Zero,One,ToStrRadix,FromStrRadix,Round};
+use std::cmp;
+use std::from_str::FromStr;
+use std::num::{Zero,One,ToStrRadix,FromStrRadix,Round};
 use super::bigint::BigInt;
 
 /// Represents the ratio between 2 numbers.
@@ -277,11 +276,10 @@ impl<T: FromStrRadix + Clone + Integer + Ord>
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use super::*;
-    use core::num::{Zero,One,FromStrRadix,IntConvertible};
-    use core::from_str::FromStr;
+    use std::num::{Zero,One,FromStrRadix,IntConvertible};
+    use std::from_str::FromStr;
 
     pub static _0 : Rational = Ratio { numer: 0, denom: 1};
     pub static _1 : Rational = Ratio { numer: 1, denom: 1};

src/libextra/par.rs

@@ -8,13 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::cast;
-use core::ptr;
-use core::sys;
-use core::uint;
-use core::vec;
+use std::cast;
+use std::ptr;
+use std::sys;
+use std::uint;
+use std::vec;
 use future_spawn = future::spawn;
 
 /**

src/libextra/priority_queue.rs

@@ -12,11 +12,10 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::unstable::intrinsics::{move_val_init, init};
-use core::util::{replace, swap};
-use core::vec;
+use std::unstable::intrinsics::{move_val_init, init};
+use std::util::{replace, swap};
+use std::vec;
 
 /// A priority queue implemented with a binary heap
 pub struct PriorityQueue<T> {

src/libextra/rc.rs

@@ -21,13 +21,12 @@ cycle cannot be created with `Rc<T>` because there is no way to modify it after
 
 */
 
-use core::prelude::*;
 
-use core::cast;
-use core::libc::{c_void, size_t, malloc, free};
-use core::ptr;
-use core::sys;
-use core::unstable::intrinsics;
+use std::cast;
+use std::libc::{c_void, size_t, malloc, free};
+use std::ptr;
+use std::sys;
+use std::unstable::intrinsics;
 
 struct RcBox<T> {
     value: T,
@@ -104,7 +103,7 @@ impl<T: DeepClone> DeepClone for Rc<T> {
 #[cfg(test)]
 mod test_rc {
     use super::*;
-    use core::cell::Cell;
+    use std::cell::Cell;
 
     #[test]
     fn test_clone() {

src/libextra/rl.rs

@@ -11,14 +11,13 @@
 // FIXME #3921. This is unsafe because linenoise uses global mutable
 // state without mutexes.
 
-use core::prelude::*;
 
-use core::libc::{c_char, c_int};
-use core::local_data;
-use core::str;
+use std::libc::{c_char, c_int};
+use std::local_data;
+use std::str;
 
 pub mod rustrt {
-    use core::libc::{c_char, c_int};
+    use std::libc::{c_char, c_int};
 
     pub extern {
         pub unsafe fn linenoise(prompt: *c_char) -> *c_char;

src/libextra/rope.rs

@@ -35,11 +35,10 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::uint;
-use core::vec;
-use core::str;
+use std::uint;
+use std::vec;
+use std::str;
 
 /// The type of ropes.
 pub type Rope = node::Root;
@@ -447,7 +446,6 @@ pub fn loop_leaves(rope: Rope, it: &fn(node::Leaf) -> bool) -> bool{
 
 pub mod iterator {
     pub mod leaf {
-        use core::prelude::*;
 
         use rope::{Rope, node};
 
@@ -462,7 +460,6 @@ pub mod iterator {
         }
     }
     pub mod char {
-        use core::prelude::*;
 
         use rope::{Rope, node};
 
@@ -558,13 +555,12 @@ pub fn char_at(rope: Rope, pos: uint) -> char {
  Section: Implementation
 */
 pub mod node {
-    use core::prelude::*;
 
     use rope::node;
 
-    use core::cast;
-    use core::uint;
-    use core::vec;
+    use std::cast;
+    use std::uint;
+    use std::vec;
 
     /// Implementation of type `rope`
     pub enum Root {
@@ -1141,11 +1137,10 @@ pub mod node {
     }
 
     pub mod leaf_iterator {
-        use core::prelude::*;
 
         use rope::node::{Concat, Leaf, Node, height};
 
-        use core::vec;
+        use std::vec;
 
         pub struct T {
             stack: ~[@Node],
@@ -1184,7 +1179,6 @@ pub mod node {
     }
 
     pub mod char_iterator {
-        use core::prelude::*;
 
         use rope::node::{Leaf, Node};
         use rope::node::leaf_iterator;
@@ -1267,12 +1261,11 @@ pub mod node {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use rope::*;
 
-    use core::uint;
-    use core::vec;
+    use std::uint;
+    use std::vec;
 
     //Utility function, used for sanity check
     fn rope_to_string(r: Rope) -> ~str {

src/libextra/semver.rs

@@ -12,15 +12,14 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::char;
-use core::cmp;
-use core::io::{ReaderUtil};
-use core::io;
-use core::option::{Option, Some, None};
-use core::to_str::ToStr;
-use core::uint;
+use std::char;
+use std::cmp;
+use std::io::{ReaderUtil};
+use std::io;
+use std::option::{Option, Some, None};
+use std::to_str::ToStr;
+use std::uint;
 
 #[deriving(Eq)]
 pub enum Identifier {

src/libextra/serialize.rs

@@ -17,13 +17,12 @@ Core encoding and decoding interfaces.
 #[allow(missing_doc)];
 #[forbid(non_camel_case_types)];
 
-use core::prelude::*;
 
-use core::at_vec;
-use core::hashmap::{HashMap, HashSet};
-use core::trie::{TrieMap, TrieSet};
-use core::uint;
-use core::vec;
+use std::at_vec;
+use std::hashmap::{HashMap, HashSet};
+use std::trie::{TrieMap, TrieSet};
+use std::uint;
+use std::vec;
 use deque::Deque;
 use dlist::DList;
 use treemap::{TreeMap, TreeSet};

src/libextra/smallintmap.rs

@@ -15,13 +15,12 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::cmp;
-use core::container::{Container, Mutable, Map, Set};
-use core::uint;
-use core::util::replace;
-use core::vec;
+use std::cmp;
+use std::container::{Container, Mutable, Map, Set};
+use std::uint;
+use std::util::replace;
+use std::vec;
 
 #[allow(missing_doc)]
 pub struct SmallIntMap<T> {
@@ -287,7 +286,6 @@ impl SmallIntSet {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use super::SmallIntMap;
 
@@ -382,11 +380,10 @@ mod tests {
 
 #[cfg(test)]
 mod test_set {
-    use core::prelude::*;
 
     use super::SmallIntSet;
 
-    use core::vec;
+    use std::vec;
 
     #[test]
     fn test_disjoint() {

src/libextra/sort.rs

@@ -10,12 +10,11 @@
 
 //! Sorting methods
 
-use core::prelude::*;
 
-use core::cmp::{Eq, Ord};
-use core::uint;
-use core::util::swap;
-use core::vec;
+use std::cmp::{Eq, Ord};
+use std::uint;
+use std::util::swap;
+use std::vec;
 
 type Le<'self, T> = &'self fn(v1: &T, v2: &T) -> bool;
 
@@ -791,12 +790,11 @@ mod test_qsort3 {
 
 #[cfg(test)]
 mod test_qsort {
-    use core::prelude::*;
 
     use sort::*;
 
-    use core::int;
-    use core::vec;
+    use std::int;
+    use std::vec;
 
     fn check_sort(v1: &mut [int], v2: &mut [int]) {
         let len = v1.len();
@@ -857,7 +855,6 @@ mod test_qsort {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use sort::*;
 
@@ -924,12 +921,11 @@ mod tests {
 
 #[cfg(test)]
 mod test_tim_sort {
-    use core::prelude::*;
 
     use sort::tim_sort;
-    use core::rand::RngUtil;
-    use core::rand;
-    use core::vec;
+    use std::rand::RngUtil;
+    use std::rand;
+    use std::vec;
 
     struct CVal {
         val: float,
@@ -1019,15 +1015,14 @@ mod test_tim_sort {
 
 #[cfg(test)]
 mod big_tests {
-    use core::prelude::*;
 
     use sort::*;
 
-    use core::local_data;
-    use core::rand::RngUtil;
-    use core::rand;
-    use core::uint;
-    use core::vec;
+    use std::local_data;
+    use std::rand::RngUtil;
+    use std::rand;
+    use std::uint;
+    use std::vec;
 
     #[test]
     fn test_unique() {

src/libextra/stats.rs

@@ -10,12 +10,11 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::f64;
-use core::cmp;
-use core::num;
-use core::vec;
+use std::f64;
+use std::cmp;
+use std::num;
+use std::vec;
 use sort;
 
 // NB: this can probably be rewritten in terms of num::Num

src/libextra/sync.rs

@@ -15,14 +15,13 @@
  * in std.
  */
 
-use core::prelude::*;
 
-use core::borrow;
-use core::comm;
-use core::task;
-use core::unstable::sync::{Exclusive, exclusive, UnsafeAtomicRcBox};
-use core::unstable::atomics;
-use core::util;
+use std::borrow;
+use std::comm;
+use std::task;
+use std::unstable::sync::{Exclusive, exclusive, UnsafeAtomicRcBox};
+use std::unstable::atomics;
+use std::util;
 
 /****************************************************************************
  * Internals
@@ -803,15 +802,14 @@ impl<'self> RWlockReadMode<'self> {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use sync::*;
 
-    use core::cast;
-    use core::cell::Cell;
-    use core::comm;
-    use core::result;
-    use core::task;
+    use std::cast;
+    use std::cell::Cell;
+    use std::comm;
+    use std::result;
+    use std::task;
 
     /************************************************************************
      * Semaphore tests

src/libextra/task_pool.rs

@@ -13,15 +13,14 @@
 /// A task pool abstraction. Useful for achieving predictable CPU
 /// parallelism.
 
-use core::prelude::*;
 
-use core::comm::Chan;
-use core::comm;
-use core::task::SchedMode;
-use core::task;
-use core::vec;
+use std::comm::Chan;
+use std::comm;
+use std::task::SchedMode;
+use std::task;
+use std::vec;
 
-#[cfg(test)] use core::task::SingleThreaded;
+#[cfg(test)] use std::task::SingleThreaded;
 
 enum Msg<T> {
     Execute(~fn(&T)),

src/libextra/tempfile.rs

@@ -10,11 +10,10 @@
 
 //! Temporary files and directories
 
-use core::prelude::*;
 
-use core::os;
-use core::rand::RngUtil;
-use core::rand;
+use std::os;
+use std::rand::RngUtil;
+use std::rand;
 
 /// Attempts to make a temporary directory inside of `tmpdir` whose name will
 /// have the suffix `suffix`. If no directory can be created, None is returned.
@@ -31,11 +30,10 @@ pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
 
 #[cfg(test)]
 mod tests {
-    use core::prelude::*;
 
     use tempfile::mkdtemp;
 
-    use core::os;
+    use std::os;
 
     #[test]
     fn test_mkdtemp() {
@@ -44,12 +42,12 @@ mod tests {
         assert!(p.to_str().ends_with("foobar"));
     }
 
-    // Ideally these would be in core::os but then core would need
+    // Ideally these would be in std::os but then core would need
     // to depend on std
     #[test]
     fn recursive_mkdir_rel() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
 
         let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel").
             expect("recursive_mkdir_rel");
@@ -67,8 +65,8 @@ mod tests {
 
     #[test]
     fn recursive_mkdir_dot() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
 
         let dot = Path(".");
         assert!(os::mkdir_recursive(&dot,  (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
@@ -78,8 +76,8 @@ mod tests {
 
     #[test]
     fn recursive_mkdir_rel_2() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
 
         let root = mkdtemp(&os::tmpdir(), "recursive_mkdir_rel_2").
             expect("recursive_mkdir_rel_2");
@@ -102,8 +100,8 @@ mod tests {
     // Ideally this would be in core, but needs mkdtemp
     #[test]
     pub fn test_rmdir_recursive_ok() {
-        use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
-        use core::os;
+        use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
+        use std::os;
 
         let rwx = (S_IRUSR | S_IWUSR | S_IXUSR) as i32;
 

src/libextra/term.rs

@@ -12,11 +12,10 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::io;
+use std::io;
 
-#[cfg(not(target_os = "win32"))] use core::os;
+#[cfg(not(target_os = "win32"))] use std::os;
 #[cfg(not(target_os = "win32"))] use terminfo::*;
 #[cfg(not(target_os = "win32"))] use terminfo::searcher::open;
 #[cfg(not(target_os = "win32"))] use terminfo::parser::compiled::parse;

src/libextra/terminfo/parm.rs

@@ -10,10 +10,9 @@
 
 //! Parameterized string expansion
 
-use core::prelude::*;
-use core::{char, vec, util};
-use core::num::strconv::{SignNone,SignNeg,SignAll,DigAll,to_str_bytes_common};
-use core::iterator::IteratorUtil;
+use std::{char, vec, util};
+use std::num::strconv::{SignNone,SignNeg,SignAll,DigAll,to_str_bytes_common};
+use std::iterator::IteratorUtil;
 
 #[deriving(Eq)]
 enum States {
@@ -549,7 +548,7 @@ priv fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use core::result::Ok;
+    use std::result::Ok;
 
     #[test]
     fn test_basic_setabf() {

src/libextra/terminfo/parser/compiled.rs

@@ -10,11 +10,10 @@
 
 /// ncurses-compatible compiled terminfo format parsing (term(5))
 
-use core::prelude::*;
 
-use core::{vec, int, str};
-use core::io::Reader;
-use core::hashmap::HashMap;
+use std::{vec, int, str};
+use std::io::Reader;
+use std::hashmap::HashMap;
 use super::super::TermInfo;
 
 // These are the orders ncurses uses in its compiled format (as of 5.9). Not sure if portable.

src/libextra/terminfo/searcher.rs

@@ -11,11 +11,10 @@
 /// Implement ncurses-compatible database discovery
 /// Does not support hashed database, only filesystem!
 
-use core::prelude::*;
-use core::{os, str};
-use core::os::getenv;
-use core::io::{file_reader, Reader};
-use path = core::path::Path;
+use std::{os, str};
+use std::os::getenv;
+use std::io::{file_reader, Reader};
+use path = std::path::Path;
 
 /// Return path to database entry for `term`
 pub fn get_dbpath_for_term(term: &str) -> Option<~path> {

src/libextra/terminfo/terminfo.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::hashmap::HashMap;
+use std::hashmap::HashMap;
 
 /// A parsed terminfo entry.
 pub struct TermInfo {

src/libextra/test.rs

@@ -15,7 +15,6 @@
 // simplest interface possible for representing and running tests
 // while providing a base that other test frameworks may build off of.
 
-use core::prelude::*;
 
 use getopts;
 use sort;
@@ -23,22 +22,22 @@ use stats::Stats;
 use term;
 use time::precise_time_ns;
 
-use core::comm::{stream, SharedChan};
-use core::either;
-use core::io;
-use core::num;
-use core::option;
-use core::rand::RngUtil;
-use core::rand;
-use core::result;
-use core::task;
-use core::to_str::ToStr;
-use core::u64;
-use core::uint;
-use core::vec;
+use std::comm::{stream, SharedChan};
+use std::either;
+use std::io;
+use std::num;
+use std::option;
+use std::rand::RngUtil;
+use std::rand;
+use std::result;
+use std::task;
+use std::to_str::ToStr;
+use std::u64;
+use std::uint;
+use std::vec;
 
 pub mod rustrt {
-    use core::libc::size_t;
+    use std::libc::size_t;
 
     #[abi = "cdecl"]
     pub extern {
@@ -573,7 +572,7 @@ pub fn run_test(force_ignore: bool,
     fn run_test_inner(desc: TestDesc,
                       monitor_ch: SharedChan<MonitorMsg>,
                       testfn: ~fn()) {
-        let testfn_cell = ::core::cell::Cell::new(testfn);
+        let testfn_cell = ::std::cell::Cell::new(testfn);
         do task::spawn {
             let mut result_future = None; // task::future_result(builder);
 
@@ -781,10 +780,10 @@ mod tests {
                StaticTestName, DynTestName, DynTestFn};
     use test::{TestOpts, run_test};
 
-    use core::either;
-    use core::comm::{stream, SharedChan};
-    use core::option;
-    use core::vec;
+    use std::either;
+    use std::comm::{stream, SharedChan};
+    use std::option;
+    use std::vec;
 
     #[test]
     pub fn do_not_run_ignored_tests() {

src/libextra/time.rs

@@ -10,12 +10,11 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::i32;
-use core::int;
-use core::io;
-use core::str;
+use std::i32;
+use std::int;
+use std::io;
+use std::str;
 
 static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
 
@@ -862,11 +861,11 @@ priv fn do_strftime(format: &str, tm: &Tm) -> ~str {
 mod tests {
     use time::*;
 
-    use core::float;
-    use core::os;
-    use core::result;
-    use core::result::{Err, Ok};
-    use core::str;
+    use std::float;
+    use std::os;
+    use std::result;
+    use std::result::{Err, Ok};
+    use std::str;
 
     fn test_get_time() {
         static some_recent_date: i64 = 1325376000i64; // 2012-01-01T00:00:00Z

src/libextra/timer.rs

@@ -10,18 +10,17 @@
 
 //! Utilities that leverage libuv's `uv_timer_*` API
 
-use core::prelude::*;
 
 use uv;
 use uv::iotask;
 use uv::iotask::IoTask;
 
-use core::cast::transmute;
-use core::cast;
-use core::comm::{stream, Chan, SharedChan, Port, select2i};
-use core::either;
-use core::libc::c_void;
-use core::libc;
+use std::cast::transmute;
+use std::cast;
+use std::comm::{stream, Chan, SharedChan, Port, select2i};
+use std::either;
+use std::libc::c_void;
+use std::libc;
 
 /**
  * Wait for timeout period then send provided value over a channel
@@ -111,7 +110,7 @@ pub fn sleep(iotask: &IoTask, msecs: uint) {
  *
  * * `iotask' - `uv::iotask` that the tcp request will run on
  * * msecs - an mount of time, in milliseconds, to wait to receive
- * * wait_port - a `core::comm::port<T>` to receive on
+ * * wait_port - a `std::comm::port<T>` to receive on
  *
  * # Returns
  *
@@ -176,16 +175,15 @@ extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) {
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use timer::*;
     use uv;
 
-    use core::cell::Cell;
-    use core::pipes::{stream, SharedChan};
-    use core::rand::RngUtil;
-    use core::rand;
-    use core::task;
+    use std::cell::Cell;
+    use std::pipes::{stream, SharedChan};
+    use std::rand::RngUtil;
+    use std::rand;
+    use std::task;
 
     #[test]
     fn test_gl_timer_simple_sleep_test() {
@@ -223,7 +221,7 @@ mod test {
                 let ch = ch.clone();
                 let hl_loop_clone = hl_loop.clone();
                 do task::spawn {
-                    use core::rand::*;
+                    use std::rand::*;
                     let mut rng = rng();
                     for times.times {
                         sleep(&hl_loop_clone, rng.next() as uint % maxms);

src/libextra/treemap.rs

@@ -12,10 +12,9 @@
 //! trees. The only requirement for the types is that the key implements
 //! `TotalOrd`.
 
-use core::prelude::*;
 
-use core::uint;
-use core::util::{swap, replace};
+use std::uint;
+use std::util::{swap, replace};
 
 // This is implemented as an AA tree, which is a simplified variation of
 // a red-black tree where red (horizontal) nodes can only be added
@@ -689,12 +688,11 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
 
 #[cfg(test)]
 mod test_treemap {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::rand::RngUtil;
-    use core::rand;
+    use std::rand::RngUtil;
+    use std::rand;
 
     #[test]
     fn find_empty() {
@@ -1010,7 +1008,6 @@ mod test_treemap {
 
 #[cfg(test)]
 mod test_set {
-    use core::prelude::*;
 
     use super::*;
 

src/libextra/uv_global_loop.rs

@@ -10,16 +10,15 @@
 
 //! A process-wide libuv event loop for library use.
 
-use core::prelude::*;
 
 use iotask = uv_iotask;
 use uv_iotask::{IoTask, spawn_iotask};
 
-use core::comm::Chan;
-use core::option::{Some, None};
-use core::task::task;
-use core::unstable::global::{global_data_clone_create, global_data_clone};
-use core::unstable::weak_task::weaken_task;
+use std::comm::Chan;
+use std::option::{Some, None};
+use std::task::task;
+use std::unstable::global::{global_data_clone_create, global_data_clone};
+use std::unstable::weak_task::weaken_task;
 
 /**
  * Race-free helper to get access to a global task where a libuv
@@ -126,11 +125,11 @@ mod test {
     use uv::ll;
     use uv_iotask::IoTask;
 
-    use core::libc;
-    use core::task;
-    use core::cast::transmute;
-    use core::libc::c_void;
-    use core::comm::{stream, SharedChan, Chan};
+    use std::libc;
+    use std::task;
+    use std::cast::transmute;
+    use std::libc::c_void;
+    use std::comm::{stream, SharedChan, Chan};
 
     extern fn simple_timer_close_cb(timer_ptr: *ll::uv_timer_t) {
         unsafe {

src/libextra/uv_iotask.rs

@@ -17,14 +17,13 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use ll = uv_ll;
 
-use core::comm::{stream, Port, Chan, SharedChan};
-use core::libc::c_void;
-use core::libc;
-use core::task;
+use std::comm::{stream, Port, Chan, SharedChan};
+use std::libc::c_void;
+use std::libc;
+use std::task;
 
 /// Used to abstract-away direct interaction with a libuv loop.
 pub struct IoTask {
@@ -226,7 +225,7 @@ struct AhData {
 
 #[cfg(test)]
 fn impl_uv_iotask_async(iotask: &IoTask) {
-    use core::ptr;
+    use std::ptr;
 
     let async_handle = ll::async_t();
     let ah_ptr: *ll::uv_async_t = &async_handle;

src/libextra/uv_ll.rs

@@ -33,14 +33,13 @@
 #[allow(non_camel_case_types)]; // C types
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
-use core::libc::{c_void, size_t};
-use core::libc;
-use core::ptr::to_unsafe_ptr;
-use core::ptr;
-use core::str;
-use core::vec;
+use std::libc::{c_void, size_t};
+use std::libc;
+use std::ptr::to_unsafe_ptr;
+use std::ptr;
+use std::str;
+use std::vec;
 
 pub type uv_handle_t = c_void;
 pub type uv_loop_t = c_void;
@@ -362,7 +361,7 @@ pub struct uv_getaddrinfo_t {
 
 pub mod uv_ll_struct_stubgen {
 
-    use core::ptr;
+    use std::ptr;
 
     use super::{
         uv_async_t,
@@ -1228,16 +1227,15 @@ pub unsafe fn addrinfo_as_sockaddr_in6(input: *addrinfo) -> *sockaddr_in6 {
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use super::*;
 
-    use core::comm::{SharedChan, stream, GenericChan, GenericPort};
-    use core::libc;
-    use core::str;
-    use core::sys;
-    use core::task;
-    use core::vec;
+    use std::comm::{SharedChan, stream, GenericChan, GenericPort};
+    use std::libc;
+    use std::str;
+    use std::sys;
+    use std::task;
+    use std::vec;
 
     enum tcp_read_data {
         tcp_read_eof,

src/libextra/workcache.rs

@@ -10,7 +10,6 @@
 
 #[allow(missing_doc)];
 
-use core::prelude::*;
 
 use digest::DigestUtil;
 use json;
@@ -18,17 +17,17 @@ use sha1::Sha1;
 use serialize::{Encoder, Encodable, Decoder, Decodable};
 use sort;
 
-use core::cell::Cell;
-use core::cmp;
-use core::comm::{PortOne, oneshot, send_one, recv_one};
-use core::either::{Either, Left, Right};
-use core::hashmap::HashMap;
-use core::io;
-use core::result;
-use core::run;
-use core::task;
-use core::to_bytes;
-use core::util::replace;
+use std::cell::Cell;
+use std::cmp;
+use std::comm::{PortOne, oneshot, send_one, recv_one};
+use std::either::{Either, Left, Right};
+use std::hashmap::HashMap;
+use std::io;
+use std::result;
+use std::run;
+use std::task;
+use std::to_bytes;
+use std::util::replace;
 
 /**
 *
@@ -403,7 +402,7 @@ fn unwrap<T:Send +
 
 //#[test]
 fn test() {
-    use core::io::WriterUtil;
+    use std::io::WriterUtil;
 
     let db = @mut Database { db_filename: Path("db.json"),
                              db_cache: HashMap::new(),

src/librust/rust.rs

@@ -20,28 +20,15 @@
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
-#[no_std];
-
-extern mod core(name = "std");
-
 extern mod rustpkg;
 extern mod rustdoc;
 extern mod rusti;
 extern mod rustc;
 
-use core::prelude::*;
-
-use core::io;
-use core::os;
-use core::run;
-use core::libc::exit;
-
-// For bootstrapping.
-mod std {
-    pub use core::os;
-    pub use core::str;
-    pub use core::unstable;
-}
+use std::io;
+use std::os;
+use std::run;
+use std::libc::exit;
 
 enum ValidUsage {
     Valid(int), Invalid

src/librustc/back/link.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use back::rpath;
 use driver::session::Session;
@@ -23,17 +22,17 @@ use middle::trans::common::gensym_name;
 use middle::ty;
 use util::ppaux;
 
-use core::char;
-use core::hash::Streaming;
-use core::hash;
-use core::libc::{c_int, c_uint};
-use core::os::consts::{macos, freebsd, linux, android, win32};
-use core::os;
-use core::ptr;
-use core::rt::io::Writer;
-use core::run;
-use core::str;
-use core::vec;
+use std::char;
+use std::hash::Streaming;
+use std::hash;
+use std::libc::{c_int, c_uint};
+use std::os::consts::{macos, freebsd, linux, android, win32};
+use std::os;
+use std::ptr;
+use std::rt::io::Writer;
+use std::run;
+use std::str;
+use std::vec;
 use syntax::ast;
 use syntax::ast_map::{path, path_mod, path_name};
 use syntax::attr;
@@ -98,7 +97,6 @@ pub fn WriteOutputFile(sess: Session,
 }
 
 pub mod jit {
-    use core::prelude::*;
 
     use back::link::llvm_err;
     use driver::session::Session;
@@ -106,11 +104,11 @@ pub mod jit {
     use lib::llvm::{ModuleRef, ContextRef};
     use metadata::cstore;
 
-    use core::cast;
-    use core::ptr;
-    use core::str;
-    use core::sys;
-    use core::unstable::intrinsics;
+    use std::cast;
+    use std::ptr;
+    use std::str;
+    use std::sys;
+    use std::unstable::intrinsics;
 
     pub fn exec(sess: Session,
                 c: ContextRef,
@@ -182,7 +180,6 @@ pub mod jit {
 }
 
 pub mod write {
-    use core::prelude::*;
 
     use back::link::jit;
     use back::link::{WriteOutputFile, output_type};
@@ -198,10 +195,10 @@ pub mod write {
 
     use back::passes;
 
-    use core::libc::{c_int, c_uint};
-    use core::path::Path;
-    use core::run;
-    use core::str;
+    use std::libc::{c_int, c_uint};
+    use std::path::Path;
+    use std::run;
+    use std::str;
 
     pub fn is_object_or_assembly_or_exe(ot: output_type) -> bool {
         match ot {
@@ -537,7 +534,7 @@ pub fn build_link_meta(sess: Session,
             write_string(symbol_hasher, len_and_str(*dh));
         }
 
-    // tjc: allocation is unfortunate; need to change core::hash
+    // tjc: allocation is unfortunate; need to change std::hash
         return truncated_hash_result(symbol_hasher).to_managed();
     }
 
@@ -618,7 +615,7 @@ pub fn symbol_hash(tcx: ty::ctxt,
     let mut hash = truncated_hash_result(symbol_hasher);
     // Prefix with _ so that it never blends into adjacent digits
     hash.unshift_char('_');
-    // tjc: allocation is unfortunate; need to change core::hash
+    // tjc: allocation is unfortunate; need to change std::hash
     hash.to_managed()
 }
 

src/librustc/back/passes.rs

@@ -8,9 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
-use core::str;
-use core::io;
+use std::str;
+use std::io;
 
 use driver::session::{OptLevel, No, Less, Aggressive};
 use driver::session::{Session};

src/librustc/back/rpath.rs

@@ -8,17 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use driver::session;
 use metadata::cstore;
 use metadata::filesearch;
 
-use core::hashmap::HashSet;
-use core::os;
-use core::uint;
-use core::util;
-use core::vec;
+use std::hashmap::HashSet;
+use std::os;
+use std::uint;
+use std::util;
+use std::vec;
 
 fn not_win32(os: session::os) -> bool {
   os != session::os_win32
@@ -113,7 +112,7 @@ pub fn get_rpath_relative_to_output(os: session::os,
                                     output: &Path,
                                     lib: &Path)
                                  -> Path {
-    use core::os;
+    use std::os;
 
     assert!(not_win32(os));
 
@@ -195,8 +194,7 @@ pub fn minimize_rpaths(rpaths: &[Path]) -> ~[Path] {
 
 #[cfg(unix, test)]
 mod test {
-    use core::prelude::*;
-    use core::os;
+    use std::os;
 
     // FIXME(#2119): the outer attribute should be #[cfg(unix, test)], then
     // these redundant #[cfg(test)] blocks can be removed

src/librustc/driver/driver.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use back::link;
 use back::{arm, x86, x86_64, mips};
@@ -24,11 +23,11 @@ use middle;
 use util::common::time;
 use util::ppaux;
 
-use core::hashmap::HashMap;
-use core::int;
-use core::io;
-use core::os;
-use core::vec;
+use std::hashmap::HashMap;
+use std::int;
+use std::io;
+use std::os;
+use std::vec;
 use extra::getopts::groups::{optopt, optmulti, optflag, optflagopt};
 use extra::getopts::{opt_present};
 use extra::getopts;
@@ -951,7 +950,6 @@ pub fn list_metadata(sess: Session, path: &Path, out: @io::Writer) {
 
 #[cfg(test)]
 mod test {
-    use core::prelude::*;
 
     use driver::driver::{build_configuration, build_session};
     use driver::driver::{build_session_options, optgroups, str_input};

src/librustc/driver/session.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use back::link;
 use back::target_strs;
@@ -29,7 +28,7 @@ use syntax::abi;
 use syntax::parse::token;
 use syntax;
 
-use core::hashmap::HashMap;
+use std::hashmap::HashMap;
 
 #[deriving(Eq)]
 pub enum os { os_win32, os_macos, os_linux, os_android, os_freebsd, }

src/librustc/front/config.rs

@@ -8,10 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::option;
-use core::vec;
+use std::option;
+use std::vec;
 use syntax::{ast, fold, attr};
 
 type in_cfg_pred = @fn(attrs: ~[ast::attribute]) -> bool;

src/librustc/front/std_inject.rs

@@ -8,11 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use driver::session::Session;
 
-use core::vec;
+use std::vec;
 use syntax::ast;
 use syntax::attr;
 use syntax::codemap::dummy_sp;

src/librustc/front/test.rs

@@ -10,12 +10,11 @@
 
 // Code that generates a test runner to run all the tests in a crate
 
-use core::prelude::*;
 
 use driver::session;
 use front::config;
 
-use core::vec;
+use std::vec;
 use syntax::ast_util::*;
 use syntax::attr;
 use syntax::codemap::{dummy_sp, span, ExpandedFrom, CallInfo, NameAndSpan};

src/librustc/lib/llvm.rs

@@ -8,12 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::hashmap::HashMap;
-use core::libc::{c_uint, c_ushort};
-use core::option;
-use core::str;
+use std::hashmap::HashMap;
+use std::libc::{c_uint, c_ushort};
+use std::option;
+use std::str;
 
 use middle::trans::type_::Type;
 
@@ -268,7 +267,7 @@ pub mod llvm {
     use super::{SectionIteratorRef, TargetDataRef, TypeKind, TypeRef, UseRef};
     use super::{ValueRef, PassRef};
     use super::debuginfo::*;
-    use core::libc::{c_char, c_int, c_longlong, c_ushort, c_uint, c_ulonglong};
+    use std::libc::{c_char, c_int, c_longlong, c_ushort, c_uint, c_ulonglong};
 
     #[link_args = "-Lrustllvm -lrustllvm"]
     #[link_name = "rustllvm"]

src/librustc/metadata/common.rs

@@ -7,8 +7,7 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
-use core::prelude::*;
-use core::cast;
+use std::cast;
 
 // EBML enum definitions and utils shared by the encoder and decoder
 

src/librustc/metadata/creader.rs

@@ -10,14 +10,13 @@
 
 //! Validates all used crates and extern libraries and loads their metadata
 
-use core::prelude::*;
 
 use metadata::cstore;
 use metadata::decoder;
 use metadata::filesearch::FileSearch;
 use metadata::loader;
 
-use core::hashmap::HashMap;
+use std::hashmap::HashMap;
 use syntax::attr;
 use syntax::codemap::{span, dummy_sp};
 use syntax::diagnostic::span_handler;
@@ -75,7 +74,7 @@ fn dump_crates(crate_cache: &[cache_entry]) {
 fn warn_if_multiple_versions(e: @mut Env,
                              diag: @span_handler,
                              crate_cache: &[cache_entry]) {
-    use core::either::*;
+    use std::either::*;
 
     if crate_cache.len() != 0u {
         let name = loader::crate_name_from_metas(

src/librustc/metadata/csearch.rs

@@ -10,7 +10,6 @@
 
 // Searching for information from the cstore
 
-use core::prelude::*;
 
 use metadata::common::*;
 use metadata::cstore;
@@ -18,7 +17,7 @@ use metadata::decoder;
 use metadata;
 use middle::{ty, resolve};
 
-use core::vec;
+use std::vec;
 use reader = extra::ebml::reader;
 use syntax::ast;
 use syntax::ast_map;

src/librustc/metadata/cstore.rs

@@ -12,13 +12,12 @@
 // The crate store - a central repo for information collected about external
 // crates and libraries
 
-use core::prelude::*;
 
 use metadata::cstore;
 use metadata::decoder;
 
-use core::hashmap::HashMap;
-use core::vec;
+use std::hashmap::HashMap;
+use std::vec;
 use extra;
 use syntax::ast;
 use syntax::parse::token::ident_interner;

src/librustc/metadata/decoder.rs

@@ -10,7 +10,6 @@
 
 // Decoding metadata from a single crate's metadata
 
-use core::prelude::*;
 
 use metadata::cstore::crate_metadata;
 use metadata::common::*;
@@ -23,13 +22,13 @@ use metadata::tydecode::{parse_ty_data, parse_def_id,
                          parse_bare_fn_ty_data, parse_trait_ref_data};
 use middle::{ty, resolve};
 
-use core::hash::HashUtil;
-use core::int;
-use core::io::WriterUtil;
-use core::io;
-use core::option;
-use core::str;
-use core::vec;
+use std::hash::HashUtil;
+use std::int;
+use std::io::WriterUtil;
+use std::io;
+use std::option;
+use std::str;
+use std::vec;
 use extra::ebml::reader;
 use extra::ebml;
 use extra::serialize::Decodable;

src/librustc/metadata/encoder.rs

@@ -10,7 +10,6 @@
 
 // Metadata encoding
 
-use core::prelude::*;
 
 use metadata::common::*;
 use metadata::cstore;
@@ -21,13 +20,13 @@ use middle::ty;
 use middle;
 use util::ppaux::ty_to_str;
 
-use core::hash::HashUtil;
-use core::hashmap::{HashMap, HashSet};
-use core::int;
-use core::io;
-use core::str;
-use core::uint;
-use core::vec;
+use std::hash::HashUtil;
+use std::hashmap::{HashMap, HashSet};
+use std::int;
+use std::io;
+use std::str;
+use std::uint;
+use std::vec;
 use extra::flate;
 use extra::serialize::Encodable;
 use extra;
@@ -46,7 +45,7 @@ use syntax::parse::token;
 use syntax;
 use writer = extra::ebml::writer;
 
-use core::cast;
+use std::cast;
 
 // used by astencode:
 type abbrev_map = @mut HashMap<ty::t, tyencode::ty_abbrev>;

src/librustc/metadata/filesearch.rs

@@ -8,12 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
-use core::option;
-use core::os;
-use core::result;
-use core::str;
+use std::option;
+use std::os;
+use std::result;
+use std::str;
 
 // A module for searching for libraries
 // FIXME (#2658): I'm not happy how this module turned out. Should

src/librustc/metadata/loader.rs

@@ -10,7 +10,6 @@
 
 //! Finds crate binaries and loads their metadata
 
-use core::prelude::*;
 
 use lib::llvm::{False, llvm, mk_object_file, mk_section_iter};
 use metadata::decoder;
@@ -24,14 +23,14 @@ use syntax::parse::token::ident_interner;
 use syntax::print::pprust;
 use syntax::{ast, attr};
 
-use core::cast;
-use core::io;
-use core::option;
-use core::os::consts::{macos, freebsd, linux, android, win32};
-use core::ptr;
-use core::str;
-use core::uint;
-use core::vec;
+use std::cast;
+use std::io;
+use std::option;
+use std::os::consts::{macos, freebsd, linux, android, win32};
+use std::ptr;
+use std::str;
+use std::uint;
+use std::vec;
 use extra::flate;
 
 pub enum os {

src/librustc/metadata/tydecode.rs

@@ -14,12 +14,11 @@
 // tjc note: Would be great to have a `match check` macro equivalent
 // for some of these
 
-use core::prelude::*;
 
 use middle::ty;
 
-use core::str;
-use core::uint;
+use std::str;
+use std::uint;
 use syntax::abi::AbiSet;
 use syntax::abi;
 use syntax::ast;

src/librustc/metadata/tyencode.rs

@@ -10,15 +10,14 @@
 
 // Type encoding
 
-use core::prelude::*;
 
 use middle::ty::param_ty;
 use middle::ty;
 
-use core::hashmap::HashMap;
-use core::io::WriterUtil;
-use core::io;
-use core::uint;
+use std::hashmap::HashMap;
+use std::io::WriterUtil;
+use std::io;
+use std::uint;
 use syntax::abi::AbiSet;
 use syntax::ast;
 use syntax::ast::*;

src/librustc/middle/astencode.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use c = metadata::common;
 use cstore = metadata::cstore;
@@ -24,8 +23,8 @@ use middle::{ty, typeck, moves};
 use middle;
 use util::ppaux::ty_to_str;
 
-use core::at_vec;
-use core::uint;
+use std::at_vec;
+use std::uint;
 use extra::ebml::reader;
 use extra::ebml;
 use extra::serialize;
@@ -43,7 +42,7 @@ use syntax::parse::token;
 use syntax;
 use writer = extra::ebml::writer;
 
-use core::cast;
+use std::cast;
 
 #[cfg(test)] use syntax::parse;
 #[cfg(test)] use syntax::print::pprust;
@@ -1243,7 +1242,7 @@ fn mk_ctxt() -> @fake_ext_ctxt {
 
 #[cfg(test)]
 fn roundtrip(in_item: Option<@ast::item>) {
-    use core::io;
+    use std::io;
 
     let in_item = in_item.get();
     let bytes = do io::with_bytes_writer |wr| {

src/librustc/middle/borrowck/check_loans.rs

@@ -17,10 +17,9 @@
 // 3. assignments do not affect things loaned out as immutable
 // 4. moves do not affect things loaned out in any way
 
-use core::prelude::*;
 
-use core::hashmap::HashSet;
-use core::uint;
+use std::hashmap::HashSet;
+use std::uint;
 use mc = middle::mem_categorization;
 use middle::borrowck::*;
 use middle::moves;

src/librustc/middle/borrowck/gather_loans/gather_moves.rs

@@ -12,7 +12,6 @@
  * Computes moves.
  */
 
-use core::prelude::*;
 use mc = middle::mem_categorization;
 use middle::borrowck::*;
 use middle::borrowck::move_data::*;

src/librustc/middle/borrowck/gather_loans/lifetime.rs

@@ -11,7 +11,6 @@
 //! This module implements the check that the lifetime of a borrow
 //! does not exceed the lifetime of the value being borrowed.
 
-use core::prelude::*;
 
 use middle::borrowck::*;
 use mc = middle::mem_categorization;

src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -16,7 +16,6 @@
 // their associated scopes.  In phase two, checking loans, we will then make
 // sure that all of these loans are honored.
 
-use core::prelude::*;
 
 use middle::borrowck::*;
 use middle::borrowck::move_data::MoveData;

src/librustc/middle/borrowck/gather_loans/restrictions.rs

@@ -10,9 +10,8 @@
 
 //! Computes the restrictions that result from a borrow.
 
-use core::prelude::*;
 
-use core::vec;
+use std::vec;
 use middle::borrowck::*;
 use mc = middle::mem_categorization;
 use middle::ty;

src/librustc/middle/borrowck/mod.rs

@@ -10,7 +10,6 @@
 
 /*! See doc.rs for a thorough explanation of the borrow checker */
 
-use core::prelude::*;
 
 use mc = middle::mem_categorization;
 use middle::ty;
@@ -21,10 +20,10 @@ use middle::dataflow::DataFlowOperator;
 use util::common::stmt_set;
 use util::ppaux::{note_and_explain_region, Repr, UserString};
 
-use core::hashmap::{HashSet, HashMap};
-use core::io;
-use core::ops::{BitOr, BitAnd};
-use core::result::{Result};
+use std::hashmap::{HashSet, HashMap};
+use std::io;
+use std::ops::{BitOr, BitAnd};
+use std::result::{Result};
 use syntax::ast;
 use syntax::ast_map;
 use syntax::visit;

src/librustc/middle/borrowck/move_data.rs

@@ -15,10 +15,9 @@ comments in the section "Moves and initialization" and in `doc.rs`.
 
 */
 
-use core::prelude::*;
 
-use core::hashmap::{HashMap, HashSet};
-use core::uint;
+use std::hashmap::{HashMap, HashSet};
+use std::uint;
 use middle::borrowck::*;
 use middle::dataflow::DataFlowContext;
 use middle::dataflow::DataFlowOperator;

src/librustc/middle/check_const.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use driver::session::Session;
 use middle::resolve;

src/librustc/middle/check_match.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use middle::const_eval::{compare_const_vals, lookup_const_by_id};
 use middle::const_eval::{eval_const_expr, const_val, const_bool};
@@ -19,8 +18,8 @@ use middle::typeck::method_map;
 use middle::moves;
 use util::ppaux::ty_to_str;
 
-use core::uint;
-use core::vec;
+use std::uint;
+use std::vec;
 use extra::sort;
 use syntax::ast::*;
 use syntax::ast_util::{unguarded_pat, walk_pat};

src/librustc/middle/const_eval.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use metadata::csearch;
 use middle::astencode;
@@ -18,9 +17,9 @@ use middle;
 use syntax::{ast, ast_map, ast_util, visit};
 use syntax::ast::*;
 
-use core::float;
-use core::hashmap::{HashMap, HashSet};
-use core::vec;
+use std::float;
+use std::hashmap::{HashMap, HashSet};
+use std::vec;
 
 //
 // This pass classifies expressions by their constant-ness.

src/librustc/middle/dataflow.rs

@@ -16,13 +16,12 @@
  * GEN and KILL bits for each expression.
  */
 
-use core::prelude::*;
 
-use core::cast;
-use core::io;
-use core::uint;
-use core::vec;
-use core::hashmap::HashMap;
+use std::cast;
+use std::io;
+use std::uint;
+use std::vec;
+use std::hashmap::HashMap;
 use syntax::ast;
 use syntax::ast_util;
 use syntax::ast_util::id_range;

src/librustc/middle/entry.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use driver::session;
 use driver::session::Session;
@@ -18,7 +17,7 @@ use syntax::codemap::span;
 use syntax::visit::{default_visitor, mk_vt, vt, Visitor, visit_crate, visit_item};
 use syntax::attr::{attrs_contains_name};
 use syntax::ast_map;
-use core::util;
+use std::util;
 
 struct EntryContext {
     session: Session,

src/librustc/middle/freevars.rs

@@ -11,12 +11,11 @@
 // A pass that annotates for each loops and functions with the free
 // variables that they contain.
 
-use core::prelude::*;
 
 use middle::resolve;
 use middle::ty;
 
-use core::hashmap::HashMap;
+use std::hashmap::HashMap;
 use syntax::codemap::span;
 use syntax::{ast, ast_util, visit};
 

src/librustc/middle/kind.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use middle::freevars::freevar_entry;
 use middle::freevars;

src/librustc/middle/lang_items.rs

@@ -19,7 +19,6 @@
 //
 // * Functions called by the compiler itself.
 
-use core::prelude::*;
 
 use driver::session::Session;
 use metadata::csearch::each_lang_item;
@@ -30,7 +29,7 @@ use syntax::ast_util::local_def;
 use syntax::visit::{default_simple_visitor, mk_simple_visitor, SimpleVisitor};
 use syntax::visit::visit_crate;
 
-use core::hashmap::HashMap;
+use std::hashmap::HashMap;
 
 pub enum LangItem {
     FreezeTraitLangItem,        // 0

src/librustc/middle/lint.rs

@@ -8,25 +8,24 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use driver::session;
 use middle::ty;
 use middle::pat_util;
 use util::ppaux::{ty_to_str};
 
-use core::char;
-use core::cmp;
-use core::hashmap::HashMap;
-use core::i16;
-use core::i32;
-use core::i64;
-use core::i8;
-use core::u16;
-use core::u32;
-use core::u64;
-use core::u8;
-use core::vec;
+use std::char;
+use std::cmp;
+use std::hashmap::HashMap;
+use std::i16;
+use std::i32;
+use std::i64;
+use std::i8;
+use std::u16;
+use std::u32;
+use std::u64;
+use std::u8;
+use std::vec;
 use extra::smallintmap::SmallIntMap;
 use syntax::attr;
 use syntax::codemap::span;
@@ -139,7 +138,7 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
     ("ctypes",
      LintSpec {
         lint: ctypes,
-        desc: "proper use of core::libc types in foreign modules",
+        desc: "proper use of std::libc types in foreign modules",
         default: warn
      }),
 

src/librustc/middle/liveness.rs

@@ -102,7 +102,6 @@
  *   to return explicitly.
  */
 
-use core::prelude::*;
 
 use middle::lint::{unused_variable, dead_assignment};
 use middle::pat_util;
@@ -110,12 +109,12 @@ use middle::ty;
 use middle::typeck;
 use middle::moves;
 
-use core::cast::transmute;
-use core::hashmap::HashMap;
-use core::io;
-use core::to_str;
-use core::uint;
-use core::vec;
+use std::cast::transmute;
+use std::hashmap::HashMap;
+use std::io;
+use std::to_str;
+use std::uint;
+use std::vec;
 use syntax::ast::*;
 use syntax::codemap::span;
 use syntax::parse::token::special_idents;

src/librustc/middle/mem_categorization.rs

@@ -46,14 +46,13 @@
  * then an index to jump forward to the relevant item.
  */
 
-use core::prelude::*;
 
 use middle::ty;
 use middle::typeck;
 use util::ppaux::{ty_to_str, region_ptr_to_str, Repr};
 use util::common::indenter;
 
-use core::uint;
+use std::uint;
 use syntax::ast::{m_imm, m_const, m_mutbl};
 use syntax::ast;
 use syntax::codemap::span;

src/librustc/middle/moves.rs

@@ -126,7 +126,6 @@ and so on.
 
 */
 
-use core::prelude::*;
 
 use middle::pat_util::{pat_bindings};
 use middle::freevars;
@@ -136,8 +135,8 @@ use util::ppaux;
 use util::ppaux::Repr;
 use util::common::indenter;
 
-use core::at_vec;
-use core::hashmap::{HashSet, HashMap};
+use std::at_vec;
+use std::hashmap::{HashSet, HashMap};
 use syntax::ast::*;
 use syntax::ast_util;
 use syntax::visit;

src/librustc/middle/pat_util.rs

@@ -8,11 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::prelude::*;
 
 use middle::resolve;
 
-use core::hashmap::HashMap;
+use std::hashmap::HashMap;
 use syntax::ast::*;
 use syntax::ast_util::{path_to_ident, walk_pat};
 use syntax::codemap::span;

src/librustc/middle/privacy.rs

@@ -11,7 +11,6 @@
 // A pass that checks to make sure private fields and methods aren't used
 // outside their scopes.
 
-use core::prelude::*;
 
 use metadata::csearch;
 use middle::ty::{ty_struct, ty_enum};
@@ -20,7 +19,7 @@ use middle::typeck::{method_map, method_origin, method_param, method_self};
 use middle::typeck::{method_super};
 use middle::typeck::{method_static, method_trait};
 
-use core::util::ignore;
+use std::util::ignore;
 use syntax::ast::{decl_item, def, def_fn, def_id, def_static_method};
 use syntax::ast::{def_variant, expr_field, expr_method_call, expr_path};
 use syntax::ast::{expr_struct, expr_unary, ident, inherited, item_enum};

src/librustc/middle/reachable.rs

@@ -15,14 +15,13 @@
 // makes all other generics or inline functions that it references
 // reachable as well.
 
-use core::prelude::*;
-use core::iterator::IteratorUtil;
+use std::iterator::IteratorUtil;
 
 use middle::resolve;
 use middle::ty;
 use middle::typeck;
 
-use core::hashmap::HashSet;
+use std::hashmap::HashSet;
 use syntax::ast::*;
 use syntax::ast;
 use syntax::ast_map;

src/librustc/middle/region.rs

@@ -17,7 +17,6 @@ region parameterized.
 
 */
 
-use core::prelude::*;
 
 use driver::session::Session;
 use metadata::csearch;
@@ -26,7 +25,7 @@ use middle::ty::{region_variance, rv_covariant, rv_invariant};
 use middle::ty::{rv_contravariant, FreeRegion};
 use middle::ty;
 
-use core::hashmap::{HashMap, HashSet};
+use std::hashmap::{HashMap, HashSet};
 use syntax::ast_map;
 use syntax::codemap::span;
 use syntax::print::pprust;