diff options
598 files changed, 1868 insertions, 450 deletions
diff --git a/doc/rust.md b/doc/rust.md index 719750ea7ca..9d96cc1dd98 100644 --- a/doc/rust.md +++ b/doc/rust.md @@ -1840,6 +1840,7 @@ is bounds-checked at run-time. When the check fails, it will put the task in a _failing state_. ~~~~ +# use std::task; # do task::spawn_unlinked { ([1, 2, 3, 4])[0]; @@ -2168,7 +2169,7 @@ fn ten_times(f: &fn(int)) { } } -ten_times(|j| io::println(fmt!("hello, %d", j))); +ten_times(|j| println(fmt!("hello, %d", j))); ~~~~ @@ -2189,7 +2190,7 @@ An example: let mut i = 0; while i < 10 { - io::println("hello\n"); + println("hello\n"); i = i + 1; } ~~~~ @@ -2335,6 +2336,7 @@ for v.each |e| { An example of a for loop over a series of integers: ~~~~ +# use std::uint; # fn bar(b:uint) { } for uint::range(0, 256) |i| { bar(i); @@ -2798,6 +2800,7 @@ the vtable pointer for the `T` implementation of `R`, and the pointer value of ` An example of an object type: ~~~~~~~~ +# use std::int; trait Printable { fn to_str(&self) -> ~str; } @@ -2807,7 +2810,7 @@ impl Printable for int { } fn print(a: @Printable) { - io::println(a.to_str()); + println(a.to_str()); } fn main() { diff --git a/doc/tutorial-ffi.md b/doc/tutorial-ffi.md index 33a8cd230bb..88f2f374cf5 100644 --- a/doc/tutorial-ffi.md +++ b/doc/tutorial-ffi.md @@ -149,7 +149,9 @@ A type with the same functionality as owned boxes can be implemented by wrapping `malloc` and `free`: ~~~~ +use std::cast; use std::libc::{c_void, size_t, malloc, free}; +use std::ptr; use std::unstable::intrinsics; use std::util; diff --git a/doc/tutorial-tasks.md b/doc/tutorial-tasks.md index 8c574e539fe..2f150755fc2 100644 --- a/doc/tutorial-tasks.md +++ b/doc/tutorial-tasks.md @@ -120,6 +120,7 @@ should interleave the output in vaguely random order. ~~~ # use std::io::print; # use std::task::spawn; +# use std::int; for int::range(0, 20) |child_task_number| { do spawn { @@ -236,6 +237,7 @@ Instead we can use a `SharedChan`, a type that allows a single ~~~ # use std::task::spawn; # use std::comm::{stream, SharedChan}; +# use std::uint; let (port, chan) = stream(); let chan = SharedChan::new(chan); @@ -269,6 +271,7 @@ might look like the example below. ~~~ # use std::task::spawn; # use std::comm::stream; +# use std::vec; // Create a vector of ports, one for each child task let ports = do vec::from_fn(3) |init_val| { @@ -310,6 +313,8 @@ the future needs to be mutable so that it can save the result for next time `get Here is another example showing how futures allow you to background computations. The workload will be distributed on the available cores. ~~~ +# use std::vec; +# use std::uint; fn partial_sum(start: uint) -> f64 { let mut local_sum = 0f64; for uint::range(start*100000, (start+1)*100000) |num| { @@ -343,6 +348,9 @@ acts as a reference to the shared data and only this reference is shared and clo Here is a small example showing how to use ARCs. We wish to run concurrently several computations on a single large vector of floats. Each task needs the full vector to perform its duty. ~~~ +# use std::vec; +# use std::uint; +# use std::rand; use extra::arc::ARC; fn pnorm(nums: &~[float], p: uint) -> float { @@ -350,7 +358,7 @@ fn pnorm(nums: &~[float], p: uint) -> float { } fn main() { - let numbers=vec::from_fn(1000000, |_| rand::random::<float>()); + let numbers = vec::from_fn(1000000, |_| rand::random::<float>()); println(fmt!("Inf-norm = %?", numbers.max())); let numbers_arc = ARC(numbers); @@ -373,12 +381,16 @@ at the power given as argument and takes the inverse power of this value). The A created by the line ~~~ # use extra::arc::ARC; -# let numbers=vec::from_fn(1000000, |_| rand::random::<float>()); +# use std::vec; +# use std::rand; +# let numbers = vec::from_fn(1000000, |_| rand::random::<float>()); let numbers_arc=ARC(numbers); ~~~ and a clone of it is sent to each task ~~~ # use extra::arc::ARC; +# use std::vec; +# use std::rand; # let numbers=vec::from_fn(1000000, |_| rand::random::<float>()); # let numbers_arc = ARC(numbers); # let (port, chan) = stream(); @@ -389,6 +401,8 @@ copying only the wrapper and not its contents. Each task recovers the underlying data by ~~~ # use extra::arc::ARC; +# use std::vec; +# use std::rand; # let numbers=vec::from_fn(1000000, |_| rand::random::<float>()); # let numbers_arc=ARC(numbers); # let (port, chan) = stream(); @@ -416,6 +430,7 @@ of all tasks are intertwined: if one fails, so do all the others. ~~~ # use std::task::spawn; +# use std::task; # fn do_some_work() { loop { task::yield() } } # do task::try { // Create a child task that fails @@ -437,6 +452,7 @@ field (representing a successful result) or an `Err` result (representing termination with an error). ~~~ +# use std::task; # fn some_condition() -> bool { false } # fn calculate_result() -> int { 0 } let result: Result<int, ()> = do task::try { @@ -479,6 +495,7 @@ By default, task failure is _bidirectionally linked_, which means that if either task fails, it kills the other one. ~~~ +# use std::task; # fn sleep_forever() { loop { task::yield() } } # do task::try { do spawn { @@ -501,6 +518,7 @@ before returning. Hence: ~~~ # use std::comm::{stream, Chan, Port}; # use std::task::{spawn, try}; +# use std::task; # fn sleep_forever() { loop { task::yield() } } # do task::try { let (receiver, sender): (Port<int>, Chan<int>) = stream(); @@ -528,6 +546,7 @@ Supervised task failure propagates across multiple generations even if an intermediate generation has already exited: ~~~ +# use std::task; # fn sleep_forever() { loop { task::yield() } } # fn wait_for_a_while() { for 1000.times { task::yield() } } # do task::try::<int> { @@ -546,6 +565,7 @@ Finally, tasks can be configured to not propagate failure to each other at all, using `task::spawn_unlinked` for _isolated failure_. ~~~ +# use std::task; # fn random() -> uint { 100 } # fn sleep_for(i: uint) { for i.times { task::yield() } } # do task::try::<()> { @@ -574,6 +594,7 @@ Here is the function that implements the child task: ~~~~ # use extra::comm::DuplexStream; +# use std::uint; fn stringifier(channel: &DuplexStream<~str, uint>) { let mut value: uint; loop { @@ -596,6 +617,7 @@ Here is the code for the parent task: ~~~~ # use std::task::spawn; +# use std::uint; # use extra::comm::DuplexStream; # fn stringifier(channel: &DuplexStream<~str, uint>) { # let mut value: uint; diff --git a/doc/tutorial.md b/doc/tutorial.md index 91a41cb9b85..14a0c6fdcfe 100644 --- a/doc/tutorial.md +++ b/doc/tutorial.md @@ -502,6 +502,7 @@ types. > items. ~~~~ +# use std::float; fn angle(vector: (float, float)) -> float { let pi = float::consts::pi; match vector { @@ -556,6 +557,7 @@ while cake_amount > 0 { `loop` denotes an infinite loop, and is the preferred way of writing `while true`: ~~~~ +# use std::int; let mut x = 5; loop { x += x - 3; @@ -699,6 +701,7 @@ get at their contents. All variant constructors can be used as patterns, as in this definition of `area`: ~~~~ +# use std::float; # struct Point {x: float, y: float} # enum Shape { Circle(Point, float), Rectangle(Point, Point) } fn area(sh: Shape) -> float { @@ -1829,6 +1832,7 @@ vector consisting of the result of applying `function` to each element of `vector`: ~~~~ +# use std::vec; fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] { let mut accumulator = ~[]; for vec::each(vector) |element| { @@ -2026,6 +2030,7 @@ themselves contain type parameters. A trait for generalized sequence types might look like the following: ~~~~ +# use std::vec; trait Seq<T> { fn len(&self) -> uint; fn iter(&self, b: &fn(v: &T)); diff --git a/src/compiletest/compiletest.rc b/src/compiletest/compiletest.rc index e009839ba97..1ac6c215d27 100644 --- a/src/compiletest/compiletest.rc +++ b/src/compiletest/compiletest.rc @@ -16,13 +16,13 @@ #[no_std]; extern mod core(name = "std", vers = "0.7-pre"); -extern mod std(name = "extra", vers = "0.7-pre"); +extern mod extra(name = "extra", vers = "0.7-pre"); use core::prelude::*; use core::*; -use std::getopts; -use std::test; +use extra::getopts; +use extra::test; use core::result::{Ok, Err}; @@ -42,6 +42,13 @@ pub mod runtest; pub mod common; pub mod errors; +mod std { + pub use core::cmp; + pub use core::str; + pub use core::sys; + pub use core::unstable; +} + pub fn main() { let args = os::args(); let config = parse_config(args); diff --git a/src/compiletest/errors.rs b/src/compiletest/errors.rs index 297ec9ee21e..728548caf77 100644 --- a/src/compiletest/errors.rs +++ b/src/compiletest/errors.rs @@ -10,6 +10,9 @@ use core::prelude::*; +use core::io; +use core::str; + pub struct ExpectedError { line: uint, kind: ~str, msg: ~str } // Load any test directives embedded in the file diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs index cc4320248cd..2bfc92bc704 100644 --- a/src/compiletest/header.rs +++ b/src/compiletest/header.rs @@ -10,8 +10,12 @@ use core::prelude::*; -use common; use common::config; +use common; + +use core::io; +use core::os; +use core::str; pub struct TestProps { // Lines that should be expected, in order, on standard out diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs index a059f97daab..57a6dc8037e 100644 --- a/src/compiletest/procsrv.rs +++ b/src/compiletest/procsrv.rs @@ -10,7 +10,13 @@ use core::prelude::*; +use core::comm; +use core::io; +use core::libc::c_int; +use core::os; use core::run; +use core::str; +use core::task; #[cfg(target_os = "win32")] fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] { diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index c1586a1b350..4db1fa6d0a0 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -22,6 +22,12 @@ use procsrv; use util; use util::logv; +use core::io; +use core::os; +use core::str; +use core::uint; +use core::vec; + pub fn run(config: config, testfile: ~str) { if config.verbose { // We're going to be dumping a lot of info. Start on a new line. diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs index e9b09e8aee8..26a62f8a5b2 100644 --- a/src/compiletest/util.rs +++ b/src/compiletest/util.rs @@ -12,6 +12,7 @@ use core::prelude::*; use common::config; +use core::io; use core::os::getenv; pub fn make_new_path(path: &str) -> ~str { diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs index e120f3dd033..e73b49044d4 100644 --- a/src/libextra/arc.rs +++ b/src/libextra/arc.rs @@ -510,9 +510,13 @@ pub impl<'self, T:Const + Owned> RWReadMode<'self, T> { #[cfg(test)] mod tests { use core::prelude::*; - use core::cell::Cell; + use arc::*; + use core::cell::Cell; + use core::comm; + use core::task; + #[test] fn manually_share_arc() { let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; @@ -541,59 +545,65 @@ mod tests { #[test] fn test_mutex_arc_condvar() { - let arc = ~MutexARC(false); - let arc2 = ~arc.clone(); - let (p,c) = comm::oneshot(); - let (c,p) = (Cell(c), Cell(p)); - do task::spawn || { - // wait until parent gets in - comm::recv_one(p.take()); - do arc2.access_cond |state, cond| { - *state = true; - cond.signal(); + unsafe { + let arc = ~MutexARC(false); + let arc2 = ~arc.clone(); + let (p,c) = comm::oneshot(); + let (c,p) = (Cell(c), Cell(p)); + do task::spawn || { + // wait until parent gets in + comm::recv_one(p.take()); + do arc2.access_cond |state, cond| { + *state = true; + cond.signal(); + } } - } - do arc.access_cond |state, cond| { - comm::send_one(c.take(), ()); - assert!(!*state); - while !*state { - cond.wait(); + do arc.access_cond |state, cond| { + comm::send_one(c.take(), ()); + assert!(!*state); + while !*state { + cond.wait(); + } } } } #[test] #[should_fail] #[ignore(cfg(windows))] fn test_arc_condvar_poison() { - let arc = ~MutexARC(1); - let arc2 = ~arc.clone(); - let (p, c) = comm::stream(); - - do task::spawn_unlinked || { - let _ = p.recv(); - do arc2.access_cond |one, cond| { - cond.signal(); - // Parent should fail when it wakes up. - assert_eq!(*one, 0); + unsafe { + let arc = ~MutexARC(1); + let arc2 = ~arc.clone(); + let (p, c) = comm::stream(); + + do task::spawn_unlinked || { + let _ = p.recv(); + do arc2.access_cond |one, cond| { + cond.signal(); + // Parent should fail when it wakes up. + assert_eq!(*one, 0); + } } - } - do arc.access_cond |one, cond| { - c.send(()); - while *one == 1 { - cond.wait(); + do arc.access_cond |one, cond| { + c.send(()); + while *one == 1 { + cond.wait(); + } } } } #[test] #[should_fail] #[ignore(cfg(windows))] fn test_mutex_arc_poison() { - let arc = ~MutexARC(1); - let arc2 = ~arc.clone(); - do task::try || { - do arc2.access |one| { - assert_eq!(*one, 2); + unsafe { + let arc = ~MutexARC(1); + let arc2 = ~arc.clone(); + do task::try || { + do arc2.access |one| { + assert_eq!(*one, 2); + } + }; + do arc.access |one| { + assert_eq!(*one, 1); } - }; - do arc.access |one| { - assert_eq!(*one, 1); } } #[test] #[should_fail] #[ignore(cfg(windows))] diff --git a/src/libextra/base64.rs b/src/libextra/base64.rs index 7829eb50a68..373bebeec71 100644 --- a/src/libextra/base64.rs +++ b/src/libextra/base64.rs @@ -12,6 +12,9 @@ use core::prelude::*; +use core::str; +use core::vec; + pub trait ToBase64 { fn to_base64(&self) -> ~str; } diff --git a/src/libextra/bitv.rs b/src/libextra/bitv.rs index 1a6e42d2fbb..afd82d42589 100644 --- a/src/libextra/bitv.rs +++ b/src/libextra/bitv.rs @@ -10,6 +10,12 @@ use core::prelude::*; +use core::cmp; +use core::ops; +use core::uint; +use core::vec::from_elem; +use core::vec; + struct SmallBitv { /// only the lowest nbits of this value are used. the rest is undefined. bits: uint diff --git a/src/libextra/c_vec.rs b/src/libextra/c_vec.rs index a8e71433ff8..7cc7b659ed9 100644 --- a/src/libextra/c_vec.rs +++ b/src/libextra/c_vec.rs @@ -38,6 +38,9 @@ use core::prelude::*; +use core::option; +use core::ptr; + /** * The type representing a foreign chunk of memory * diff --git a/src/libextra/comm.rs b/src/libextra/comm.rs index 095da6570fd..1ef61926c92 100644 --- a/src/libextra/comm.rs +++ b/src/libextra/comm.rs @@ -18,6 +18,7 @@ use core::prelude::*; use core::comm::{GenericChan, GenericSmartChan, GenericPort}; use core::comm::{Chan, Port, Selectable, Peekable}; +use core::comm; use core::pipes; /// An extension of `pipes::stream` that allows both sending and receiving. diff --git a/src/libextra/deque.rs b/src/libextra/deque.rs index ad3b6ab3df4..ccb52fa038c 100644 --- a/src/libextra/deque.rs +++ b/src/libextra/deque.rs @@ -12,7 +12,9 @@ use core::prelude::*; +use core::uint; use core::util::replace; +use core::vec; static initial_capacity: uint = 32u; // 2^5 diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs index d3da13dde98..fc6cdb102a0 100644 --- a/src/libextra/dlist.rs +++ b/src/libextra/dlist.rs @@ -21,6 +21,8 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate. use core::prelude::*; use core::managed; +use core::old_iter; +use core::vec; pub type DListLink<T> = Option<@mut DListNode<T>>; @@ -538,6 +540,9 @@ mod tests { use super::*; + use core::old_iter; + use core::vec; + #[test] fn test_dlist_concat() { let a = from_vec([1,2]); diff --git a/src/libextra/fileinput.rs b/src/libextra/fileinput.rs index 42dde4ab890..e6f3fba6b15 100644 --- a/src/libextra/fileinput.rs +++ b/src/libextra/fileinput.rs @@ -96,6 +96,11 @@ total line count). use core::prelude::*; +use core::io::ReaderUtil; +use core::io; +use core::os; +use core::vec; + /** A summary of the internal state of a `FileInput` object. `line_num` and `line_num_file` represent the number of lines read in total and in @@ -407,6 +412,11 @@ mod test { use super::{FileInput, pathify, input_vec, input_vec_state}; + use core::io; + use core::str; + use core::uint; + use core::vec; + fn make_file(path : &Path, contents: &[~str]) { let file = io::file_writer(path, [io::Create, io::Truncate]).get(); diff --git a/src/libextra/flate.rs b/src/libextra/flate.rs index d184e67ab29..e24c80b4463 100644 --- a/src/libextra/flate.rs +++ b/src/libextra/flate.rs @@ -16,8 +16,9 @@ Simple compression use core::prelude::*; -use core::libc; use core::libc::{c_void, size_t, c_int}; +use core::libc; +use core::vec; pub mod rustrt { use core::libc::{c_int, c_void, size_t}; diff --git a/src/libextra/flatpipes.rs b/src/libextra/flatpipes.rs index 8cb94abcd38..955da13c7b3 100644 --- a/src/libextra/flatpipes.rs +++ b/src/libextra/flatpipes.rs @@ -345,11 +345,11 @@ pub mod flatteners { use core::cast; use core::io::{Writer, Reader, ReaderUtil}; + use core::io; use core::ptr; use core::sys::size_of; use core::vec; - // FIXME #4074: Copy + Owned != POD pub struct PodUnflattener<T> { bogus: () @@ -511,8 +511,10 @@ pub mod bytepipes { use flatpipes::{ByteChan, BytePort}; - use core::io::{Writer, Reader, ReaderUtil}; use core::comm::{Port, Chan}; + use core::comm; + use core::io::{Writer, Reader, ReaderUtil}; + use core::vec; pub struct ReaderBytePort<R> { reader: R @@ -646,7 +648,12 @@ 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::sys; + use core::task; #[test] #[ignore(reason = "ebml failure")] @@ -873,6 +880,11 @@ mod test { use flatpipes::pod; use io_util::BufReader; + use core::comm; + use core::io; + use core::sys; + use core::task; + type PortLoader<P> = ~fn(~[u8]) -> FlatPort<int, PodUnflattener<int>, P>; diff --git a/src/libextra/json.rs b/src/libextra/json.rs index 15823d68062..c3ef346dba3 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -16,8 +16,14 @@ use core::prelude::*; -use core::io::{WriterUtil, ReaderUtil}; +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 serialize::Encodable; use serialize; @@ -1332,6 +1338,8 @@ mod tests { use super::*; use core::hashmap::HashMap; + use core::io; + use core::result; use std::serialize::Decodable; diff --git a/src/libextra/list.rs b/src/libextra/list.rs index 0cde57d5ad7..6f2c8447eca 100644 --- a/src/libextra/list.rs +++ b/src/libextra/list.rs @@ -8,10 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! A standard linked list +//! A standard, garbage-collected linked list. use core::prelude::*; +use core::vec; + #[deriving(Eq)] pub enum List<T> { Cons(T, @List<T>), diff --git a/src/libextra/net_tcp.rs b/src/libextra/net_tcp.rs index aaa10fe562a..8dff9b330a5 100644 --- a/src/libextra/net_tcp.rs +++ b/src/libextra/net_tcp.rs @@ -1451,6 +1451,10 @@ mod test { use core::cell::Cell; use core::comm::{stream, SharedChan}; + use core::io; + use core::result; + use core::str; + use core::task; // FIXME don't run on fbsd or linux 32 bit (#2064) #[cfg(target_os="win32")] diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs index 7ff8c25d95f..0151c300a4a 100644 --- a/src/libextra/num/bigint.rs +++ b/src/libextra/num/bigint.rs @@ -19,7 +19,11 @@ A BigInt is a combination of BigUint and Sign. 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; /** A BigDigit is a BigUint's composing element. @@ -1148,8 +1152,13 @@ mod biguint_tests { use core::prelude::*; use super::*; - use core::num::{IntConvertible, Zero, One, FromStrRadix}; + 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; #[test] fn test_from_slice() { @@ -1616,8 +1625,12 @@ 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; #[test] fn test_from_biguint() { diff --git a/src/libextra/num/rational.rs b/src/libextra/num/rational.rs index de114a35e36..b33d113161c 100644 --- a/src/libextra/num/rational.rs +++ b/src/libextra/num/rational.rs @@ -13,8 +13,11 @@ use core::prelude::*; -use core::num::{Zero,One,ToStrRadix,FromStrRadix,Round}; +use core::cmp; use core::from_str::FromStr; +use core::num::{Zero,One,ToStrRadix,FromStrRadix,Round}; +use core::str; +use core::vec; use super::bigint::BigInt; /// Represents the ratio between 2 numbers. diff --git a/src/libextra/par.rs b/src/libextra/par.rs index 52e7d517d6e..49696a5fa25 100644 --- a/src/libextra/par.rs +++ b/src/libextra/par.rs @@ -10,6 +10,11 @@ use core::prelude::*; +use core::cast; +use core::ptr; +use core::sys; +use core::uint; +use core::vec; use future_spawn = future::spawn; /** diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs index 4b84e2aa8c9..9345c246750 100644 --- a/src/libextra/priority_queue.rs +++ b/src/libextra/priority_queue.rs @@ -15,6 +15,7 @@ use core::prelude::*; use core::old_iter::BaseIter; use core::unstable::intrinsics::{move_val_init, init}; use core::util::{replace, swap}; +use core::vec; pub struct PriorityQueue<T> { priv data: ~[T], diff --git a/src/libextra/rc.rs b/src/libextra/rc.rs index a1a14c31b28..73f98a3b19c 100644 --- a/src/libextra/rc.rs +++ b/src/libextra/rc.rs @@ -21,7 +21,10 @@ 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 core::util; diff --git a/src/libextra/rl.rs b/src/libextra/rl.rs index 41574424139..040adcc443d 100644 --- a/src/libextra/rl.rs +++ b/src/libextra/rl.rs @@ -14,6 +14,8 @@ use core::prelude::*; use core::libc::{c_char, c_int}; +use core::local_data; +use core::str; pub mod rustrt { use core::libc::{c_char, c_int}; diff --git a/src/libextra/rope.rs b/src/libextra/rope.rs index 4efe131c7cb..566bbfd6df6 100644 --- a/src/libextra/rope.rs +++ b/src/libextra/rope.rs @@ -35,6 +35,10 @@ use core::prelude::*; +use core::str; +use core::uint; +use core::vec; + /// The type of ropes. pub type Rope = node::Root; @@ -556,6 +560,11 @@ pub mod node { use rope::node; + use core::cast; + use core::str; + use core::uint; + use core::vec; + /// Implementation of type `rope` pub enum Root { /// An empty rope @@ -1137,6 +1146,8 @@ pub mod node { use rope::node::{Concat, Leaf, Node, height}; + use core::vec; + pub struct T { stack: ~[@Node], stackpos: int, @@ -1176,6 +1187,8 @@ pub mod node { pub mod char_iterator { use core::prelude::*; + use core::str; + use rope::node::{Leaf, Node}; use rope::node::leaf_iterator; @@ -1258,9 +1271,14 @@ pub mod node { #[cfg(test)] mod tests { - use rope::*; use core::prelude::*; + use rope::*; + + use core::str; + use core::uint; + use core::vec; + //Utility function, used for sanity check fn rope_to_string(r: Rope) -> ~str { match (r) { diff --git a/src/libextra/serialize.rs b/src/libextra/serialize.rs index 749e9d5dc61..d20aed69240 100644 --- a/src/libextra/serialize.rs +++ b/src/libextra/serialize.rs @@ -18,8 +18,11 @@ Core encoding and decoding interfaces. use core::prelude::*; +use core::at_vec; use core::hashmap::{HashMap, HashSet}; use core::trie::{TrieMap, TrieSet}; +use core::uint; +use core::vec; use deque::Deque; use dlist::DList; use treemap::{TreeMap, TreeSet}; diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs index a3c02b2366d..a85f113b68f 100644 --- a/src/libextra/smallintmap.rs +++ b/src/libextra/smallintmap.rs @@ -15,11 +15,13 @@ use core::prelude::*; +use core::cmp; use core::container::{Container, Mutable, Map, Set}; use core::old_iter::BaseIter; use core::old_iter; -use core::option::{Some, None}; +use core::uint; use core::util::replace; +use core::vec; pub struct SmallIntMap<T> { priv v: ~[Option<T>], @@ -285,6 +287,11 @@ mod tests { use super::SmallIntMap; + use core::local_data; + use core::rand; + use core::uint; + use core::vec; + #[test] fn test_find_mut() { let mut m = SmallIntMap::new(); @@ -380,6 +387,8 @@ mod test_set { use super::SmallIntSet; + use core::vec; + #[test] fn test_disjoint() { let mut xs = SmallIntSet::new(); diff --git a/src/libextra/sort.rs b/src/libextra/sort.rs index 3039fa46f06..b3118dd37e1 100644 --- a/src/libextra/sort.rs +++ b/src/libextra/sort.rs @@ -13,9 +13,10 @@ use core::prelude::*; use core::cmp::{Eq, Ord}; +use core::uint; +use core::util::swap; use core::vec::len; use core::vec; -use core::util::swap; type Le<'self, T> = &'self fn(v1: &T, v2: &T) -> bool; @@ -926,7 +927,12 @@ mod test_tim_sort { use core::prelude::*; use sort::tim_sort; + + use core::local_data; use core::rand::RngUtil; + use core::rand; + use core::uint; + use core::vec; struct CVal { val: float, @@ -1019,7 +1025,12 @@ 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; #[test] fn test_unique() { diff --git a/src/libextra/std.rc b/src/libextra/std.rc index 6166e65f4f7..8c03701f513 100644 --- a/src/libextra/std.rc +++ b/src/libextra/std.rc @@ -133,6 +133,9 @@ pub mod std { 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 { diff --git a/src/libextra/sync.rs b/src/libextra/sync.rs index beea3b6f52b..5a1982d830d 100644 --- a/src/libextra/sync.rs +++ b/src/libextra/sync.rs @@ -17,9 +17,10 @@ use core::prelude::*; -use core::unstable::sync::{Exclusive, exclusive}; +use core::comm; use core::ptr; use core::task; +use core::unstable::sync::{Exclusive, exclusive}; use core::util; /**************************************************************************** @@ -728,6 +729,8 @@ mod tests { use core::cast; use core::cell::Cell; + use core::comm; + use core::ptr; use core::result; use core::task; use core::vec; diff --git a/src/libextra/task_pool.rs b/src/libextra/task_pool.rs index 926045a6b52..eba4f0d1b75 100644 --- a/src/libextra/task_pool.rs +++ b/src/libextra/task_pool.rs @@ -14,6 +14,7 @@ use core::prelude::*; use core::comm::Chan; +use core::comm; use core::task::SchedMode; use core::task; use core::vec; @@ -101,6 +102,6 @@ fn test_task_pool() { }; let mut pool = TaskPool::new(4, Some(SingleThreaded), f); for 8.times { - pool.execute(|i| io::println(fmt!("Hello from thread %u!", *i))); + pool.execute(|i| println(fmt!("Hello from thread %u!", *i))); } } diff --git a/src/libextra/tempfile.rs b/src/libextra/tempfile.rs index 7f073d0decb..c514631e787 100644 --- a/src/libextra/tempfile.rs +++ b/src/libextra/tempfile.rs @@ -12,7 +12,9 @@ use core::prelude::*; +use core::os; use core::rand::RngUtil; +use core::rand; pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> { let mut r = rand::rng(); @@ -30,7 +32,10 @@ mod tests { use core::prelude::*; use tempfile::mkdtemp; + use tempfile; + use core::os; + use core::str; #[test] fn test_mkdtemp() { diff --git a/src/libextra/test.rs b/src/libextra/test.rs index ba2ee3c352e..59c6a12e036 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -21,8 +21,18 @@ use getopts; use sort; use term; -use core::to_str::ToStr; use core::comm::{stream, SharedChan}; +use core::either; +use core::io; +use core::num; +use core::option; +use core::result; +use core::str; +use core::task; +use core::to_str::ToStr; +use core::u64; +use core::uint; +use core::vec; pub mod rustrt { use core::libc::size_t; @@ -601,10 +611,14 @@ fn calc_result(desc: &TestDesc, task_succeeded: bool) -> TestResult { pub mod bench { use core::prelude::*; - use time::precise_time_ns; - use test::{BenchHarness, BenchSamples}; - use stats::Stats; + use core::num; use core::rand::RngUtil; + use core::rand; + use core::u64; + use core::vec; + use stats::Stats; + use test::{BenchHarness, BenchSamples}; + use time::precise_time_ns; pub impl BenchHarness { diff --git a/src/libextra/time.rs b/src/libextra/time.rs index d5a8cd78249..93fbf6a4054 100644 --- a/src/libextra/time.rs +++ b/src/libextra/time.rs @@ -10,6 +10,11 @@ use core::prelude::*; +use core::i32; +use core::int; +use core::io; +use core::str; + static NSEC_PER_SEC: i32 = 1_000_000_000_i32; pub mod rustrt { diff --git a/src/libextra/timer.rs b/src/libextra/timer.rs index 75caf1a4829..4f662613b00 100644 --- a/src/libextra/timer.rs +++ b/src/libextra/timer.rs @@ -19,6 +19,7 @@ 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; @@ -179,9 +180,12 @@ mod test { use timer::*; use uv; + use core::cell::Cell; - use core::rand::RngUtil; use core::pipes::{stream, SharedChan}; + use core::rand::RngUtil; + use core::rand; + use core::task; #[test] fn test_gl_timer_simple_sleep_test() { diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs index 5551431b551..a05c532c92f 100644 --- a/src/libextra/treemap.rs +++ b/src/libextra/treemap.rs @@ -15,6 +15,7 @@ use core::prelude::*; use core::iterator::*; +use core::uint; use core::util::{swap, replace}; // This is implemented as an AA tree, which is a simplified variation of @@ -701,9 +702,13 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>, mod test_treemap { use core::prelude::*; - use core::iterator::*; use super::*; + + use core::iterator::*; use core::rand::RngUtil; + use core::rand; + use core::str; + use core::vec; #[test] fn find_empty() { @@ -1021,8 +1026,11 @@ mod test_treemap { mod test_set { use core::prelude::*; use core::iterator::*; + use super::*; + use core::vec; + #[test] fn test_clear() { let mut s = TreeSet::new(); diff --git a/src/libextra/uv_global_loop.rs b/src/libextra/uv_global_loop.rs index ae59f91cf83..8752f675a8d 100644 --- a/src/libextra/uv_global_loop.rs +++ b/src/libextra/uv_global_loop.rs @@ -16,7 +16,9 @@ use iotask = uv_iotask; use uv_iotask::{IoTask, spawn_iotask}; use core::comm::Chan; +use core::libc; use core::option::{Some, None}; +use core::str; use core::task::task; use core::unstable::global::{global_data_clone_create, global_data_clone}; use core::unstable::weak_task::weaken_task; diff --git a/src/libextra/uv_iotask.rs b/src/libextra/uv_iotask.rs index ff726c1464c..6cf753b8016 100644 --- a/src/libextra/uv_iotask.rs +++ b/src/libextra/uv_iotask.rs @@ -22,6 +22,7 @@ use ll = uv_ll; use core::comm::{stream, Port, Chan, SharedChan}; use core::libc::c_void; use core::libc; +use core::task; /// Used to abstract-away direct interaction with a libuv loop. pub struct IoTask { @@ -223,6 +224,8 @@ struct AhData { #[cfg(test)] fn impl_uv_iotask_async(iotask: &IoTask) { + use core::ptr; + let async_handle = ll::async_t(); let ah_ptr: *ll::uv_async_t = &async_handle; let (exit_po, exit_ch) = stream::<()>(); diff --git a/src/libextra/uv_ll.rs b/src/libextra/uv_ll.rs index 5be8dd514de..d5f7cb12e4f 100644 --- a/src/libextra/uv_ll.rs +++ b/src/libextra/uv_ll.rs @@ -34,9 +34,12 @@ use core::prelude::*; -use core::libc::size_t; -use core::libc::c_void; +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; pub type uv_handle_t = c_void; pub type uv_loop_t = c_void; @@ -1225,9 +1228,17 @@ pub unsafe fn addrinfo_as_sockaddr_in6(input: *addrinfo) -> *sockaddr_in6 { #[cfg(test)] mod test { use core::prelude::*; - use core::comm::{SharedChan, stream, GenericChan, GenericPort}; + use super::*; + use core::comm::{SharedChan, stream, GenericChan, GenericPort}; + use core::libc; + use core::result; + use core::str; + use core::sys; + use core::task; + use core::vec; + enum tcp_read_data { tcp_read_eof, tcp_read_more(~[u8]), diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs index 9df9ffd9465..798cf1ba55d 100644 --- a/src/libextra/workcache.rs +++ b/src/libextra/workcache.rs @@ -21,7 +21,9 @@ 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; diff --git a/src/libfuzzer/fuzzer.rc b/src/libfuzzer/fuzzer.rc index 0107517ff3f..9280be146f9 100644 --- a/src/libfuzzer/fuzzer.rc +++ b/src/libfuzzer/fuzzer.rc @@ -28,7 +28,16 @@ extern mod extra(name = "extra", vers = "0.7-pre"); extern mod syntax(vers = "0.7-pre"); use std::prelude::*; + +use std::int; +use std::io; +use std::option; +use std::os; +use std::result; use std::run; +use std::str; +use std::uint; +use std::vec; use syntax::diagnostic; use syntax::parse::token::ident_interner; diff --git a/src/librust/rust.rc b/src/librust/rust.rc index 00925a5700a..ff766417c2a 100644 --- a/src/librust/rust.rc +++ b/src/librust/rust.rc @@ -31,8 +31,18 @@ extern mod rustc; use core::prelude::*; +use core::io; +use core::os; use core::run; use core::libc::exit; +use core::str; + +// For bootstrapping. +mod std { + pub use core::os; + pub use core::str; + pub use core::unstable; +} enum ValidUsage { Valid(int), Invalid diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index c3847ee4f15..785b79f66b9 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -22,12 +22,17 @@ use middle::trans::common::CrateContext; 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 syntax::ast; use syntax::ast_map::{path, path_mod, path_name}; use syntax::attr; @@ -100,7 +105,12 @@ pub mod jit { use lib::llvm::{ModuleRef, PassManagerRef}; use metadata::cstore; + use core::cast; + use core::char; use core::libc::c_int; + use core::os; + use core::ptr; + use core::str; pub mod rusti { #[nolink] @@ -188,6 +198,7 @@ pub mod write { use core::libc::{c_int, c_uint}; use core::path::Path; use core::run; + use core::str; pub fn is_object_or_assembly_or_exe(ot: output_type) -> bool { if ot == output_type_assembly || ot == output_type_object || diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs index 8695d0c79ef..16d10d0a35e 100644 --- a/src/librustc/back/rpath.rs +++ b/src/librustc/back/rpath.rs @@ -14,8 +14,11 @@ use driver::session; use metadata::cstore; use metadata::filesearch; -use core::util; use core::hashmap::HashSet; +use core::os; +use core::uint; +use core::util; +use core::vec; fn not_win32(os: session::os) -> bool { match os { @@ -210,6 +213,13 @@ pub fn minimize_rpaths(rpaths: &[Path]) -> ~[Path] { mod test { use core::prelude::*; + use core::os; + use core::str; + + // FIXME(#2119): the outer attribute should be #[cfg(unix, test)], then + // these redundant #[cfg(test)] blocks can be removed + #[cfg(test)] + #[cfg(test)] use back::rpath::{get_absolute_rpath, get_install_prefix_rpath}; use back::rpath::{get_relative_to, get_rpath_relative_to_output}; use back::rpath::{minimize_rpaths, rpaths_to_flags}; diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs index b295e7524cf..f7ce376ca28 100644 --- a/src/librustc/front/config.rs +++ b/src/librustc/front/config.rs @@ -10,6 +10,8 @@ use core::prelude::*; +use core::option; +use core::vec; use syntax::{ast, fold, attr}; type in_cfg_pred = @fn(attrs: ~[ast::attribute]) -> bool; diff --git a/src/librustc/front/intrinsic_inject.rs b/src/librustc/front/intrinsic_inject.rs index 7a8a2a7eb97..2cdfd17c169 100644 --- a/src/librustc/front/intrinsic_inject.rs +++ b/src/librustc/front/intrinsic_inject.rs @@ -10,6 +10,7 @@ use core::prelude::*; +use core::vec; use driver::session::Session; use syntax::parse; use syntax::ast; diff --git a/src/librustc/front/std_inject.rs b/src/librustc/front/std_inject.rs index c8135abf334..a05dfc446ec 100644 --- a/src/librustc/front/std_inject.rs +++ b/src/librustc/front/std_inject.rs @@ -12,10 +12,11 @@ use core::prelude::*; use driver::session::Session; +use core::vec; use syntax::ast; use syntax::attr; -use syntax::codemap; use syntax::codemap::dummy_sp; +use syntax::codemap; use syntax::fold; static STD_VERSION: &'static str = "0.7-pre"; diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index e41f26aab08..08a19577308 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -15,6 +15,7 @@ use core::prelude::*; use driver::session; use front::config; +use core::vec; use syntax::ast_util::*; use syntax::attr; use syntax::codemap::{dummy_sp, span, ExpandedFrom, CallInfo, NameAndSpan}; @@ -309,7 +310,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item { let mainfn = (quote_item!( pub fn main() { #[main]; - extra::test::test_main_static(::os::args(), tests); + extra::test::test_main_static(::std::os::args(), tests); } )).get(); diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs index a12a8be3b11..49a682e68f1 100644 --- a/src/librustc/lib/llvm.rs +++ b/src/librustc/lib/llvm.rs @@ -12,6 +12,10 @@ use core::prelude::*; use core::hashmap::HashMap; use core::libc::{c_uint, c_ushort}; +use core::option; +use core::ptr; +use core::str; +use core::vec; pub type Opcode = u32; pub type Bool = c_uint; diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index d189ddf9533..2c9b3c3a4ef 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -18,6 +18,7 @@ use metadata::filesearch::FileSearch; use metadata::loader; use core::hashmap::HashMap; +use core::vec; use syntax::attr; use syntax::codemap::{span, dummy_sp}; use syntax::diagnostic::span_handler; diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index 57d6c46d9f3..2a2419b0e30 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -18,6 +18,7 @@ use metadata::decoder; use metadata; use middle::{ty, resolve}; +use core::vec; use reader = extra::ebml::reader; use syntax::ast; use syntax::ast_map; diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 6cc211e0e99..6cc01cb90b8 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -18,6 +18,7 @@ use metadata::cstore; use metadata::decoder; use core::hashmap::HashMap; +use core::vec; use extra; use syntax::ast; use syntax::parse::token::ident_interner; diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 5467c50c7b8..a488d39d187 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -22,9 +22,14 @@ use middle::ty; use middle; use util::ppaux::ty_to_str; -use extra::flate; use core::hash::HashUtil; use core::hashmap::HashMap; +use core::int; +use core::io; +use core::str; +use core::uint; +use core::vec; +use extra::flate; use extra::serialize::Encodable; use extra; use syntax::abi::AbiSet; @@ -34,10 +39,10 @@ use syntax::ast_map; use syntax::ast_util::*; use syntax::attr; use syntax::diagnostic::span_handler; -use syntax::parse::token::special_idents; -use syntax::{ast_util, visit}; use syntax::opt_vec::OptVec; use syntax::opt_vec; +use syntax::parse::token::special_idents; +use syntax::{ast_util, visit}; use syntax; use writer = extra::ebml::writer; diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 0d9b16d3117..4dbcd21e8f3 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -10,6 +10,11 @@ use core::prelude::*; +use core::option; +use core::os; +use core::result; +use core::str; + // A module for searching for libraries // FIXME (#2658): I'm not happy how this module turned out. Should // probably just be folded into cstore. diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 94060ab3271..5c64bd43943 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -23,8 +23,15 @@ use syntax::parse::token::ident_interner; use syntax::print::pprust; use syntax::{ast, attr}; -use extra::flate; +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 extra::flate; pub enum os { os_macos, diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index a726ca4bd52..f26a52cd8cd 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -18,6 +18,9 @@ use core::prelude::*; use middle::ty; +use core::str; +use core::uint; +use core::vec; use syntax::abi::AbiSet; use syntax::abi; use syntax::ast; diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 3ebcf72e485..276b78d2e12 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -25,6 +25,9 @@ use middle::{ty, typeck, moves}; use middle; use util::ppaux::ty_to_str; +use core::at_vec; +use core::str; +use core::uint; use extra::ebml::reader; use extra::ebml; use extra::serialize; diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 183771956ea..1801585900b 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -19,17 +19,18 @@ use core::prelude::*; -use middle::moves; -use middle::borrowck::*; +use core::hashmap::HashSet; +use core::uint; use mc = middle::mem_categorization; +use middle::borrowck::*; +use middle::moves; use middle::ty; -use util::ppaux::Repr; -use core::hashmap::HashSet; use syntax::ast::{m_mutbl, m_imm, m_const}; use syntax::ast; use syntax::ast_util; -use syntax::visit; use syntax::codemap::span; +use syntax::visit; +use util::ppaux::Repr; struct CheckLoanCtxt<'self> { bccx: @BorrowckCtxt, diff --git a/src/librustc/middle/borrowck/gather_loans/restrictions.rs b/src/librustc/middle/borrowck/gather_loans/restrictions.rs index 82a3b145e1d..6bd32f04ce5 100644 --- a/src/librustc/middle/borrowck/gather_loans/restrictions.rs +++ b/src/librustc/middle/borrowck/gather_loans/restrictions.rs @@ -12,6 +12,7 @@ use core::prelude::*; +use core::vec; use middle::borrowck::*; use mc = middle::mem_categorization; use middle::ty; diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 1babf08aa70..066d0189fcb 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -23,8 +23,9 @@ use util::ppaux::{note_and_explain_region, Repr, UserString}; use core::hashmap::{HashSet, HashMap}; use core::io; -use core::result::{Result}; use core::ops::{BitOr, BitAnd}; +use core::result::{Result}; +use core::str; use syntax::ast; use syntax::ast_map; use syntax::visit; diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs index 91962f17d59..2443c19ac97 100644 --- a/src/librustc/middle/borrowck/move_data.rs +++ b/src/librustc/middle/borrowck/move_data.rs @@ -16,7 +16,9 @@ comments in the section "Moves and initialization" and in `doc.rs`. */ use core::prelude::*; + use core::hashmap::{HashMap, HashSet}; +use core::uint; use middle::borrowck::*; use middle::dataflow::DataFlowContext; use middle::dataflow::DataFlowOperator; diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 748ae83a60c..58c5ce6f2b5 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -19,6 +19,8 @@ use middle::typeck::method_map; use middle::moves; use util::ppaux::ty_to_str; +use core::uint; +use core::vec; use extra::sort; use syntax::ast::*; use syntax::ast_util::{unguarded_pat, walk_pat}; diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 448ca4ab523..d68bbf8cdb3 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -18,7 +18,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; // // This pass classifies expressions by their constant-ness. diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index e0806359c5d..cd60279873a 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -19,7 +19,10 @@ use core::prelude::*; use core::cast; +use core::io; +use core::str; use core::uint; +use core::vec; use syntax::ast; use syntax::ast_util; use syntax::ast_util::id_range; diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs index d2f0a5580ef..d809e653f69 100644 --- a/src/librustc/middle/effect.rs +++ b/src/librustc/middle/effect.rs @@ -73,15 +73,17 @@ pub fn check_crate(tcx: ty::ctxt, let visitor = visit::mk_vt(@visit::Visitor { visit_fn: |fn_kind, fn_decl, block, span, node_id, _, visitor| { - let is_unsafe_fn = match *fn_kind { - fk_item_fn(_, _, purity, _) => purity == unsafe_fn, - fk_method(_, _, method) => method.purity == unsafe_fn, - _ => false, + let (is_item_fn, is_unsafe_fn) = match *fn_kind { + fk_item_fn(_, _, purity, _) => (true, purity == unsafe_fn), + fk_method(_, _, method) => (true, method.purity == unsafe_fn), + _ => (false, false), }; let old_unsafe_context = context.unsafe_context; if is_unsafe_fn { context.unsafe_context = UnsafeFn + } else if is_item_fn { + context.unsafe_context = SafeContext } visit::visit_fn(fn_kind, @@ -97,7 +99,8 @@ pub fn check_crate(tcx: ty::ctxt, visit_block: |block, _, visitor| { let old_unsafe_context = context.unsafe_context; - if block.node.rules == unsafe_blk { + if block.node.rules == unsafe_blk && + context.unsafe_context == SafeContext { context.unsafe_context = UnsafeBlock(block.node.id) } diff --git a/src/librustc/middle/freevars.rs b/src/librustc/middle/freevars.rs index 9dffd09e548..7a57f78d60b 100644 --- a/src/librustc/middle/freevars.rs +++ b/src/librustc/middle/freevars.rs @@ -17,6 +17,7 @@ use middle::resolve; use middle::ty; use core::hashmap::HashMap; +use core::vec; use syntax::codemap::span; use syntax::{ast, ast_util, visit}; diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index a03191e2c4d..b988a88a901 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -18,6 +18,7 @@ use middle::typeck; use util::ppaux::{Repr, ty_to_str}; use util::ppaux::UserString; +use core::vec; use syntax::ast::*; use syntax::attr::attrs_contains_name; use syntax::codemap::span; diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 96ccb2999ae..56c024f12ae 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -15,7 +15,19 @@ 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::str; +use core::u16; +use core::u32; +use core::u64; +use core::u8; +use core::vec; use extra::smallintmap::SmallIntMap; use syntax::attr; use syntax::codemap::span; diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 4897d6c87de..ee7b21638b2 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -112,6 +112,11 @@ use middle::moves; use core::cast::transmute; use core::hashmap::HashMap; +use core::io; +use core::old_iter; +use core::to_str; +use core::uint; +use core::vec; use syntax::ast::*; use syntax::codemap::span; use syntax::parse::token::special_idents; diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 0d335559747..3a14a681628 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -53,6 +53,7 @@ use middle::typeck; use util::ppaux::{ty_to_str, region_to_str, Repr}; use util::common::indenter; +use core::uint; use syntax::ast::{m_imm, m_const, m_mutbl}; use syntax::ast; use syntax::codemap::span; diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index abec56d32d7..c58ebcd1ee4 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -136,6 +136,7 @@ use util::ppaux; use util::ppaux::Repr; use util::common::indenter; +use core::at_vec; use core::hashmap::{HashSet, HashMap}; use syntax::ast::*; use syntax::ast_util; diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 979d04e18c3..fa17fa04ed8 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -39,8 +39,10 @@ use syntax::visit::{visit_foreign_item, visit_item}; use syntax::visit::{visit_mod, visit_ty, vt}; use syntax::opt_vec::OptVec; -use core::option::Some; use core::str::each_split_str; +use core::str; +use core::uint; +use core::vec; use core::hashmap::{HashMap, HashSet}; use core::util; diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 9365a698a7e..ca7ce9c02d1 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -168,6 +168,7 @@ use middle::ty; use util::common::indenter; use core::hashmap::HashMap; +use core::vec; use syntax::ast; use syntax::ast::ident; use syntax::ast_util::path_to_ident; diff --git a/src/librustc/middle/trans/asm.rs b/src/librustc/middle/trans/asm.rs index fad5dc73c1a..bfcd6b16857 100644 --- a/src/librustc/middle/trans/asm.rs +++ b/src/librustc/middle/trans/asm.rs @@ -20,6 +20,7 @@ use middle::trans::callee; use middle::trans::common::*; use middle::ty; +use core::str; use syntax::ast; // Take an inline assembly expression and splat it out via LLVM diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 678446023d1..a36eb39c049 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -66,7 +66,12 @@ use util::ppaux::{Repr, ty_to_str}; use core::hash; use core::hashmap::{HashMap, HashSet}; +use core::int; +use core::io; use core::libc::c_uint; +use core::str; +use core::uint; +use core::vec; use extra::time; use syntax::ast::ident; use syntax::ast_map::{path, path_elt_to_str, path_name}; diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index 7079c11e7d0..a77e27bf0fe 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -19,8 +19,11 @@ use middle::trans::common::*; use middle::trans::machine::llalign_of_min; use syntax::codemap::span; +use core::cast; use core::hashmap::HashMap; use core::libc::{c_uint, c_ulonglong, c_char}; +use core::str; +use core::vec; pub fn terminate(cx: block, _: &str) { cx.terminated = true; diff --git a/src/librustc/middle/trans/cabi_mips.rs b/src/librustc/middle/trans/cabi_mips.rs index 2282952ab88..c9fb01905fb 100644 --- a/src/librustc/middle/trans/cabi_mips.rs +++ b/src/librustc/middle/trans/cabi_mips.rs @@ -11,6 +11,9 @@ use core::prelude::*; use core::libc::c_uint; +use core::ptr; +use core::uint; +use core::vec; use lib::llvm::{llvm, TypeRef, Integer, Pointer, Float, Double}; use lib::llvm::{Struct, Array, Attribute}; use lib::llvm::{StructRetAttribute}; diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index b710f33d6ab..1e6e31e4277 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -43,6 +43,7 @@ use middle::ty; use middle::typeck; use util::ppaux::Repr; +use core::vec; use syntax::ast; use syntax::ast_map; use syntax::visit; diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index 335dd47b78b..fa3e6eeb0b6 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/src/librustc/middle/trans/closure.rs @@ -26,6 +26,8 @@ use middle::trans::type_of::*; use middle::ty; use util::ppaux::ty_to_str; +use core::str; +use core::vec; use syntax::ast; use syntax::ast_map::path_name; use syntax::ast_util; diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index ad5dadaf870..d148dbd2183 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -40,11 +40,15 @@ use middle::borrowck::root_map_key; use util::ppaux::{Repr}; use core::cast::transmute; +use core::cast; use core::hash; use core::hashmap::{HashMap, HashSet}; use core::libc::{c_uint, c_longlong, c_ulonglong}; +use core::ptr; +use core::str; use core::to_bytes; use core::vec::raw::to_ptr; +use core::vec; use syntax::ast::ident; use syntax::ast_map::{path, path_elt}; use syntax::codemap::span; diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index 97ccb6d7908..d47fc184cf3 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -31,6 +31,7 @@ use middle::ty; use util::ppaux::{Repr, ty_to_str}; use core::libc::c_uint; +use core::str; use syntax::{ast, ast_util, ast_map}; pub fn const_lit(cx: @CrateContext, e: @ast::expr, lit: ast::lit) diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs index efe23aee9e6..5ef4376e811 100644 --- a/src/librustc/middle/trans/controlflow.rs +++ b/src/librustc/middle/trans/controlflow.rs @@ -24,6 +24,8 @@ use middle::ty; use util::common::indenter; use util::ppaux; +use core::str; +use core::vec; use syntax::ast; use syntax::ast::ident; use syntax::ast_map::path_mod; diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 6be5dbe1beb..c8b9e3f8f0e 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -104,6 +104,7 @@ use util::common::indenter; use util::ppaux::ty_to_str; use core::to_bytes; +use core::uint; use syntax::ast; use syntax::codemap::span; use syntax::parse::token::special_idents; diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 979559ad481..c1661b80cf8 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -20,8 +20,14 @@ use middle::trans; use middle::ty; use util::ppaux::ty_to_str; +use core::cast; use core::hashmap::HashMap; use core::libc; +use core::option; +use core::ptr; +use core::str; +use core::sys; +use core::vec; use syntax::codemap::span; use syntax::parse::token::ident_interner; use syntax::{ast, codemap, ast_util, ast_map}; diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index d581d8043f8..99860e60c6b 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -154,6 +154,7 @@ use util::ppaux::Repr; use core::cast::transmute; use core::hashmap::HashMap; +use core::vec; use syntax::print::pprust::{expr_to_str}; use syntax::ast; use syntax::codemap; diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index 63356a135d0..a7a8cd088d2 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -34,6 +34,9 @@ use middle::ty; use middle::ty::FnSig; use util::ppaux::ty_to_str; +use core::str; +use core::uint; +use core::vec; use syntax::codemap::span; use syntax::{ast, ast_util}; use syntax::{attr, ast_map}; diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index 405e5e36de7..013a40c95c5 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -36,7 +36,10 @@ use middle::ty; use util::ppaux; use util::ppaux::ty_to_short_str; +use core::io; use core::libc::c_uint; +use core::str; +use core::vec; use extra::time; use syntax::ast; diff --git a/src/librustc/middle/trans/inline.rs b/src/librustc/middle/trans/inline.rs index aa4bb775323..1f9bdcb5abb 100644 --- a/src/librustc/middle/trans/inline.rs +++ b/src/librustc/middle/trans/inline.rs @@ -19,6 +19,7 @@ use middle::trans::common::*; use middle::ty; use util::ppaux::ty_to_str; +use core::vec; use syntax::ast; use syntax::ast_map::path_name; use syntax::ast_util::local_def; diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index 381c257f651..1e43a3c502b 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -31,6 +31,8 @@ use middle::typeck; use util::common::indenter; use util::ppaux::Repr; +use core::str; +use core::vec; use syntax::ast_map::{path, path_mod, path_name}; use syntax::ast_util; use syntax::{ast, ast_map}; diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index 1b3150f14b2..7e29d3bd33a 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -32,6 +32,7 @@ use middle::ty::{FnSig}; use middle::typeck; use util::ppaux::Repr; +use core::vec; use syntax::ast; use syntax::ast_map; use syntax::ast_map::path_name; diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index e17fe63af76..8815259b3cc 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -27,9 +27,17 @@ use util::ppaux::{Repr, UserString}; use util::common::{indenter}; use util::enum_set::{EnumSet, CLike}; +use core::cast; +use core::cmp; +use core::hashmap::{HashMap, HashSet}; +use core::iter; +use core::ops; use core::ptr::to_unsafe_ptr; use core::to_bytes; -use core::hashmap::{HashMap, HashSet}; +use core::u32; +use core::uint; +use core::vec; +use extra::smallintmap::SmallIntMap; use syntax::ast::*; use syntax::ast_util::is_local; use syntax::ast_util; diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 5cc2b0dcedd..390ba2dc0de 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -63,6 +63,8 @@ use middle::typeck::rscope::{region_scope, RegionError}; use middle::typeck::rscope::RegionParamNames; use middle::typeck::lookup_def_tcx; +use core::result; +use core::vec; use syntax::abi::AbiSet; use syntax::{ast, ast_util}; use syntax::codemap::span; diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs index 8edae63cea9..e469856f08f 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -19,6 +19,7 @@ use middle::typeck::check::{structure_of, valid_range_bounds}; use middle::typeck::require_same_types; use core::hashmap::{HashMap, HashSet}; +use core::vec; use syntax::ast; use syntax::ast_util; use syntax::codemap::span; diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 68deb900886..1b7368b3dbf 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -96,6 +96,9 @@ use middle::typeck::check::regionmanip::replace_bound_regions_in_fn_sig; use util::common::indenter; use core::hashmap::HashSet; +use core::result; +use core::uint; +use core::vec; use extra::list::Nil; use syntax::ast::{def_id, sty_value, sty_region, sty_box}; use syntax::ast::{sty_uniq, sty_static, node_id}; diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index f25d451363b..7ba759e63ee 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -111,7 +111,10 @@ use util::ppaux; use core::cast::transmute; use core::hashmap::HashMap; +use core::result; +use core::str; use core::util::replace; +use core::vec; use extra::list::Nil; use syntax::abi::AbiSet; use syntax::ast::{provided, required}; diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index 642022c5b8f..13b9c59e2d9 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -36,10 +36,11 @@ use middle::typeck::check::FnCtxt; use middle::typeck::check::regionmanip::relate_nested_regions; use middle::typeck::infer::resolve_and_force_all_but_regions; use middle::typeck::infer::resolve_type; -use util::ppaux::{note_and_explain_region, ty_to_str, - region_to_str}; +use util::ppaux::{note_and_explain_region, ty_to_str, region_to_str}; use middle::pat_util; +use core::result; +use core::uint; use syntax::ast::{ManagedSigil, OwnedSigil, BorrowedSigil}; use syntax::ast::{def_arg, def_binding, def_local, def_self, def_upvar}; use syntax::ast; @@ -789,6 +790,8 @@ pub mod guarantor { use syntax::codemap::span; use util::ppaux::{ty_to_str}; + use core::uint; + pub fn for_addr_of(rcx: @mut Rcx, expr: @ast::expr, base: @ast::expr) { /*! * Computes the guarantor for an expression `&base` and then diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs index 67d7b064115..37497e9a2bb 100644 --- a/src/librustc/middle/typeck/check/vtable.rs +++ b/src/librustc/middle/typeck/check/vtable.rs @@ -26,6 +26,8 @@ use util::ppaux::tys_to_str; use util::ppaux; use core::hashmap::HashSet; +use core::result; +use core::uint; use syntax::ast; use syntax::ast_util; use syntax::codemap::span; diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index 14a4034c6bb..f9aa01c0956 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -54,9 +54,11 @@ use syntax::visit::{Visitor, SimpleVisitor}; use syntax::visit::{visit_mod}; use util::ppaux::ty_to_str; -use core::result::Ok; use core::hashmap::{HashMap, HashSet}; +use core::old_iter; +use core::result::Ok; use core::uint; +use core::vec; pub struct UniversalQuantificationResult { monotype: t, diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index b3b59c2fc9e..a2c1211c5c4 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -47,6 +47,8 @@ use util::common::pluralize; use util::ppaux; use util::ppaux::UserString; +use core::result; +use core::vec; use syntax::abi::AbiSet; use syntax::ast::{RegionTyParamBound, TraitTyParamBound}; use syntax::ast; diff --git a/src/librustc/middle/typeck/infer/combine.rs b/src/librustc/middle/typeck/infer/combine.rs index d07752ee20a..f0fe4891807 100644 --- a/src/librustc/middle/typeck/infer/combine.rs +++ b/src/librustc/middle/typeck/infer/combine.rs @@ -68,6 +68,7 @@ use middle::typeck::infer::{cres, InferCtxt, ures}; use util::common::indent; use core::result::{iter_vec2, map_vec2}; +use core::vec; use syntax::ast::{Onceness, purity}; use syntax::ast; use syntax::opt_vec; diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs index f2371e927b8..6a1fd05baf7 100644 --- a/src/librustc/middle/typeck/infer/mod.rs +++ b/src/librustc/middle/typeck/infer/mod.rs @@ -267,6 +267,8 @@ use middle::typeck::isr_alist; use util::common::indent; use util::ppaux::{bound_region_to_str, ty_to_str, trait_ref_to_str}; +use core::result; +use core::vec; use extra::list::Nil; use extra::smallintmap::SmallIntMap; use syntax::ast::{m_imm, m_mutbl}; diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs index 217d9716f7d..ea0bdc68ac2 100644 --- a/src/librustc/middle/typeck/infer/resolve.rs +++ b/src/librustc/middle/typeck/infer/resolve.rs @@ -58,6 +58,7 @@ use middle::typeck::infer::unify::Root; use util::common::{indent, indenter}; use util::ppaux::ty_to_str; +use core::vec; use syntax::ast; pub static resolve_nested_tvar: uint = 0b0000000001; diff --git a/src/librustc/middle/typeck/infer/to_str.rs b/src/librustc/middle/typeck/infer/to_str.rs index 888339b707d..ef3b837e98a 100644 --- a/src/librustc/middle/typeck/infer/to_str.rs +++ b/src/librustc/middle/typeck/infer/to_str.rs @@ -18,6 +18,8 @@ use middle::typeck::infer::InferCtxt; use middle::typeck::infer::unify::{Redirect, Root, VarValue}; use util::ppaux::{mt_to_str, ty_to_str, trait_ref_to_str}; +use core::str; +use core::uint; use syntax::ast; pub trait InferStr { diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index b75654e7251..5cb4928d514 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -59,6 +59,7 @@ use util::ppaux::Repr; use util::ppaux; use core::hashmap::HashMap; +use core::result; use extra::list::List; use extra::list; use syntax::codemap::span; diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs index 1f787e14f18..709d631de11 100644 --- a/src/librustc/middle/typeck/rscope.rs +++ b/src/librustc/middle/typeck/rscope.rs @@ -12,6 +12,7 @@ use core::prelude::*; use middle::ty; +use core::result; use syntax::ast; use syntax::codemap::span; use syntax::opt_vec::OptVec; diff --git a/src/librustc/rustc.rc b/src/librustc/rustc.rc index 019ca2a0ed5..07056a10f3a 100644 --- a/src/librustc/rustc.rc +++ b/src/librustc/rustc.rc @@ -34,6 +34,12 @@ extern mod std(name = "extra", vers = "0.7-pre"); #[cfg(not(stage0))] extern mod std(name = "std", vers = "0.7-pre"); +// For bootstrapping purposes. +#[cfg(stage0)] +pub use core::str; +#[cfg(stage0)] +pub use core::unstable; + use core::prelude::*; use driver::driver::{host_triple, optgroups, early_error}; @@ -44,6 +50,13 @@ use driver::driver::{compile_input}; use driver::session; use middle::lint; +use core::io; +use core::os; +use core::result; +use core::str; +use core::task; +use core::uint; +use core::vec; use extra::getopts::{groups, opt_present}; use extra::getopts; use syntax::codemap; @@ -148,6 +161,18 @@ pub mod lib { pub mod llvm; } +// A curious inner module that allows ::std::foo to be available in here for +// macros. +mod std { + pub use core::cmp; + pub use core::os; + pub use core::str; + pub use core::sys; + pub use core::to_bytes; + pub use core::unstable; + pub use extra::serialize; +} + pub fn version(argv0: &str) { let mut vers = ~"unknown version"; let env_vers = env!("CFG_VERSION"); diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index cbf1d0df09f..a44c409aa33 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -15,6 +15,8 @@ use syntax::codemap::{span}; use syntax::visit; use core::hashmap::HashSet; +use core::io; +use core::str; use extra; pub fn time<T>(do_it: bool, what: ~str, thunk: &fn() -> T) -> T { diff --git a/src/librustc/util/enum_set.rs b/src/librustc/util/enum_set.rs index 6534a7ba9b0..4e9b7cf00a0 100644 --- a/src/librustc/util/enum_set.rs +++ b/src/librustc/util/enum_set.rs @@ -98,6 +98,7 @@ impl<E:CLike> BitAnd<EnumSet<E>, EnumSet<E>> for EnumSet<E> { mod test { use core::prelude::*; + use core::cast; use core::iter; use util::enum_set::*; diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 8694c0e356e..dcf631f0f7b 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -31,6 +31,9 @@ use syntax::codemap::span; use syntax::print::pprust; use syntax::{ast, ast_util}; +use core::str; +use core::vec; + /// Produces a string suitable for debugging output. pub trait Repr { fn repr(&self, tcx: ctxt) -> ~str; diff --git a/src/librustdoc/astsrv.rs b/src/librustdoc/astsrv.rs index 21ce70e7f5f..23810748b43 100644 --- a/src/librustdoc/astsrv.rs +++ b/src/librustdoc/astsrv.rs @@ -23,6 +23,8 @@ use parse; use core::cell::Cell; use core::comm::{stream, SharedChan, Port}; +use core::task; +use core::vec; use rustc::driver::driver; use rustc::driver::session::Session; use rustc::driver::session::{basic_options, options}; diff --git a/src/librustdoc/attr_parser.rs b/src/librustdoc/attr_parser.rs index 717b49dfe26..d2d9ec7d79b 100644 --- a/src/librustdoc/attr_parser.rs +++ b/src/librustdoc/attr_parser.rs @@ -17,6 +17,7 @@ an AST's attributes. use core::prelude::*; +use core::str; use syntax::ast; use syntax::attr; diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs index 1e6d6d7bd89..a1dad7d17f8 100644 --- a/src/librustdoc/attr_pass.rs +++ b/src/librustdoc/attr_pass.rs @@ -27,6 +27,7 @@ use fold::Fold; use fold; use pass::Pass; +use core::vec; use syntax::ast; use syntax::ast_map; diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index 603ce0de67d..4beb8583bae 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -11,9 +11,12 @@ use core::prelude::*; use core::cell::Cell; -use core::run; -use core::run::ProcessOutput; +use core::os; use core::result::Result; +use core::result; +use core::run::ProcessOutput; +use core::run; +use core::vec; use extra::getopts; /// The type of document to output @@ -243,7 +246,9 @@ pub fn maybe_find_pandoc( #[cfg(test)] mod test { use core::prelude::*; + use config::*; + use core::result; use core::run::ProcessOutput; fn parse_config(args: &[~str]) -> Result<Config, ~str> { diff --git a/src/librustdoc/desc_to_brief_pass.rs b/src/librustdoc/desc_to_brief_pass.rs index 972299d35f0..7a3ab259b1d 100644 --- a/src/librustdoc/desc_to_brief_pass.rs +++ b/src/librustdoc/desc_to_brief_pass.rs @@ -24,7 +24,9 @@ use fold::Fold; use fold; use pass::Pass; +use core::str; use core::util; +use core::vec; pub fn mk_pass() -> Pass { Pass { diff --git a/src/librustdoc/doc.rs b/src/librustdoc/doc.rs index b383a41a91c..2d5f60e714b 100644 --- a/src/librustdoc/doc.rs +++ b/src/librustdoc/doc.rs @@ -14,6 +14,8 @@ use core::prelude::*; use doc; +use core::vec; + pub type AstId = int; #[deriving(Eq)] diff --git a/src/librustdoc/extract.rs b/src/librustdoc/extract.rs index 3ef907d819d..3303a79d1b2 100644 --- a/src/librustdoc/extract.rs +++ b/src/librustdoc/extract.rs @@ -16,6 +16,8 @@ use astsrv; use doc::ItemUtils; use doc; +use core::local_data::local_data_get; +use core::vec; use syntax::ast; use syntax::parse::token::{ident_interner}; use syntax::parse::token; diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs index 5bd394215a9..bd999b637c2 100644 --- a/src/librustdoc/fold.rs +++ b/src/librustdoc/fold.rs @@ -14,6 +14,8 @@ use doc; #[cfg(test)] use extract; #[cfg(test)] use parse; +use core::vec; + pub struct Fold<T> { ctxt: T, fold_doc: FoldDoc<T>, diff --git a/src/librustdoc/markdown_index_pass.rs b/src/librustdoc/markdown_index_pass.rs index 289aa33f67c..87a73f5c9d3 100644 --- a/src/librustdoc/markdown_index_pass.rs +++ b/src/librustdoc/markdown_index_pass.rs @@ -22,6 +22,8 @@ use markdown_pass; use markdown_writer; use pass::Pass; +use core::str; + pub fn mk_pass(config: config::Config) -> Pass { Pass { name: ~"markdown_index", diff --git a/src/librustdoc/markdown_pass.rs b/src/librustdoc/markdown_pass.rs index a3ad8d8d04d..d34aa7c9955 100644 --- a/src/librustdoc/markdown_pass.rs +++ b/src/librustdoc/markdown_pass.rs @@ -23,6 +23,8 @@ use pass::Pass; use sort_pass; use core::cell::Cell; +use core::str; +use core::vec; use syntax; pub fn mk_pass(writer_factory: WriterFactory) -> Pass { @@ -539,6 +541,8 @@ mod test { use tystr_pass; use unindent_pass; + use core::str; + fn render(source: ~str) -> ~str { let (srv, doc) = create_doc_srv(source); let markdown = write_markdown_str_srv(srv, doc); diff --git a/src/librustdoc/markdown_writer.rs b/src/librustdoc/markdown_writer.rs index 973326b10dc..86b51dfabf0 100644 --- a/src/librustdoc/markdown_writer.rs +++ b/src/librustdoc/markdown_writer.rs @@ -14,8 +14,15 @@ use config; use doc::ItemUtils; use doc; -use core::run; use core::comm::*; +use core::comm; +use core::io; +use core::libc; +use core::os; +use core::result; +use core::run; +use core::str; +use core::task; use extra::future; pub enum WriteInstr { diff --git a/src/librustdoc/page_pass.rs b/src/librustdoc/page_pass.rs index 581bc742eb9..29a6765f16d 100644 --- a/src/librustdoc/page_pass.rs +++ b/src/librustdoc/page_pass.rs @@ -27,6 +27,7 @@ use pass::Pass; use util::NominalOp; use core::comm::*; +use core::task; use syntax::ast; #[cfg(test)] use doc::PageUtils; diff --git a/src/librustdoc/pass.rs b/src/librustdoc/pass.rs index 95998ba1358..8a51339c896 100644 --- a/src/librustdoc/pass.rs +++ b/src/librustdoc/pass.rs @@ -10,6 +10,8 @@ use core::prelude::*; +use core::vec; + use astsrv; use doc; use time; diff --git a/src/librustdoc/rustdoc.rc b/src/librustdoc/rustdoc.rc index d4a25f6eb8b..7ed5d5f5516 100644 --- a/src/librustdoc/rustdoc.rc +++ b/src/librustdoc/rustdoc.rc @@ -66,6 +66,15 @@ pub mod escape_pass; pub mod prune_private_pass; pub mod util; +mod std { + pub use core::clone; + pub use core::cmp; + pub use core::os; + pub use core::str; + pub use core::sys; + pub use core::unstable; +} + pub fn main() { let args = os::args(); diff --git a/src/librustdoc/sectionalize_pass.rs b/src/librustdoc/sectionalize_pass.rs index ed069b5ed56..1a475879fc1 100644 --- a/src/librustdoc/sectionalize_pass.rs +++ b/src/librustdoc/sectionalize_pass.rs @@ -19,6 +19,8 @@ use fold::Fold; use fold; use pass::Pass; +use core::str; + pub fn mk_pass() -> Pass { Pass { name: ~"sectionalize", @@ -170,6 +172,9 @@ mod test { use extract; use sectionalize_pass::run; + use core::str; + use core::vec; + fn mk_doc(source: ~str) -> doc::Doc { do astsrv::from_str(copy source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); diff --git a/src/librustdoc/text_pass.rs b/src/librustdoc/text_pass.rs index 61f66c43521..7e5444af05c 100644 --- a/src/librustdoc/text_pass.rs +++ b/src/librustdoc/text_pass.rs @@ -149,6 +149,8 @@ mod test { use sectionalize_pass; use text_pass::mk_pass; + use core::str; + fn mk_doc(source: ~str) -> doc::Doc { do astsrv::from_str(copy source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs index 716784c51c5..57a45d3dcc2 100644 --- a/src/librustdoc/tystr_pass.rs +++ b/src/librustdoc/tystr_pass.rs @@ -21,6 +21,7 @@ use fold::Fold; use fold; use pass::Pass; +use core::vec; use syntax::ast; use syntax::print::pprust; use syntax::ast_map; diff --git a/src/librustdoc/unindent_pass.rs b/src/librustdoc/unindent_pass.rs index ef34de113cf..e78edf1fbf3 100644 --- a/src/librustdoc/unindent_pass.rs +++ b/src/librustdoc/unindent_pass.rs @@ -21,6 +21,10 @@ middle of a line, and each of the following lines is indented. use core::prelude::*; +use core::str; +use core::task; +use core::uint; +use core::vec; use pass::Pass; use text_pass; diff --git a/src/librusti/rusti.rc b/src/librusti/rusti.rc index 9486d9d1ffc..d17379a2193 100644 --- a/src/librusti/rusti.rc +++ b/src/librusti/rusti.rc @@ -223,7 +223,7 @@ fn compile_crate(src_filename: ~str, binary: ~str) -> Option<bool> { None => { }, } if (should_compile) { - io::println(fmt!("compiling %s...", src_filename)); + println(fmt!("compiling %s...", src_filename)); driver::compile_upto(sess, cfg, &input, driver::cu_everything, Some(outputs)); true @@ -271,7 +271,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer, //rl::clear(); } ~"help" => { - io::println( + println( ~":{\\n ..lines.. \\n:}\\n - execute multiline command\n" + ":load <crate> ... - \ loads given crates as dynamic libraries\n" + @@ -305,9 +305,9 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer, } } if loaded_crates.is_empty() { - io::println("no crates loaded"); + println("no crates loaded"); } else { - io::println(fmt!("crates loaded: %s", + println(fmt!("crates loaded: %s", str::connect(loaded_crates, ", "))); } } @@ -328,7 +328,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer, } action = action_run_line(multiline_cmd); } - _ => io::println(~"unknown cmd: " + cmd) + _ => println(~"unknown cmd: " + cmd) } return action; } @@ -394,9 +394,9 @@ pub fn main() { // only print this stuff if the user is actually typing into rusti if istty { - io::println("WARNING: The Rust REPL is experimental and may be"); - io::println("unstable. If you encounter problems, please use the"); - io::println("compiler instead. Type :help for help."); + println("WARNING: The Rust REPL is experimental and may be"); + println("unstable. If you encounter problems, please use the"); + println("compiler instead. Type :help for help."); unsafe { do rl::complete |line, suggest| { @@ -416,7 +416,7 @@ pub fn main() { Some(line) => { if line.is_empty() { if istty { - io::println("()"); + println("()"); } loop; } diff --git a/src/librusti/wrapper.rs b/src/librusti/wrapper.rs index 9c3026f0915..664e5e3b246 100644 --- a/src/librusti/wrapper.rs +++ b/src/librusti/wrapper.rs @@ -26,5 +26,5 @@ extern mod std; fn print<T>(result: T) { - io::println(fmt!("%?", result)); + println(fmt!("%?", result)); } diff --git a/src/librustpkg/path_util.rs b/src/librustpkg/path_util.rs index 700b3338a3a..2fca0419629 100644 --- a/src/librustpkg/path_util.rs +++ b/src/librustpkg/path_util.rs @@ -11,10 +11,12 @@ // rustpkg utilities having to do with paths and directories use core::prelude::*; + pub use util::{PkgId, RemotePath, LocalPath}; +pub use util::{normalize, OutputType, Main, Lib, Bench, Test}; use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR}; use core::os::mkdir_recursive; -pub use util::{normalize, OutputType, Main, Lib, Bench, Test}; +use core::os; /// Returns the value of RUST_PATH, as a list /// of Paths. In general this should be read from the diff --git a/src/librustpkg/rustpkg.rc b/src/librustpkg/rustpkg.rc index ae4bfc6bc4b..6b560541e52 100644 --- a/src/librustpkg/rustpkg.rc +++ b/src/librustpkg/rustpkg.rc @@ -21,7 +21,7 @@ #[no_std]; extern mod core(name = "std"); -extern mod std(name = "extra"); +extern mod extra(name = "extra"); extern mod rustc; extern mod syntax; @@ -32,7 +32,7 @@ pub use core::path::Path; use core::hashmap::HashMap; use rustc::driver::{driver, session}; use rustc::metadata::filesearch; -use std::{getopts}; +use extra::{getopts}; use syntax::{ast, diagnostic}; use util::*; use path_util::{build_pkg_id_in_workspace, pkgid_src_in_workspace, u_rwx}; @@ -51,6 +51,15 @@ mod workspace; pub mod usage; +mod std { + pub use core::cmp; + pub use core::condition; + pub use core::os; + pub use core::str; + pub use core::sys; + pub use core::unstable; +} + /// A PkgScript represents user-supplied custom logic for /// special build hooks. This only exists for packages with /// an explicit package script. diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs index 6a69eb71eaf..9499430ef4c 100644 --- a/src/librustpkg/tests.rs +++ b/src/librustpkg/tests.rs @@ -12,8 +12,11 @@ use context::Ctx; use core::hashmap::HashMap; +use core::io; +use core::os; use core::prelude::*; -use std::tempfile::mkdtemp; +use core::result; +use extra::tempfile::mkdtemp; use util::{PkgId, default_version}; use path_util::{target_executable_in_workspace, target_library_in_workspace, target_test_in_workspace, target_bench_in_workspace, diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs index 80533b2d3b1..8019b3b8afb 100644 --- a/src/librustpkg/util.rs +++ b/src/librustpkg/util.rs @@ -15,9 +15,9 @@ use core::hash::Streaming; use core::rt::io::Writer; use rustc::driver::{driver, session}; use rustc::metadata::filesearch; -use std::getopts::groups::getopts; -use std::semver; -use std::term; +use extra::getopts::groups::getopts; +use extra::semver; +use extra::term; use syntax::ast_util::*; use syntax::codemap::{dummy_sp, spanned, dummy_spanned}; use syntax::ext::base::ExtCtxt; 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; diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index 2d4bc9a8c49..2b8d8cb3d31 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -10,6 +10,7 @@ use core::prelude::*; +use core::str; use core::to_bytes; #[deriving(Eq)] diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index e3ef56541b8..48c2df5a894 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -22,7 +22,10 @@ use print::pprust; use visit; use syntax::parse::token::special_idents; +use core::cmp; use core::hashmap::HashMap; +use core::str; +use core::vec; pub enum path_elt { path_mod(ident), diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index ba56d544880..c8cac4ba2d7 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -14,11 +14,14 @@ use ast::*; use ast; use ast_util; use codemap::{span, spanned}; +use opt_vec; use parse::token; use visit; -use opt_vec; -use core::hashmap::HashMap; +use core::hashmap::HashMap; +use core::int; +use core::option; +use core::str; use core::to_bytes; pub fn path_name_i(idents: &[ident], intr: @token::ident_interner) -> ~str { diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 6ac743d3844..2da64563159 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -20,6 +20,7 @@ use diagnostic::span_handler; use parse::comments::{doc_comment_style, strip_doc_comment_decoration}; use core::hashmap::HashSet; +use core::vec; use extra; /* Constructors */ diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 42117e3b73c..aedf30127ad 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -23,7 +23,10 @@ source code snippets, etc. use core::prelude::*; +use core::cmp; +use core::str; use core::to_bytes; +use core::uint; use extra::serialize::{Encodable, Decodable, Encoder, Decoder}; pub trait Pos { diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 0057579c9b7..76ede098ac3 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -13,6 +13,10 @@ use core::prelude::*; use codemap::{Pos, span}; use codemap; +use core::io; +use core::str; +use core::uint; +use core::vec; use extra::term; pub type Emitter = @fn(cmsp: Option<(@codemap::CodeMap, span)>, diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index 05ac87adcc5..874c10fae5f 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -21,6 +21,9 @@ use ext::base::*; use parse; use parse::token; +use core::str; +use core::vec; + enum State { Asm, Outputs, diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 311636ee7c1..a9b12c16b31 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -20,6 +20,7 @@ use parse; use parse::token; use core::hashmap::HashMap; +use core::vec; // new-style macro! tt code: // diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index d1f1c4187d5..4ae4533956e 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -15,15 +15,17 @@ encodable.rs for more. use core::prelude::*; -use ast; use ast::*; +use ast; +use ast_util; +use codemap::{span, spanned}; use ext::base::ExtCtxt; use ext::build::AstBuilder; use ext::deriving::*; -use codemap::{span, spanned}; -use ast_util; use opt_vec; +use core::uint; + pub fn expand_deriving_decodable( cx: @ExtCtxt, span: span, diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs index e250f970e62..d4b3488cc4f 100644 --- a/src/libsyntax/ext/deriving/generic.rs +++ b/src/libsyntax/ext/deriving/generic.rs @@ -173,6 +173,9 @@ use ext::deriving::*; use codemap::{span,respan}; use opt_vec; +use core::uint; +use core::vec; + pub use self::ty::*; mod ty; diff --git a/src/libsyntax/ext/deriving/iter_bytes.rs b/src/libsyntax/ext/deriving/iter_bytes.rs index 401b91227fc..64ce6dfbc19 100644 --- a/src/libsyntax/ext/deriving/iter_bytes.rs +++ b/src/libsyntax/ext/deriving/iter_bytes.rs @@ -16,6 +16,8 @@ use ext::base::ExtCtxt; use ext::build::AstBuilder; use ext::deriving::generic::*; +use core::vec; + pub fn expand_deriving_iter_bytes(cx: @ExtCtxt, span: span, mitem: @meta_item, diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index 3159b6db0af..796ccd304ff 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -28,6 +28,9 @@ use codemap::span; use parse::token::special_idents::clownshoes_extensions; use opt_vec; +use core::uint; +use core::vec; + pub mod clone; pub mod iter_bytes; pub mod encodable; diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs index d62e4972fd1..b2e039786ad 100644 --- a/src/libsyntax/ext/deriving/rand.rs +++ b/src/libsyntax/ext/deriving/rand.rs @@ -17,6 +17,8 @@ use ext::base::ExtCtxt; use ext::build::{AstBuilder, Duplicate}; use ext::deriving::generic::*; +use core::vec; + pub fn expand_deriving_rand(cx: @ExtCtxt, span: span, mitem: @meta_item, diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs index 3e5fb939f62..4d074b4d0e6 100644 --- a/src/libsyntax/ext/env.rs +++ b/src/libsyntax/ext/env.rs @@ -22,6 +22,8 @@ use ext::base::*; use ext::base; use ext::build::AstBuilder; +use core::os; + pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> base::MacResult { diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 7fa235fc334..89ed9b7294d 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -24,6 +24,8 @@ use fold::*; use parse; use parse::{parse_item_from_source_str}; +use core::vec; + pub fn expand_expr(extsbox: @mut SyntaxEnv, cx: @ExtCtxt, e: &expr_, diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs index 2efed5780b4..65b29ecaa91 100644 --- a/src/libsyntax/ext/fmt.rs +++ b/src/libsyntax/ext/fmt.rs @@ -22,7 +22,9 @@ use ext::base::*; use ext::base; use ext::build::AstBuilder; +use core::option; use core::unstable::extfmt::ct::*; +use core::vec; pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> base::MacResult { @@ -52,8 +54,11 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span, -> @ast::expr { fn make_path_vec(cx: @ExtCtxt, ident: &str) -> ~[ast::ident] { let intr = cx.parse_sess().interner; - return ~[intr.intern("unstable"), intr.intern("extfmt"), - intr.intern("rt"), intr.intern(ident)]; + return ~[intr.intern("std"), + intr.intern("unstable"), + intr.intern("extfmt"), + intr.intern("rt"), + intr.intern(ident)]; } fn make_rt_path_expr(cx: @ExtCtxt, sp: span, nm: &str) -> @ast::expr { let path = make_path_vec(cx, nm); @@ -252,6 +257,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span, /* 'ident' is the local buffer building up the result of fmt! */ let ident = cx.parse_sess().interner.intern("__fmtbuf"); let buf = || cx.expr_ident(fmt_sp, ident); + let core_ident = cx.parse_sess().interner.intern("std"); let str_ident = cx.parse_sess().interner.intern("str"); let push_ident = cx.parse_sess().interner.intern("push_str"); let mut stms = ~[]; @@ -273,7 +279,9 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span, } else { let args = ~[cx.expr_mut_addr_of(fmt_sp, buf()), cx.expr_str(fmt_sp, s)]; let call = cx.expr_call_global(fmt_sp, - ~[str_ident, push_ident], + ~[core_ident, + str_ident, + push_ident], args); stms.push(cx.stmt_expr(call)); } diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs index 423ade835a0..95cf4a18ab4 100644 --- a/src/libsyntax/ext/log_syntax.rs +++ b/src/libsyntax/ext/log_syntax.rs @@ -16,6 +16,9 @@ use ext::base::*; use ext::base; use print; +use core::io; +use core::vec; + pub fn expand_syntax_ext(cx: @ExtCtxt, sp: codemap::span, tt: &[ast::token_tree]) diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs index da59059a0cc..37d5e0206cb 100644 --- a/src/libsyntax/ext/pipes/ast_builder.rs +++ b/src/libsyntax/ext/pipes/ast_builder.rs @@ -19,6 +19,9 @@ use ast::ident; use ast; use codemap::span; +use core::str; +use core::vec; + // Transitional reexports so qquote can find the paths it is looking for mod syntax { pub use ext; diff --git a/src/libsyntax/ext/pipes/liveness.rs b/src/libsyntax/ext/pipes/liveness.rs index f1f5a7f12b2..43bcb68b8e0 100644 --- a/src/libsyntax/ext/pipes/liveness.rs +++ b/src/libsyntax/ext/pipes/liveness.rs @@ -42,6 +42,7 @@ use core::prelude::*; use ext::base::ExtCtxt; use ext::pipes::proto::{protocol_}; +use core::str; use extra::bitv::Bitv; pub fn analyze(proto: @mut protocol_, _cx: @ExtCtxt) { diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index e55ecbc29bc..db0efdd7b0f 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -23,6 +23,9 @@ use ext::quote::rt::*; use opt_vec; use opt_vec::OptVec; +use core::str; +use core::vec; + pub trait gen_send { fn gen_send(&mut self, cx: @ExtCtxt, try: bool) -> @ast::item; fn to_ty(&mut self, cx: @ExtCtxt) -> @ast::Ty; diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 9a5645a5b0c..9182b99bf30 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -19,6 +19,8 @@ use parse::token::*; use parse::token; use parse; +use core::vec; + /** * * Quasiquoting works via token trees. diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs index 73b84c2a5ab..8a60b239b89 100644 --- a/src/libsyntax/ext/source_util.rs +++ b/src/libsyntax/ext/source_util.rs @@ -20,6 +20,11 @@ use ext::build::AstBuilder; use parse; use print::pprust; +use core::io; +use core::result; +use core::str; +use core::vec; + // These macros all relate to the file system; they either return // the column/row/filename of the expression, or they include // a given file into the current one. diff --git a/src/libsyntax/ext/trace_macros.rs b/src/libsyntax/ext/trace_macros.rs index f899004de5c..111e176d4c5 100644 --- a/src/libsyntax/ext/trace_macros.rs +++ b/src/libsyntax/ext/trace_macros.rs @@ -18,6 +18,8 @@ use parse::lexer::{new_tt_reader, reader}; use parse::parser::Parser; use parse::token::keywords; +use core::vec; + pub fn expand_trace_macros(cx: @ExtCtxt, sp: span, tt: &[ast::token_tree]) diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index be79722373b..183bc2a77c5 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -23,6 +23,9 @@ use parse::token::{Token, EOF, to_str, nonterminal}; use parse::token; use core::hashmap::HashMap; +use core::str; +use core::uint; +use core::vec; /* This is an Earley-like parser, without support for in-grammar nonterminals, only by calling out to the main rust parser for named nonterminals (which it diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 04ac311579f..261943132b3 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -26,6 +26,7 @@ use parse::token::{FAT_ARROW, SEMI, nt_matchers, nt_tt}; use print; use core::io; +use core::vec; pub fn add_new_extension(cx: @ExtCtxt, sp: span, diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 3e63360fbec..cac963727e3 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -19,6 +19,8 @@ use parse::token::{EOF, INTERPOLATED, IDENT, Token, nt_ident, ident_interner}; use parse::lexer::TokenAndSpan; use core::hashmap::HashMap; +use core::option; +use core::vec; ///an unzipping of `token_tree`s struct TtFrame { diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 0d863c736ed..27a10c36ead 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -15,6 +15,8 @@ use ast; use codemap::{span, spanned}; use opt_vec::OptVec; +use core::vec; + pub trait ast_fold { fn fold_crate(@self, &crate) -> crate; fn fold_view_item(@self, @view_item) -> @view_item; diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index 3fa0fa3b0f0..001a693d1ae 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -20,6 +20,10 @@ use parse::lexer; use parse::token; use parse; +use core::io; +use core::str; +use core::uint; + #[deriving(Eq)] pub enum cmnt_style { isolated, // No code on either side of each line of the comment diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index eabe664d8ef..4a9ef2faa54 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -18,6 +18,11 @@ use ext::tt::transcribe::{tt_next_token}; use ext::tt::transcribe::{dup_tt_reader}; use parse::token; +use core::char; +use core::either; +use core::str; +use core::u64; + pub use ext::tt::transcribe::{TtReader, new_tt_reader}; pub trait reader { diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 9a8001386ab..085d24d7e68 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -26,6 +26,7 @@ use parse::parser::Parser; use parse::token::{keywords, Token}; use parse::token; +use core::str; use core::to_bytes; /// The specific types of unsupported syntax diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index de93bb3712b..27dfc2c0a46 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -92,9 +92,11 @@ use parse::{new_sub_parser_from_file, next_node_id, ParseSess}; use opt_vec; use opt_vec::OptVec; +use core::char; use core::either::Either; use core::either; use core::hashmap::HashSet; +use core::str; use core::vec; #[deriving(Eq)] diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index a4b3783f22d..b1a385ada07 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -16,8 +16,14 @@ use parse::token; use util::interner::StrInterner; use util::interner; +use core::cast; +use core::char; use core::cmp::Equiv; +use core::hashmap::HashSet; +use core::local_data; +use core::str; use core::to_bytes; +use core::vec; #[deriving(Encodable, Decodable, Eq)] pub enum binop { diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index d3b5c751e69..11830dc3c29 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -63,6 +63,9 @@ use core::prelude::*; +use core::io; +use core::vec; + #[deriving(Eq)] pub enum breaks { consistent, inconsistent, } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 5f814cc3576..6a32e535295 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -29,6 +29,13 @@ use print::pp::{breaks, consistent, inconsistent, eof}; use print::pp; use print::pprust; +use core::char; +use core::io; +use core::str; +use core::u64; +use core::uint; +use core::vec; + // The @ps is stored here to prevent recursive type. pub enum ann_node<'self> { node_block(@ps, &'self ast::blk), diff --git a/src/libsyntax/syntax.rc b/src/libsyntax/syntax.rc index cb1c2269c1e..78fbcab213c 100644 --- a/src/libsyntax/syntax.rc +++ b/src/libsyntax/syntax.rc @@ -35,6 +35,12 @@ extern mod std(name = "extra"); #[cfg(not(stage0))] extern mod std(name = "std"); +// For bootstrapping purposes. +#[cfg(stage0)] +pub use core::str; +#[cfg(stage0)] +pub use core::unstable; + use core::prelude::*; pub mod util { diff --git a/src/test/auxiliary/anon-extern-mod-cross-crate-1.rs b/src/test/auxiliary/anon-extern-mod-cross-crate-1.rs index bccbb8173aa..77f257ea4f5 100644 --- a/src/test/auxiliary/anon-extern-mod-cross-crate-1.rs +++ b/src/test/auxiliary/anon-extern-mod-cross-crate-1.rs @@ -14,6 +14,10 @@ vers = "0.1")]; #[crate_type = "lib"]; + +use std::libc; + extern { - fn rust_get_argc() -> libc::c_int; + pub fn rust_get_argc() -> libc::c_int; } + diff --git a/src/test/auxiliary/cci_capture_clause.rs b/src/test/auxiliary/cci_capture_clause.rs index 13cc27e0e27..e58b28aa3de 100644 --- a/src/test/auxiliary/cci_capture_clause.rs +++ b/src/test/auxiliary/cci_capture_clause.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::comm::*; +use std::task; pub fn foo<T:Owned + Copy>(x: T) -> Port<T> { let (p, c) = stream(); diff --git a/src/test/auxiliary/cci_class_5.rs b/src/test/auxiliary/cci_class_5.rs index c04cdbcab1a..10dedc12399 100644 --- a/src/test/auxiliary/cci_class_5.rs +++ b/src/test/auxiliary/cci_class_5.rs @@ -9,6 +9,8 @@ // except according to those terms. pub mod kitties { + use std::uint; + pub struct cat { priv meows : uint, how_hungry : int, diff --git a/src/test/auxiliary/explicit_self_xcrate.rs b/src/test/auxiliary/explicit_self_xcrate.rs index 058cb53f918..be65cadcc7f 100644 --- a/src/test/auxiliary/explicit_self_xcrate.rs +++ b/src/test/auxiliary/explicit_self_xcrate.rs @@ -20,6 +20,6 @@ pub struct Bar { impl Foo for Bar { #[inline(always)] fn f(&self) { - io::println((*self).x); + println((*self).x); } } diff --git a/src/test/auxiliary/extern-crosscrate-source.rs b/src/test/auxiliary/extern-crosscrate-source.rs index 3c81c787a09..ba9091ce0e5 100644 --- a/src/test/auxiliary/extern-crosscrate-source.rs +++ b/src/test/auxiliary/extern-crosscrate-source.rs @@ -13,7 +13,11 @@ #[crate_type = "lib"]; +use std::libc; + pub mod rustrt { + use std::libc; + pub extern { pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t; diff --git a/src/test/auxiliary/foreign_lib.rs b/src/test/auxiliary/foreign_lib.rs index fe5b9e45593..f8b2c2f458a 100644 --- a/src/test/auxiliary/foreign_lib.rs +++ b/src/test/auxiliary/foreign_lib.rs @@ -11,6 +11,8 @@ #[link(name="foreign_lib", vers="0.0")]; pub mod rustrt { + use std::libc; + pub extern { pub fn rust_get_argc() -> libc::c_int; } diff --git a/src/test/auxiliary/issue-3012-1.rs b/src/test/auxiliary/issue-3012-1.rs index 36343d42b75..ce40afff3ae 100644 --- a/src/test/auxiliary/issue-3012-1.rs +++ b/src/test/auxiliary/issue-3012-1.rs @@ -12,6 +12,8 @@ #[crate_type = "lib"]; pub mod socket { + use std::libc; + pub struct socket_handle { sockfd: libc::c_int, } diff --git a/src/test/auxiliary/moves_based_on_type_lib.rs b/src/test/auxiliary/moves_based_on_type_lib.rs index 857593a84d2..b3a9b3e1ee9 100644 --- a/src/test/auxiliary/moves_based_on_type_lib.rs +++ b/src/test/auxiliary/moves_based_on_type_lib.rs @@ -16,7 +16,7 @@ pub struct S { impl Drop for S { fn finalize(&self) { - io::println("goodbye"); + println("goodbye"); } } diff --git a/src/test/auxiliary/static-methods-crate.rs b/src/test/auxiliary/static-methods-crate.rs index 2ecd318db3c..b5b33853129 100644 --- a/src/test/auxiliary/static-methods-crate.rs +++ b/src/test/auxiliary/static-methods-crate.rs @@ -13,6 +13,8 @@ #[crate_type = "lib"]; +use std::int; + pub trait read { fn readMaybe(s: ~str) -> Option<Self>; } diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index 7904041ea3c..fd1110abb22 100644 --- a/src/test/bench/core-map.rs +++ b/src/test/bench/core-map.rs @@ -10,12 +10,15 @@ extern mod extra; -use std::io; use extra::time; use extra::treemap::TreeMap; use std::hashmap::{HashMap, HashSet}; -use std::trie::TrieMap; +use std::io; +use std::os; use std::rand::Rng; +use std::trie::TrieMap; +use std::uint; +use std::vec; fn timed(label: &str, f: &fn()) { let start = time::precise_time_s(); diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs index 86215e609ee..5281c1b863c 100644 --- a/src/test/bench/core-set.rs +++ b/src/test/bench/core-set.rs @@ -9,9 +9,14 @@ // except according to those terms. extern mod extra; -use std::hashmap::HashSet; + use extra::bitv::BitvSet; use extra::treemap::TreeSet; +use std::hashmap::HashSet; +use std::io; +use std::os; +use std::rand; +use std::uint; struct Results { sequential_ints: float, diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 024d4a02897..287daf68eff 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -13,8 +13,15 @@ extern mod extra; use extra::time::precise_time_s; +use std::int; +use std::io; +use std::os; use std::rand::RngUtil; +use std::rand; +use std::result; +use std::uint; use std::util; +use std::vec; macro_rules! bench ( ($id:ident) => (maybe_run_test(argv, stringify!($id).to_owned(), $id)) diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs index c637fcbaf50..cbf73d5c059 100644 --- a/src/test/bench/core-uint-to-str.rs +++ b/src/test/bench/core-uint-to-str.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::os; +use std::uint; + fn main() { let args = os::args(); let args = if os::getenv(~"RUST_BENCH").is_some() { diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index 06c8d0c145b..38cc3127343 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -23,7 +23,12 @@ use extra::deque::Deque; use extra::par; use std::hashmap::HashSet; use std::int::abs; +use std::io; +use std::os; use std::rand::RngUtil; +use std::rand; +use std::uint; +use std::vec; type node_id = i64; type graph = ~[~[node_id]]; diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index e041f607057..9fbc1d4590d 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -19,10 +19,16 @@ // version. extern mod extra; -use std::io::Writer; -use std::io::WriterUtil; use std::comm::{Port, Chan, SharedChan}; +use std::comm; +use std::io::{Writer, WriterUtil}; +use std::io; +use std::os; +use std::task; +use std::ptr; +use std::uint; +use std::vec; macro_rules! move_out ( { $x:expr } => { unsafe { let y = *ptr::to_unsafe_ptr(&($x)); y } } diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index a854de0a828..2663bb26670 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -15,10 +15,15 @@ // I *think* it's the same, more or less. extern mod extra; -use std::io::Writer; -use std::io::WriterUtil; use std::comm::{Port, PortSet, Chan, stream}; +use std::io::{Writer, WriterUtil}; +use std::io; +use std::os; +use std::ptr; +use std::task; +use std::uint; +use std::vec; macro_rules! move_out ( { $x:expr } => { unsafe { let y = *ptr::to_unsafe_ptr(&($x)); y } } diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs index ffca59e3e8f..3d3a6a68beb 100644 --- a/src/test/bench/msgsend-ring-mutex-arcs.rs +++ b/src/test/bench/msgsend-ring-mutex-arcs.rs @@ -16,26 +16,35 @@ // This also serves as a pipes test, because ARCs are implemented with pipes. extern mod extra; -use extra::time; + use extra::arc; use extra::future; +use extra::time; use std::cell::Cell; +use std::io; +use std::os; +use std::uint; +use std::vec; // A poor man's pipe. type pipe = arc::MutexARC<~[uint]>; fn send(p: &pipe, msg: uint) { - do p.access_cond |state, cond| { - state.push(msg); - cond.signal(); + unsafe { + do p.access_cond |state, cond| { + state.push(msg); + cond.signal(); + } } } fn recv(p: &pipe) -> uint { - do p.access_cond |state, cond| { - while vec::is_empty(*state) { - cond.wait(); + unsafe { + do p.access_cond |state, cond| { + while vec::is_empty(*state) { + cond.wait(); + } + state.pop() } - state.pop() } } diff --git a/src/test/bench/msgsend-ring-pipes.rs b/src/test/bench/msgsend-ring-pipes.rs index 7b6e94fa10b..21753f5f331 100644 --- a/src/test/bench/msgsend-ring-pipes.rs +++ b/src/test/bench/msgsend-ring-pipes.rs @@ -18,11 +18,15 @@ extern mod extra; +use extra::future; +use extra::time; use std::cell::Cell; +use std::io; +use std::os; use std::pipes::recv; +use std::ptr; +use std::uint; use std::util; -use extra::time; -use extra::future; proto! ring ( num:send { diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs index 78f7c02a40b..46ca59f2d31 100644 --- a/src/test/bench/msgsend-ring-rw-arcs.rs +++ b/src/test/bench/msgsend-ring-rw-arcs.rs @@ -17,10 +17,14 @@ extern mod extra; -use std::cell::Cell; -use extra::time; use extra::arc; use extra::future; +use extra::time; +use std::cell::Cell; +use std::io; +use std::os; +use std::uint; +use std::vec; // A poor man's pipe. type pipe = arc::RWARC<~[uint]>; diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs index cf1eae3d37b..8f39ae62f9e 100644 --- a/src/test/bench/noise.rs +++ b/src/test/bench/noise.rs @@ -1,6 +1,10 @@ // Perlin noise benchmark from https://gist.github.com/1170424 +use std::f32; +use std::float; +use std::int; use std::rand::{Rng, RngUtil}; +use std::rand; struct Vec2 { x: f32, diff --git a/src/test/bench/pingpong.rs b/src/test/bench/pingpong.rs index 970a970feb1..382de68ba57 100644 --- a/src/test/bench/pingpong.rs +++ b/src/test/bench/pingpong.rs @@ -14,9 +14,12 @@ extern mod extra; +use extra::time::precise_time_s; use std::cell::Cell; +use std::io; +use std::os; use std::pipes::*; -use extra::time::precise_time_s; +use std::task; proto! pingpong ( ping: send { diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs index 4a811305679..51fec4dbfe8 100644 --- a/src/test/bench/shootout-ackermann.rs +++ b/src/test/bench/shootout-ackermann.rs @@ -10,6 +10,10 @@ extern mod extra; +use std::int; +use std::io; +use std::os; + fn ack(m: int, n: int) -> int { if m == 0 { return n + 1 diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index 0ccb9a16ada..58b8a9cd47b 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -11,9 +11,16 @@ // chameneos extern mod extra; + use extra::sort; use std::cell::Cell; use std::comm::*; +use std::io; +use std::option; +use std::os; +use std::task; +use std::uint; +use std::vec; fn print_complements() { let all = ~[Blue, Red, Yellow]; diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs index a65bfe228b2..1dd346a2813 100644 --- a/src/test/bench/shootout-fannkuch-redux.rs +++ b/src/test/bench/shootout-fannkuch-redux.rs @@ -1,6 +1,8 @@ use std::from_str::FromStr; use std::i32::range; +use std::os; use std::vec::MutableVector; +use std::vec; fn max(a: i32, b: i32) -> i32 { if a > b { diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index 840f6fdb17b..9ea58d9970d 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -1,8 +1,11 @@ use std::cast::transmute; use std::from_str::FromStr; use std::libc::{FILE, STDOUT_FILENO, c_int, fdopen, fputc, fputs, fwrite, size_t}; +use std::os; +use std::str; use std::uint::{min, range}; use std::vec::bytes::copy_memory; +use std::vec; static LINE_LEN: uint = 60; static LOOKUP_SIZE: uint = 4 * 1024; diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index f3de8bf01e9..78a37f06bb9 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -16,7 +16,17 @@ * http://shootout.alioth.debian.org/ */ extern mod extra; + +use std::int; +use std::io; +use std::option; +use std::os; use std::rand::Rng; +use std::rand; +use std::result; +use std::str; +use std::uint; +use std::vec; fn LINE_LENGTH() -> uint { return 60u; } diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs index cfb8e0fe7c9..a1bb0e9e6d8 100644 --- a/src/test/bench/shootout-fibo.rs +++ b/src/test/bench/shootout-fibo.rs @@ -10,6 +10,10 @@ extern mod extra; +use std::int; +use std::io; +use std::os; + fn fib(n: int) -> int { if n < 2 { return 1; diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index e0ffd3e4133..e403ba6e73d 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -12,12 +12,21 @@ // multi tasking k-nucleotide extern mod extra; + use extra::sort; +use std::cmp::Ord; +use std::comm::{stream, Port, Chan}; +use std::comm; use std::hashmap::HashMap; use std::io::ReaderUtil; -use std::comm::{stream, Port, Chan}; -use std::cmp::Ord; +use std::io; +use std::option; +use std::os; +use std::result; +use std::str; +use std::task; use std::util; +use std::vec; // given a map, print a sorted version of it fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str { diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index d4c3862fd7e..69eff07093b 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -2,6 +2,7 @@ use std::cast::transmute; use std::from_str::FromStr; use std::i32::range; use std::libc::{STDOUT_FILENO, c_int, fdopen, fputc}; +use std::os; static ITER: uint = 50; static LIMIT: f64 = 2.0; diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index a226d50dc27..744e3041c8f 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -1,5 +1,8 @@ +use std::f64; use std::from_str::FromStr; +use std::os; use std::uint::range; +use std::vec; static PI: f64 = 3.141592653589793; static SOLAR_MASS: f64 = 4.0 * PI * PI; diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index e201438a6ef..0a093d87a15 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -22,11 +22,17 @@ extern mod extra; use extra::{time, getopts}; -use std::int::range; use std::comm::*; +use std::int::range; use std::io::WriterUtil; - +use std::io; +use std::os; use std::result::{Ok, Err}; +use std::str; +use std::task; +use std::u64; +use std::uint; +use std::vec; fn fib(n: int) -> int { fn pfib(c: &Chan<int>, n: int) { diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index a3beee7c90d..77aaa2782d8 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -1,5 +1,8 @@ +use std::f64; use std::from_str::FromStr; use std::iter::ExtendedMutableIter; +use std::os; +use std::vec; #[inline] fn A(i: i32, j: i32) -> i32 { diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index f1cd05e1d9e..23ac68315e3 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -11,8 +11,12 @@ // Microbenchmark for the smallintmap library extern mod extra; + use extra::smallintmap::SmallIntMap; use std::io::WriterUtil; +use std::io; +use std::os; +use std::uint; fn append_sequential(min: uint, max: uint, map: &mut SmallIntMap<uint>) { for uint::range(min, max) |i| { diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index e3f02684bb0..dbce9d60af7 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -14,7 +14,12 @@ extern mod extra; use std::io::{ReaderUtil, WriterUtil}; use std::io; +use std::os; +use std::str; +use std::u8; +use std::uint; use std::unstable::intrinsics::cttz16; +use std::vec; // Computes a single solution to a given 9x9 sudoku // @@ -167,10 +172,10 @@ impl Colors { let val = **self & heads; if (0u16 == val) { return 0u8; - } - else - { - return cttz16(val as i16) as u8; + } else { + unsafe { + return cttz16(val as i16) as u8; + } } } diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs index a6d94c75354..a0363bd568a 100644 --- a/src/test/bench/task-perf-alloc-unwind.rs +++ b/src/test/bench/task-perf-alloc-unwind.rs @@ -14,6 +14,8 @@ extern mod extra; use extra::list::{List, Cons, Nil}; use extra::time::precise_time_s; +use std::os; +use std::task; enum UniqueList { ULNil, ULCons(~UniqueList) diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs index 4600cf46892..78923c8cc96 100644 --- a/src/test/bench/task-perf-jargon-metal-smoke.rs +++ b/src/test/bench/task-perf-jargon-metal-smoke.rs @@ -18,6 +18,10 @@ // The filename is a song reference; google it in quotes. use std::cell::Cell; +use std::comm; +use std::os; +use std::task; +use std::uint; fn child_generation(gens_left: uint, c: comm::Chan<()>) { // This used to be O(n^2) in the number of generations that ever existed. diff --git a/src/test/bench/task-perf-linked-failure.rs b/src/test/bench/task-perf-linked-failure.rs index b8cba98c6fb..514b85c6ae0 100644 --- a/src/test/bench/task-perf-linked-failure.rs +++ b/src/test/bench/task-perf-linked-failure.rs @@ -23,6 +23,10 @@ // Doesn't return until all such tasks are ready, but doesn't block forever itself. use std::comm::*; +use std::os; +use std::result; +use std::task; +use std::uint; fn grandchild_group(num_tasks: uint) { let (po, ch) = stream(); diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs index 56e981b735d..e1a5253444f 100644 --- a/src/test/bench/task-perf-one-million.rs +++ b/src/test/bench/task-perf-one-million.rs @@ -11,6 +11,10 @@ // Test for concurrent tasks use std::comm::*; +use std::os; +use std::task; +use std::uint; +use std::vec; fn calc(children: uint, parent_wait_chan: &Chan<Chan<Chan<int>>>) { diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs index e6da898a034..1a8fc7e098d 100644 --- a/src/test/bench/task-perf-spawnalot.rs +++ b/src/test/bench/task-perf-spawnalot.rs @@ -8,6 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::os; +use std::task; +use std::uint; + fn f(n: uint) { let mut i = 0u; while i < n { diff --git a/src/test/compile-fail/assign-to-method.rs b/src/test/compile-fail/assign-to-method.rs index 4993846f445..55a358a32e2 100644 --- a/src/test/compile-fail/assign-to-method.rs +++ b/src/test/compile-fail/assign-to-method.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv mut meows : uint, + priv meows : uint, how_hungry : int, } diff --git a/src/test/compile-fail/bind-by-move-no-guards.rs b/src/test/compile-fail/bind-by-move-no-guards.rs index ffc160ac111..348781d7497 100644 --- a/src/test/compile-fail/bind-by-move-no-guards.rs +++ b/src/test/compile-fail/bind-by-move-no-guards.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm; + fn main() { let (p,c) = comm::stream(); let x = Some(p); diff --git a/src/test/compile-fail/block-arg-as-stmt-with-value.rs b/src/test/compile-fail/block-arg-as-stmt-with-value.rs index 73a53d6cc98..dc90dfb2cad 100644 --- a/src/test/compile-fail/block-arg-as-stmt-with-value.rs +++ b/src/test/compile-fail/block-arg-as-stmt-with-value.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; fn compute1() -> float { let v = ~[0f, 1f, 2f, 3f]; diff --git a/src/test/compile-fail/block-must-not-have-result-for.rs b/src/test/compile-fail/block-must-not-have-result-for.rs index d1e001f722c..778309122cb 100644 --- a/src/test/compile-fail/block-must-not-have-result-for.rs +++ b/src/test/compile-fail/block-must-not-have-result-for.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + fn main() { for vec::each(~[0]) |_i| { //~ ERROR A for-loop body must return (), but true diff --git a/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs b/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs index 2ba5d0473cc..b9758e669e0 100644 --- a/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs +++ b/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs @@ -10,6 +10,8 @@ // Tests that auto-ref can't create mutable aliases to immutable memory. +use std::io; + struct Foo { x: int } diff --git a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs index 50dd815d493..1e74e91a821 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::task; + fn borrow(v: &int, f: &fn(x: &int)) { f(v); } diff --git a/src/test/compile-fail/borrowck-loan-local-as-both-mut-and-imm.rs b/src/test/compile-fail/borrowck-loan-local-as-both-mut-and-imm.rs index 9ea4fe8aef4..01ca3cd1c28 100644 --- a/src/test/compile-fail/borrowck-loan-local-as-both-mut-and-imm.rs +++ b/src/test/compile-fail/borrowck-loan-local-as-both-mut-and-imm.rs @@ -22,7 +22,7 @@ use std::either::{Either, Left, Right}; fn g() { let mut x: Either<int,float> = Left(3); - io::println(f(&mut x, &x).to_str()); //~ ERROR cannot borrow + println(f(&mut x, &x).to_str()); //~ ERROR cannot borrow } fn h() { diff --git a/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs b/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs index 061a6c553e4..443bcc92183 100644 --- a/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs +++ b/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs @@ -13,7 +13,7 @@ struct Point { y: int, } -impl ops::Add<int,int> for Point { +impl Add<int,int> for Point { fn add(&self, z: &int) -> int { self.x + self.y + (*z) } diff --git a/src/test/compile-fail/borrowck-ref-into-rvalue.rs b/src/test/compile-fail/borrowck-ref-into-rvalue.rs index 7026f06c2b7..cb56e929754 100644 --- a/src/test/compile-fail/borrowck-ref-into-rvalue.rs +++ b/src/test/compile-fail/borrowck-ref-into-rvalue.rs @@ -16,5 +16,5 @@ fn main() { }, None => { fail!() } } - io::println(*msg); + println(*msg); } diff --git a/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs b/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs index 6f669e67ec7..c02a0b4cfaf 100644 --- a/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs +++ b/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs @@ -9,5 +9,5 @@ fn a() -> &int { fn main() { let fifth = a(); - io::println(fmt!("%d", *fifth)); + println(fmt!("%d", *fifth)); } diff --git a/src/test/compile-fail/by-move-pattern-binding.rs b/src/test/compile-fail/by-move-pattern-binding.rs index dc42e28ec25..8c0cf68c164 100644 --- a/src/test/compile-fail/by-move-pattern-binding.rs +++ b/src/test/compile-fail/by-move-pattern-binding.rs @@ -17,6 +17,6 @@ fn main() { }; match &s.x { &Foo => {} - &Bar(ref identifier) => io::println(*identifier) + &Bar(ref identifier) => println(*identifier) }; } diff --git a/src/test/compile-fail/class-cast-to-trait.rs b/src/test/compile-fail/class-cast-to-trait.rs index 06627365451..8df9650d950 100644 --- a/src/test/compile-fail/class-cast-to-trait.rs +++ b/src/test/compile-fail/class-cast-to-trait.rs @@ -13,9 +13,9 @@ trait noisy { } struct cat { - priv mut meows : uint, + priv meows : uint, - mut how_hungry : int, + how_hungry : int, name : ~str, } diff --git a/src/test/compile-fail/class-missing-self.rs b/src/test/compile-fail/class-missing-self.rs index b78b065d028..4d1c22dfabe 100644 --- a/src/test/compile-fail/class-missing-self.rs +++ b/src/test/compile-fail/class-missing-self.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv mut meows : uint, + priv meows : uint, } priv impl cat { diff --git a/src/test/compile-fail/die-not-static.rs b/src/test/compile-fail/die-not-static.rs index d33c591d8c8..c7f5e271818 100644 --- a/src/test/compile-fail/die-not-static.rs +++ b/src/test/compile-fail/die-not-static.rs @@ -1,3 +1,5 @@ +use std::str; + fn main() { let v = ~"test"; let sslice = str::slice(v, 0, v.len()); diff --git a/src/test/compile-fail/drop-on-non-struct.rs b/src/test/compile-fail/drop-on-non-struct.rs index b2f87686ac6..5e422d26753 100644 --- a/src/test/compile-fail/drop-on-non-struct.rs +++ b/src/test/compile-fail/drop-on-non-struct.rs @@ -13,7 +13,7 @@ type Foo = @[u8]; impl Drop for Foo { //~ ERROR the Drop trait may only be implemented //~^ ERROR cannot provide an extension implementation fn finalize(&self) { - io::println("kaboom"); + println("kaboom"); } } diff --git a/src/test/compile-fail/explicit-call-to-dtor.rs b/src/test/compile-fail/explicit-call-to-dtor.rs index 24fedaaabe3..ce2942c3146 100644 --- a/src/test/compile-fail/explicit-call-to-dtor.rs +++ b/src/test/compile-fail/explicit-call-to-dtor.rs @@ -14,7 +14,7 @@ struct Foo { impl Drop for Foo { fn finalize(&self) { - io::println("kaboom"); + println("kaboom"); } } diff --git a/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs b/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs index fd49889a3f7..1a5eb696fa2 100644 --- a/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs +++ b/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs @@ -18,7 +18,7 @@ trait Bar : Drop { impl Drop for Foo { fn finalize(&self) { - io::println("kaboom"); + println("kaboom"); } } diff --git a/src/test/compile-fail/foreign-unsafe-fn.rs b/src/test/compile-fail/foreign-unsafe-fn.rs deleted file mode 100644 index fce269ab517..00000000000 --- a/src/test/compile-fail/foreign-unsafe-fn.rs +++ /dev/null @@ -1,23 +0,0 @@ -// -*- rust -*- -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <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. - - -mod test { - #[abi = "cdecl"] - pub extern { - pub unsafe fn free(); - } -} - -fn main() { - let x = test::free; - //~^ ERROR call to unsafe function requires unsafe function or block -} diff --git a/src/test/compile-fail/issue-2151.rs b/src/test/compile-fail/issue-2151.rs index bb6d47a4762..8f4bbe4eabc 100644 --- a/src/test/compile-fail/issue-2151.rs +++ b/src/test/compile-fail/issue-2151.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + fn main() { for vec::each(fail!()) |i| { let _ = i * 2; //~ ERROR the type of this value must be known diff --git a/src/test/compile-fail/issue-2548.rs b/src/test/compile-fail/issue-2548.rs index fdaf1f562c8..2f690008440 100644 --- a/src/test/compile-fail/issue-2548.rs +++ b/src/test/compile-fail/issue-2548.rs @@ -20,7 +20,7 @@ struct foo { impl Drop for foo { fn finalize(&self) { unsafe { - io::println("Goodbye, World!"); + println("Goodbye, World!"); *self.x += 1; } } diff --git a/src/test/compile-fail/issue-2817-2.rs b/src/test/compile-fail/issue-2817-2.rs index 17b0d88a6a8..166f7e048df 100644 --- a/src/test/compile-fail/issue-2817-2.rs +++ b/src/test/compile-fail/issue-2817-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; + fn not_bool(f: &fn(int) -> ~str) -> bool {} fn main() { diff --git a/src/test/compile-fail/issue-2817.rs b/src/test/compile-fail/issue-2817.rs index 77585d15b6b..49516831904 100644 --- a/src/test/compile-fail/issue-2817.rs +++ b/src/test/compile-fail/issue-2817.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; + fn uuid() -> uint { fail!(); } fn from_str(s: ~str) -> uint { fail!(); } diff --git a/src/test/compile-fail/issue-3044.rs b/src/test/compile-fail/issue-3044.rs index 06fb18d7e47..4cac844bdea 100644 --- a/src/test/compile-fail/issue-3044.rs +++ b/src/test/compile-fail/issue-3044.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + fn main() { let needlesArr: ~[char] = ~['a', 'f']; do vec::foldr(needlesArr) |x, y| { diff --git a/src/test/compile-fail/issue-3096-2.rs b/src/test/compile-fail/issue-3096-2.rs index eb58cf3e13b..5f3af865454 100644 --- a/src/test/compile-fail/issue-3096-2.rs +++ b/src/test/compile-fail/issue-3096-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ptr; + enum bottom { } fn main() { diff --git a/src/test/compile-fail/issue-3344.rs b/src/test/compile-fail/issue-3344.rs index e931a8fa7e1..ac5b469c56e 100644 --- a/src/test/compile-fail/issue-3344.rs +++ b/src/test/compile-fail/issue-3344.rs @@ -9,7 +9,7 @@ // except according to those terms. struct thing(uint); -impl cmp::Ord for thing { //~ ERROR missing method `gt` +impl Ord for thing { //~ ERROR missing method `gt` fn lt(&self, other: &thing) -> bool { **self < **other } fn le(&self, other: &thing) -> bool { **self < **other } fn ge(&self, other: &thing) -> bool { **self < **other } diff --git a/src/test/compile-fail/issue-3651.rs b/src/test/compile-fail/issue-3651.rs index 8d704859fe5..7e65d8ab82d 100644 --- a/src/test/compile-fail/issue-3651.rs +++ b/src/test/compile-fail/issue-3651.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::task; + fn main() { for task::spawn { return true; } //~ ERROR A `for` loop iterator should expect a closure that //~^ ERROR expected `for` closure to return `bool` diff --git a/src/test/compile-fail/issue-3820.rs b/src/test/compile-fail/issue-3820.rs index 2bd11b5111a..8fafd04d1e2 100644 --- a/src/test/compile-fail/issue-3820.rs +++ b/src/test/compile-fail/issue-3820.rs @@ -22,5 +22,5 @@ fn main() { let u = Thing {x: 2}; let _v = u.mul(&3); // This is ok let w = u * 3; //~ ERROR binary operation * cannot be applied to type `Thing` - io::println(fmt!("%i", w.x)); + println(fmt!("%i", w.x)); } diff --git a/src/test/compile-fail/issue-3953.rs b/src/test/compile-fail/issue-3953.rs index fc8e456f56b..e3af6ce78e2 100644 --- a/src/test/compile-fail/issue-3953.rs +++ b/src/test/compile-fail/issue-3953.rs @@ -31,8 +31,8 @@ impl Eq for Lol { fn main() { if Lol(2) == Lol(4) { - io::println("2 == 4"); + println("2 == 4"); } else { - io::println("2 != 4"); + println("2 != 4"); } } diff --git a/src/test/compile-fail/issue-4335.rs b/src/test/compile-fail/issue-4335.rs index 5f907b35e41..ffa11e59260 100644 --- a/src/test/compile-fail/issue-4335.rs +++ b/src/test/compile-fail/issue-4335.rs @@ -14,5 +14,5 @@ fn f<'r, T>(v: &'r T) -> &'r fn()->T { id::<&'r fn()->T>(|| *v) } //~ ERROR cann fn main() { let v = &5; - io::println(fmt!("%d", f(v)())); + println(fmt!("%d", f(v)())); } diff --git a/src/test/compile-fail/issue-511.rs b/src/test/compile-fail/issue-511.rs index a053424b30d..ed2eede76c6 100644 --- a/src/test/compile-fail/issue-511.rs +++ b/src/test/compile-fail/issue-511.rs @@ -12,10 +12,10 @@ extern mod extra; use std::cmp::Eq; fn f<T:Eq>(o: &mut Option<T>) { - assert!(*o == option::None); + assert!(*o == None); } fn main() { - f::<int>(&mut option::None); + f::<int>(&mut None); //~^ ERROR cannot borrow } diff --git a/src/test/compile-fail/kindck-implicit-close-over-mut-var.rs b/src/test/compile-fail/kindck-implicit-close-over-mut-var.rs index c2732d383ab..b21063361ab 100644 --- a/src/test/compile-fail/kindck-implicit-close-over-mut-var.rs +++ b/src/test/compile-fail/kindck-implicit-close-over-mut-var.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::task; + fn user(_i: int) {} fn foo() { diff --git a/src/test/compile-fail/lint-default-methods.rs b/src/test/compile-fail/lint-default-methods.rs index 89b99fcebca..23befde7559 100644 --- a/src/test/compile-fail/lint-default-methods.rs +++ b/src/test/compile-fail/lint-default-methods.rs @@ -1,7 +1,7 @@ #[forbid(default_methods)]; trait Foo { //~ ERROR default methods are experimental - fn bar(&self) { io::println("hi"); } + fn bar(&self) { println("hi"); } } fn main() {} diff --git a/src/test/compile-fail/lint-unused-imports.rs b/src/test/compile-fail/lint-unused-imports.rs index 201b2e9b989..4a748cc5670 100644 --- a/src/test/compile-fail/lint-unused-imports.rs +++ b/src/test/compile-fail/lint-unused-imports.rs @@ -12,6 +12,8 @@ use cal = bar::c::cc; +use std::io; + use std::either::Right; //~ ERROR unused import use std::util::*; // shouldn't get errors for not using diff --git a/src/test/compile-fail/lint-unused-unsafe.rs b/src/test/compile-fail/lint-unused-unsafe.rs index 465e5548f67..1b5aabb9537 100644 --- a/src/test/compile-fail/lint-unused-unsafe.rs +++ b/src/test/compile-fail/lint-unused-unsafe.rs @@ -27,8 +27,8 @@ unsafe fn bad3() { unsafe {} } //~ ERROR: unnecessary `unsafe` block fn bad4() { unsafe { do callback {} } } //~ ERROR: unnecessary `unsafe` block unsafe fn bad5() { unsafe { unsf() } } //~ ERROR: unnecessary `unsafe` block fn bad6() { - unsafe { //~ ERROR: unnecessary `unsafe` block - unsafe { // don't put the warning here + unsafe { // don't put the warning here + unsafe { //~ ERROR: unnecessary `unsafe` block unsf() } } diff --git a/src/test/compile-fail/liveness-issue-2163.rs b/src/test/compile-fail/liveness-issue-2163.rs index 914b7d9d677..ec4f3f9a3fd 100644 --- a/src/test/compile-fail/liveness-issue-2163.rs +++ b/src/test/compile-fail/liveness-issue-2163.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + fn main() { let a: ~[int] = ~[]; vec::each(a, |_| -> bool { diff --git a/src/test/compile-fail/match-vec-unreachable.rs b/src/test/compile-fail/match-vec-unreachable.rs index 2719d84b2dd..3930e7d2192 100644 --- a/src/test/compile-fail/match-vec-unreachable.rs +++ b/src/test/compile-fail/match-vec-unreachable.rs @@ -7,7 +7,7 @@ fn main() { } match [~"foo", ~"bar", ~"baz"] { - [a, _, _, .._] => { io::println(a); } + [a, _, _, .._] => { println(a); } [~"foo", ~"bar", ~"baz", ~"foo", ~"bar"] => { } //~ ERROR unreachable pattern _ => { } } diff --git a/src/test/compile-fail/moves-based-on-type-block-bad.rs b/src/test/compile-fail/moves-based-on-type-block-bad.rs index ca58097b555..11c4d078208 100644 --- a/src/test/compile-fail/moves-based-on-type-block-bad.rs +++ b/src/test/compile-fail/moves-based-on-type-block-bad.rs @@ -18,7 +18,7 @@ fn main() { do f(&s) |hellothere| { match hellothere.x { ~Foo(_) => {} - ~Bar(x) => io::println(x.to_str()), //~ ERROR cannot move out + ~Bar(x) => println(x.to_str()), //~ ERROR cannot move out ~Baz => {} } } diff --git a/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs b/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs index 6dce011ddc8..706ab051ca1 100644 --- a/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs +++ b/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs @@ -1,7 +1,9 @@ +use std::task; + fn main() { let x = ~"Hello world!"; do task::spawn { - io::println(x); + println(x); } - io::println(x); //~ ERROR use of moved value + println(x); //~ ERROR use of moved value } diff --git a/src/test/compile-fail/moves-based-on-type-exprs.rs b/src/test/compile-fail/moves-based-on-type-exprs.rs index 40ee37fae78..d39b2e06e69 100644 --- a/src/test/compile-fail/moves-based-on-type-exprs.rs +++ b/src/test/compile-fail/moves-based-on-type-exprs.rs @@ -1,6 +1,8 @@ // Tests that references to move-by-default values trigger moves when // they occur as part of various kinds of expressions. +use std::vec; + struct Foo<A> { f: A } fn guard(_s: ~str) -> bool {fail!()} fn touch<A>(_a: &A) {} diff --git a/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs b/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs index ecd58d485a8..e25ba0f39f2 100644 --- a/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs +++ b/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; + fn test(_x: ~uint) {} fn main() { diff --git a/src/test/compile-fail/mutable-class-fields-2.rs b/src/test/compile-fail/mutable-class-fields-2.rs index f5d24b31641..7d41481354f 100644 --- a/src/test/compile-fail/mutable-class-fields-2.rs +++ b/src/test/compile-fail/mutable-class-fields-2.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv mut meows : uint, + priv meows : uint, how_hungry : int, } diff --git a/src/test/compile-fail/mutable-class-fields.rs b/src/test/compile-fail/mutable-class-fields.rs index 8bebec7134c..a88156a4b47 100644 --- a/src/test/compile-fail/mutable-class-fields.rs +++ b/src/test/compile-fail/mutable-class-fields.rs @@ -9,7 +9,7 @@ // except according to those terms. struct cat { - priv mut meows : uint, + priv meows : uint, how_hungry : int, } diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs index 2a83e479e87..b036071fd87 100644 --- a/src/test/compile-fail/no-capture-arc.rs +++ b/src/test/compile-fail/no-capture-arc.rs @@ -13,6 +13,8 @@ extern mod extra; use extra::arc; +use std::task; + fn main() { let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let arc_v = arc::ARC(v); diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs index c9e5144557a..28f3ea7af9f 100644 --- a/src/test/compile-fail/no-reuse-move-arc.rs +++ b/src/test/compile-fail/no-reuse-move-arc.rs @@ -11,6 +11,8 @@ extern mod extra; use extra::arc; +use std::task; + fn main() { let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let arc_v = arc::ARC(v); diff --git a/src/test/compile-fail/no-send-res-ports.rs b/src/test/compile-fail/no-send-res-ports.rs index 951103bfbe3..9847efd2dd5 100644 --- a/src/test/compile-fail/no-send-res-ports.rs +++ b/src/test/compile-fail/no-send-res-ports.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::cell::Cell; +use std::task; struct Port<T>(@T); diff --git a/src/test/compile-fail/non-copyable-void.rs b/src/test/compile-fail/non-copyable-void.rs index b89e22582bb..f979f8273a0 100644 --- a/src/test/compile-fail/non-copyable-void.rs +++ b/src/test/compile-fail/non-copyable-void.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::libc; + fn main() { let x : *~[int] = &~[1,2,3]; let y : *libc::c_void = x as *libc::c_void; diff --git a/src/test/compile-fail/noncopyable-match-pattern.rs b/src/test/compile-fail/noncopyable-match-pattern.rs index 155b3981483..a7c8950486c 100644 --- a/src/test/compile-fail/noncopyable-match-pattern.rs +++ b/src/test/compile-fail/noncopyable-match-pattern.rs @@ -8,12 +8,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::unstable; + fn main() { - let x = Some(unstable::sync::exclusive(false)); - match x { - Some(copy z) => { //~ ERROR copying a value of non-copyable type - do z.with |b| { assert!(!*b); } + unsafe { + let x = Some(unstable::sync::exclusive(false)); + match x { + Some(copy z) => { //~ ERROR copying a value of non-copyable type + do z.with |b| { assert!(!*b); } + } + None => fail!() } - None => fail!() } } diff --git a/src/test/compile-fail/packed-struct-generic-transmute.rs b/src/test/compile-fail/packed-struct-generic-transmute.rs index c03261816ef..3b9b17e051d 100644 --- a/src/test/compile-fail/packed-struct-generic-transmute.rs +++ b/src/test/compile-fail/packed-struct-generic-transmute.rs @@ -15,6 +15,8 @@ // error-pattern: transmute called on types with different size +use std::cast; + #[packed] struct Foo<T,S> { bar: T, diff --git a/src/test/compile-fail/packed-struct-transmute.rs b/src/test/compile-fail/packed-struct-transmute.rs index cad78f9e5d1..bf62bab8b40 100644 --- a/src/test/compile-fail/packed-struct-transmute.rs +++ b/src/test/compile-fail/packed-struct-transmute.rs @@ -15,6 +15,8 @@ // error-pattern: transmute called on types with different size +use std::cast; + #[packed] struct Foo { bar: u8, diff --git a/src/test/compile-fail/private-method.rs b/src/test/compile-fail/private-method.rs index 0d84bc2fc60..800bb1c5703 100644 --- a/src/test/compile-fail/private-method.rs +++ b/src/test/compile-fail/private-method.rs @@ -11,8 +11,10 @@ // error-pattern:method `nap` is private mod kitties { + use std::uint; + pub struct cat { - priv mut meows : uint, + priv meows : uint, how_hungry : int, } diff --git a/src/test/compile-fail/refutable-pattern-in-fn-arg.rs b/src/test/compile-fail/refutable-pattern-in-fn-arg.rs index 957925709e1..524deed20f2 100644 --- a/src/test/compile-fail/refutable-pattern-in-fn-arg.rs +++ b/src/test/compile-fail/refutable-pattern-in-fn-arg.rs @@ -9,6 +9,6 @@ // except according to those terms. fn main() { - let f = |3: int| io::println("hello"); //~ ERROR refutable pattern + let f = |3: int| println("hello"); //~ ERROR refutable pattern f(4); } diff --git a/src/test/compile-fail/regions-addr-of-upvar-self.rs b/src/test/compile-fail/regions-addr-of-upvar-self.rs index b9a9e2f38f5..1c7235743ea 100644 --- a/src/test/compile-fail/regions-addr-of-upvar-self.rs +++ b/src/test/compile-fail/regions-addr-of-upvar-self.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; + struct dog { food: uint, } diff --git a/src/test/compile-fail/repeat-to-run-dtor-twice.rs b/src/test/compile-fail/repeat-to-run-dtor-twice.rs index e1e1e2313f4..0dd12822dfa 100644 --- a/src/test/compile-fail/repeat-to-run-dtor-twice.rs +++ b/src/test/compile-fail/repeat-to-run-dtor-twice.rs @@ -18,7 +18,7 @@ struct Foo { impl Drop for Foo { fn finalize(&self) { - io::println("Goodbye!"); + println("Goodbye!"); } } diff --git a/src/test/compile-fail/spawn-non-nil-fn.rs b/src/test/compile-fail/spawn-non-nil-fn.rs index 9dbef369257..8db2c686f30 100644 --- a/src/test/compile-fail/spawn-non-nil-fn.rs +++ b/src/test/compile-fail/spawn-non-nil-fn.rs @@ -12,4 +12,6 @@ extern mod extra; +use std::task; + fn main() { task::spawn(|| -> int { 10 }); } diff --git a/src/test/compile-fail/tuple-struct-nonexhaustive.rs b/src/test/compile-fail/tuple-struct-nonexhaustive.rs index de28a06abab..785eeb24784 100644 --- a/src/test/compile-fail/tuple-struct-nonexhaustive.rs +++ b/src/test/compile-fail/tuple-struct-nonexhaustive.rs @@ -13,7 +13,7 @@ struct Foo(int, int); fn main() { let x = Foo(1, 2); match x { //~ ERROR non-exhaustive - Foo(1, b) => io::println(fmt!("%d", b)), - Foo(2, b) => io::println(fmt!("%d", b)) + Foo(1, b) => println(fmt!("%d", b)), + Foo(2, b) => println(fmt!("%d", b)) } } diff --git a/src/test/compile-fail/unique-object-noncopyable.rs b/src/test/compile-fail/unique-object-noncopyable.rs index 95945b0b5ba..3844dab726e 100644 --- a/src/test/compile-fail/unique-object-noncopyable.rs +++ b/src/test/compile-fail/unique-object-noncopyable.rs @@ -22,7 +22,7 @@ impl Drop for Bar { impl Foo for Bar { fn f(&self) { - io::println("hi"); + println("hi"); } } diff --git a/src/test/compile-fail/unsendable-class.rs b/src/test/compile-fail/unsendable-class.rs index 3eebc4647c2..58de0926f7c 100644 --- a/src/test/compile-fail/unsendable-class.rs +++ b/src/test/compile-fail/unsendable-class.rs @@ -11,6 +11,8 @@ // Test that a class with an unsendable field can't be // sent +use std::comm; + struct foo { i: int, j: @~str, diff --git a/src/test/compile-fail/unsupported-cast.rs b/src/test/compile-fail/unsupported-cast.rs index 3af012a6c3f..da8f69d7eae 100644 --- a/src/test/compile-fail/unsupported-cast.rs +++ b/src/test/compile-fail/unsupported-cast.rs @@ -10,6 +10,8 @@ // error-pattern:unsupported cast +use std::libc; + fn main() { debug!(1.0 as *libc::FILE); // Can't cast float to foreign. } diff --git a/src/test/compile-fail/use-after-move-based-on-type.rs b/src/test/compile-fail/use-after-move-based-on-type.rs index 3d176bb339d..e8802e6e5cb 100644 --- a/src/test/compile-fail/use-after-move-based-on-type.rs +++ b/src/test/compile-fail/use-after-move-based-on-type.rs @@ -11,5 +11,5 @@ fn main() { let x = ~"Hello!"; let _y = x; - io::println(x); //~ ERROR use of moved value + println(x); //~ ERROR use of moved value } diff --git a/src/test/compile-fail/use-after-move-self-based-on-type.rs b/src/test/compile-fail/use-after-move-self-based-on-type.rs index da8e0c9f2b6..e4e5802fafb 100644 --- a/src/test/compile-fail/use-after-move-self-based-on-type.rs +++ b/src/test/compile-fail/use-after-move-self-based-on-type.rs @@ -17,5 +17,5 @@ pub impl S { fn main() { let x = S { x: 1 }; - io::println(x.foo().to_str()); + println(x.foo().to_str()); } diff --git a/src/test/compile-fail/use-after-move-self.rs b/src/test/compile-fail/use-after-move-self.rs index 37db40d1436..4750a5fbd2d 100644 --- a/src/test/compile-fail/use-after-move-self.rs +++ b/src/test/compile-fail/use-after-move-self.rs @@ -13,5 +13,5 @@ pub impl S { fn main() { let x = S { x: ~1 }; - io::println(x.foo().to_str()); + println(x.foo().to_str()); } diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow.rs b/src/test/run-fail/bug-2470-bounds-check-overflow.rs index 6a6402c6a5e..bd7d86d7295 100644 --- a/src/test/run-fail/bug-2470-bounds-check-overflow.rs +++ b/src/test/run-fail/bug-2470-bounds-check-overflow.rs @@ -10,6 +10,9 @@ // error-pattern:index out of bounds +use std::sys; +use std::vec; + fn main() { // This should cause a bounds-check failure, but may not if we do our diff --git a/src/test/run-fail/extern-fail.rs b/src/test/run-fail/extern-fail.rs index 15cc8a48867..2be41d3bed0 100644 --- a/src/test/run-fail/extern-fail.rs +++ b/src/test/run-fail/extern-fail.rs @@ -12,9 +12,13 @@ // Testing that runtime failure doesn't cause callbacks to abort abnormally. // Instead the failure will be delivered after the callbacks return. +use std::libc; use std::old_iter; +use std::task; mod rustrt { + use std::libc; + pub extern { pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t; diff --git a/src/test/run-fail/for-each-loop-fail.rs b/src/test/run-fail/for-each-loop-fail.rs index 06422244af9..97ca36cf448 100644 --- a/src/test/run-fail/for-each-loop-fail.rs +++ b/src/test/run-fail/for-each-loop-fail.rs @@ -10,4 +10,7 @@ // error-pattern:moop extern mod extra; + +use std::uint; + fn main() { for uint::range(0u, 10u) |_i| { fail!("moop"); } } diff --git a/src/test/run-fail/issue-2156.rs b/src/test/run-fail/issue-2156.rs index de0b903b53c..0e0bd81d659 100644 --- a/src/test/run-fail/issue-2156.rs +++ b/src/test/run-fail/issue-2156.rs @@ -11,7 +11,9 @@ // error-pattern:explicit failure // Don't double free the string extern mod extra; + use std::io::ReaderUtil; +use std::io; fn main() { do io::with_str_reader(~"") |rdr| { diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs index 6a87e202d13..41a9d7ddcea 100644 --- a/src/test/run-fail/linked-failure.rs +++ b/src/test/run-fail/linked-failure.rs @@ -13,6 +13,9 @@ // error-pattern:1 == 2 extern mod extra; +use std::comm; +use std::task; + fn child() { assert!((1 == 2)); } fn main() { diff --git a/src/test/run-fail/linked-failure2.rs b/src/test/run-fail/linked-failure2.rs index 9f09c16ed6a..0269e395986 100644 --- a/src/test/run-fail/linked-failure2.rs +++ b/src/test/run-fail/linked-failure2.rs @@ -12,6 +12,9 @@ // error-pattern:fail +use std::comm; +use std::task; + fn child() { fail!(); } fn main() { diff --git a/src/test/run-fail/linked-failure3.rs b/src/test/run-fail/linked-failure3.rs index 4b09cb75324..1203f74322f 100644 --- a/src/test/run-fail/linked-failure3.rs +++ b/src/test/run-fail/linked-failure3.rs @@ -12,6 +12,9 @@ // error-pattern:fail +use std::comm; +use std::task; + fn grandchild() { fail!("grandchild dies"); } fn child() { diff --git a/src/test/run-fail/linked-failure4.rs b/src/test/run-fail/linked-failure4.rs index 3dc87e190a5..766b43f211f 100644 --- a/src/test/run-fail/linked-failure4.rs +++ b/src/test/run-fail/linked-failure4.rs @@ -11,6 +11,9 @@ // error-pattern:1 == 2 +use std::comm; +use std::task; + fn child() { assert!((1 == 2)); } fn parent() { diff --git a/src/test/run-fail/match-wildcards.rs b/src/test/run-fail/match-wildcards.rs index 306357b0001..22613f45b3b 100644 --- a/src/test/run-fail/match-wildcards.rs +++ b/src/test/run-fail/match-wildcards.rs @@ -10,9 +10,9 @@ // error-pattern:squirrelcupcake fn cmp() -> int { - match (option::Some('a'), option::None::<char>) { - (option::Some(_), _) => { fail!("squirrelcupcake"); } - (_, option::Some(_)) => { fail!(); } + match (Some('a'), None::<char>) { + (Some(_), _) => { fail!("squirrelcupcake"); } + (_, Some(_)) => { fail!(); } _ => { fail!("wat"); } } } diff --git a/src/test/run-fail/morestack2.rs b/src/test/run-fail/morestack2.rs index f829767edf1..d03433d5872 100644 --- a/src/test/run-fail/morestack2.rs +++ b/src/test/run-fail/morestack2.rs @@ -17,7 +17,12 @@ extern mod extra; +use std::libc; +use std::task; + mod rustrt { + use std::libc; + pub extern { pub fn rust_get_argc() -> libc::c_int; } diff --git a/src/test/run-fail/morestack3.rs b/src/test/run-fail/morestack3.rs index 6ab064f3827..d2e17d28561 100644 --- a/src/test/run-fail/morestack3.rs +++ b/src/test/run-fail/morestack3.rs @@ -14,6 +14,8 @@ extern mod extra; +use std::task; + fn getbig_and_fail(i: int) { let _r = and_then_get_big_again(5); if i != 0 { diff --git a/src/test/run-fail/morestack4.rs b/src/test/run-fail/morestack4.rs index e07c7997108..c4f7de49555 100644 --- a/src/test/run-fail/morestack4.rs +++ b/src/test/run-fail/morestack4.rs @@ -14,6 +14,8 @@ extern mod extra; +use std::task; + fn getbig_and_fail(i: int) { let r = and_then_get_big_again(5); if i != 0 { diff --git a/src/test/run-fail/result-get-fail.rs b/src/test/run-fail/result-get-fail.rs index 1e4e7685e27..cb9cce3249f 100644 --- a/src/test/run-fail/result-get-fail.rs +++ b/src/test/run-fail/result-get-fail.rs @@ -9,6 +9,9 @@ // except according to those terms. // error-pattern:get called on error result: ~"kitty" + +use std::result; + fn main() { error!(result::get(&result::Err::<int,~str>(~"kitty"))); } diff --git a/src/test/run-fail/rt-set-exit-status-fail.rs b/src/test/run-fail/rt-set-exit-status-fail.rs index f6e9602470f..6b5c2b554a4 100644 --- a/src/test/run-fail/rt-set-exit-status-fail.rs +++ b/src/test/run-fail/rt-set-exit-status-fail.rs @@ -10,6 +10,8 @@ // error-pattern:whatever +use std::os; + fn main() { error!(~"whatever"); // Setting the exit status only works when the scheduler terminates diff --git a/src/test/run-fail/rt-set-exit-status-fail2.rs b/src/test/run-fail/rt-set-exit-status-fail2.rs index bf33b10cc61..3d0341d01f4 100644 --- a/src/test/run-fail/rt-set-exit-status-fail2.rs +++ b/src/test/run-fail/rt-set-exit-status-fail2.rs @@ -10,6 +10,9 @@ // error-pattern:whatever +use std::os; +use std::task; + struct r { x:int, } diff --git a/src/test/run-fail/rt-set-exit-status.rs b/src/test/run-fail/rt-set-exit-status.rs index 2cff4ff09df..4f71cdc67e9 100644 --- a/src/test/run-fail/rt-set-exit-status.rs +++ b/src/test/run-fail/rt-set-exit-status.rs @@ -10,6 +10,8 @@ // error-pattern:whatever +use std::os; + fn main() { error!(~"whatever"); // 101 is the code the runtime uses on task failure and the value diff --git a/src/test/run-fail/small-negative-indexing.rs b/src/test/run-fail/small-negative-indexing.rs index 87df00fcce5..ee58f76fc99 100644 --- a/src/test/run-fail/small-negative-indexing.rs +++ b/src/test/run-fail/small-negative-indexing.rs @@ -9,6 +9,9 @@ // except according to those terms. // error-pattern:index out of bounds: the len is 1024 but the index is -1 + +use std::vec; + fn main() { let v = vec::from_fn(1024u, {|n| n}); // this should trip a bounds check diff --git a/src/test/run-fail/spawnfail.rs b/src/test/run-fail/spawnfail.rs index fc4977308ae..de085a6f3ad 100644 --- a/src/test/run-fail/spawnfail.rs +++ b/src/test/run-fail/spawnfail.rs @@ -12,6 +12,8 @@ // error-pattern:explicit extern mod extra; +use std::task; + // We don't want to see any invalid reads fn main() { fn f() { diff --git a/src/test/run-fail/task-comm-recv-block.rs b/src/test/run-fail/task-comm-recv-block.rs index ca411872b61..8302b96ca3e 100644 --- a/src/test/run-fail/task-comm-recv-block.rs +++ b/src/test/run-fail/task-comm-recv-block.rs @@ -10,6 +10,9 @@ // error-pattern:goodfail +use std::comm; +use std::task; + fn goodfail() { task::yield(); fail!("goodfail"); diff --git a/src/test/run-fail/task-spawn-barefn.rs b/src/test/run-fail/task-spawn-barefn.rs index 11c9de6e14f..2456f968c3c 100644 --- a/src/test/run-fail/task-spawn-barefn.rs +++ b/src/test/run-fail/task-spawn-barefn.rs @@ -10,6 +10,9 @@ // error-pattern:Ensure that the child task runs by failing +use std::str; +use std::task; + fn main() { // the purpose of this test is to make sure that task::spawn() // works when provided with a bare function: diff --git a/src/test/run-fail/unwind-box-res.rs b/src/test/run-fail/unwind-box-res.rs index d5d54ade444..a1e1ee433bb 100644 --- a/src/test/run-fail/unwind-box-res.rs +++ b/src/test/run-fail/unwind-box-res.rs @@ -10,6 +10,8 @@ // error-pattern:fail +use std::cast; + fn failfn() { fail!(); } diff --git a/src/test/run-pass/anon-extern-mod-cross-crate-2.rs b/src/test/run-pass/anon-extern-mod-cross-crate-2.rs index ed57b32b3d9..4eeb85469de 100644 --- a/src/test/run-pass/anon-extern-mod-cross-crate-2.rs +++ b/src/test/run-pass/anon-extern-mod-cross-crate-2.rs @@ -15,5 +15,7 @@ extern mod anonexternmod; use anonexternmod::*; pub fn main() { - rust_get_argc(); + unsafe { + rust_get_argc(); + } } diff --git a/src/test/run-pass/anon-extern-mod.rs b/src/test/run-pass/anon-extern-mod.rs index 6e73022fad2..8e03a6393b4 100644 --- a/src/test/run-pass/anon-extern-mod.rs +++ b/src/test/run-pass/anon-extern-mod.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::libc; + #[abi = "cdecl"] #[link_name = "rustrt"] extern { diff --git a/src/test/run-pass/anon-trait-static-method.rs b/src/test/run-pass/anon-trait-static-method.rs index 91bbbf5c0a0..10462fa4abb 100644 --- a/src/test/run-pass/anon-trait-static-method.rs +++ b/src/test/run-pass/anon-trait-static-method.rs @@ -20,5 +20,5 @@ pub impl Foo { pub fn main() { let x = Foo::new(); - io::println(x.x.to_str()); + println(x.x.to_str()); } diff --git a/src/test/run-pass/anon_trait_static_method_exe.rs b/src/test/run-pass/anon_trait_static_method_exe.rs index 1baeca00083..5780a4e97ae 100644 --- a/src/test/run-pass/anon_trait_static_method_exe.rs +++ b/src/test/run-pass/anon_trait_static_method_exe.rs @@ -16,5 +16,5 @@ use anon_trait_static_method_lib::Foo; pub fn main() { let x = Foo::new(); - io::println(x.x.to_str()); + println(x.x.to_str()); } diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs index 64e1e20e4ba..5d2341ae42d 100644 --- a/src/test/run-pass/assignability-trait.rs +++ b/src/test/run-pass/assignability-trait.rs @@ -12,6 +12,8 @@ // making method calls, but only if there aren't any matches without // it. +use std::vec; + trait iterable<A> { fn iterate(&self, blk: &fn(x: &A) -> bool) -> bool; } diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index 0c2f24b5bf7..eebd4d51fb6 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -20,7 +20,9 @@ extern mod extra; use EBReader = extra::ebml::reader; use EBWriter = extra::ebml::writer; use std::cmp::Eq; +use std::cmp; use std::io::Writer; +use std::io; use extra::ebml; use extra::serialize::{Decodable, Encodable}; use extra::time; diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs index dbcbb77efa3..f148c509d4d 100644 --- a/src/test/run-pass/auto-loop.rs +++ b/src/test/run-pass/auto-loop.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + pub fn main() { let mut sum = 0; for vec::each(~[1, 2, 3, 4, 5]) |x| { diff --git a/src/test/run-pass/auto-ref-bounded-ty-param.rs b/src/test/run-pass/auto-ref-bounded-ty-param.rs index 08c936f2bb6..bb01c27fa0d 100644 --- a/src/test/run-pass/auto-ref-bounded-ty-param.rs +++ b/src/test/run-pass/auto-ref-bounded-ty-param.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::io; + trait Foo { fn f(&self); } diff --git a/src/test/run-pass/auto-ref.rs b/src/test/run-pass/auto-ref.rs index ee250b97219..7171b0ee86c 100644 --- a/src/test/run-pass/auto-ref.rs +++ b/src/test/run-pass/auto-ref.rs @@ -18,7 +18,7 @@ trait Stuff { impl Stuff for Foo { fn printme(&self) { - io::println(fmt!("%d", self.x)); + println(fmt!("%d", self.x)); } } diff --git a/src/test/run-pass/bare-static-string.rs b/src/test/run-pass/bare-static-string.rs index 6208a9c3cc3..9b2855d269d 100644 --- a/src/test/run-pass/bare-static-string.rs +++ b/src/test/run-pass/bare-static-string.rs @@ -10,5 +10,5 @@ pub fn main() { let x: &'static str = "foo"; - io::println(x); + println(x); } diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs index a7e910538c9..1c73bf6cc36 100644 --- a/src/test/run-pass/binops.rs +++ b/src/test/run-pass/binops.rs @@ -10,6 +10,8 @@ // Binop corner cases +use std::libc; + fn test_nil() { assert_eq!((), ()); assert!((!(() != ()))); @@ -80,6 +82,8 @@ fn test_ptr() { } mod test { + use std::libc; + #[abi = "cdecl"] #[nolink] pub extern { diff --git a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs index d10bcaa216a..73b436e7476 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + pub fn main() { let v = ~[-1f, 0f, 1f, 2f, 3f]; diff --git a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs index 194fa297361..7894bf93848 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + pub fn main() { fn f(i: &fn() -> uint) -> uint { i() } let v = ~[-1f, 0f, 1f, 2f, 3f]; diff --git a/src/test/run-pass/block-arg-can-be-followed-by-call.rs b/src/test/run-pass/block-arg-can-be-followed-by-call.rs index 5243eae30ca..5fb6de19878 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-call.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-call.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + pub fn main() { fn f(i: uint) -> uint { i } let v = ~[-1f, 0f, 1f, 2f, 3f]; diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs index ea189de562a..ec211a3a144 100644 --- a/src/test/run-pass/block-arg-in-parentheses.rs +++ b/src/test/run-pass/block-arg-in-parentheses.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + fn w_semi(v: ~[int]) -> int { // the semicolon causes compiler not to // complain about the ignored return value: diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs index de29ec99167..906a3629f3a 100644 --- a/src/test/run-pass/block-arg.rs +++ b/src/test/run-pass/block-arg.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + // Check usage and precedence of block arguments in expressions: pub fn main() { let v = ~[-1f, 0f, 1f, 2f, 3f]; diff --git a/src/test/run-pass/block-vec-map_zip.rs b/src/test/run-pass/block-vec-map_zip.rs index 4c37000113c..739dbab4d3a 100644 --- a/src/test/run-pass/block-vec-map_zip.rs +++ b/src/test/run-pass/block-vec-map_zip.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; +use std::vec; pub fn main() { let v = diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs index 5149c87c490..b10f152abe0 100644 --- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs +++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ptr; + fn borrow(x: &int, f: &fn(x: &int)) { f(x) } diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs index fa5ae984507..1b43e98cc17 100644 --- a/src/test/run-pass/borrowck-mut-uniq.rs +++ b/src/test/run-pass/borrowck-mut-uniq.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; use std::util; struct Ints {sum: ~int, values: ~[int]} diff --git a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs index 4b5d73f597e..d63ebf7d24d 100644 --- a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs +++ b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + fn want_slice(v: &[int]) -> int { let mut sum = 0; for vec::each(v) |i| { sum += *i; } diff --git a/src/test/run-pass/borrowck-preserve-box-in-discr.rs b/src/test/run-pass/borrowck-preserve-box-in-discr.rs index 5a94e2f5cd0..8434651dbbf 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-discr.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-discr.rs @@ -10,6 +10,8 @@ // exec-env:RUST_POISON_ON_FREE=1 +use std::ptr; + struct F { f: ~int } pub fn main() { diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs index f86471fd209..93ceeef37b3 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-field.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs @@ -10,6 +10,8 @@ // exec-env:RUST_POISON_ON_FREE=1 +use std::ptr; + fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); diff --git a/src/test/run-pass/borrowck-preserve-box-in-pat.rs b/src/test/run-pass/borrowck-preserve-box-in-pat.rs index 17f9dcb627d..1323ac0df5e 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-pat.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-pat.rs @@ -10,6 +10,8 @@ // exec-env:RUST_POISON_ON_FREE=1 +use std::ptr; + struct F { f: ~int } pub fn main() { diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs index 25bc5c0c982..dcecf77335a 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs @@ -10,6 +10,8 @@ // exec-env:RUST_POISON_ON_FREE=1 +use std::ptr; + fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); diff --git a/src/test/run-pass/borrowck-preserve-box.rs b/src/test/run-pass/borrowck-preserve-box.rs index 5f4d907e962..8bd8049ea1d 100644 --- a/src/test/run-pass/borrowck-preserve-box.rs +++ b/src/test/run-pass/borrowck-preserve-box.rs @@ -10,6 +10,8 @@ // exec-env:RUST_POISON_ON_FREE=1 +use std::ptr; + fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs index ac1463caddf..6e683c79875 100644 --- a/src/test/run-pass/borrowck-preserve-expl-deref.rs +++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs @@ -10,6 +10,8 @@ // exec-env:RUST_POISON_ON_FREE=1 +use std::ptr; + fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); diff --git a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm-3.rs b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm-3.rs index 0699df703c6..212bc62a98a 100644 --- a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm-3.rs +++ b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm-3.rs @@ -5,7 +5,7 @@ struct Wizard { pub impl Wizard { fn cast(&mut self) { for self.spells.each |&spell| { - io::println(spell); + println(spell); } } } diff --git a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs index dea4ec4959b..3b18a8649ee 100644 --- a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs +++ b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs @@ -1,5 +1,5 @@ fn g(x: &Option<int>) { - io::println(x.get().to_str()); + println(x.get().to_str()); } fn f(x: &mut Option<int>) { diff --git a/src/test/run-pass/borrowck-wg-simple.rs b/src/test/run-pass/borrowck-wg-simple.rs index f28b0e4c4ec..c07962e10aa 100644 --- a/src/test/run-pass/borrowck-wg-simple.rs +++ b/src/test/run-pass/borrowck-wg-simple.rs @@ -1,5 +1,5 @@ fn f(x: &int) { - io::println(x.to_str()); + println(x.to_str()); } pub fn main() { diff --git a/src/test/run-pass/boxed-trait-with-vstore.rs b/src/test/run-pass/boxed-trait-with-vstore.rs index 1313a17f81d..1d901d42742 100644 --- a/src/test/run-pass/boxed-trait-with-vstore.rs +++ b/src/test/run-pass/boxed-trait-with-vstore.rs @@ -14,7 +14,7 @@ trait Foo { impl Foo for int { fn foo(@self) { - io::println("Hello world!"); + println("Hello world!"); } } diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs index da362c8194d..2edb270762c 100644 --- a/src/test/run-pass/break.rs +++ b/src/test/run-pass/break.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + pub fn main() { let mut i = 0; while i < 20 { i += 1; if i == 10 { break; } } diff --git a/src/test/run-pass/c-stack-as-value.rs b/src/test/run-pass/c-stack-as-value.rs index 661aa7a90b1..0a482c745ba 100644 --- a/src/test/run-pass/c-stack-as-value.rs +++ b/src/test/run-pass/c-stack-as-value.rs @@ -8,7 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::libc; + mod rustrt { + use std::libc; + #[abi = "cdecl"] pub extern { pub fn get_task_id() -> libc::intptr_t; diff --git a/src/test/run-pass/c-stack-returning-int64.rs b/src/test/run-pass/c-stack-returning-int64.rs index 647c42cf891..4553257df31 100644 --- a/src/test/run-pass/c-stack-returning-int64.rs +++ b/src/test/run-pass/c-stack-returning-int64.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; +use std::str; mod libc { #[abi = "cdecl"] diff --git a/src/test/run-pass/cap-clause-move.rs b/src/test/run-pass/cap-clause-move.rs index 19939650633..aadd6a72494 100644 --- a/src/test/run-pass/cap-clause-move.rs +++ b/src/test/run-pass/cap-clause-move.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ptr; + pub fn main() { let x = ~1; let y = ptr::to_unsafe_ptr(&(*x)) as uint; diff --git a/src/test/run-pass/capture_nil.rs b/src/test/run-pass/capture_nil.rs index c9a1c031e84..6182ec79a3b 100644 --- a/src/test/run-pass/capture_nil.rs +++ b/src/test/run-pass/capture_nil.rs @@ -25,6 +25,7 @@ // irrelevant). use std::comm::*; +use std::task; fn foo(x: ()) -> Port<()> { let (p, c) = stream::<()>(); diff --git a/src/test/run-pass/cast-region-to-uint.rs b/src/test/run-pass/cast-region-to-uint.rs index 81fa3d6538c..714cbe6bfa1 100644 --- a/src/test/run-pass/cast-region-to-uint.rs +++ b/src/test/run-pass/cast-region-to-uint.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ptr; + pub fn main() { let x = 3; debug!("&x=%x", ptr::to_uint(&x)); diff --git a/src/test/run-pass/cci_impl_exe.rs b/src/test/run-pass/cci_impl_exe.rs index db25b36aa61..43d9db391d9 100644 --- a/src/test/run-pass/cci_impl_exe.rs +++ b/src/test/run-pass/cci_impl_exe.rs @@ -19,7 +19,7 @@ pub fn main() { //debug!("%?", bt0); do 3u.to(10u) |i| { - io::print(fmt!("%u\n", i)); + print(fmt!("%u\n", i)); //let bt1 = sys::frame_address(); //debug!("%?", bt1); diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs index cb713adcb28..f9a2d786929 100644 --- a/src/test/run-pass/cci_iter_exe.rs +++ b/src/test/run-pass/cci_iter_exe.rs @@ -17,7 +17,7 @@ pub fn main() { //let bt0 = sys::rusti::frame_address(1u32); //debug!("%?", bt0); do cci_iter_lib::iter(~[1, 2, 3]) |i| { - io::print(fmt!("%d", *i)); + print(fmt!("%d", *i)); //assert!(bt0 == sys::rusti::frame_address(2u32)); } } diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs index a1c2666b2e5..92d0e23589b 100644 --- a/src/test/run-pass/cci_no_inline_exe.rs +++ b/src/test/run-pass/cci_no_inline_exe.rs @@ -23,7 +23,7 @@ pub fn main() { //let bt0 = sys::frame_address(); //debug!("%?", bt0); do iter(~[1u, 2u, 3u]) |i| { - io::print(fmt!("%u\n", i)); + print(fmt!("%u\n", i)); //let bt1 = sys::frame_address(); //debug!("%?", bt1); diff --git a/src/test/run-pass/child-outlives-parent.rs b/src/test/run-pass/child-outlives-parent.rs index de933b53a18..9232547dd8b 100644 --- a/src/test/run-pass/child-outlives-parent.rs +++ b/src/test/run-pass/child-outlives-parent.rs @@ -10,7 +10,7 @@ // Reported as issue #126, child leaks the string. -extern mod extra; +use std::task; fn child2(s: ~str) { } diff --git a/src/test/run-pass/class-cast-to-trait-multiple-types.rs b/src/test/run-pass/class-cast-to-trait-multiple-types.rs index 051c09fac53..c41a8c2b284 100644 --- a/src/test/run-pass/class-cast-to-trait-multiple-types.rs +++ b/src/test/run-pass/class-cast-to-trait-multiple-types.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; + trait noisy { fn speak(&self) -> int; } diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs index a73af840fe4..b8ea3bec21a 100644 --- a/src/test/run-pass/class-impl-very-parameterized-trait.rs +++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs @@ -10,8 +10,11 @@ // xfail-fast +use std::cmp; use std::container::{Container, Mutable, Map}; +use std::int; use std::old_iter::BaseIter; +use std::uint; enum cat_type { tuxedo, tabby, tortoiseshell } diff --git a/src/test/run-pass/class-implement-trait-cross-crate.rs b/src/test/run-pass/class-implement-trait-cross-crate.rs index 226dbe535fa..724f9a0f7b1 100644 --- a/src/test/run-pass/class-implement-trait-cross-crate.rs +++ b/src/test/run-pass/class-implement-trait-cross-crate.rs @@ -13,6 +13,8 @@ extern mod cci_class_trait; use cci_class_trait::animals::*; +use std::uint; + struct cat { priv meows: uint, diff --git a/src/test/run-pass/class-implement-traits.rs b/src/test/run-pass/class-implement-traits.rs index 1c0a09d52cf..d8ba7320b95 100644 --- a/src/test/run-pass/class-implement-traits.rs +++ b/src/test/run-pass/class-implement-traits.rs @@ -10,6 +10,8 @@ // xfail-fast +use std::uint; + trait noisy { fn speak(&mut self); } diff --git a/src/test/run-pass/classes-cross-crate.rs b/src/test/run-pass/classes-cross-crate.rs index 6a8a47990b8..0af433bd655 100644 --- a/src/test/run-pass/classes-cross-crate.rs +++ b/src/test/run-pass/classes-cross-crate.rs @@ -13,6 +13,8 @@ extern mod cci_class_4; use cci_class_4::kitties::*; +use std::uint; + pub fn main() { let mut nyan = cat(0u, 2, ~"nyan"); nyan.eat(); diff --git a/src/test/run-pass/classes.rs b/src/test/run-pass/classes.rs index 52346904141..e3f9b651083 100644 --- a/src/test/run-pass/classes.rs +++ b/src/test/run-pass/classes.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; + struct cat { priv meows : uint, diff --git a/src/test/run-pass/cleanup-copy-mode.rs b/src/test/run-pass/cleanup-copy-mode.rs index cb378da13ea..2446e9057c2 100644 --- a/src/test/run-pass/cleanup-copy-mode.rs +++ b/src/test/run-pass/cleanup-copy-mode.rs @@ -9,6 +9,10 @@ // except according to those terms. // xfail-win32 + +use std::result; +use std::task; + fn adder(x: @int, y: @int) -> int { return *x + *y; } fn failer() -> @int { fail!(); } pub fn main() { diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs index 18a28722c70..3d216c1885f 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs @@ -1,3 +1,5 @@ +use std::vec; + trait Reverser { fn reverse(&self); } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs index aa787328c41..d62ed77fdab 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs @@ -1,3 +1,5 @@ +use std::vec; + trait Reverser { fn reverse(self); } diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index c307cf809b6..b0bdfd598fb 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -10,6 +10,7 @@ // except according to those terms. use std::comm::*; +use std::task; pub fn main() { let (p, ch) = stream(); diff --git a/src/test/run-pass/const-cast-ptr-int.rs b/src/test/run-pass/const-cast-ptr-int.rs index 3dc94936304..88ab70f596a 100644 --- a/src/test/run-pass/const-cast-ptr-int.rs +++ b/src/test/run-pass/const-cast-ptr-int.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ptr; + static a: *u8 = 0 as *u8; pub fn main() { diff --git a/src/test/run-pass/const-cast.rs b/src/test/run-pass/const-cast.rs index 1c8e92b91cd..280fe44c3da 100644 --- a/src/test/run-pass/const-cast.rs +++ b/src/test/run-pass/const-cast.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::libc; + extern fn foo() {} static x: *u8 = foo; diff --git a/src/test/run-pass/const-fields-and-indexing.rs b/src/test/run-pass/const-fields-and-indexing.rs index ccc7b486d1e..990e5e67219 100644 --- a/src/test/run-pass/const-fields-and-indexing.rs +++ b/src/test/run-pass/const-fields-and-indexing.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::io; + static x : [int, ..4] = [1,2,3,4]; static p : int = x[2]; static y : &'static [int] = &[1,2,3,4]; diff --git a/src/test/run-pass/const-rec-and-tup.rs b/src/test/run-pass/const-rec-and-tup.rs index acb7fa2f0f4..31b806bf41a 100644 --- a/src/test/run-pass/const-rec-and-tup.rs +++ b/src/test/run-pass/const-rec-and-tup.rs @@ -21,5 +21,5 @@ static y : AnotherPair = AnotherPair{ x: (0xf0f0f0f0_f0f0f0f0, pub fn main() { let (p, _) = y.x; assert_eq!(p, - 1085102592571150096); - io::println(fmt!("0x%x", p as uint)); + println(fmt!("0x%x", p as uint)); } diff --git a/src/test/run-pass/const-region-ptrs-noncopy.rs b/src/test/run-pass/const-region-ptrs-noncopy.rs index 14397569ad9..3eaf733d784 100644 --- a/src/test/run-pass/const-region-ptrs-noncopy.rs +++ b/src/test/run-pass/const-region-ptrs-noncopy.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ptr; + type Big = [u64, ..8]; struct Pair<'self> { a: int, b: &'self Big } static x: &'static Big = &([13, 14, 10, 13, 11, 14, 14, 15]); diff --git a/src/test/run-pass/const-region-ptrs.rs b/src/test/run-pass/const-region-ptrs.rs index 12712844c8a..cdc71292ae0 100644 --- a/src/test/run-pass/const-region-ptrs.rs +++ b/src/test/run-pass/const-region-ptrs.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::io; struct Pair<'self> { a: int, b: &'self int } diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs index 48eb4d6ce59..2f0cd3c611f 100644 --- a/src/test/run-pass/const-str-ptr.rs +++ b/src/test/run-pass/const-str-ptr.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::str; + static a: [u8, ..3] = ['h' as u8, 'i' as u8, 0 as u8]; static c: &'static [u8, ..3] = &a; static b: *u8 = c as *u8; diff --git a/src/test/run-pass/const-struct.rs b/src/test/run-pass/const-struct.rs index 24542f54922..8a93a3e4c1c 100644 --- a/src/test/run-pass/const-struct.rs +++ b/src/test/run-pass/const-struct.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::cmp; +use std::io; struct foo { a: int, b: int, c: int } diff --git a/src/test/run-pass/const-vecs-and-slices.rs b/src/test/run-pass/const-vecs-and-slices.rs index 134ee580425..0aee53a4ed2 100644 --- a/src/test/run-pass/const-vecs-and-slices.rs +++ b/src/test/run-pass/const-vecs-and-slices.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::io; + static x : [int, ..4] = [1,2,3,4]; static y : &'static [int] = &[1,2,3,4]; diff --git a/src/test/run-pass/core-export-f64-sqrt.rs b/src/test/run-pass/core-export-f64-sqrt.rs index 7e00d7efbe2..3a683bc7cb9 100644 --- a/src/test/run-pass/core-export-f64-sqrt.rs +++ b/src/test/run-pass/core-export-f64-sqrt.rs @@ -10,9 +10,12 @@ // Regression test that f64 exports things properly +use std::f64; +use std::float; + pub fn main() { let digits: uint = 10 as uint; - ::std::io::println(float::to_str_digits(f64::sqrt(42.0f64) as float, digits)); + println(float::to_str_digits(f64::sqrt(42.0f64) as float, digits)); } diff --git a/src/test/run-pass/core-run-destroy.rs b/src/test/run-pass/core-run-destroy.rs index a80d9661aa2..81cdb926e5f 100644 --- a/src/test/run-pass/core-run-destroy.rs +++ b/src/test/run-pass/core-run-destroy.rs @@ -15,8 +15,11 @@ // memory, which makes for some *confusing* logs. That's why these are here // instead of in std. -use std::run; +use std::libc; +use std::os; use std::run::*; +use std::run; +use std::str; #[test] fn test_destroy_once() { diff --git a/src/test/run-pass/default-method-simple.rs b/src/test/run-pass/default-method-simple.rs index 3f44f3f1ef8..378852d8150 100644 --- a/src/test/run-pass/default-method-simple.rs +++ b/src/test/run-pass/default-method-simple.rs @@ -12,7 +12,7 @@ trait Foo { fn f(&self) { - io::println("Hello!"); + println("Hello!"); self.g(); } fn g(&self); @@ -24,7 +24,7 @@ struct A { impl Foo for A { fn g(&self) { - io::println("Goodbye!"); + println("Goodbye!"); } } diff --git a/src/test/run-pass/deriving-rand.rs b/src/test/run-pass/deriving-rand.rs index dd4664e7446..193bb1628ef 100644 --- a/src/test/run-pass/deriving-rand.rs +++ b/src/test/run-pass/deriving-rand.rs @@ -9,6 +9,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::rand; + #[deriving(Rand)] struct A; @@ -36,4 +38,4 @@ fn main() { rand::random::<C>(); rand::random::<D>(); } -} \ No newline at end of file +} diff --git a/src/test/run-pass/deriving-to-str.rs b/src/test/run-pass/deriving-to-str.rs index 4b98f9a73c5..fcf0a009d9b 100644 --- a/src/test/run-pass/deriving-to-str.rs +++ b/src/test/run-pass/deriving-to-str.rs @@ -9,6 +9,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::rand; + #[deriving(Rand,ToStr)] struct A; @@ -42,4 +44,4 @@ fn main() { t!(C); t!(D); } -} \ No newline at end of file +} diff --git a/src/test/run-pass/drop-trait-generic.rs b/src/test/run-pass/drop-trait-generic.rs index 6c565604fce..894c387b036 100644 --- a/src/test/run-pass/drop-trait-generic.rs +++ b/src/test/run-pass/drop-trait-generic.rs @@ -15,7 +15,7 @@ struct S<T> { #[unsafe_destructor] impl<T> ::std::ops::Drop for S<T> { fn finalize(&self) { - io::println("bye"); + println("bye"); } } diff --git a/src/test/run-pass/drop-trait.rs b/src/test/run-pass/drop-trait.rs index b516c6f6de4..258a0f88ab5 100644 --- a/src/test/run-pass/drop-trait.rs +++ b/src/test/run-pass/drop-trait.rs @@ -14,7 +14,7 @@ struct Foo { impl Drop for Foo { fn finalize(&self) { - io::println("bye"); + println("bye"); } } diff --git a/src/test/run-pass/early-vtbl-resolution.rs b/src/test/run-pass/early-vtbl-resolution.rs index 58b192e839b..57f4a41fee9 100644 --- a/src/test/run-pass/early-vtbl-resolution.rs +++ b/src/test/run-pass/early-vtbl-resolution.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; trait thing<A> { fn foo(&self) -> Option<A>; diff --git a/src/test/run-pass/empty-tag.rs b/src/test/run-pass/empty-tag.rs index a8822e9a3fc..7b9046318ab 100644 --- a/src/test/run-pass/empty-tag.rs +++ b/src/test/run-pass/empty-tag.rs @@ -10,7 +10,7 @@ enum chan { chan_t, } -impl cmp::Eq for chan { +impl Eq for chan { fn eq(&self, other: &chan) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/enum-alignment.rs b/src/test/run-pass/enum-alignment.rs index cf92515e010..19a6365a2e4 100644 --- a/src/test/run-pass/enum-alignment.rs +++ b/src/test/run-pass/enum-alignment.rs @@ -8,6 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::cast; +use std::ptr; +use std::sys; + fn addr_of<T>(ptr: &T) -> uint { let ptr = ptr::to_unsafe_ptr(ptr); unsafe { ptr as uint } diff --git a/src/test/run-pass/exec-env.rs b/src/test/run-pass/exec-env.rs index 2043a170aba..2437946a1f0 100644 --- a/src/test/run-pass/exec-env.rs +++ b/src/test/run-pass/exec-env.rs @@ -11,6 +11,8 @@ // xfail-fast (exec-env not supported in fast mode) // exec-env:TEST_EXEC_ENV=22 +use std::os; + pub fn main() { assert_eq!(os::getenv(~"TEST_EXEC_ENV"), Some(~"22")); } diff --git a/src/test/run-pass/export-unexported-dep.rs b/src/test/run-pass/export-unexported-dep.rs index ba2a7c6104a..004761479f3 100644 --- a/src/test/run-pass/export-unexported-dep.rs +++ b/src/test/run-pass/export-unexported-dep.rs @@ -15,7 +15,7 @@ mod foo { // not exported enum t { t1, t2, } - impl cmp::Eq for t { + impl Eq for t { fn eq(&self, other: &t) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/expr-if-struct.rs b/src/test/run-pass/expr-if-struct.rs index 13479bb80dc..00e0fe1f582 100644 --- a/src/test/run-pass/expr-if-struct.rs +++ b/src/test/run-pass/expr-if-struct.rs @@ -24,7 +24,7 @@ fn test_rec() { enum mood { happy, sad, } -impl cmp::Eq for mood { +impl Eq for mood { fn eq(&self, other: &mood) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/expr-match-struct.rs b/src/test/run-pass/expr-match-struct.rs index 57483d96e8b..7cfcc38f8dd 100644 --- a/src/test/run-pass/expr-match-struct.rs +++ b/src/test/run-pass/expr-match-struct.rs @@ -23,7 +23,7 @@ fn test_rec() { enum mood { happy, sad, } -impl cmp::Eq for mood { +impl Eq for mood { fn eq(&self, other: &mood) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/extern-call-deep.rs b/src/test/run-pass/extern-call-deep.rs index 6831048bee4..9a50c2ceb02 100644 --- a/src/test/run-pass/extern-call-deep.rs +++ b/src/test/run-pass/extern-call-deep.rs @@ -8,7 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::libc; + mod rustrt { + use std::libc; + pub extern { pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t; diff --git a/src/test/run-pass/extern-call-deep2.rs b/src/test/run-pass/extern-call-deep2.rs index 4c5d4218b1f..c4ccf645be4 100644 --- a/src/test/run-pass/extern-call-deep2.rs +++ b/src/test/run-pass/extern-call-deep2.rs @@ -8,7 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::libc; +use std::task; + mod rustrt { + use std::libc; + pub extern { pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t; diff --git a/src/test/run-pass/extern-call-scrub.rs b/src/test/run-pass/extern-call-scrub.rs index 5c4d594476f..e0f352a81ef 100644 --- a/src/test/run-pass/extern-call-scrub.rs +++ b/src/test/run-pass/extern-call-scrub.rs @@ -12,7 +12,12 @@ // make sure the stack pointers are maintained properly in both // directions +use std::libc; +use std::task; + mod rustrt { + use std::libc; + pub extern { pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t; diff --git a/src/test/run-pass/extern-call.rs b/src/test/run-pass/extern-call.rs index ec335cf8a82..4c36090015b 100644 --- a/src/test/run-pass/extern-call.rs +++ b/src/test/run-pass/extern-call.rs @@ -8,7 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::libc; + mod rustrt { + use std::libc; + pub extern { pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t; diff --git a/src/test/run-pass/extern-mod-syntax.rs b/src/test/run-pass/extern-mod-syntax.rs index 0db61fc8cd5..b78f607792b 100644 --- a/src/test/run-pass/extern-mod-syntax.rs +++ b/src/test/run-pass/extern-mod-syntax.rs @@ -14,5 +14,5 @@ extern mod extra; use extra::json::Object; pub fn main() { - io::println("Hello world!"); + println("Hello world!"); } diff --git a/src/test/run-pass/extern-pub.rs b/src/test/run-pass/extern-pub.rs index 1cd709ee91b..29b0457fc05 100644 --- a/src/test/run-pass/extern-pub.rs +++ b/src/test/run-pass/extern-pub.rs @@ -1,3 +1,7 @@ +use std::libc; +use std::sys; +use std::vec; + extern { pub unsafe fn vec_reserve_shared_actual(t: *sys::TypeDesc, v: **vec::raw::VecRepr, diff --git a/src/test/run-pass/extern-stress.rs b/src/test/run-pass/extern-stress.rs index 4257f2b2435..9da4dffffc2 100644 --- a/src/test/run-pass/extern-stress.rs +++ b/src/test/run-pass/extern-stress.rs @@ -11,7 +11,12 @@ // This creates a bunch of yielding tasks that run concurrently // while holding onto C stacks +use std::libc; +use std::task; + mod rustrt { + use std::libc; + pub extern { pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t; diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs index b0c44030a17..75e259a38c1 100644 --- a/src/test/run-pass/extern-yield.rs +++ b/src/test/run-pass/extern-yield.rs @@ -8,7 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::libc; +use std::task; + mod rustrt { + use std::libc; + pub extern { pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t; diff --git a/src/test/run-pass/fixed_length_vec_glue.rs b/src/test/run-pass/fixed_length_vec_glue.rs index eef898a05ed..d026f041250 100644 --- a/src/test/run-pass/fixed_length_vec_glue.rs +++ b/src/test/run-pass/fixed_length_vec_glue.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::sys; + struct Struc { a: u8, b: [int, ..3], c: int } pub fn main() { diff --git a/src/test/run-pass/float-literal-inference.rs b/src/test/run-pass/float-literal-inference.rs index a5246eef0b0..d2c872c0534 100644 --- a/src/test/run-pass/float-literal-inference.rs +++ b/src/test/run-pass/float-literal-inference.rs @@ -14,9 +14,9 @@ struct S { pub fn main() { let x: f32 = 4.0; - io::println(x.to_str()); + println(x.to_str()); let y: float = 64.0; - io::println(y.to_str()); + println(y.to_str()); let z = S { z: 1.0 }; - io::println(z.z.to_str()); + println(z.z.to_str()); } diff --git a/src/test/run-pass/fn-pattern-expected-type-2.rs b/src/test/run-pass/fn-pattern-expected-type-2.rs index 501bd81d558..ee1e7311024 100644 --- a/src/test/run-pass/fn-pattern-expected-type-2.rs +++ b/src/test/run-pass/fn-pattern-expected-type-2.rs @@ -11,7 +11,7 @@ pub fn main() { let v : &[(int,int)] = &[ (1, 2), (3, 4), (5, 6) ]; for v.each |&(x, y)| { - io::println(y.to_str()); - io::println(x.to_str()); + println(y.to_str()); + println(x.to_str()); } } diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs index bbcb7d58923..4926dbd0086 100644 --- a/src/test/run-pass/for-destruct.rs +++ b/src/test/run-pass/for-destruct.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + struct Pair { x: int, y: int } pub fn main() { diff --git a/src/test/run-pass/foreign-call-no-runtime.rs b/src/test/run-pass/foreign-call-no-runtime.rs index 6ff8b24ab83..e9bf17a037a 100644 --- a/src/test/run-pass/foreign-call-no-runtime.rs +++ b/src/test/run-pass/foreign-call-no-runtime.rs @@ -1,3 +1,5 @@ +use std::cast; +use std::libc; use std::unstable::run_in_bare_thread; extern { diff --git a/src/test/run-pass/foreign-dupe.rs b/src/test/run-pass/foreign-dupe.rs index fe1d5e1200d..200610e0dfe 100644 --- a/src/test/run-pass/foreign-dupe.rs +++ b/src/test/run-pass/foreign-dupe.rs @@ -12,6 +12,8 @@ // calling pin_task and that's having wierd side-effects. mod rustrt1 { + use std::libc; + #[abi = "cdecl"] #[link_name = "rustrt"] pub extern { @@ -20,6 +22,8 @@ mod rustrt1 { } mod rustrt2 { + use std::libc; + #[abi = "cdecl"] #[link_name = "rustrt"] pub extern { diff --git a/src/test/run-pass/foreign-fn-linkname.rs b/src/test/run-pass/foreign-fn-linkname.rs index 15e14e3abe5..27b0c903791 100644 --- a/src/test/run-pass/foreign-fn-linkname.rs +++ b/src/test/run-pass/foreign-fn-linkname.rs @@ -10,6 +10,10 @@ extern mod extra; +use std::libc; +use std::str; +use std::vec; + mod libc { #[nolink] #[abi = "cdecl"] diff --git a/src/test/run-pass/foreign-no-abi.rs b/src/test/run-pass/foreign-no-abi.rs index 67959be866e..76ce5625844 100644 --- a/src/test/run-pass/foreign-no-abi.rs +++ b/src/test/run-pass/foreign-no-abi.rs @@ -11,6 +11,8 @@ // ABI is cdecl by default mod rustrt { + use std::libc; + pub extern { pub fn get_task_id() -> libc::intptr_t; } diff --git a/src/test/run-pass/functional-struct-update.rs b/src/test/run-pass/functional-struct-update.rs index 297b5e78a92..6d95f6b23ab 100644 --- a/src/test/run-pass/functional-struct-update.rs +++ b/src/test/run-pass/functional-struct-update.rs @@ -16,5 +16,5 @@ struct Foo { pub fn main() { let a = Foo { x: 1, y: 2 }; let c = Foo { x: 4, .. a}; - io::println(fmt!("%?", c)); + println(fmt!("%?", c)); } diff --git a/src/test/run-pass/generic-newtype-struct.rs b/src/test/run-pass/generic-newtype-struct.rs index cf4279d67b8..541f9460bc0 100644 --- a/src/test/run-pass/generic-newtype-struct.rs +++ b/src/test/run-pass/generic-newtype-struct.rs @@ -2,5 +2,5 @@ struct S<T>(T); pub fn main() { let s = S(2i); - io::println(s.to_str()); + println(s.to_str()); } diff --git a/src/test/run-pass/getopts_ref.rs b/src/test/run-pass/getopts_ref.rs index 5abef9e5f89..3be685c6389 100644 --- a/src/test/run-pass/getopts_ref.rs +++ b/src/test/run-pass/getopts_ref.rs @@ -19,9 +19,9 @@ pub fn main() { let opts = ~[optopt(~"b")]; match getopts(args, opts) { - result::Ok(ref m) => + Ok(ref m) => assert!(!opt_present(m, "b")), - result::Err(ref f) => fail!(fail_str(copy *f)) + Err(ref f) => fail!(fail_str(copy *f)) }; } diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index fb82e93047d..e7317031332 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -19,8 +19,10 @@ pub fn map(filename: ~str, emit: map_reduce::putter) { emit(filename, ~"1"); } mod map_reduce { - use std::hashmap::HashMap; use std::comm::*; + use std::hashmap::HashMap; + use std::str; + use std::task; pub type putter = @fn(~str, ~str); diff --git a/src/test/run-pass/hello.rs b/src/test/run-pass/hello.rs index 84d525dd0e6..93f6c3db255 100644 --- a/src/test/run-pass/hello.rs +++ b/src/test/run-pass/hello.rs @@ -9,7 +9,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - pub fn main() { - io::println("hello, world"); + println("hello, world"); } diff --git a/src/test/run-pass/impl-privacy-xc-2.rs b/src/test/run-pass/impl-privacy-xc-2.rs index 74d9a34e161..b3e4a4e6711 100644 --- a/src/test/run-pass/impl-privacy-xc-2.rs +++ b/src/test/run-pass/impl-privacy-xc-2.rs @@ -6,5 +6,5 @@ extern mod impl_privacy_xc_2; pub fn main() { let fish1 = impl_privacy_xc_2::Fish { x: 1 }; let fish2 = impl_privacy_xc_2::Fish { x: 2 }; - io::println(if fish1.eq(&fish2) { "yes" } else { "no " }); + println(if fish1.eq(&fish2) { "yes" } else { "no " }); } diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs index 0e95ee25c42..b036a57e19c 100644 --- a/src/test/run-pass/import-glob-crate.rs +++ b/src/test/run-pass/import-glob-crate.rs @@ -16,6 +16,6 @@ use std::vec::*; pub fn main() { let mut v = from_elem(0u, 0); - v = vec::append(v, ~[4, 2]); + v = append(v, ~[4, 2]); assert_eq!(reversed(v), ~[2, 4]); } diff --git a/src/test/run-pass/instantiable.rs b/src/test/run-pass/instantiable.rs index 2173bae85e1..5415a6ad258 100644 --- a/src/test/run-pass/instantiable.rs +++ b/src/test/run-pass/instantiable.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ptr; // check that we do not report a type like this as uninstantiable, // even though it would be if the nxt field had type @foo: diff --git a/src/test/run-pass/intrinsics-math.rs b/src/test/run-pass/intrinsics-math.rs index c73df8209e8..b7e449a1117 100644 --- a/src/test/run-pass/intrinsics-math.rs +++ b/src/test/run-pass/intrinsics-math.rs @@ -10,6 +10,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::f64; + mod rusti { #[abi = "rust-intrinsic"] pub extern "rust-intrinsic" { @@ -50,6 +52,9 @@ pub fn main() { unsafe { use rusti::*; + use std::f32; + use std::f64; + assert!((sqrtf32(64f32).approx_eq(&8f32))); assert!((sqrtf64(64f64).approx_eq(&8f64))); diff --git a/src/test/run-pass/invoke-external-foreign.rs b/src/test/run-pass/invoke-external-foreign.rs index 69fce9e541e..15f08ca23e7 100644 --- a/src/test/run-pass/invoke-external-foreign.rs +++ b/src/test/run-pass/invoke-external-foreign.rs @@ -18,5 +18,7 @@ extern mod foreign_lib; pub fn main() { - let foo = foreign_lib::rustrt::rust_get_argc(); + unsafe { + let foo = foreign_lib::rustrt::rust_get_argc(); + } } diff --git a/src/test/run-pass/issue-1251.rs b/src/test/run-pass/issue-1251.rs index c14dd625a8e..886ea53c299 100644 --- a/src/test/run-pass/issue-1251.rs +++ b/src/test/run-pass/issue-1251.rs @@ -11,6 +11,8 @@ #[link(name = "get_task_id")]; mod rustrt { + use std::libc; + pub extern { pub fn get_task_id() -> libc::intptr_t; } diff --git a/src/test/run-pass/issue-1696.rs b/src/test/run-pass/issue-1696.rs index d531217e550..62088e013be 100644 --- a/src/test/run-pass/issue-1696.rs +++ b/src/test/run-pass/issue-1696.rs @@ -11,6 +11,7 @@ // except according to those terms. use std::hashmap::HashMap; +use std::str; pub fn main() { let mut m = HashMap::new(); diff --git a/src/test/run-pass/issue-2611.rs b/src/test/run-pass/issue-2611.rs index 3d4bed4b62f..d7508bca41e 100644 --- a/src/test/run-pass/issue-2611.rs +++ b/src/test/run-pass/issue-2611.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::old_iter::BaseIter; +use std::old_iter; trait FlatMapToVec<A> { fn flat_map_to_vec<B, IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B]; diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index 48599b2a538..4dad60225dd 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -14,8 +14,10 @@ use std::util; // tjc: I don't know why pub mod pipes { - use std::util; use std::cast::{forget, transmute}; + use std::cast; + use std::task; + use std::util; pub struct Stuff<T> { state: state, diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs index bb2dbb9fe21..d42d0b5aac0 100644 --- a/src/test/run-pass/issue-2804.rs +++ b/src/test/run-pass/issue-2804.rs @@ -11,8 +11,10 @@ // except according to those terms. extern mod extra; -use std::hashmap::HashMap; + use extra::json; +use std::hashmap::HashMap; +use std::option; enum object { bool_value(bool), diff --git a/src/test/run-pass/issue-2895.rs b/src/test/run-pass/issue-2895.rs index 780ea2dc2c9..e6b3f9f6f35 100644 --- a/src/test/run-pass/issue-2895.rs +++ b/src/test/run-pass/issue-2895.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::sys; + struct Cat { x: int } diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs index 1cb8a74e5a4..7670a7eee7c 100644 --- a/src/test/run-pass/issue-2904.rs +++ b/src/test/run-pass/issue-2904.rs @@ -15,6 +15,9 @@ extern mod extra; use std::io::ReaderUtil; +use std::io; +use std::str; +use std::to_str; enum square { bot, diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs index 8ef67840ba3..c13821bddf1 100644 --- a/src/test/run-pass/issue-2989.rs +++ b/src/test/run-pass/issue-2989.rs @@ -10,6 +10,10 @@ extern mod extra; +use std::io; +use std::uint; +use std::vec; + trait methods { fn to_bytes(&self) -> ~[u8]; } diff --git a/src/test/run-pass/issue-3012-2.rs b/src/test/run-pass/issue-3012-2.rs index ef115c5c02c..7d478bbabeb 100644 --- a/src/test/run-pass/issue-3012-2.rs +++ b/src/test/run-pass/issue-3012-2.rs @@ -11,7 +11,9 @@ // xfail-fast // aux-build:issue-3012-1.rs extern mod socketlib; + use socketlib::socket; +use std::libc; pub fn main() { let fd: libc::c_int = 1 as libc::c_int; diff --git a/src/test/run-pass/issue-3168.rs b/src/test/run-pass/issue-3168.rs index d4eb0793dac..fbe66708e47 100644 --- a/src/test/run-pass/issue-3168.rs +++ b/src/test/run-pass/issue-3168.rs @@ -10,6 +10,9 @@ // xfail-fast +use std::comm; +use std::task; + pub fn main() { let (p,c) = comm::stream(); do task::try || { diff --git a/src/test/run-pass/issue-3176.rs b/src/test/run-pass/issue-3176.rs index 54094a0c008..96648a2706b 100644 --- a/src/test/run-pass/issue-3176.rs +++ b/src/test/run-pass/issue-3176.rs @@ -11,6 +11,8 @@ // xfail-fast use std::comm::{Select2, Selectable}; +use std::comm; +use std::task; pub fn main() { let (p,c) = comm::stream(); diff --git a/src/test/run-pass/issue-3211.rs b/src/test/run-pass/issue-3211.rs index 360df325919..c7b0823296c 100644 --- a/src/test/run-pass/issue-3211.rs +++ b/src/test/run-pass/issue-3211.rs @@ -4,5 +4,5 @@ pub fn main() { x += 1; } assert_eq!(x, 4096); - io::println(fmt!("x = %u", x)); + println(fmt!("x = %u", x)); } diff --git a/src/test/run-pass/issue-3389.rs b/src/test/run-pass/issue-3389.rs index 6203f14f10f..d9919b1695d 100644 --- a/src/test/run-pass/issue-3389.rs +++ b/src/test/run-pass/issue-3389.rs @@ -15,7 +15,7 @@ struct trie_node { fn print_str_vector(vector: ~[~str]) { for vector.each() |string| { - io::println(*string); + println(*string); } } diff --git a/src/test/run-pass/issue-3424.rs b/src/test/run-pass/issue-3424.rs index a6eb5097b36..a40d1cf1c6e 100644 --- a/src/test/run-pass/issue-3424.rs +++ b/src/test/run-pass/issue-3424.rs @@ -12,7 +12,10 @@ // rustc --test ignores2.rs && ./ignores2 extern mod extra; + use std::path::{Path}; +use std::path; +use std::result; type rsrc_loader = ~fn(path: &Path) -> result::Result<~str, ~str>; diff --git a/src/test/run-pass/issue-3447.rs b/src/test/run-pass/issue-3447.rs index 191259e5a57..20355238e3e 100644 --- a/src/test/run-pass/issue-3447.rs +++ b/src/test/run-pass/issue-3447.rs @@ -17,7 +17,7 @@ pub impl<'self, T> list<'self, T>{ fn addEnd(&mut self, element: &'self T) { let newList = list { element: element, - next: option::None + next: None }; self.next = Some(@mut newList); @@ -28,7 +28,7 @@ pub fn main() { let s = @"str"; let ls = list { element: &s, - next: option::None + next: None }; - io::println(*ls.element); + println(*ls.element); } diff --git a/src/test/run-pass/issue-3556.rs b/src/test/run-pass/issue-3556.rs index ca67f1dae43..6709ef761a4 100644 --- a/src/test/run-pass/issue-3556.rs +++ b/src/test/run-pass/issue-3556.rs @@ -9,7 +9,9 @@ // except according to those terms. extern mod extra; + use std::io::WriterUtil; +use std::io; enum Token { Text(@~str), diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs index bfdf4aa053d..10d448b7952 100644 --- a/src/test/run-pass/issue-3563-3.rs +++ b/src/test/run-pass/issue-3563-3.rs @@ -20,7 +20,11 @@ extern mod extra; // Extern mod controls linkage. Use controls the visibility of names to modules that are // already linked in. Using WriterUtil allows us to use the write_line method. +use std::int; use std::io::WriterUtil; +use std::io; +use std::str; +use std::vec; // Represents a position on a canvas. struct Point { diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs index a1aced7b5df..ab62d9c4142 100644 --- a/src/test/run-pass/issue-3609.rs +++ b/src/test/run-pass/issue-3609.rs @@ -1,6 +1,8 @@ extern mod extra; use std::comm::Chan; +use std::task; +use std::uint; type RingBuffer = ~[float]; type SamplesFn = ~fn(samples: &RingBuffer); diff --git a/src/test/run-pass/issue-3702.rs b/src/test/run-pass/issue-3702.rs index 7c2f8cf98cb..7d65d6e984c 100644 --- a/src/test/run-pass/issue-3702.rs +++ b/src/test/run-pass/issue-3702.rs @@ -14,7 +14,7 @@ pub fn main() { } fn to_string(t: @Text) { - io::println(t.to_str()); + println(t.to_str()); } } diff --git a/src/test/run-pass/issue-3753.rs b/src/test/run-pass/issue-3753.rs index 948ff1afd81..825a49e91b0 100644 --- a/src/test/run-pass/issue-3753.rs +++ b/src/test/run-pass/issue-3753.rs @@ -12,6 +12,8 @@ // Issue Name: pub method preceeded by attribute can't be parsed // Abstract: Visibility parsing failed when compiler parsing +use std::float; + struct Point { x: float, y: float @@ -33,5 +35,5 @@ pub impl Shape { pub fn main(){ let s = Circle(Point { x: 1f, y: 2f }, 3f); - io::println(fmt!("%f", s.area(s))); + println(fmt!("%f", s.area(s))); } diff --git a/src/test/run-pass/issue-3847.rs b/src/test/run-pass/issue-3847.rs index 4d1b042661c..b5f41dd1630 100644 --- a/src/test/run-pass/issue-3847.rs +++ b/src/test/run-pass/issue-3847.rs @@ -18,5 +18,5 @@ pub fn main() { buildings::Tower { height: h } => { h } }; - io::println(h.to_str()); + println(h.to_str()); } diff --git a/src/test/run-pass/issue-3888-2.rs b/src/test/run-pass/issue-3888-2.rs index 2992d9a4ac8..60c50624435 100644 --- a/src/test/run-pass/issue-3888-2.rs +++ b/src/test/run-pass/issue-3888-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] { // This doesn't work, and should. // v.slice(1, 5) diff --git a/src/test/run-pass/issue-4333.rs b/src/test/run-pass/issue-4333.rs index 159ba4bb255..98280271bde 100644 --- a/src/test/run-pass/issue-4333.rs +++ b/src/test/run-pass/issue-4333.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::io; + fn main() { let stdout = &io::stdout() as &io::WriterUtil; stdout.write_line("Hello!"); diff --git a/src/test/run-pass/issue-4401.rs b/src/test/run-pass/issue-4401.rs index 73faa9845e7..d0d211c109c 100644 --- a/src/test/run-pass/issue-4401.rs +++ b/src/test/run-pass/issue-4401.rs @@ -4,5 +4,5 @@ pub fn main() { count += 1; } assert_eq!(count, 999_999); - io::println(fmt!("%u", count)); + println(fmt!("%u", count)); } diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs index e1ec65bc10f..212406f9a20 100644 --- a/src/test/run-pass/issue-4448.rs +++ b/src/test/run-pass/issue-4448.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm; +use std::task; + pub fn main() { let (port, chan) = comm::stream::<&'static str>(); diff --git a/src/test/run-pass/issue-5572.rs b/src/test/run-pass/issue-5572.rs index d0db5e5cb3c..064413dd93c 100644 --- a/src/test/run-pass/issue-5572.rs +++ b/src/test/run-pass/issue-5572.rs @@ -1,3 +1,3 @@ -fn foo<T: ::cmp::Eq>(t: T) { } +fn foo<T: ::std::cmp::Eq>(t: T) { } fn main() { } diff --git a/src/test/run-pass/issue-5741.rs b/src/test/run-pass/issue-5741.rs index b80e37a425b..d6d09cb0510 100644 --- a/src/test/run-pass/issue-5741.rs +++ b/src/test/run-pass/issue-5741.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::io; + fn main() { return; while io::stdin().read_line() != ~"quit" { }; diff --git a/src/test/run-pass/item-attributes.rs b/src/test/run-pass/item-attributes.rs index 5a1d54c48b5..de11ce2bdf2 100644 --- a/src/test/run-pass/item-attributes.rs +++ b/src/test/run-pass/item-attributes.rs @@ -167,6 +167,8 @@ mod test_other_forms { mod test_foreign_items { pub mod rustrt { + use std::libc; + #[abi = "cdecl"] pub extern { #[attr]; diff --git a/src/test/run-pass/iter-all.rs b/src/test/run-pass/iter-all.rs index b21ddc656c9..b3177d1f84f 100644 --- a/src/test/run-pass/iter-all.rs +++ b/src/test/run-pass/iter-all.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + fn is_even(x: &uint) -> bool { (*x % 2) == 0 } pub fn main() { diff --git a/src/test/run-pass/iter-any.rs b/src/test/run-pass/iter-any.rs index 657c8d7c624..08a89f8dd22 100644 --- a/src/test/run-pass/iter-any.rs +++ b/src/test/run-pass/iter-any.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + fn is_even(x: &uint) -> bool { (*x % 2) == 0 } pub fn main() { diff --git a/src/test/run-pass/iter-contains.rs b/src/test/run-pass/iter-contains.rs index 5d5db170efe..5034102c730 100644 --- a/src/test/run-pass/iter-contains.rs +++ b/src/test/run-pass/iter-contains.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + pub fn main() { assert_eq!([].contains(&22u), false); assert_eq!([1u, 3u].contains(&22u), false); diff --git a/src/test/run-pass/iter-count.rs b/src/test/run-pass/iter-count.rs index 3f717195fbc..3f867e49bd4 100644 --- a/src/test/run-pass/iter-count.rs +++ b/src/test/run-pass/iter-count.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + pub fn main() { assert_eq!([].count(&22u), 0u); assert_eq!([1u, 3u].count(&22u), 0u); diff --git a/src/test/run-pass/iter-eachi.rs b/src/test/run-pass/iter-eachi.rs index 781f02230c0..0740f2cb8e4 100644 --- a/src/test/run-pass/iter-eachi.rs +++ b/src/test/run-pass/iter-eachi.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + pub fn main() { let mut c = 0u; for [1u, 2u, 3u, 4u, 5u].eachi |i, v| { diff --git a/src/test/run-pass/iter-filter-to-vec.rs b/src/test/run-pass/iter-filter-to-vec.rs index 0bb7cd1c4dd..2b254765c76 100644 --- a/src/test/run-pass/iter-filter-to-vec.rs +++ b/src/test/run-pass/iter-filter-to-vec.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + fn is_even(x: &uint) -> bool { (*x % 2) == 0 } pub fn main() { diff --git a/src/test/run-pass/iter-flat-map-to-vec.rs b/src/test/run-pass/iter-flat-map-to-vec.rs index af23905fe76..b0b61aaa816 100644 --- a/src/test/run-pass/iter-flat-map-to-vec.rs +++ b/src/test/run-pass/iter-flat-map-to-vec.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + fn repeat(x: &uint) -> ~[uint] { ~[*x, *x] } fn incd_if_even(x: &uint) -> Option<uint> { diff --git a/src/test/run-pass/iter-foldl.rs b/src/test/run-pass/iter-foldl.rs index f40abe0c56c..7e5890b3e3a 100644 --- a/src/test/run-pass/iter-foldl.rs +++ b/src/test/run-pass/iter-foldl.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + fn add(x: &float, y: &uint) -> float { *x + ((*y) as float) } pub fn main() { diff --git a/src/test/run-pass/iter-map-to-vec.rs b/src/test/run-pass/iter-map-to-vec.rs index e9fd68d10f1..706f0c5c150 100644 --- a/src/test/run-pass/iter-map-to-vec.rs +++ b/src/test/run-pass/iter-map-to-vec.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + fn inc(x: &uint) -> uint { *x + 1 } pub fn main() { diff --git a/src/test/run-pass/iter-min-max.rs b/src/test/run-pass/iter-min-max.rs index 6ce24aedf13..9020976029d 100644 --- a/src/test/run-pass/iter-min-max.rs +++ b/src/test/run-pass/iter-min-max.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + fn is_even(x: uint) -> bool { (x % 2u) == 0u } pub fn main() { diff --git a/src/test/run-pass/iter-to-vec.rs b/src/test/run-pass/iter-to-vec.rs index b7f2ac77074..317b6089637 100644 --- a/src/test/run-pass/iter-to-vec.rs +++ b/src/test/run-pass/iter-to-vec.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::old_iter; + pub fn main() { assert_eq!([1u, 3u].to_vec(), ~[1u, 3u]); let e: ~[uint] = ~[]; diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs index 5b1102a1917..8d87ff40061 100644 --- a/src/test/run-pass/ivec-tag.rs +++ b/src/test/run-pass/ivec-tag.rs @@ -1,4 +1,5 @@ use std::comm::*; +use std::task; fn producer(c: &Chan<~[u8]>) { c.send( diff --git a/src/test/run-pass/let-assignability.rs b/src/test/run-pass/let-assignability.rs index 0afc3ee87e0..2a341474872 100644 --- a/src/test/run-pass/let-assignability.rs +++ b/src/test/run-pass/let-assignability.rs @@ -11,7 +11,7 @@ fn f() { let a = ~"hello"; let b: &str = a; - io::println(b); + println(b); } pub fn main() { diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs index c9f768d7606..7ab915a9628 100644 --- a/src/test/run-pass/linear-for-loop.rs +++ b/src/test/run-pass/linear-for-loop.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +use std::str; pub fn main() { let x = ~[1, 2, 3]; diff --git a/src/test/run-pass/log-str.rs b/src/test/run-pass/log-str.rs index d45602d9ed1..fc48f4aea0c 100644 --- a/src/test/run-pass/log-str.rs +++ b/src/test/run-pass/log-str.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::sys; + pub fn main() { let act = sys::log_str(&~[1, 2, 3]); assert_eq!(~"~[1, 2, 3]", act); diff --git a/src/test/run-pass/lots-a-fail.rs b/src/test/run-pass/lots-a-fail.rs index 4eb0cd81bc3..04486a83455 100644 --- a/src/test/run-pass/lots-a-fail.rs +++ b/src/test/run-pass/lots-a-fail.rs @@ -11,6 +11,9 @@ // xfail-win32 leaks extern mod extra; +use std::task; +use std::uint; + fn die() { fail!(); } diff --git a/src/test/run-pass/match-ref-binding-in-guard-3256.rs b/src/test/run-pass/match-ref-binding-in-guard-3256.rs index ed7a6316374..a199a75de56 100644 --- a/src/test/run-pass/match-ref-binding-in-guard-3256.rs +++ b/src/test/run-pass/match-ref-binding-in-guard-3256.rs @@ -8,12 +8,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::unstable; + pub fn main() { - let x = Some(unstable::sync::exclusive(true)); - match x { - Some(ref z) if z.with(|b| *b) => { - do z.with |b| { assert!(*b); } - }, - _ => fail!() + unsafe { + let x = Some(unstable::sync::exclusive(true)); + match x { + Some(ref z) if z.with(|b| *b) => { + do z.with |b| { assert!(*b); } + }, + _ => fail!() + } } } diff --git a/src/test/run-pass/match-with-ret-arm.rs b/src/test/run-pass/match-with-ret-arm.rs index f46521f1d55..fb85064bfde 100644 --- a/src/test/run-pass/match-with-ret-arm.rs +++ b/src/test/run-pass/match-with-ret-arm.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; + pub fn main() { // sometimes we have had trouble finding // the right type for f, as we unified diff --git a/src/test/run-pass/max-min-classes.rs b/src/test/run-pass/max-min-classes.rs index d986d7e676a..87e80568c32 100644 --- a/src/test/run-pass/max-min-classes.rs +++ b/src/test/run-pass/max-min-classes.rs @@ -35,5 +35,5 @@ fn Foo(x: int, y: int) -> Foo { pub fn main() { let foo = Foo(3, 20); - io::println(fmt!("%d %d", foo.sum(), foo.product())); + println(fmt!("%d %d", foo.sum(), foo.product())); } diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs index 6803eb1c6d7..69545238db4 100644 --- a/src/test/run-pass/monad.rs +++ b/src/test/run-pass/monad.rs @@ -10,6 +10,8 @@ // xfail-fast +use std::int; + trait vec_monad<A> { fn bind<B:Copy>(&self, f: &fn(&A) -> ~[B]) -> ~[B]; } diff --git a/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs b/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs index efbf9302117..eb3c1e4cd27 100644 --- a/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs +++ b/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs @@ -10,6 +10,8 @@ extern mod extra; +use std::io; + trait Serializer { } diff --git a/src/test/run-pass/morestack5.rs b/src/test/run-pass/morestack5.rs index 492196ed7f0..7f947e332c0 100644 --- a/src/test/run-pass/morestack5.rs +++ b/src/test/run-pass/morestack5.rs @@ -12,6 +12,8 @@ extern mod extra; +use std::task; + fn getbig(i: int) { if i != 0 { getbig(i - 1); diff --git a/src/test/run-pass/morestack6.rs b/src/test/run-pass/morestack6.rs index 79c66ba72b0..1dc8503aeb2 100644 --- a/src/test/run-pass/morestack6.rs +++ b/src/test/run-pass/morestack6.rs @@ -11,7 +11,12 @@ // This test attempts to force the dynamic linker to resolve // external symbols as close to the red zone as possible. +use std::rand; +use std::task; + mod rustrt { + use std::libc; + pub extern { pub fn debug_get_stk_seg() -> *u8; diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs index 7b71fc4f86e..1df2e3a382d 100644 --- a/src/test/run-pass/move-3-unique.rs +++ b/src/test/run-pass/move-3-unique.rs @@ -10,6 +10,8 @@ extern mod extra; +use std::uint; + struct Triple { x: int, y: int, z: int } fn test(x: bool, foo: ~Triple) -> int { diff --git a/src/test/run-pass/move-3.rs b/src/test/run-pass/move-3.rs index 64519034ebe..a52f34c54db 100644 --- a/src/test/run-pass/move-3.rs +++ b/src/test/run-pass/move-3.rs @@ -10,6 +10,8 @@ extern mod extra; +use std::uint; + struct Triple { x: int, y: int, z: int } fn test(x: bool, foo: @Triple) -> int { diff --git a/src/test/run-pass/move-self.rs b/src/test/run-pass/move-self.rs index 4ed1faf65b6..61ece52453e 100644 --- a/src/test/run-pass/move-self.rs +++ b/src/test/run-pass/move-self.rs @@ -8,7 +8,7 @@ pub impl S { } fn bar(self) { - io::println(self.x); + println(self.x); } } diff --git a/src/test/run-pass/moves-based-on-type-capture-clause.rs b/src/test/run-pass/moves-based-on-type-capture-clause.rs index 26d4773d961..349be13e323 100644 --- a/src/test/run-pass/moves-based-on-type-capture-clause.rs +++ b/src/test/run-pass/moves-based-on-type-capture-clause.rs @@ -1,6 +1,8 @@ +use std::task; + pub fn main() { let x = ~"Hello world!"; do task::spawn { - io::println(x); + println(x); } } diff --git a/src/test/run-pass/multibyte.rs b/src/test/run-pass/multibyte.rs index 7cb959b3437..417662b65c6 100644 --- a/src/test/run-pass/multibyte.rs +++ b/src/test/run-pass/multibyte.rs @@ -10,5 +10,5 @@ // Test that multibyte characters don't crash the compiler fn main() { - io::println("마이너스 사인이 없으면"); + println("마이너스 사인이 없으면"); } diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs index aef857f36ee..0b4f92f1d7c 100644 --- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs +++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + fn test1() { let mut ints = [0, ..32]; ints[0] += 1; diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs index b058df7fc7a..91f4fdb01f6 100644 --- a/src/test/run-pass/mutable-alias-vec.rs +++ b/src/test/run-pass/mutable-alias-vec.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - - // -*- rust -*- extern mod extra; +use std::vec; + fn grow(v: &mut ~[int]) { *v += ~[1]; } pub fn main() { diff --git a/src/test/run-pass/new-impl-syntax.rs b/src/test/run-pass/new-impl-syntax.rs index 2603353f0cf..71c13ecb9a3 100644 --- a/src/test/run-pass/new-impl-syntax.rs +++ b/src/test/run-pass/new-impl-syntax.rs @@ -20,6 +20,6 @@ impl<T:ToStr> ToStr for PolymorphicThingy<T> { } pub fn main() { - io::println(Thingy { x: 1, y: 2 }.to_str()); - io::println(PolymorphicThingy { x: Thingy { x: 1, y: 2 } }.to_str()); + println(Thingy { x: 1, y: 2 }.to_str()); + println(PolymorphicThingy { x: Thingy { x: 1, y: 2 } }.to_str()); } diff --git a/src/test/run-pass/newtype.rs b/src/test/run-pass/newtype.rs index 6d36357ccfa..d26210e9a4c 100644 --- a/src/test/run-pass/newtype.rs +++ b/src/test/run-pass/newtype.rs @@ -16,6 +16,6 @@ fn compute(i: mytype) -> int { return i.val + 20; } pub fn main() { let myval = mytype(Mytype{compute: compute, val: 30}); - io::println(fmt!("%d", compute(myval))); + println(fmt!("%d", compute(myval))); assert_eq!((myval.compute)(myval), 50); } diff --git a/src/test/run-pass/nullable-pointer-size.rs b/src/test/run-pass/nullable-pointer-size.rs index 1e8ddc2905e..704fd4eafba 100644 --- a/src/test/run-pass/nullable-pointer-size.rs +++ b/src/test/run-pass/nullable-pointer-size.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::sys; + enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8, ..0]) } struct S<T>(int, T); diff --git a/src/test/run-pass/operator-overloading.rs b/src/test/run-pass/operator-overloading.rs index b54e3188dae..e75af5729d5 100644 --- a/src/test/run-pass/operator-overloading.rs +++ b/src/test/run-pass/operator-overloading.rs @@ -10,6 +10,9 @@ // xfail-fast +use std::cmp; +use std::ops; + struct Point { x: int, y: int diff --git a/src/test/run-pass/option-ext.rs b/src/test/run-pass/option-ext.rs index 63114da9d9d..7355bde61f3 100644 --- a/src/test/run-pass/option-ext.rs +++ b/src/test/run-pass/option-ext.rs @@ -8,11 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::str; + pub fn main() { let thing = ~"{{ f }}"; let f = str::find_str(thing, ~"{{"); if f.is_none() { - io::println(~"None!"); + println(~"None!"); } } diff --git a/src/test/run-pass/packed-struct-generic-layout.rs b/src/test/run-pass/packed-struct-generic-layout.rs index fd6e3b670f5..18b3cf2f91e 100644 --- a/src/test/run-pass/packed-struct-generic-layout.rs +++ b/src/test/run-pass/packed-struct-generic-layout.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::cast; + #[packed] struct S<T, S> { a: T, diff --git a/src/test/run-pass/packed-struct-generic-size.rs b/src/test/run-pass/packed-struct-generic-size.rs index a5c4d5385a2..98e922c3288 100644 --- a/src/test/run-pass/packed-struct-generic-size.rs +++ b/src/test/run-pass/packed-struct-generic-size.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::sys; + #[packed] struct S<T, S> { a: T, diff --git a/src/test/run-pass/packed-struct-layout.rs b/src/test/run-pass/packed-struct-layout.rs index 8d27e55e191..ea51bbcea32 100644 --- a/src/test/run-pass/packed-struct-layout.rs +++ b/src/test/run-pass/packed-struct-layout.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::cast; + #[packed] struct S4 { a: u8, diff --git a/src/test/run-pass/packed-struct-size-xc.rs b/src/test/run-pass/packed-struct-size-xc.rs index ddfc2b17aa7..19f6046c7d6 100644 --- a/src/test/run-pass/packed-struct-size-xc.rs +++ b/src/test/run-pass/packed-struct-size-xc.rs @@ -3,6 +3,8 @@ extern mod packed; +use std::sys; + fn main() { assert_eq!(sys::size_of::<packed::S>(), 5); } diff --git a/src/test/run-pass/packed-struct-size.rs b/src/test/run-pass/packed-struct-size.rs index 372fe3d37f6..6dcb1f04a4d 100644 --- a/src/test/run-pass/packed-struct-size.rs +++ b/src/test/run-pass/packed-struct-size.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::sys; + #[packed] struct S4 { a: u8, diff --git a/src/test/run-pass/packed-struct-vec.rs b/src/test/run-pass/packed-struct-vec.rs index b1ac29b7721..1f3d4c26bd2 100644 --- a/src/test/run-pass/packed-struct-vec.rs +++ b/src/test/run-pass/packed-struct-vec.rs @@ -8,6 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::sys; +use std::uint; + #[packed] #[deriving(Eq)] struct Foo { diff --git a/src/test/run-pass/packed-tuple-struct-layout.rs b/src/test/run-pass/packed-tuple-struct-layout.rs index 9c2fe621a32..3691f475098 100644 --- a/src/test/run-pass/packed-tuple-struct-layout.rs +++ b/src/test/run-pass/packed-tuple-struct-layout.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::cast; + #[packed] struct S4(u8,[u8, .. 3]); diff --git a/src/test/run-pass/packed-tuple-struct-size.rs b/src/test/run-pass/packed-tuple-struct-size.rs index 23faa2eb0ad..c8f2dda61db 100644 --- a/src/test/run-pass/packed-tuple-struct-size.rs +++ b/src/test/run-pass/packed-tuple-struct-size.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::sys; + #[packed] struct S4(u8,[u8, .. 3]); diff --git a/src/test/run-pass/pattern-bound-var-in-for-each.rs b/src/test/run-pass/pattern-bound-var-in-for-each.rs index a2630c39803..5a0f9ed6eb4 100644 --- a/src/test/run-pass/pattern-bound-var-in-for-each.rs +++ b/src/test/run-pass/pattern-bound-var-in-for-each.rs @@ -12,6 +12,8 @@ // pattern-bound var is an upvar (when translating // the for-each body) +use std::uint; + fn foo(src: uint) { match Some(src) { diff --git a/src/test/run-pass/pattern-in-closure.rs b/src/test/run-pass/pattern-in-closure.rs index 08c749235c2..bee3583c6a4 100644 --- a/src/test/run-pass/pattern-in-closure.rs +++ b/src/test/run-pass/pattern-in-closure.rs @@ -14,8 +14,8 @@ struct Foo { } pub fn main() { - let f = |(x, _): (int, int)| io::println((x + 1).to_str()); - let g = |Foo { x: x, y: y }: Foo| io::println((x + 1).to_str()); + let f = |(x, _): (int, int)| println((x + 1).to_str()); + let g = |Foo { x: x, y: y }: Foo| println((x + 1).to_str()); f((2, 3)); g(Foo { x: 1, y: 2 }); } diff --git a/src/test/run-pass/pipe-bank-proto.rs b/src/test/run-pass/pipe-bank-proto.rs index 83031b46704..d723fa32209 100644 --- a/src/test/run-pass/pipe-bank-proto.rs +++ b/src/test/run-pass/pipe-bank-proto.rs @@ -17,6 +17,7 @@ use std::pipes; use std::pipes::try_recv; +use std::ptr; pub type username = ~str; pub type password = ~str; @@ -81,7 +82,7 @@ fn client_follow(bank: bank::client::login) { let bank = client::withdrawal(bank, 50.00); switch(bank, follow! ( money(m) -> _next { - io::println(~"Yay! I got money!"); + println(~"Yay! I got money!"); } insufficient_funds -> _next { fail!("someone stole my money") @@ -105,7 +106,7 @@ fn bank_client(bank: bank::client::login) { let bank = client::withdrawal(bank, 50.00); match try_recv(bank) { Some(money(*)) => { - io::println(~"Yay! I got money!"); + println(~"Yay! I got money!"); } Some(insufficient_funds(_)) => { fail!("someone stole my money") diff --git a/src/test/run-pass/pipe-detect-term.rs b/src/test/run-pass/pipe-detect-term.rs index d922eef5dbb..ae846217318 100644 --- a/src/test/run-pass/pipe-detect-term.rs +++ b/src/test/run-pass/pipe-detect-term.rs @@ -20,6 +20,7 @@ use extra::uv; use std::cell::Cell; use std::pipes::{try_recv, recv}; +use std::task; proto! oneshot ( waiting:send { diff --git a/src/test/run-pass/pipe-pingpong-bounded.rs b/src/test/run-pass/pipe-pingpong-bounded.rs index b4c92dc0614..d36289f33c8 100644 --- a/src/test/run-pass/pipe-pingpong-bounded.rs +++ b/src/test/run-pass/pipe-pingpong-bounded.rs @@ -15,6 +15,7 @@ // protocols. use std::cell::Cell; +use std::task; // This was generated initially by the pipe compiler, but it's been // modified in hopefully straightforward ways. diff --git a/src/test/run-pass/pipe-pingpong-proto.rs b/src/test/run-pass/pipe-pingpong-proto.rs index 95502b14c53..18cb4059307 100644 --- a/src/test/run-pass/pipe-pingpong-proto.rs +++ b/src/test/run-pass/pipe-pingpong-proto.rs @@ -14,6 +14,7 @@ use std::cell::Cell; use std::option; +use std::task; proto! pingpong ( ping:send { diff --git a/src/test/run-pass/pipe-select.rs b/src/test/run-pass/pipe-select.rs index a386c3a2e05..309092b14b5 100644 --- a/src/test/run-pass/pipe-select.rs +++ b/src/test/run-pass/pipe-select.rs @@ -18,8 +18,9 @@ use extra::timer::sleep; use extra::uv; use std::cell::Cell; -use std::pipes; use std::pipes::*; +use std::pipes; +use std::task; proto! oneshot ( waiting:send { @@ -110,8 +111,8 @@ fn test_select2() { stream::client::send(ac, 42); match pipes::select2(ap, bp) { - either::Left(*) => { } - either::Right(*) => { fail!() } + Left(*) => { } + Right(*) => { fail!() } } stream::client::send(bc, ~"abc"); @@ -124,8 +125,8 @@ fn test_select2() { stream::client::send(bc, ~"abc"); match pipes::select2(ap, bp) { - either::Left(*) => { fail!() } - either::Right(*) => { } + Left(*) => { fail!() } + Right(*) => { } } stream::client::send(ac, 42); diff --git a/src/test/run-pass/pipe-sleep.rs b/src/test/run-pass/pipe-sleep.rs index 674ad5f3405..97fefde6cff 100644 --- a/src/test/run-pass/pipe-sleep.rs +++ b/src/test/run-pass/pipe-sleep.rs @@ -11,11 +11,13 @@ // except according to those terms. extern mod extra; + use extra::timer::sleep; use extra::uv; use std::cell::Cell; -use std::pipes; use std::pipes::*; +use std::pipes; +use std::task; proto! oneshot ( waiting:send { diff --git a/src/test/run-pass/placement-new-arena.rs b/src/test/run-pass/placement-new-arena.rs index 1dafbca22f7..839f40fe67f 100644 --- a/src/test/run-pass/placement-new-arena.rs +++ b/src/test/run-pass/placement-new-arena.rs @@ -17,6 +17,6 @@ pub fn main() { let mut arena = arena::Arena(); let p = &mut arena; let x = p.alloc(|| 4u); - io::print(fmt!("%u", *x)); + print(fmt!("%u", *x)); assert_eq!(*x, 4u); } diff --git a/src/test/run-pass/platform_thread.rs b/src/test/run-pass/platform_thread.rs index 774f2470b3c..ea39d00edf7 100644 --- a/src/test/run-pass/platform_thread.rs +++ b/src/test/run-pass/platform_thread.rs @@ -12,6 +12,8 @@ // The OS main scheduler should continue to be available and not terminate // while it is not in use. +use std::task; + pub fn main() { run(100); } diff --git a/src/test/run-pass/private-method.rs b/src/test/run-pass/private-method.rs index 1fab77cb5c8..2b811a69db0 100644 --- a/src/test/run-pass/private-method.rs +++ b/src/test/run-pass/private-method.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; + struct cat { priv meows : uint, diff --git a/src/test/run-pass/rcvr-borrowed-to-slice.rs b/src/test/run-pass/rcvr-borrowed-to-slice.rs index 188dca2f039..5eaf12f6a51 100644 --- a/src/test/run-pass/rcvr-borrowed-to-slice.rs +++ b/src/test/run-pass/rcvr-borrowed-to-slice.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + trait sum { fn sum(self) -> int; } diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs index 202f6a4ac64..475b9153fdc 100644 --- a/src/test/run-pass/rec-align-u32.rs +++ b/src/test/run-pass/rec-align-u32.rs @@ -10,6 +10,8 @@ // Issue #2303 +use std::sys; + mod rusti { #[abi = "rust-intrinsic"] pub extern "rust-intrinsic" { diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs index 49092c26c95..8c67b971243 100644 --- a/src/test/run-pass/rec-align-u64.rs +++ b/src/test/run-pass/rec-align-u64.rs @@ -10,6 +10,8 @@ // Issue #2303 +use std::sys; + mod rusti { #[abi = "rust-intrinsic"] pub extern "rust-intrinsic" { diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs index 9663beb279e..387e21fb9d6 100644 --- a/src/test/run-pass/reflect-visit-data.rs +++ b/src/test/run-pass/reflect-visit-data.rs @@ -11,7 +11,10 @@ // xfail-fast use std::bool; +use std::int; use std::libc::c_void; +use std::ptr; +use std::sys; use std::vec::UnboxedVecRepr; use intrinsic::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Opaque}; @@ -654,7 +657,7 @@ pub fn main() { visit_tydesc(td, v); for (u.vals.clone()).each |s| { - io::println(fmt!("val: %s", *s)); + println(fmt!("val: %s", *s)); } error!("%?", u.vals.clone()); assert!(u.vals == ~[ diff --git a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs index 33d147c22b6..702b64881ab 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::uint; use std::util; pub fn main() { diff --git a/src/test/run-pass/regions-mock-trans.rs b/src/test/run-pass/regions-mock-trans.rs index 0ea6f852a89..56000d7471d 100644 --- a/src/test/run-pass/regions-mock-trans.rs +++ b/src/test/run-pass/regions-mock-trans.rs @@ -8,6 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::cast; +use std::libc; +use std::sys; + struct arena(()); struct Bcx<'self> { diff --git a/src/test/run-pass/resource-cycle.rs b/src/test/run-pass/resource-cycle.rs index f498553834a..3ce5ea66781 100644 --- a/src/test/run-pass/resource-cycle.rs +++ b/src/test/run-pass/resource-cycle.rs @@ -10,6 +10,8 @@ // Don't leak the unique pointers +use std::cast; + struct r { v: *int, } diff --git a/src/test/run-pass/resource-cycle2.rs b/src/test/run-pass/resource-cycle2.rs index 2a59d4d2190..0f031424ad4 100644 --- a/src/test/run-pass/resource-cycle2.rs +++ b/src/test/run-pass/resource-cycle2.rs @@ -10,6 +10,8 @@ // Don't leak the unique pointers +use std::cast; + struct U { a: int, b: int, diff --git a/src/test/run-pass/resource-cycle3.rs b/src/test/run-pass/resource-cycle3.rs index ef713724778..f3ca932778a 100644 --- a/src/test/run-pass/resource-cycle3.rs +++ b/src/test/run-pass/resource-cycle3.rs @@ -12,6 +12,8 @@ // Don't leak the unique pointers +use std::cast; + struct U { a: int, b: int, diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs index 9a547bd4bdf..d9d4b332f5f 100644 --- a/src/test/run-pass/ret-break-cont-in-block.rs +++ b/src/test/run-pass/ret-break-cont-in-block.rs @@ -11,6 +11,7 @@ // xfail-fast use std::cmp::Eq; +use std::vec; fn iter<T>(v: ~[T], it: &fn(&T) -> bool) -> bool { let mut i = 0u, l = v.len(); diff --git a/src/test/run-pass/rt-sched-1.rs b/src/test/run-pass/rt-sched-1.rs index a60b24987c8..d1767235a2b 100644 --- a/src/test/run-pass/rt-sched-1.rs +++ b/src/test/run-pass/rt-sched-1.rs @@ -10,7 +10,9 @@ // Tests of the runtime's scheduler interface +use std::cast; use std::comm::*; +use std::libc; pub type sched_id = int; pub type task_id = *libc::c_void; @@ -21,6 +23,8 @@ pub type closure = *libc::c_void; mod rustrt { use super::{closure, sched_id, task, task_id}; + use std::libc; + pub extern { pub fn rust_new_sched(num_threads: libc::uintptr_t) -> sched_id; pub fn rust_get_sched_id() -> sched_id; diff --git a/src/test/run-pass/send-iloop.rs b/src/test/run-pass/send-iloop.rs index ed0a5263035..4977082e7ed 100644 --- a/src/test/run-pass/send-iloop.rs +++ b/src/test/run-pass/send-iloop.rs @@ -11,6 +11,10 @@ // xfail-win32 extern mod extra; +use std::comm; +use std::task; +use std::uint; + fn die() { fail!(); } diff --git a/src/test/run-pass/send-resource.rs b/src/test/run-pass/send-resource.rs index 17789e0b509..a2cee0082b5 100644 --- a/src/test/run-pass/send-resource.rs +++ b/src/test/run-pass/send-resource.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::comm::*; +use std::task; struct test { f: int, diff --git a/src/test/run-pass/sendable-class.rs b/src/test/run-pass/sendable-class.rs index 8ef0173dbd3..6b262966277 100644 --- a/src/test/run-pass/sendable-class.rs +++ b/src/test/run-pass/sendable-class.rs @@ -10,6 +10,8 @@ // Test that a class with only sendable fields can be sent +use std::comm; + struct foo { i: int, j: char, diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs index 2351540baa9..31a1e7bded7 100644 --- a/src/test/run-pass/sendfn-generic-fn.rs +++ b/src/test/run-pass/sendfn-generic-fn.rs @@ -10,6 +10,8 @@ // xfail-fast +use std::task; + pub fn main() { test05(); } struct Pair<A,B> { a: A, b: B } diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs index 19e85319927..d9f491297ea 100644 --- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs +++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::cell::Cell; +use std::task; pub fn main() { test05(); } diff --git a/src/test/run-pass/shebang.rs b/src/test/run-pass/shebang.rs index f47faca52c0..94760ce36b5 100644 --- a/src/test/run-pass/shebang.rs +++ b/src/test/run-pass/shebang.rs @@ -11,4 +11,4 @@ // pp-exact -pub fn main() { io::println("Hello World"); } +pub fn main() { println("Hello World"); } diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs index 37501a61066..e3e39b9d5b5 100644 --- a/src/test/run-pass/spawn-fn.rs +++ b/src/test/run-pass/spawn-fn.rs @@ -9,6 +9,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::task; fn x(s: ~str, n: int) { debug!(s); diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs index 58b7b8c09a5..f448d74c4bd 100644 --- a/src/test/run-pass/spawn-types.rs +++ b/src/test/run-pass/spawn-types.rs @@ -15,6 +15,7 @@ */ use std::comm::*; +use std::task; type ctx = Chan<int>; diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs index fef00549fa7..dff73aa7b8e 100644 --- a/src/test/run-pass/spawn.rs +++ b/src/test/run-pass/spawn.rs @@ -9,9 +9,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - extern mod extra; +use std::task; pub fn main() { task::spawn(|| child(10) ); diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs index cb35f0828f2..61ed7053456 100644 --- a/src/test/run-pass/spawn2.rs +++ b/src/test/run-pass/spawn2.rs @@ -9,6 +9,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::task; + pub fn main() { task::spawn(|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) ); } fn child(args: (int, int, int, int, int, int, int, int, int)) { diff --git a/src/test/run-pass/stable-addr-of.rs b/src/test/run-pass/stable-addr-of.rs index 9008e9452db..dc68777e033 100644 --- a/src/test/run-pass/stable-addr-of.rs +++ b/src/test/run-pass/stable-addr-of.rs @@ -10,6 +10,8 @@ // Issue #2040 +use std::ptr; + pub fn main() { let foo = 1; assert_eq!(ptr::to_unsafe_ptr(&foo), ptr::to_unsafe_ptr(&foo)); diff --git a/src/test/run-pass/stat.rs b/src/test/run-pass/stat.rs index f9216135038..a3774d58ee7 100644 --- a/src/test/run-pass/stat.rs +++ b/src/test/run-pass/stat.rs @@ -11,8 +11,12 @@ // xfail-fast extern mod extra; -use std::io::WriterUtil; + use extra::tempfile; +use std::io::WriterUtil; +use std::io; +use std::os; +use std::uint; pub fn main() { let dir = tempfile::mkdtemp(&Path("."), "").unwrap(); diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs index e96ab30f037..46457f667ae 100644 --- a/src/test/run-pass/static-impl.rs +++ b/src/test/run-pass/static-impl.rs @@ -10,6 +10,9 @@ // xfail-fast +use std::uint; +use std::vec; + pub trait plus { fn plus(&self) -> int; } diff --git a/src/test/run-pass/static-method-test.rs b/src/test/run-pass/static-method-test.rs index 3ae8768e41e..4dde143f686 100644 --- a/src/test/run-pass/static-method-test.rs +++ b/src/test/run-pass/static-method-test.rs @@ -10,6 +10,10 @@ // xfail-fast +use std::at_vec; +use std::uint; +use std::vec; + // A trait for objects that can be used to do an if-then-else // (No actual need for this to be static, but it is a simple test.) trait bool_like { diff --git a/src/test/run-pass/static-method-xcrate.rs b/src/test/run-pass/static-method-xcrate.rs index 946c86ab298..6697daa28b6 100644 --- a/src/test/run-pass/static-method-xcrate.rs +++ b/src/test/run-pass/static-method-xcrate.rs @@ -12,6 +12,7 @@ // aux-build:static-methods-crate.rs extern mod static_methods_crate; + use static_methods_crate::read; pub fn main() { diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs index 6fe383a64a2..f02600bb137 100644 --- a/src/test/run-pass/string-self-append.rs +++ b/src/test/run-pass/string-self-append.rs @@ -10,6 +10,8 @@ extern mod extra; +use std::str; + pub fn main() { // Make sure we properly handle repeated self-appends. let mut a: ~str = ~"A"; diff --git a/src/test/run-pass/struct-order-of-eval-1.rs b/src/test/run-pass/struct-order-of-eval-1.rs index 884459cf069..cfa0401e5b9 100644 --- a/src/test/run-pass/struct-order-of-eval-1.rs +++ b/src/test/run-pass/struct-order-of-eval-1.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::str; + struct S { f0: ~str, f1: int } pub fn main() { diff --git a/src/test/run-pass/struct-order-of-eval-2.rs b/src/test/run-pass/struct-order-of-eval-2.rs index 419c4ac3942..f58e5bab3fe 100644 --- a/src/test/run-pass/struct-order-of-eval-2.rs +++ b/src/test/run-pass/struct-order-of-eval-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::str; + struct S { f0: ~str, f1: ~str } pub fn main() { diff --git a/src/test/run-pass/struct-pattern-matching.rs b/src/test/run-pass/struct-pattern-matching.rs index 1bda2d2412d..68fa1373975 100644 --- a/src/test/run-pass/struct-pattern-matching.rs +++ b/src/test/run-pass/struct-pattern-matching.rs @@ -16,6 +16,6 @@ struct Foo { pub fn main() { let a = Foo { x: 1, y: 2 }; match a { - Foo { x: x, y: y } => io::println(fmt!("yes, %d, %d", x, y)) + Foo { x: x, y: y } => println(fmt!("yes, %d, %d", x, y)) } } diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs index d03bc594bb4..c67a72e90c9 100644 --- a/src/test/run-pass/structured-compare.rs +++ b/src/test/run-pass/structured-compare.rs @@ -12,7 +12,7 @@ enum foo { large, small, } -impl cmp::Eq for foo { +impl Eq for foo { fn eq(&self, other: &foo) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/supported-cast.rs b/src/test/run-pass/supported-cast.rs index 791f493b5cc..36e41242f8f 100644 --- a/src/test/run-pass/supported-cast.rs +++ b/src/test/run-pass/supported-cast.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::libc; + pub fn main() { let f = 1 as *libc::FILE; debug!(f as int); diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs index 52092b994f9..cf3a465d812 100644 --- a/src/test/run-pass/swap-2.rs +++ b/src/test/run-pass/swap-2.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::util; +use std::vec; pub fn main() { let mut a: ~[int] = ~[0, 1, 2, 3, 4, 5, 6]; diff --git a/src/test/run-pass/swap-overlapping.rs b/src/test/run-pass/swap-overlapping.rs index 1f1b121d362..d1d84137334 100644 --- a/src/test/run-pass/swap-overlapping.rs +++ b/src/test/run-pass/swap-overlapping.rs @@ -10,6 +10,7 @@ // Issue #5041 - avoid overlapping memcpy when src and dest of a swap are the same +use std::ptr; use std::util; pub fn main() { diff --git a/src/test/run-pass/tag-disr-val-shape.rs b/src/test/run-pass/tag-disr-val-shape.rs index a562b79e4fd..d1dec9c44e0 100644 --- a/src/test/run-pass/tag-disr-val-shape.rs +++ b/src/test/run-pass/tag-disr-val-shape.rs @@ -18,7 +18,7 @@ enum color { pub fn main() { let act = fmt!("%?", red); - io::println(act); + println(act); assert_eq!(~"red", act); assert_eq!(~"green", fmt!("%?", green)); assert_eq!(~"white", fmt!("%?", white)); diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs index d1e26a9c50c..a6252bf5f38 100644 --- a/src/test/run-pass/tag-variant-disr-val.rs +++ b/src/test/run-pass/tag-variant-disr-val.rs @@ -19,7 +19,7 @@ enum color { orange = 8 >> 1 } -impl cmp::Eq for color { +impl Eq for color { fn eq(&self, other: &color) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs index 626e0938aed..ff251a70f65 100644 --- a/src/test/run-pass/tag.rs +++ b/src/test/run-pass/tag.rs @@ -8,13 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - - - // -*- rust -*- + enum colour { red(int, int), green, } -impl cmp::Eq for colour { +impl Eq for colour { fn eq(&self, other: &colour) -> bool { match *self { red(a0, b0) => { diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs index 90812f9a7f8..686cafb0119 100644 --- a/src/test/run-pass/task-comm-0.rs +++ b/src/test/run-pass/task-comm-0.rs @@ -14,6 +14,8 @@ extern mod extra; use std::comm::Chan; use std::comm::Port; +use std::comm; +use std::task; pub fn main() { test05(); } diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs index b8e314c4c6e..4d34e3bae32 100644 --- a/src/test/run-pass/task-comm-1.rs +++ b/src/test/run-pass/task-comm-1.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::task; + pub fn main() { test00(); } fn start() { debug!("Started / Finished task."); } diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs index b4b9592329b..15fbf8c07b8 100644 --- a/src/test/run-pass/task-comm-10.rs +++ b/src/test/run-pass/task-comm-10.rs @@ -12,6 +12,9 @@ extern mod extra; +use std::comm; +use std::task; + fn start(c: &comm::Chan<comm::Chan<~str>>) { let (p, ch) = comm::stream(); c.send(ch); diff --git a/src/test/run-pass/task-comm-11.rs b/src/test/run-pass/task-comm-11.rs index 2c6baf91862..8931531d544 100644 --- a/src/test/run-pass/task-comm-11.rs +++ b/src/test/run-pass/task-comm-11.rs @@ -12,6 +12,9 @@ extern mod extra; +use std::comm; +use std::task; + fn start(c: &comm::Chan<comm::Chan<int>>) { let (p, ch) = comm::stream(); c.send(ch); diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs index 9ecbbaeaee2..a241e9a49a7 100644 --- a/src/test/run-pass/task-comm-12.rs +++ b/src/test/run-pass/task-comm-12.rs @@ -10,6 +10,8 @@ extern mod extra; +use std::task; + pub fn main() { test00(); } fn start(task_number: int) { debug!("Started / Finished task."); } diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs index f10aa46ae6e..b625b0557a7 100644 --- a/src/test/run-pass/task-comm-13.rs +++ b/src/test/run-pass/task-comm-13.rs @@ -12,6 +12,9 @@ extern mod extra; +use std::comm; +use std::task; + fn start(c: &comm::Chan<int>, start: int, number_of_messages: int) { let mut i: int = 0; while i < number_of_messages { c.send(start + i); i += 1; } diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs index 8b4855deaa5..a637d951757 100644 --- a/src/test/run-pass/task-comm-14.rs +++ b/src/test/run-pass/task-comm-14.rs @@ -10,6 +10,9 @@ // xfail-fast +use std::comm; +use std::task; + pub fn main() { let po = comm::PortSet::new(); diff --git a/src/test/run-pass/task-comm-15.rs b/src/test/run-pass/task-comm-15.rs index 3941f846666..95f8e62523b 100644 --- a/src/test/run-pass/task-comm-15.rs +++ b/src/test/run-pass/task-comm-15.rs @@ -13,6 +13,9 @@ extern mod extra; +use std::comm; +use std::task; + fn start(c: &comm::Chan<int>, i0: int) { let mut i = i0; while i > 0 { diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index c9e8ae3ab79..d5a4b1a72c9 100644 --- a/src/test/run-pass/task-comm-16.rs +++ b/src/test/run-pass/task-comm-16.rs @@ -9,6 +9,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm; +use std::cmp; // Tests of ports and channels on various types fn test_rec() { diff --git a/src/test/run-pass/task-comm-17.rs b/src/test/run-pass/task-comm-17.rs index 25bddc7fe94..47e0a710a12 100644 --- a/src/test/run-pass/task-comm-17.rs +++ b/src/test/run-pass/task-comm-17.rs @@ -14,6 +14,8 @@ extern mod extra; +use std::task; + fn f() { } diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs index faa1d8a69b1..dd8168ff947 100644 --- a/src/test/run-pass/task-comm-3.rs +++ b/src/test/run-pass/task-comm-3.rs @@ -11,7 +11,10 @@ // xfail-fast extern mod extra; + use std::comm::Chan; +use std::comm; +use std::task; pub fn main() { debug!("===== WITHOUT THREADS ====="); test00(); } diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs index a1afefed2ee..2033092d2ce 100644 --- a/src/test/run-pass/task-comm-4.rs +++ b/src/test/run-pass/task-comm-4.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm; + pub fn main() { test00(); } fn test00() { diff --git a/src/test/run-pass/task-comm-5.rs b/src/test/run-pass/task-comm-5.rs index 22ca343ff17..472a7d7e3da 100644 --- a/src/test/run-pass/task-comm-5.rs +++ b/src/test/run-pass/task-comm-5.rs @@ -10,6 +10,8 @@ extern mod extra; +use std::comm; + pub fn main() { test00(); } fn test00() { diff --git a/src/test/run-pass/task-comm-6.rs b/src/test/run-pass/task-comm-6.rs index 16d6f53ad86..db6234857d6 100644 --- a/src/test/run-pass/task-comm-6.rs +++ b/src/test/run-pass/task-comm-6.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::comm::Chan; +use std::comm; pub fn main() { test00(); } diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs index 3cc1127fbbf..2ec3ff24089 100644 --- a/src/test/run-pass/task-comm-7.rs +++ b/src/test/run-pass/task-comm-7.rs @@ -12,6 +12,9 @@ extern mod extra; +use std::comm; +use std::task; + pub fn main() { test00(); } fn test00_start(c: &comm::Chan<int>, start: int, number_of_messages: int) { diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs index 41e91097d27..d520949fb22 100644 --- a/src/test/run-pass/task-comm-9.rs +++ b/src/test/run-pass/task-comm-9.rs @@ -12,6 +12,9 @@ extern mod extra; +use std::comm; +use std::task; + pub fn main() { test00(); } fn test00_start(c: &comm::Chan<int>, number_of_messages: int) { diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs index 64b587eff9a..8010089f3c6 100644 --- a/src/test/run-pass/task-comm-chan-nil.rs +++ b/src/test/run-pass/task-comm-chan-nil.rs @@ -12,6 +12,8 @@ extern mod extra; +use std::comm; + // rustboot can't transmit nils across channels because they don't have // any size, but rustc currently can because they do have size. Whether // or not this is desirable I don't know, but here's a regression test. diff --git a/src/test/run-pass/task-killjoin-rsrc.rs b/src/test/run-pass/task-killjoin-rsrc.rs index 4b89ddc4a6c..6d35a9228b0 100644 --- a/src/test/run-pass/task-killjoin-rsrc.rs +++ b/src/test/run-pass/task-killjoin-rsrc.rs @@ -15,6 +15,8 @@ use std::cell::Cell; use std::comm::*; +use std::ptr; +use std::task; struct notify { ch: Chan<bool>, v: @mut bool, diff --git a/src/test/run-pass/task-killjoin.rs b/src/test/run-pass/task-killjoin.rs index 73c069e560c..c94e00251d2 100644 --- a/src/test/run-pass/task-killjoin.rs +++ b/src/test/run-pass/task-killjoin.rs @@ -15,6 +15,8 @@ // task will kill the supervising task, waking it up. The supervising task no // longer needs to be wakened when the supervised task exits. +use std::task; + fn supervised() { // Yield to make sure the supervisor joins before we fail. This is // currently not needed because the supervisor runs first, but I can diff --git a/src/test/run-pass/task-life-0.rs b/src/test/run-pass/task-life-0.rs index 0ec62ff8541..370971bd7b9 100644 --- a/src/test/run-pass/task-life-0.rs +++ b/src/test/run-pass/task-life-0.rs @@ -9,6 +9,9 @@ // except according to those terms. extern mod extra; + +use std::task; + pub fn main() { task::spawn(|| child(~"Hello") ); } diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs index 3e17c5d992c..f3a105e0852 100644 --- a/src/test/run-pass/task-spawn-move-and-copy.rs +++ b/src/test/run-pass/task-spawn-move-and-copy.rs @@ -9,6 +9,8 @@ // except according to those terms. use std::comm::*; +use std::ptr; +use std::task; pub fn main() { let (p, ch) = stream::<uint>(); diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs index 0e1bf1e9062..6d34f7a9701 100644 --- a/src/test/run-pass/terminate-in-initializer.rs +++ b/src/test/run-pass/terminate-in-initializer.rs @@ -14,6 +14,8 @@ extern mod extra; +use std::task; + fn test_break() { loop { let x: @int = break; } } fn test_cont() { let mut i = 0; while i < 1 { i += 1; let x: @int = loop; } } diff --git a/src/test/run-pass/test-ignore-cfg.rs b/src/test/run-pass/test-ignore-cfg.rs index 536dd78bba1..d8b12437dfa 100644 --- a/src/test/run-pass/test-ignore-cfg.rs +++ b/src/test/run-pass/test-ignore-cfg.rs @@ -13,6 +13,8 @@ extern mod extra; +use std::vec; + #[test] #[ignore(cfg(ignorecfg))] fn shouldignore() { diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs index 47b49513a60..8922ff91cfd 100644 --- a/src/test/run-pass/threads.rs +++ b/src/test/run-pass/threads.rs @@ -9,9 +9,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - extern mod extra; +use std::task; + pub fn main() { let mut i = 10; while i > 0 { task::spawn({let i = i; || child(i)}); i = i - 1; } diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs index fedf6e25ec3..3aa30aab7c2 100644 --- a/src/test/run-pass/trait-generic.rs +++ b/src/test/run-pass/trait-generic.rs @@ -10,6 +10,8 @@ // xfail-fast +use std::int; + trait to_str { fn to_str(&self) -> ~str; } diff --git a/src/test/run-pass/trait-inheritance-num2.rs b/src/test/run-pass/trait-inheritance-num2.rs index ff9c792af29..bc1583a0878 100644 --- a/src/test/run-pass/trait-inheritance-num2.rs +++ b/src/test/run-pass/trait-inheritance-num2.rs @@ -99,7 +99,7 @@ impl FloatExt for f64 {} impl FloatExt for float {} -fn test_float_ext<T:FloatExt>(n: T) { io::println(fmt!("%?", n < n)) } +fn test_float_ext<T:FloatExt>(n: T) { println(fmt!("%?", n < n)) } pub fn main() { test_float_ext(1f32); diff --git a/src/test/run-pass/trait-inheritance-num3.rs b/src/test/run-pass/trait-inheritance-num3.rs index 98fa6a5ebf1..e0285a7b598 100644 --- a/src/test/run-pass/trait-inheritance-num3.rs +++ b/src/test/run-pass/trait-inheritance-num3.rs @@ -16,7 +16,7 @@ pub trait NumExt: Eq + Ord + Num + NumCast {} impl NumExt for f32 {} fn num_eq_one<T:NumExt>(n: T) { - io::println(fmt!("%?", n == NumCast::from(1))) + println(fmt!("%?", n == NumCast::from(1))) } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-self-in-supertype.rs b/src/test/run-pass/trait-inheritance-self-in-supertype.rs index 8105cf23d80..f28f8cadfd9 100644 --- a/src/test/run-pass/trait-inheritance-self-in-supertype.rs +++ b/src/test/run-pass/trait-inheritance-self-in-supertype.rs @@ -1,5 +1,8 @@ // Test for issue #4183: use of Self in supertraits. +use std::f32; +use std::f64; + pub static FUZZY_EPSILON: float = 0.1; pub trait FuzzyEq<Eps> { @@ -58,4 +61,4 @@ pub fn main() { assert!(compare::<f64>(6.19)); assert!(!compare::<f64>(7.28318530717958647692528676655900576)); assert!(!compare::<f64>(6.18)); -} \ No newline at end of file +} diff --git a/src/test/run-pass/trait-inheritance-self.rs b/src/test/run-pass/trait-inheritance-self.rs index 5eb87b7a96b..75b71c673a9 100644 --- a/src/test/run-pass/trait-inheritance-self.rs +++ b/src/test/run-pass/trait-inheritance-self.rs @@ -12,7 +12,7 @@ struct S { impl Foo<S> for S { fn f(&self, x: &S) { - io::println(x.x.to_str()); + println(x.x.to_str()); } } diff --git a/src/test/run-pass/trait-region-pointer-simple.rs b/src/test/run-pass/trait-region-pointer-simple.rs index 7162420dbc3..0b54ccbbd47 100644 --- a/src/test/run-pass/trait-region-pointer-simple.rs +++ b/src/test/run-pass/trait-region-pointer-simple.rs @@ -18,7 +18,7 @@ struct A { impl Foo for A { fn f(&self) -> int { - io::println(~"Today's number is " + self.x.to_str()); + println(~"Today's number is " + self.x.to_str()); return self.x; } } diff --git a/src/test/run-pass/trait-static-method-overwriting.rs b/src/test/run-pass/trait-static-method-overwriting.rs index 86ebc5356eb..1f5c33e2bc0 100644 --- a/src/test/run-pass/trait-static-method-overwriting.rs +++ b/src/test/run-pass/trait-static-method-overwriting.rs @@ -11,6 +11,8 @@ // except according to those terms. mod base { + use std::io; + pub trait HasNew<T> { fn new() -> T; } @@ -21,7 +23,7 @@ mod base { impl ::base::HasNew<Foo> for Foo { fn new() -> Foo { - unsafe { io::println("Foo"); } + unsafe { println("Foo"); } Foo { dummy: () } } } diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs index 059d7ea5f70..2e0cc7e5a57 100644 --- a/src/test/run-pass/trivial-message.rs +++ b/src/test/run-pass/trivial-message.rs @@ -12,6 +12,9 @@ This is about the simplest program that can successfully send a message. */ + +use std::comm; + pub fn main() { let (po, ch) = comm::stream(); ch.send(42); diff --git a/src/test/run-pass/tuple-struct-construct.rs b/src/test/run-pass/tuple-struct-construct.rs index c5ea3e14d39..20be5df3242 100644 --- a/src/test/run-pass/tuple-struct-construct.rs +++ b/src/test/run-pass/tuple-struct-construct.rs @@ -12,5 +12,5 @@ struct Foo(int, int); pub fn main() { let x = Foo(1, 2); - io::println(fmt!("%?", x)); + println(fmt!("%?", x)); } diff --git a/src/test/run-pass/tuple-struct-destructuring.rs b/src/test/run-pass/tuple-struct-destructuring.rs index c7dc132f3b7..4a1258264f8 100644 --- a/src/test/run-pass/tuple-struct-destructuring.rs +++ b/src/test/run-pass/tuple-struct-destructuring.rs @@ -13,7 +13,7 @@ struct Foo(int, int); pub fn main() { let x = Foo(1, 2); let Foo(y, z) = x; - io::println(fmt!("%d %d", y, z)); + println(fmt!("%d %d", y, z)); assert_eq!(y, 1); assert_eq!(z, 2); } diff --git a/src/test/run-pass/tuple-struct-matching.rs b/src/test/run-pass/tuple-struct-matching.rs index 037f847629c..261b913b1d2 100644 --- a/src/test/run-pass/tuple-struct-matching.rs +++ b/src/test/run-pass/tuple-struct-matching.rs @@ -16,7 +16,7 @@ pub fn main() { Foo(a, b) => { assert_eq!(a, 1); assert_eq!(b, 2); - io::println(fmt!("%d %d", a, b)); + println(fmt!("%d %d", a, b)); } } } diff --git a/src/test/run-pass/type-use-i1-versus-i8.rs b/src/test/run-pass/type-use-i1-versus-i8.rs index d180f6c7260..88b4fffc5a5 100644 --- a/src/test/run-pass/type-use-i1-versus-i8.rs +++ b/src/test/run-pass/type-use-i1-versus-i8.rs @@ -8,8 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::unstable; + pub fn main() { - let mut x: bool = false; - // this line breaks it - unstable::intrinsics::move_val_init(&mut x, false); + unsafe { + let mut x: bool = false; + // this line breaks it + unstable::intrinsics::move_val_init(&mut x, false); + } } diff --git a/src/test/run-pass/unify-return-ty.rs b/src/test/run-pass/unify-return-ty.rs index 2f686d21b96..8bdce601b28 100644 --- a/src/test/run-pass/unify-return-ty.rs +++ b/src/test/run-pass/unify-return-ty.rs @@ -13,6 +13,8 @@ // in that type gets resolved. extern mod extra; +use std::cast; + fn null<T>() -> *T { unsafe { cast::transmute(0) diff --git a/src/test/run-pass/uniq-cc-generic.rs b/src/test/run-pass/uniq-cc-generic.rs index 7327f4a3498..b54b3b52692 100644 --- a/src/test/run-pass/uniq-cc-generic.rs +++ b/src/test/run-pass/uniq-cc-generic.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ptr; + enum maybe_pointy { none, p(@mut Pointy), diff --git a/src/test/run-pass/unique-copy-box.rs b/src/test/run-pass/unique-copy-box.rs index 38a608c191b..7634641a56e 100644 --- a/src/test/run-pass/unique-copy-box.rs +++ b/src/test/run-pass/unique-copy-box.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::sys; + pub fn main() { unsafe { let i = ~@1; diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs index 3684a6ef788..a6bed9e2398 100644 --- a/src/test/run-pass/unique-send-2.rs +++ b/src/test/run-pass/unique-send-2.rs @@ -9,6 +9,8 @@ // except according to those terms. use std::comm::*; +use std::task; +use std::uint; fn child(c: &SharedChan<~uint>, i: uint) { c.send(~i); diff --git a/src/test/run-pass/unit-like-struct.rs b/src/test/run-pass/unit-like-struct.rs index 1b81015b029..82aeb08a703 100644 --- a/src/test/run-pass/unit-like-struct.rs +++ b/src/test/run-pass/unit-like-struct.rs @@ -13,6 +13,6 @@ struct Foo; pub fn main() { let x: Foo = Foo; match x { - Foo => { io::println("hi"); } + Foo => { println("hi"); } } } diff --git a/src/test/run-pass/unwind-box.rs b/src/test/run-pass/unwind-box.rs index 5184ffb8d23..2d0967a6fa3 100644 --- a/src/test/run-pass/unwind-box.rs +++ b/src/test/run-pass/unwind-box.rs @@ -11,6 +11,8 @@ // xfail-win32 extern mod extra; +use std::task; + fn f() { let a = @0; fail!(); diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs index 012b12ea99e..4b71d79ccc4 100644 --- a/src/test/run-pass/unwind-resource.rs +++ b/src/test/run-pass/unwind-resource.rs @@ -12,6 +12,7 @@ extern mod extra; use std::comm::*; +use std::task; struct complainer { c: SharedChan<bool>, diff --git a/src/test/run-pass/unwind-resource2.rs b/src/test/run-pass/unwind-resource2.rs index 0d7c717cd36..b5a496eb206 100644 --- a/src/test/run-pass/unwind-resource2.rs +++ b/src/test/run-pass/unwind-resource2.rs @@ -11,6 +11,8 @@ // xfail-win32 extern mod extra; +use std::task; + struct complainer { c: @int, } diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs index f5f5209fa54..ba75676298b 100644 --- a/src/test/run-pass/unwind-unique.rs +++ b/src/test/run-pass/unwind-unique.rs @@ -11,6 +11,8 @@ // xfail-win32 extern mod extra; +use std::task; + fn f() { let a = ~0; fail!(); diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs index aab51207a9f..fd5bc07e015 100644 --- a/src/test/run-pass/utf8.rs +++ b/src/test/run-pass/utf8.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::str; + pub fn main() { let yen: char = '¥'; // 0xa5 let c_cedilla: char = 'ç'; // 0xe7 diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs index 23dddf59925..2343949f049 100644 --- a/src/test/run-pass/utf8_chars.rs +++ b/src/test/run-pass/utf8_chars.rs @@ -10,6 +10,9 @@ extern mod extra; +use std::str; +use std::vec; + pub fn main() { // Chars of 1, 2, 3, and 4 bytes let chs: ~[char] = ~['e', 'é', '€', 0x10000 as char]; diff --git a/src/test/run-pass/utf8_idents.rs b/src/test/run-pass/utf8_idents.rs index 4e86b6cc948..2e1bec53cee 100644 --- a/src/test/run-pass/utf8_idents.rs +++ b/src/test/run-pass/utf8_idents.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::float; + pub fn main() { let ε = 0.00001; let Π = 3.14; diff --git a/src/test/run-pass/vec-each2_mut.rs b/src/test/run-pass/vec-each2_mut.rs index 05314f94c67..73e0418993c 100644 --- a/src/test/run-pass/vec-each2_mut.rs +++ b/src/test/run-pass/vec-each2_mut.rs @@ -9,6 +9,10 @@ // except according to those terms. // -*- rust -*- + +use std::io; +use std::vec; + fn main(){ let mut t1 = ~[]; t1.push('a'); diff --git a/src/test/run-pass/vec-fixed-length.rs b/src/test/run-pass/vec-fixed-length.rs index 2c4add63e8b..56adc6d2598 100644 --- a/src/test/run-pass/vec-fixed-length.rs +++ b/src/test/run-pass/vec-fixed-length.rs @@ -10,5 +10,5 @@ pub fn main() { let x: [int, ..4] = [1, 2, 3, 4]; - io::println(fmt!("%d", x[0])); + println(fmt!("%d", x[0])); } diff --git a/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs b/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs index acd9a9664f7..aae287deb8a 100644 --- a/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs +++ b/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs @@ -5,6 +5,6 @@ pub fn main() { [1, ..ref tail] => &tail[0], _ => ::std::util::unreachable() }; - io::println(fmt!("%d", *el)); + println(fmt!("%d", *el)); } } diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs index 25ae7340bc1..8448e4e0532 100644 --- a/src/test/run-pass/vec-slice.rs +++ b/src/test/run-pass/vec-slice.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::vec; + pub fn main() { let v = ~[1,2,3,4,5]; let v2 = vec::slice(v, 1, 3); diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs index 7e2229e78ea..8f990e07015 100644 --- a/src/test/run-pass/writealias.rs +++ b/src/test/run-pass/writealias.rs @@ -9,15 +9,20 @@ // except according to those terms. +use std::unstable; - -// -*- rust -*- struct Point {x: int, y: int, z: int} fn f(p: &mut Point) { p.z = 13; } pub fn main() { - let mut x: Point = Point {x: 10, y: 11, z: 12}; - f(&mut x); - assert_eq!(x.z, 13); + unsafe { + let x = Some(unstable::sync::exclusive(true)); + match x { + Some(ref z) if z.with(|b| *b) => { + do z.with |b| { assert!(*b); } + }, + _ => fail!() + } + } } diff --git a/src/test/run-pass/yield.rs b/src/test/run-pass/yield.rs index 2d916abf0da..8beaee83864 100644 --- a/src/test/run-pass/yield.rs +++ b/src/test/run-pass/yield.rs @@ -9,6 +9,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::task; + pub fn main() { let mut result = None; let mut builder = task::task(); diff --git a/src/test/run-pass/yield1.rs b/src/test/run-pass/yield1.rs index f3ca5b12118..37ec8af7e57 100644 --- a/src/test/run-pass/yield1.rs +++ b/src/test/run-pass/yield1.rs @@ -9,6 +9,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::task; + pub fn main() { let mut result = None; let mut builder = task::task(); diff --git a/src/test/run-pass/yield2.rs b/src/test/run-pass/yield2.rs index 83b60d1863e..a2b8ef0429d 100644 --- a/src/test/run-pass/yield2.rs +++ b/src/test/run-pass/yield2.rs @@ -9,6 +9,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::task; + pub fn main() { let mut i: int = 0; while i < 100 { i = i + 1; error!(i); task::yield(); } diff --git a/src/test/run-pass/zip-same-length.rs b/src/test/run-pass/zip-same-length.rs index bf45b2fc039..83759dd82e6 100644 --- a/src/test/run-pass/zip-same-length.rs +++ b/src/test/run-pass/zip-same-length.rs @@ -11,6 +11,8 @@ // In this case, the code should compile and should // succeed at runtime +use std::vec; + fn enum_chars(start: u8, end: u8) -> ~[char] { assert!(start < end); let mut i = start; |