diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index bdbfbfd7c89d6..ad1264828cb96 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -22,8 +22,8 @@ extern crate regex; use std::os; use std::io; use std::io::fs; -use std::str::FromStr; -use std::thunk::{Thunk}; +use std::str::{FromStr, from_str}; +use std::thunk::Thunk; use getopts::{optopt, optflag, reqopt}; use common::Config; use common::{Pretty, DebugInfoGdb, DebugInfoLldb, Codegen}; diff --git a/src/doc/guide-ffi.md b/src/doc/guide-ffi.md index 3a87271ede7d8..b8808eaf57d93 100644 --- a/src/doc/guide-ffi.md +++ b/src/doc/guide-ffi.md @@ -450,6 +450,8 @@ them. ~~~no_run extern crate libc; + +use std::c_str::ToCStr; use std::ptr; #[link(name = "readline")] diff --git a/src/doc/guide.md b/src/doc/guide.md index f4ec787a79491..a3a24abeb2e47 100644 --- a/src/doc/guide.md +++ b/src/doc/guide.md @@ -26,7 +26,7 @@ in the `$`s, they just indicate the start of each command): curl -L https://static.rust-lang.org/rustup.sh | sudo sh ``` -If you're concerned about the [potential insecurity](http://curlpipesh.tumblr.com/) of using `curl | sudo sh`, +If you're concerned about the [potential insecurity](http://curlpipesh.tumblr.com/) of using `curl | sudo sh`, please keep reading and see our disclaimer below. And feel free to use a two-step version of the installation and examine our installation script: ```bash @@ -1106,13 +1106,21 @@ enum Ordering { ``` An `Ordering` can only be _one_ of `Less`, `Equal`, or `Greater` at any given -time. Here's an example: +time. + +Because `Ordering` is provided by the standard library, we can use the `use` +keyword to use it in our code. We'll learn more about `use` later, but it's +used to bring names into scope. + +Here's an example of how to use `Ordering`: ```{rust} +use std::cmp::Ordering; + fn cmp(a: int, b: int) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } fn main() { @@ -1121,28 +1129,35 @@ fn main() { let ordering = cmp(x, y); // ordering: Ordering - if ordering == Less { + if ordering == Ordering::Less { println!("less"); - } else if ordering == Greater { + } else if ordering == Ordering::Greater { println!("greater"); - } else if ordering == Equal { + } else if ordering == Ordering::Equal { println!("equal"); } } ``` -`cmp` is a function that compares two things, and returns an `Ordering`. We -return either `Less`, `Greater`, or `Equal`, depending on if the two values -are greater, less, or equal. +There's a symbol here we haven't seen before: the double colon (`::`). +This is used to indicate a namesapce. In this case, `Ordering` lives in +the `cmp` submodule of the `std` module. We'll talk more about modules +later in the guide. For now, all you need to know is that you can `use` +things from the standard library if you need them. -The `ordering` variable has the type `Ordering`, and so contains one of the -three values. We can then do a bunch of `if`/`else` comparisons to check -which one it is. +Okay, let's talk about the actual code in the example. `cmp` is a function that +compares two things, and returns an `Ordering`. We return either +`Ordering::Less`, `Ordering::Greater`, or `Ordering::Equal`, depending on if +the two values are greater, less, or equal. Note that each variant of the +`enum` is namespaced under the `enum` itself: it's `Ordering::Greater` not +`Greater`. -However, repeated `if`/`else` comparisons get quite tedious. Rust has a feature -that not only makes them nicer to read, but also makes sure that you never -miss a case. Before we get to that, though, let's talk about another kind of -enum: one with values. +The `ordering` variable has the type `Ordering`, and so contains one of the +three values. We can then do a bunch of `if`/`else` comparisons to check which +one it is. However, repeated `if`/`else` comparisons get quite tedious. Rust +has a feature that not only makes them nicer to read, but also makes sure that +you never miss a case. Before we get to that, though, let's talk about another +kind of enum: one with values. This enum has two variants, one of which has a value: @@ -1175,18 +1190,19 @@ enum StringResult { ErrorReason(String), } ``` -Where a `StringResult` is either a `StringOK`, with the result of a computation, or an -`ErrorReason` with a `String` explaining what caused the computation to fail. These kinds of -`enum`s are actually very useful and are even part of the standard library. +Where a `StringResult` is either a `StringResult::StringOK`, with the result of +a computation, or an `StringResult::ErrorReason` with a `String` explaining +what caused the computation to fail. These kinds of `enum`s are actually very +useful and are even part of the standard library. -Enum variants are namespaced under the enum names. For example, here is an example of using -our `StringResult`: +Here is an example of using our `StringResult`: ```rust -# enum StringResult { -# StringOK(String), -# ErrorReason(String), -# } +enum StringResult { + StringOK(String), + ErrorReason(String), +} + fn respond(greeting: &str) -> StringResult { if greeting == "Hello" { StringResult::StringOK("Good morning!".to_string()) @@ -1196,10 +1212,7 @@ fn respond(greeting: &str) -> StringResult { } ``` -Notice that we need both the enum name and the variant name: `StringResult::StringOK`, but -we didn't need to with `Ordering` – we just said `Greater` rather than `Ordering::Greater`. -There's a reason: the Rust prelude imports the variants of `Ordering` as well as the enum -itself. We can use the `use` keyword to do something similar with `StringResult`: +That's a lot of typing! We can use the `use` keyword to make it shorter: ```rust use StringResult::StringOK; @@ -1221,12 +1234,11 @@ fn respond(greeting: &str) -> StringResult { } ``` -We'll learn more about `use` later, but it's used to bring names into scope. `use` declarations -must come before anything else, which looks a little strange in this example, since we `use` -the variants before we define them. Anyway, in the body of `respond`, we can just say `StringOK` -now, rather than the full `StringResult::StringOK`. Importing variants can be convenient, but can -also cause name conflicts, so do this with caution. It's considered good style to rarely import -variants for this reason. +`use` declarations must come before anything else, which looks a little strange in this example, +since we `use` the variants before we define them. Anyway, in the body of `respond`, we can just +say `StringOK` now, rather than the full `StringResult::StringOK`. Importing variants can be +convenient, but can also cause name conflicts, so do this with caution. It's considered good style +to rarely import variants for this reason. As you can see, `enum`s with values are quite a powerful tool for data representation, and can be even more useful when they're generic across types. Before we get to generics, @@ -1280,10 +1292,12 @@ for every possible value of `x`, and so our program will compile successfully. section on enums? ```{rust} +use std::cmp::Ordering; + fn cmp(a: int, b: int) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } fn main() { @@ -1292,11 +1306,11 @@ fn main() { let ordering = cmp(x, y); - if ordering == Less { + if ordering == Ordering::Less { println!("less"); - } else if ordering == Greater { + } else if ordering == Ordering::Greater { println!("greater"); - } else if ordering == Equal { + } else if ordering == Ordering::Equal { println!("equal"); } } @@ -1305,10 +1319,12 @@ fn main() { We can re-write this as a `match`: ```{rust} +use std::cmp::Ordering; + fn cmp(a: int, b: int) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } fn main() { @@ -1316,9 +1332,9 @@ fn main() { let y = 10i; match cmp(x, y) { - Less => println!("less"), - Greater => println!("greater"), - Equal => println!("equal"), + Ordering::Less => println!("less"), + Ordering::Greater => println!("greater"), + Ordering::Equal => println!("equal"), } } ``` @@ -1365,10 +1381,12 @@ side of a `let` binding or directly where an expression is used. We could also implement the previous line like this: ```{rust} +use std::cmp::Ordering; + fn cmp(a: int, b: int) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } fn main() { @@ -1376,9 +1394,9 @@ fn main() { let y = 10i; println!("{}", match cmp(x, y) { - Less => "less", - Greater => "greater", - Equal => "equal", + Ordering::Less => "less", + Ordering::Greater => "greater", + Ordering::Equal => "equal", }); } ``` @@ -2139,6 +2157,7 @@ guess to the secret number: ```{rust,ignore} use std::io; use std::rand; +use std::cmp::Ordering; fn main() { println!("Guess the number!"); @@ -2157,16 +2176,16 @@ fn main() { println!("You guessed: {}", input); match cmp(input, secret_number) { - Less => println!("Too small!"), - Greater => println!("Too big!"), - Equal => println!("You win!"), + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), } } fn cmp(a: int, b: int) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } ``` @@ -2193,6 +2212,7 @@ we wrote the `cmp` function! Let's change it to take `uint`s: ```{rust,ignore} use std::io; use std::rand; +use std::cmp::Ordering; fn main() { println!("Guess the number!"); @@ -2211,16 +2231,16 @@ fn main() { println!("You guessed: {}", input); match cmp(input, secret_number) { - Less => println!("Too small!"), - Greater => println!("Too big!"), - Equal => println!("You win!"), + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), } } fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } ``` @@ -2290,6 +2310,7 @@ Anyway, with us now converting our input to a number, our code looks like this: ```{rust,ignore} use std::io; use std::rand; +use std::cmp::Ordering; fn main() { println!("Guess the number!"); @@ -2308,16 +2329,16 @@ fn main() { println!("You guessed: {}", input_num); match cmp(input_num, secret_number) { - Less => println!("Too small!"), - Greater => println!("Too big!"), - Equal => println!("You win!"), + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), } } fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } ``` @@ -2339,6 +2360,7 @@ to do that. Try this code: ```{rust,no_run} use std::io; use std::rand; +use std::cmp::Ordering; fn main() { println!("Guess the number!"); @@ -2366,16 +2388,16 @@ fn main() { println!("You guessed: {}", num); match cmp(num, secret_number) { - Less => println!("Too small!"), - Greater => println!("Too big!"), - Equal => println!("You win!"), + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), } } fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } ``` @@ -2405,6 +2427,7 @@ code looks like this: ```{rust,no_run} use std::io; use std::rand; +use std::cmp::Ordering; fn main() { println!("Guess the number!"); @@ -2432,16 +2455,16 @@ fn main() { println!("You guessed: {}", num); match cmp(num, secret_number) { - Less => println!("Too small!"), - Greater => println!("Too big!"), - Equal => println!("You win!"), + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), } } fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } ``` @@ -2478,6 +2501,7 @@ Let's add that in: ```{rust,no_run} use std::io; use std::rand; +use std::cmp::Ordering; fn main() { println!("Guess the number!"); @@ -2507,17 +2531,17 @@ fn main() { println!("You guessed: {}", num); match cmp(num, secret_number) { - Less => println!("Too small!"), - Greater => println!("Too big!"), - Equal => println!("You win!"), + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => println!("You win!"), } } } fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } ``` @@ -2553,6 +2577,7 @@ suboptimal to say the least. First, let's actually quit when you win the game: ```{rust,no_run} use std::io; use std::rand; +use std::cmp::Ordering; fn main() { println!("Guess the number!"); @@ -2582,9 +2607,9 @@ fn main() { println!("You guessed: {}", num); match cmp(num, secret_number) { - Less => println!("Too small!"), - Greater => println!("Too big!"), - Equal => { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => { println!("You win!"); return; }, @@ -2593,9 +2618,9 @@ fn main() { } fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } ``` @@ -2608,6 +2633,7 @@ we don't want to quit, we just want to ignore it. Change that `return` to ```{rust,no_run} use std::io; use std::rand; +use std::cmp::Ordering; fn main() { println!("Guess the number!"); @@ -2637,9 +2663,9 @@ fn main() { println!("You guessed: {}", num); match cmp(num, secret_number) { - Less => println!("Too small!"), - Greater => println!("Too big!"), - Equal => { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => { println!("You win!"); return; }, @@ -2648,9 +2674,9 @@ fn main() { } fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } ``` @@ -2686,6 +2712,7 @@ It was good for testing, but it kind of ruins the game. Here's our final source: ```{rust,no_run} use std::io; use std::rand; +use std::cmp::Ordering; fn main() { println!("Guess the number!"); @@ -2713,9 +2740,9 @@ fn main() { println!("You guessed: {}", num); match cmp(num, secret_number) { - Less => println!("Too small!"), - Greater => println!("Too big!"), - Equal => { + Ordering::Less => println!("Too small!"), + Ordering::Greater => println!("Too big!"), + Ordering::Equal => { println!("You win!"); return; }, @@ -2724,9 +2751,9 @@ fn main() { } fn cmp(a: uint, b: uint) -> Ordering { - if a < b { Less } - else if a > b { Greater } - else { Equal } + if a < b { Ordering::Less } + else if a > b { Ordering::Greater } + else { Ordering::Equal } } ``` @@ -5217,7 +5244,7 @@ as you can see, there's no overhead of deciding which version to call here, hence 'statically dispatched'. The downside is that we have two copies of the same function, so our binary is a little bit larger. -# Threads +# Threads Concurrency and parallelism are topics that are of increasing interest to a broad subsection of software developers. Modern computers are often multi-core, diff --git a/src/doc/reference.md b/src/doc/reference.md index f3ad19bbd2a6c..7b3a0b74b8a5c 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -4149,11 +4149,11 @@ Unwinding the stack of a thread is done by the thread itself, on its own control stack. If a value with a destructor is freed during unwinding, the code for the destructor is run, also on the thread's control stack. Running the destructor code causes a temporary transition to a *running* state, and allows the -destructor code to cause any subsequent state transitions. The original thread +destructor code to cause any subsequent state transitions. The original thread of unwinding and panicking thereby may suspend temporarily, and may involve (recursive) unwinding of the stack of a failed destructor. Nonetheless, the outermost unwinding activity will continue until the stack is unwound and the -thread transitions to the *dead* state. There is no way to "recover" from thread +thread transitions to the *dead* state. There is no way to "recover" from thread panics. Once a thread has temporarily suspended its unwinding in the *panicking* state, a panic occurring from within this destructor results in *hard* panic. A hard panic currently results in the process aborting. diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index 64e10e69a2ef3..f748c8ad1eb2a 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -26,6 +26,7 @@ //! [dir_graph]: http://en.wikipedia.org/wiki/Directed_graph //! //! ``` +//! use std::cmp::Ordering; //! use std::collections::BinaryHeap; //! use std::uint; //! @@ -151,6 +152,7 @@ use core::prelude::*; use core::default::Default; +use core::iter::FromIterator; use core::mem::{zeroed, replace, swap}; use core::ptr; diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index d8dfc02c97a46..0b3de11304211 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -82,17 +82,19 @@ use core::prelude::*; +use core::cmp::Ordering; use core::cmp; use core::default::Default; use core::fmt; +use core::hash; use core::iter::{Cloned, Chain, Enumerate, Repeat, Skip, Take, repeat}; -use core::iter; +use core::iter::{mod, FromIterator, RandomAccessIterator}; use core::num::Int; -use core::slice; +use core::ops::Index; +use core::slice::{Iter, IterMut}; use core::{u8, u32, uint}; use bitv_set; //so meta -use core::hash; use Vec; type Blocks<'a> = Cloned>; @@ -2507,7 +2509,7 @@ mod tests { #[cfg(test)] mod bitv_bench { - use std::prelude::*; + use std::prelude::v1::*; use std::rand; use std::rand::Rng; use std::u32; @@ -3002,7 +3004,7 @@ mod bitv_set_test { #[cfg(test)] mod bitv_set_bench { - use std::prelude::*; + use std::prelude::v1::*; use std::rand; use std::rand::Rng; use std::u32; diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 87b40aa1ceeaf..6d41883dc8d9e 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -19,21 +19,23 @@ pub use self::Entry::*; use core::prelude::*; -use self::StackOp::*; -use super::node::{mod, Node, Found, GoDown}; -use super::node::{Traversal, MutTraversal, MoveTraversal}; -use super::node::TraversalItem::{mod, Elem, Edge}; -use super::node::ForceResult::{Leaf, Internal}; use core::borrow::BorrowFrom; -use std::hash::{Writer, Hash}; +use core::cmp::Ordering; use core::default::Default; -use core::{iter, fmt, mem}; use core::fmt::Show; -use core::iter::Map; +use core::hash::{Writer, Hash}; +use core::iter::{Map, FromIterator}; +use core::ops::{Index, IndexMut}; +use core::{iter, fmt, mem}; use ring_buf::RingBuf; use self::Continuation::{Continue, Finished}; +use self::StackOp::*; +use super::node::ForceResult::{Leaf, Internal}; +use super::node::TraversalItem::{mod, Elem, Edge}; +use super::node::{Traversal, MutTraversal, MoveTraversal}; +use super::node::{mod, Node, Found, GoDown}; // FIXME(conventions): implement bounded iterators @@ -501,6 +503,7 @@ mod stack { use core::prelude::*; use core::kinds::marker; use core::mem; + use core::ops::{Deref, DerefMut}; use super::BTreeMap; use super::super::node::{mod, Node, Fit, Split, Internal, Leaf}; use super::super::node::handle; diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 3907f28092a37..053563683653b 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -18,10 +18,12 @@ pub use self::TraversalItem::*; use core::prelude::*; -use core::{slice, mem, ptr, cmp, num, raw}; -use core::iter::Zip; use core::borrow::BorrowFrom; +use core::cmp::Ordering::{Greater, Less, Equal}; +use core::iter::Zip; +use core::ops::{Deref, DerefMut}; use core::ptr::Unique; +use core::{slice, mem, ptr, cmp, num, raw}; use alloc::heap; /// Represents the result of an Insertion: either the item fit, or the node had to split diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index f3f6727f1c06b..3e8988530e63e 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -13,13 +13,16 @@ use core::prelude::*; -use btree_map::{BTreeMap, Keys}; -use std::hash::Hash; use core::borrow::BorrowFrom; +use core::cmp::Ordering::{mod, Less, Greater, Equal}; use core::default::Default; -use core::fmt; -use core::iter::{Peekable, Map}; use core::fmt::Show; +use core::fmt; +use core::hash::Hash; +use core::iter::{Peekable, Map, FromIterator}; +use core::ops::{BitOr, BitAnd, BitXor, Sub}; + +use btree_map::{BTreeMap, Keys}; // FIXME(conventions): implement bounded iterators diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 8b7b7176b80e0..68acbfcb3c3c8 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -22,12 +22,13 @@ use core::prelude::*; use alloc::boxed::Box; +use core::cmp::Ordering; use core::default::Default; use core::fmt; -use core::iter; +use core::hash::{Writer, Hash}; +use core::iter::{mod, FromIterator}; use core::mem; use core::ptr; -use std::hash::{Writer, Hash}; /// A doubly-linked list. #[stable] diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index b484fc41ff6e5..ea3d8659f54a4 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -16,6 +16,8 @@ use core::prelude::*; use core::fmt; use core::num::Int; +use core::iter::FromIterator; +use core::ops::{Sub, BitOr, BitAnd, BitXor}; // FIXME(contentions): implement union family of methods? (general design may be wrong here) diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 12148947a19a6..e4c9e51a8455b 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -14,14 +14,16 @@ use core::prelude::*; +use core::cmp::Ordering; use core::default::Default; use core::fmt; -use core::iter; -use core::raw::Slice as RawSlice; -use core::ptr; +use core::iter::{mod, FromIterator, RandomAccessIterator}; use core::kinds::marker; use core::mem; use core::num::{Int, UnsignedInt}; +use core::ops::{Index, IndexMut}; +use core::ptr; +use core::raw::Slice as RawSlice; use std::hash::{Writer, Hash}; use std::cmp; diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 61111d96bd064..9e2b4b77910e2 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -89,15 +89,19 @@ use alloc::boxed::Box; use core::borrow::{BorrowFrom, BorrowFromMut, ToOwned}; -use core::cmp; -use core::iter::{range_step, MultiplicativeIterator}; +use core::clone::Clone; +use core::cmp::Ordering::{mod, Greater, Less}; +use core::cmp::{mod, Ord}; +use core::iter::{Iterator, IteratorExt, IteratorCloneExt}; +use core::iter::{range, range_step, MultiplicativeIterator}; use core::kinds::Sized; use core::mem::size_of; use core::mem; -use core::ops::{FnMut,SliceMut}; -use core::prelude::{Clone, Greater, Iterator, IteratorExt, Less, None, Option}; -use core::prelude::{Ord, Ordering, PtrExt, Some, range, IteratorCloneExt, Result}; +use core::ops::{FnMut, SliceMut}; +use core::option::Option::{mod, Some, None}; +use core::ptr::PtrExt; use core::ptr; +use core::result::Result; use core::slice as core_slice; use self::Direction::*; diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 37a6e690f5d30..ae038a9f0891f 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -17,12 +17,14 @@ use core::prelude::*; use core::borrow::{Cow, IntoCow}; +use core::cmp::Equiv; use core::default::Default; use core::fmt; use core::hash; +use core::iter::FromIterator; use core::mem; +use core::ops::{mod, Deref, Add}; use core::ptr; -use core::ops; use core::raw::Slice as RawSlice; use unicode::str as unicode_str; use unicode::str::Utf16Item; diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index a1952352badfa..4b7aa89687052 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -50,14 +50,16 @@ use alloc::boxed::Box; use alloc::heap::{EMPTY, allocate, reallocate, deallocate}; use core::borrow::{Cow, IntoCow}; use core::cmp::max; +use core::cmp::{Equiv, Ordering}; use core::default::Default; use core::fmt; use core::hash::{mod, Hash}; -use core::iter::repeat; +use core::iter::{repeat, FromIterator}; use core::kinds::marker::{ContravariantLifetime, InvariantType}; use core::mem; use core::nonzero::NonZero; use core::num::{Int, UnsignedInt}; +use core::ops::{Index, IndexMut, Deref, Add}; use core::ops; use core::ptr; use core::raw::Slice as RawSlice; diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index 7c30912cf91ba..172fd56ed3962 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -15,12 +15,14 @@ use core::prelude::*; +use core::cmp::Ordering; use core::default::Default; use core::fmt; use core::hash::{Hash, Writer}; +use core::iter::{Enumerate, FilterMap, Map, FromIterator}; use core::iter; -use core::iter::{Enumerate, FilterMap, Map}; use core::mem::replace; +use core::ops::{Index, IndexMut}; use {vec, slice}; use vec::Vec; diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 367c794e84bb6..38906892a339f 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -125,11 +125,12 @@ impl Ordering { /// # Example /// /// ```rust + /// use std::cmp::Ordering::{Less, Equal, Greater}; + /// /// assert_eq!(Less.reverse(), Greater); /// assert_eq!(Equal.reverse(), Equal); /// assert_eq!(Greater.reverse(), Less); /// - /// /// let mut data: &mut [_] = &mut [2u, 10, 5, 8]; /// /// // sort the array from largest to smallest. @@ -170,6 +171,8 @@ pub trait Ord for Sized?: Eq + PartialOrd { /// the expression `self other` if true. For example: /// /// ``` + /// use std::cmp::Ordering::{Less, Equal, Greater}; + /// /// assert_eq!( 5u.cmp(&10), Less); // because 5 < 10 /// assert_eq!(10u.cmp(&5), Greater); // because 10 > 5 /// assert_eq!( 5u.cmp(&5), Equal); // because 5 == 5 diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index af07869e95feb..15016562699d6 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -25,6 +25,8 @@ //! demonstrates adding and subtracting two `Point`s. //! //! ```rust +//! use std::ops::{Add, Sub}; +//! //! #[deriving(Show)] //! struct Point { //! x: int, @@ -68,13 +70,13 @@ use option::Option::{mod, Some, None}; /// struct HasDrop; /// /// impl Drop for HasDrop { -/// fn drop(&mut self) { -/// println!("Dropping!"); -/// } +/// fn drop(&mut self) { +/// println!("Dropping!"); +/// } /// } /// /// fn main() { -/// let _x = HasDrop; +/// let _x = HasDrop; /// } /// ``` #[lang="drop"] @@ -91,6 +93,8 @@ pub trait Drop { /// calling `add`, and therefore, `main` prints `Adding!`. /// /// ```rust +/// use std::ops::Add; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -130,6 +134,8 @@ add_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 } /// calling `sub`, and therefore, `main` prints `Subtracting!`. /// /// ```rust +/// use std::ops::Sub; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -169,6 +175,8 @@ sub_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 } /// calling `mul`, and therefore, `main` prints `Multiplying!`. /// /// ```rust +/// use std::ops::Mul; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -208,6 +216,8 @@ mul_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 } /// calling `div`, and therefore, `main` prints `Dividing!`. /// /// ``` +/// use std::ops::Div; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -247,6 +257,8 @@ div_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 } /// calling `rem`, and therefore, `main` prints `Remainder-ing!`. /// /// ``` +/// use std::ops::Rem; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -300,6 +312,8 @@ rem_float_impl! { f64, fmod } /// `neg`, and therefore, `main` prints `Negating!`. /// /// ``` +/// use std::ops::Neg; +/// /// struct Foo; /// /// impl Copy for Foo {} @@ -356,6 +370,8 @@ neg_uint_impl! { u64, i64 } /// `not`, and therefore, `main` prints `Not-ing!`. /// /// ``` +/// use std::ops::Not; +/// /// struct Foo; /// /// impl Copy for Foo {} @@ -396,6 +412,8 @@ not_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 } /// calling `bitand`, and therefore, `main` prints `Bitwise And-ing!`. /// /// ``` +/// use std::ops::BitAnd; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -435,6 +453,8 @@ bitand_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 } /// calling `bitor`, and therefore, `main` prints `Bitwise Or-ing!`. /// /// ``` +/// use std::ops::BitOr; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -474,6 +494,8 @@ bitor_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 } /// calling `bitxor`, and therefore, `main` prints `Bitwise Xor-ing!`. /// /// ``` +/// use std::ops::BitXor; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -513,6 +535,8 @@ bitxor_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 } /// calling `shl`, and therefore, `main` prints `Shifting left!`. /// /// ``` +/// use std::ops::Shl; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -554,6 +578,8 @@ shl_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 } /// calling `shr`, and therefore, `main` prints `Shifting right!`. /// /// ``` +/// use std::ops::Shr; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -594,6 +620,8 @@ shr_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 } /// calling `index`, and therefore, `main` prints `Indexing!`. /// /// ``` +/// use std::ops::Index; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -623,6 +651,8 @@ pub trait Index for Sized? { /// calling `index_mut`, and therefore, `main` prints `Indexing!`. /// /// ``` +/// use std::ops::IndexMut; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -652,6 +682,8 @@ pub trait IndexMut for Sized? { /// calling `slice_to`, and therefore, `main` prints `Slicing!`. /// /// ```ignore +/// use std::ops::Slice; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -699,6 +731,8 @@ pub trait Slice for Sized? { /// calling `slice_from_mut`, and therefore, `main` prints `Slicing!`. /// /// ```ignore +/// use std::ops::SliceMut; +/// /// #[deriving(Copy)] /// struct Foo; /// @@ -827,6 +861,8 @@ pub struct RangeTo { /// struct. /// /// ``` +/// use std::ops::Deref; +/// /// struct DerefExample { /// value: T /// } @@ -865,6 +901,8 @@ impl<'a, Sized? T> Deref for &'a mut T { /// struct. /// /// ``` +/// use std::ops::{Deref, DerefMut}; +/// /// struct DerefMutExample { /// value: T /// } diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs index cecb493815380..210850be13a8e 100644 --- a/src/libcore/prelude.rs +++ b/src/libcore/prelude.rs @@ -30,39 +30,24 @@ // Reexported core operators pub use kinds::{Copy, Send, Sized, Sync}; -pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not}; -pub use ops::{BitAnd, BitOr, BitXor}; -pub use ops::{Drop, Deref, DerefMut}; -pub use ops::{Shl, Shr}; -pub use ops::{Index, IndexMut}; -pub use ops::{Slice, SliceMut}; -pub use ops::{Fn, FnMut, FnOnce}; +pub use ops::{Drop, Fn, FnMut, FnOnce}; // Reexported functions pub use iter::range; pub use mem::drop; -pub use str::from_str; // Reexported types and traits pub use char::Char; pub use clone::Clone; pub use cmp::{PartialEq, PartialOrd, Eq, Ord}; -pub use cmp::{Ordering, Equiv}; -pub use cmp::Ordering::{Less, Equal, Greater}; -pub use iter::{FromIterator, Extend, IteratorExt}; -pub use iter::{Iterator, DoubleEndedIterator, DoubleEndedIteratorExt, RandomAccessIterator}; -pub use iter::{IteratorCloneExt, CloneIteratorExt, IteratorPairExt}; -pub use iter::{IteratorOrdExt, MutableDoubleEndedIterator, ExactSizeIterator}; -pub use num::{ToPrimitive, FromPrimitive}; -pub use option::Option; -pub use option::Option::{Some, None}; +pub use iter::{Extend, IteratorExt}; +pub use iter::{Iterator, DoubleEndedIterator, DoubleEndedIteratorExt}; +pub use iter::{IteratorCloneExt, CloneIteratorExt}; +pub use iter::{IteratorOrdExt, ExactSizeIterator, IteratorPairExt}; +pub use option::Option::{mod, Some, None}; pub use ptr::{PtrExt, MutPtrExt}; -pub use result::Result; -pub use result::Result::{Ok, Err}; -pub use str::{Str, StrExt}; -pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4}; -pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8}; -pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12}; -pub use slice::{PartialEqSliceExt, OrdSliceExt}; +pub use result::Result::{mod, Ok, Err}; pub use slice::{AsSlice, SliceExt}; +pub use slice::{PartialEqSliceExt, OrdSliceExt}; +pub use str::{Str, StrExt}; diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index 576989fabe77c..ad2323296d97f 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -32,35 +32,6 @@ //! * `PartialOrd` //! * `Ord` //! * `Default` -//! -//! # Examples -//! -//! Using methods: -//! -//! ``` -//! #[allow(deprecated)] -//! # fn main() { -//! let pair = ("pi", 3.14f64); -//! assert_eq!(pair.val0(), "pi"); -//! assert_eq!(pair.val1(), 3.14f64); -//! # } -//! ``` -//! -//! Using traits implemented for tuples: -//! -//! ``` -//! use std::default::Default; -//! -//! let a = (1i, 2i); -//! let b = (3i, 4i); -//! assert!(a != b); -//! -//! let c = b.clone(); -//! assert!(b == c); -//! -//! let d : (u32, f32) = Default::default(); -//! assert_eq!(d, (0u32, 0.0f32)); -//! ``` #![stable] diff --git a/src/libcoretest/cmp.rs b/src/libcoretest/cmp.rs index 716300f652d67..992c99f1f9fe0 100644 --- a/src/libcoretest/cmp.rs +++ b/src/libcoretest/cmp.rs @@ -8,7 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use core::cmp::{ partial_min, partial_max }; +use core::cmp::{partial_min, partial_max}; +use core::cmp::Ordering::{Less, Greater, Equal}; #[test] fn test_int_totalord() { diff --git a/src/libcoretest/num/int_macros.rs b/src/libcoretest/num/int_macros.rs index 55e0f10c8655c..e409dc61510f6 100644 --- a/src/libcoretest/num/int_macros.rs +++ b/src/libcoretest/num/int_macros.rs @@ -17,6 +17,7 @@ mod tests { use core::int; use core::num::{FromStrRadix, Int, SignedInt}; use core::str::from_str; + use core::ops::{Shl, Shr, Not, BitXor, BitAnd, BitOr}; use num; #[test] diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs index acc593d7be9c0..82e91c5b7120a 100644 --- a/src/libcoretest/num/mod.rs +++ b/src/libcoretest/num/mod.rs @@ -13,6 +13,7 @@ use core::fmt::Show; use core::num::{NumCast, cast}; use core::ops::{Add, Sub, Mul, Div, Rem}; use core::kinds::Copy; +use std::str::from_str; mod int_macros; mod i8; @@ -54,6 +55,7 @@ mod test { use core::option::Option::{Some, None}; use core::num::Float; use core::num::from_str_radix; + use core::str::from_str; #[test] fn from_str_issue7588() { diff --git a/src/libcoretest/num/uint_macros.rs b/src/libcoretest/num/uint_macros.rs index b21ac11e6a0b5..2311c19d5573a 100644 --- a/src/libcoretest/num/uint_macros.rs +++ b/src/libcoretest/num/uint_macros.rs @@ -16,6 +16,7 @@ mod tests { use core::$T_i::*; use core::num::Int; use num; + use core::ops::{BitOr, BitAnd, BitXor, Shl, Shr, Not}; #[test] fn test_overflows() { diff --git a/src/libcoretest/str.rs b/src/libcoretest/str.rs index 63d6e14a4a6b8..fc02f46724fb8 100644 --- a/src/libcoretest/str.rs +++ b/src/libcoretest/str.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::str::from_str; + #[test] fn test_bool_from_str() { assert_eq!(from_str::("true"), Some(true)); diff --git a/src/libcoretest/tuple.rs b/src/libcoretest/tuple.rs index f7b714757f8da..c3bc38a6614b8 100644 --- a/src/libcoretest/tuple.rs +++ b/src/libcoretest/tuple.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::cmp::Ordering::{Equal, Less, Greater}; + #[test] fn test_clone() { let a = (1i, "2"); diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 7dd0649e4837d..01e55fb2edd9a 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -47,6 +47,7 @@ //! which is cyclic. //! //! ```rust +//! use std::borrow::IntoCow; //! use graphviz as dot; //! //! type Nd = int; @@ -146,6 +147,7 @@ //! entity `&sube`). //! //! ```rust +//! use std::borrow::IntoCow; //! use graphviz as dot; //! //! type Nd = uint; @@ -201,6 +203,7 @@ //! Hasse-diagram for the subsets of the set `{x, y}`. //! //! ```rust +//! use std::borrow::IntoCow; //! use graphviz as dot; //! //! type Nd<'a> = (uint, &'a str); @@ -273,6 +276,7 @@ pub use self::LabelText::*; +use std::borrow::IntoCow; use std::io; use std::str::CowString; use std::vec::CowVec; @@ -586,6 +590,7 @@ mod tests { use super::{Nodes, Edges, GraphWalk, render}; use std::io::IoResult; use std::str; + use std::borrow::IntoCow; /// each node is an index in a vector in the graph. type Node = uint; diff --git a/src/libgraphviz/maybe_owned_vec.rs b/src/libgraphviz/maybe_owned_vec.rs index ddda2b38c223a..573f0926e2915 100644 --- a/src/libgraphviz/maybe_owned_vec.rs +++ b/src/libgraphviz/maybe_owned_vec.rs @@ -12,8 +12,10 @@ pub use self::MaybeOwnedVector::*; +use std::cmp::{Equiv, Ordering}; use std::default::Default; use std::fmt; +use std::iter::FromIterator; use std::path::BytesContainer; use std::slice; @@ -125,7 +127,7 @@ impl<'a,T> FromIterator for MaybeOwnedVector<'a,T> { fn from_iter>(iterator: I) -> MaybeOwnedVector<'a,T> { // If we are building from scratch, might as well build the // most flexible variant. - Growable(FromIterator::from_iter(iterator)) + Growable(iterator.collect()) } } diff --git a/src/librand/chacha.rs b/src/librand/chacha.rs index 49577cd279bf8..8e6c7de305f82 100644 --- a/src/librand/chacha.rs +++ b/src/librand/chacha.rs @@ -206,7 +206,7 @@ impl Rand for ChaChaRng { #[cfg(test)] mod test { - use std::prelude::*; + use std::prelude::v1::*; use core::iter::order; use {Rng, SeedableRng}; diff --git a/src/librand/distributions/exponential.rs b/src/librand/distributions/exponential.rs index f31f3468a4c00..981b0eeee53e0 100644 --- a/src/librand/distributions/exponential.rs +++ b/src/librand/distributions/exponential.rs @@ -94,7 +94,7 @@ impl IndependentSample for Exp { #[cfg(test)] mod test { - use std::prelude::*; + use std::prelude::v1::*; use distributions::{Sample, IndependentSample}; use super::Exp; @@ -124,7 +124,7 @@ mod test { mod bench { extern crate test; - use std::prelude::*; + use std::prelude::v1::*; use self::test::Bencher; use std::mem::size_of; diff --git a/src/librand/distributions/gamma.rs b/src/librand/distributions/gamma.rs index 618db380db8d4..378029d1f9b37 100644 --- a/src/librand/distributions/gamma.rs +++ b/src/librand/distributions/gamma.rs @@ -323,7 +323,7 @@ impl IndependentSample for StudentT { #[cfg(test)] mod test { - use std::prelude::*; + use std::prelude::v1::*; use distributions::{Sample, IndependentSample}; use super::{ChiSquared, StudentT, FisherF}; @@ -385,7 +385,7 @@ mod test { #[cfg(test)] mod bench { extern crate test; - use std::prelude::*; + use std::prelude::v1::*; use self::test::Bencher; use std::mem::size_of; use distributions::IndependentSample; diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 54cb8ae190718..d0123d9c76c99 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -258,7 +258,7 @@ fn ziggurat( #[cfg(test)] mod tests { - use std::prelude::*; + use std::prelude::v1::*; use {Rng, Rand}; use super::{RandSample, WeightedChoice, Weighted, Sample, IndependentSample}; diff --git a/src/librand/distributions/normal.rs b/src/librand/distributions/normal.rs index 3507282ec486a..543e236f96dd2 100644 --- a/src/librand/distributions/normal.rs +++ b/src/librand/distributions/normal.rs @@ -160,7 +160,7 @@ impl IndependentSample for LogNormal { #[cfg(test)] mod tests { - use std::prelude::*; + use std::prelude::v1::*; use distributions::{Sample, IndependentSample}; use super::{Normal, LogNormal}; @@ -200,7 +200,7 @@ mod tests { #[cfg(test)] mod bench { extern crate test; - use std::prelude::*; + use std::prelude::v1::*; use self::test::Bencher; use std::mem::size_of; use distributions::{Sample}; diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs index 20ba3566d5b12..558fa20125675 100644 --- a/src/librand/distributions/range.rs +++ b/src/librand/distributions/range.rs @@ -164,7 +164,7 @@ float_impl! { f64 } #[cfg(test)] mod tests { use std::num::Int; - use std::prelude::*; + use std::prelude::v1::*; use distributions::{Sample, IndependentSample}; use super::Range; diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index 1fe435a59adcb..1ea4784407592 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -487,7 +487,7 @@ impl Rand for Isaac64Rng { #[cfg(test)] mod test { - use std::prelude::*; + use std::prelude::v1::*; use core::iter::order; use {Rng, SeedableRng}; diff --git a/src/librand/rand_impls.rs b/src/librand/rand_impls.rs index e50153076c390..c331807c1b9d3 100644 --- a/src/librand/rand_impls.rs +++ b/src/librand/rand_impls.rs @@ -214,7 +214,7 @@ impl Rand for Option { #[cfg(test)] mod tests { - use std::prelude::*; + use std::prelude::v1::*; use std::rand::{Rng, thread_rng, Open01, Closed01}; struct ConstantRng(u64); diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs index 94a11c040e497..46371d427e63f 100644 --- a/src/librand/reseeding.rs +++ b/src/librand/reseeding.rs @@ -149,7 +149,7 @@ impl Default for ReseedWithDefault { #[cfg(test)] mod test { - use std::prelude::*; + use std::prelude::v1::*; use core::iter::order; use super::{ReseedingRng, ReseedWithDefault}; diff --git a/src/libregex/re.rs b/src/libregex/re.rs index 51c234631550c..3171966a596db 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -11,6 +11,7 @@ pub use self::NamesIter::*; pub use self::Regex::*; +use std::borrow::IntoCow; use std::collections::HashMap; use std::fmt; use std::str::CowString; diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs index 72e0e559c805b..603ca57d15d5b 100644 --- a/src/libregex/vm.rs +++ b/src/libregex/vm.rs @@ -37,6 +37,7 @@ pub use self::MatchKind::*; pub use self::StepState::*; use std::cmp; +use std::cmp::Ordering::{mod, Less, Equal, Greater}; use std::mem; use std::iter::repeat; use std::slice::SliceExt; diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 692ecf75091c4..5e74b90dba34c 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -36,10 +36,11 @@ use util::ppaux::{ty_to_string}; use util::nodemap::{FnvHashMap, NodeSet}; use lint::{Context, LintPass, LintArray}; -use std::{cmp, slice}; use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::num::SignedInt; +use std::{cmp, slice}; use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64}; + use syntax::{abi, ast, ast_map}; use syntax::ast_util::is_shift_binop; use syntax::attr::{mod, AttrMetaMethods}; diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index d079d0e52aafa..70325294743e8 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -32,13 +32,15 @@ use middle::ty::{ImplContainer, TraitContainer}; use middle::ty::{mod, Ty}; use middle::astencode::vtable_decoder_helpers; +use std::collections::HashMap; use std::hash::Hash; use std::hash; use std::io::extensions::u64_from_be_bytes; use std::io; -use std::collections::hash_map::HashMap; +use std::num::FromPrimitive; use std::rc::Rc; use std::str; + use rbml::reader; use rbml; use serialize::Decodable; diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 88c7ccf1b1e36..2d3ff95ffa66e 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -25,7 +25,6 @@ use middle::ty::{mod, AsPredicate, Ty}; use std::rc::Rc; use std::str; -use std::string::String; use syntax::abi; use syntax::ast; use syntax::parse::token; diff --git a/src/librustc/middle/cfg/graphviz.rs b/src/librustc/middle/cfg/graphviz.rs index 13bd22a67c410..06fef66c1e003 100644 --- a/src/librustc/middle/cfg/graphviz.rs +++ b/src/librustc/middle/cfg/graphviz.rs @@ -11,7 +11,9 @@ /// This module provides linkage between rustc::middle::graph and /// libgraphviz traits. -/// For clarity, rename the graphviz crate locally to dot. +use std::borrow::IntoCow; + +// For clarity, rename the graphviz crate locally to dot. use graphviz as dot; use syntax::ast; diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 4c5d76a2c40e5..d16224ec5b8ac 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -24,8 +24,7 @@ use middle::pat_util::*; use middle::ty::*; use middle::ty; use std::fmt; -use std::iter::AdditiveIterator; -use std::iter::{range_inclusive, repeat}; +use std::iter::{range_inclusive, AdditiveIterator, FromIterator, repeat}; use std::num::Float; use std::slice; use syntax::ast::{mod, DUMMY_NODE_ID, NodeId, Pat}; diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 5b89912dd03fc..9fc5cb0335313 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -27,8 +27,8 @@ use syntax::ptr::P; use syntax::visit::{mod, Visitor}; use syntax::{ast_map, ast_util, codemap}; -use std::rc::Rc; use std::collections::hash_map::Entry::Vacant; +use std::rc::Rc; // // This pass classifies expressions by their constant-ness. diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 7372bb267b06c..6ac1c5470cc75 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -33,8 +33,9 @@ use util::nodemap::{FnvHashMap, FnvHashSet}; use util::ppaux::Repr; use std::cell::{Cell, RefCell}; -use std::u32; +use std::cmp::Ordering::{mod, Less, Greater, Equal}; use std::iter::repeat; +use std::u32; use syntax::ast; mod doc; diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 2aef430719923..78fabcd588a28 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -36,6 +36,7 @@ use syntax::visit::Visitor; use syntax::visit; use std::iter::Enumerate; +use std::num::FromPrimitive; use std::slice; // The actual lang items defined come at the end of this file in one handy table. diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 7bc5d3d070894..07ff0ed67a64e 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -69,7 +69,7 @@ use util::nodemap::{FnvHashMap}; use arena::TypedArena; use std::borrow::BorrowFrom; use std::cell::{Cell, RefCell}; -use std::cmp; +use std::cmp::{mod, Ordering}; use std::fmt::{mod, Show}; use std::hash::{Hash, sip, Writer}; use std::mem; diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 19ac6d466fb58..f6f46017f37b9 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -394,6 +394,7 @@ macro_rules! cgoptions { mod cgsetters { use super::{CodegenOptions, Passes, SomePasses, AllPasses}; + use std::str::from_str; $( pub fn $opt(cg: &mut CodegenOptions, v: Option<&str>) -> bool { diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index 73b345a70af46..8d3aa397f3061 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -33,7 +33,7 @@ impl<'tcx> MoveErrorCollector<'tcx> { } pub fn report_potential_errors<'a>(&self, bccx: &BorrowckCtxt<'a, 'tcx>) { - report_move_errors(bccx, self.errors.borrow().deref()) + report_move_errors(bccx, &*self.errors.borrow()) } } diff --git a/src/librustc_borrowck/graphviz.rs b/src/librustc_borrowck/graphviz.rs index e2813c8e9882a..ac6b962d64704 100644 --- a/src/librustc_borrowck/graphviz.rs +++ b/src/librustc_borrowck/graphviz.rs @@ -24,6 +24,7 @@ use rustc::middle::cfg::{CFGIndex}; use rustc::middle::dataflow::{DataFlowOperator, DataFlowContext, EntryOrExit}; use rustc::middle::dataflow; use std::rc::Rc; +use std::borrow::IntoCow; #[deriving(Show, Copy)] pub enum Variant { diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 181f38d89939e..f3013d2066c3d 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -54,6 +54,8 @@ use rustc::metadata; use rustc::DIAGNOSTICS; use std::any::AnyRefExt; +use std::cmp::Ordering::Equal; +use std::comm::channel; use std::io; use std::iter::repeat; use std::os; diff --git a/src/librustc_llvm/archive_ro.rs b/src/librustc_llvm/archive_ro.rs index 6c3778787e2e2..53992d4567a34 100644 --- a/src/librustc_llvm/archive_ro.rs +++ b/src/librustc_llvm/archive_ro.rs @@ -13,8 +13,9 @@ use libc; use ArchiveRef; -use std::raw; +use std::c_str::ToCStr; use std::mem; +use std::raw; pub struct ArchiveRO { ptr: ArchiveRef, diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 7dbcc810b571b..8553a20900513 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -61,8 +61,9 @@ use syntax::parse::token::{mod, special_idents}; use syntax::codemap::{Span, DUMMY_SP}; use syntax::visit::{mod, Visitor}; -use std::rc::Rc; use std::mem::replace; +use std::ops::{Deref, DerefMut}; +use std::rc::Rc; // Specifies how duplicates should be handled when adding a child item if // another item exists with the same name in some namespace. diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs index 78527315199ca..b3d0d30726c5d 100644 --- a/src/librustc_resolve/check_unused.rs +++ b/src/librustc_resolve/check_unused.rs @@ -17,6 +17,8 @@ // `use` directives. // +use std::ops::{Deref, DerefMut}; + use Resolver; use Namespace::{TypeNS, ValueNS}; diff --git a/src/librustc_resolve/record_exports.rs b/src/librustc_resolve/record_exports.rs index 9c2437c376ddd..4f314291da628 100644 --- a/src/librustc_resolve/record_exports.rs +++ b/src/librustc_resolve/record_exports.rs @@ -27,6 +27,7 @@ use rustc::middle::def::Export; use syntax::ast; use syntax::parse::token; +use std::ops::{Deref, DerefMut}; use std::rc::Rc; struct ExportRecorder<'a, 'b:'a, 'tcx:'b> { diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs index 1271330897e73..7cf4bafe032e0 100644 --- a/src/librustc_trans/back/lto.rs +++ b/src/librustc_trans/back/lto.rs @@ -20,6 +20,7 @@ use rustc::util::common::time; use libc; use flate; +use std::c_str::ToCStr; use std::iter; use std::mem; use std::num::Int; diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index a6f2c7dfed0b1..f74f0abc18625 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -23,6 +23,7 @@ use syntax::diagnostic; use syntax::diagnostic::{Emitter, Handler, Level, mk_handler}; use std::c_str::{ToCStr, CString}; +use std::comm::channel; use std::io::Command; use std::io::fs; use std::iter::Unfold; diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index 51ea0af8e10ea..b877a771bbc6c 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -1202,8 +1202,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { let glob_map = &self.analysis.glob_map; let glob_map = glob_map.as_ref().unwrap(); if glob_map.contains_key(&id) { - let names = glob_map.index(&id); - for n in names.iter() { + for n in glob_map[id].iter() { if name_string.len() > 0 { name_string.push_str(", "); } diff --git a/src/librustc_trans/trans/builder.rs b/src/librustc_trans/trans/builder.rs index b39dbd71117e8..97f0b92a290f8 100644 --- a/src/librustc_trans/trans/builder.rs +++ b/src/librustc_trans/trans/builder.rs @@ -20,7 +20,7 @@ use trans::machine::llalign_of_pref; use trans::type_::Type; use util::nodemap::FnvHashMap; use libc::{c_uint, c_char}; -use std::string::String; +use std::c_str::ToCStr; use syntax::codemap::Span; pub struct Builder<'a, 'tcx: 'a> { diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index 83765270ef103..99dc971ed945d 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -26,6 +26,7 @@ use trans::type_of; use middle::ty::{mod, Ty}; use middle::subst::{Substs}; use std::cmp; +use std::c_str::ToCStr; use libc::c_uint; use syntax::abi::{Cdecl, Aapcs, C, Win64, Abi}; use syntax::abi::{RustIntrinsic, Rust, RustCall, Stdcall, Fastcall, System}; diff --git a/src/librustdoc/flock.rs b/src/librustdoc/flock.rs index a89b20c949b40..0f0dbf6a24dff 100644 --- a/src/librustdoc/flock.rs +++ b/src/librustdoc/flock.rs @@ -18,10 +18,10 @@ pub use self::imp::Lock; - #[cfg(unix)] mod imp { use libc; + use std::c_str::ToCStr; #[cfg(target_os = "linux")] mod os { diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index 2c05524ea7f7b..468fed1d33910 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -29,11 +29,12 @@ use libc; use std::ascii::AsciiExt; +use std::c_str::ToCStr; use std::cell::{RefCell, Cell}; +use std::collections::HashMap; use std::fmt; use std::slice; use std::str; -use std::collections::HashMap; use html::toc::TocBuilder; use html::highlight; diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index f8a0b88b4088d..ceb66be2d6674 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -35,6 +35,7 @@ pub use self::ExternalLocation::*; use std::cell::RefCell; +use std::cmp::Ordering::{mod, Less, Greater, Equal}; use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::collections::{HashMap, HashSet}; use std::default::Default; diff --git a/src/librustdoc/stability_summary.rs b/src/librustdoc/stability_summary.rs index 2e3adf8e76787..058a7acd4550b 100644 --- a/src/librustdoc/stability_summary.rs +++ b/src/librustdoc/stability_summary.rs @@ -13,8 +13,9 @@ //! hierarchy, with item counts for every stability level per module. A parent //! module's count includes its children's. -use std::ops::Add; +use std::cmp::Ordering; use std::num::Zero; +use std::ops::Add; use syntax::attr::{Deprecated, Experimental, Unstable, Stable, Frozen, Locked}; use syntax::ast::Public; diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index ba66c51b8fc68..b7b8360fced85 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -9,14 +9,14 @@ // except according to those terms. use std::cell::RefCell; +use std::comm::channel; use std::dynamic_lib::DynamicLibrary; use std::io::{Command, TempDir}; use std::io; use std::os; use std::str; -use std::string::String; -use std::thunk::Thunk; use std::thread::Thread; +use std::thunk::Thunk; use std::collections::{HashSet, HashMap}; use testing; diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 2c2b7313a7bb4..857a7072009bd 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -315,8 +315,8 @@ static ASCII_UPPERCASE_MAP: [u8; 256] = [ #[cfg(test)] mod tests { + use prelude::v1::*; use super::*; - use prelude::*; use char::from_u32; #[test] diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs index aeb4df402a2cf..72220926c0d86 100644 --- a/src/libstd/bitflags.rs +++ b/src/libstd/bitflags.rs @@ -209,7 +209,7 @@ macro_rules! bitflags { } } - impl BitOr<$BitFlags, $BitFlags> for $BitFlags { + impl ::std::ops::BitOr<$BitFlags, $BitFlags> for $BitFlags { /// Returns the union of the two sets of flags. #[inline] fn bitor(self, other: $BitFlags) -> $BitFlags { @@ -217,7 +217,7 @@ macro_rules! bitflags { } } - impl BitXor<$BitFlags, $BitFlags> for $BitFlags { + impl ::std::ops::BitXor<$BitFlags, $BitFlags> for $BitFlags { /// Returns the left flags, but with all the right flags toggled. #[inline] fn bitxor(self, other: $BitFlags) -> $BitFlags { @@ -225,7 +225,7 @@ macro_rules! bitflags { } } - impl BitAnd<$BitFlags, $BitFlags> for $BitFlags { + impl ::std::ops::BitAnd<$BitFlags, $BitFlags> for $BitFlags { /// Returns the intersection between the two sets of flags. #[inline] fn bitand(self, other: $BitFlags) -> $BitFlags { @@ -233,7 +233,7 @@ macro_rules! bitflags { } } - impl Sub<$BitFlags, $BitFlags> for $BitFlags { + impl ::std::ops::Sub<$BitFlags, $BitFlags> for $BitFlags { /// Returns the set difference of the two sets of flags. #[inline] fn sub(self, other: $BitFlags) -> $BitFlags { @@ -241,7 +241,7 @@ macro_rules! bitflags { } } - impl Not<$BitFlags> for $BitFlags { + impl ::std::ops::Not<$BitFlags> for $BitFlags { /// Returns the complement of this set of flags. #[inline] fn not(self) -> $BitFlags { diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs index 46498610e5604..6418841eda8cf 100644 --- a/src/libstd/c_str.rs +++ b/src/libstd/c_str.rs @@ -45,6 +45,8 @@ //! ```rust //! extern crate libc; //! +//! use std::c_str::ToCStr; +//! //! extern { //! fn puts(s: *const libc::c_char); //! } @@ -70,6 +72,7 @@ use core::prelude::*; use libc; +use cmp::Ordering; use fmt; use hash; use mem; @@ -155,6 +158,8 @@ impl CString { /// one). /// /// ```rust + /// use std::c_str::ToCStr; + /// /// let foo = "some string"; /// /// // right @@ -170,6 +175,8 @@ impl CString { /// ```rust /// extern crate libc; /// + /// use std::c_str::ToCStr; + /// /// fn main() { /// let c_str = "foo bar".to_c_str(); /// unsafe { @@ -189,6 +196,8 @@ impl CString { /// one). /// /// ```rust + /// use std::c_str::ToCStr; + /// /// let foo = "some string"; /// /// // right @@ -309,6 +318,8 @@ pub trait ToCStr for Sized? { /// ```rust /// extern crate libc; /// + /// use std::c_str::ToCStr; + /// /// fn main() { /// let s = "PATH".with_c_str(|path| unsafe { /// libc::getenv(path) @@ -539,8 +550,7 @@ pub unsafe fn from_c_multistring(buf: *const libc::c_char, #[cfg(test)] mod tests { use super::*; - use prelude::{spawn, Some, None, Option, FnOnce, ToString, CloneSliceExt}; - use prelude::{Clone, PtrExt, Iterator, SliceExt, StrExt}; + use prelude::v1::*; use ptr; use thread::Thread; use libc; @@ -732,9 +742,10 @@ mod tests { mod bench { extern crate test; + use prelude::v1::*; use self::test::Bencher; use libc; - use prelude::*; + use c_str::ToCStr; #[inline] fn check(s: &str, c_str: *const libc::c_char) { diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 0aa51ee66ed63..de60f06efd218 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -172,7 +172,7 @@ impl AsSlice for CVec { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; use super::CVec; use libc; diff --git a/src/libstd/collections/hash/bench.rs b/src/libstd/collections/hash/bench.rs index 87aebb24f987b..28689767cb0e3 100644 --- a/src/libstd/collections/hash/bench.rs +++ b/src/libstd/collections/hash/bench.rs @@ -11,7 +11,7 @@ #![cfg(test)] extern crate test; -use prelude::*; +use prelude::v1::*; use self::test::Bencher; use iter::{range_inclusive}; diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index f6063df543489..c0536fc5ca4e4 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -87,7 +87,7 @@ impl DefaultResizePolicy { #[test] fn test_resize_policy() { - use prelude::*; + use prelude::v1::*; let rp = DefaultResizePolicy; for n in range(0u, 1000) { assert!(rp.min_capacity(rp.usable_capacity(n)) <= n); @@ -1530,8 +1530,9 @@ impl, V, S, H: Hasher + Default> Extend<(K, V)> for HashMap Iterator<&'a T> for Union<'a, T, H> #[cfg(test)] mod test_set { - use prelude::*; + use prelude::v1::*; use super::HashSet; diff --git a/src/libstd/comm/mod.rs b/src/libstd/comm/mod.rs index a405627aecc45..dcef24c62bd23 100644 --- a/src/libstd/comm/mod.rs +++ b/src/libstd/comm/mod.rs @@ -60,6 +60,7 @@ //! //! ``` //! use std::thread::Thread; +//! use std::comm::channel; //! //! // Create a simple streaming channel //! let (tx, rx) = channel(); @@ -73,6 +74,7 @@ //! //! ``` //! use std::thread::Thread; +//! use std::comm::channel; //! //! // Create a shared channel that can be sent along from many threads //! // where tx is the sending half (tx for transmission), and rx is the receiving @@ -94,6 +96,8 @@ //! Propagating panics: //! //! ```should_fail +//! use std::comm::channel; +//! //! // The call to recv() will panic!() because the channel has already hung //! // up (or been deallocated) //! let (tx, rx) = channel::(); @@ -105,6 +109,7 @@ //! //! ``` //! use std::thread::Thread; +//! use std::comm::sync_channel; //! //! let (tx, rx) = sync_channel::(0); //! Thread::spawn(move|| { @@ -120,6 +125,7 @@ //! after 10 seconds no matter what: //! //! ```no_run +//! use std::comm::channel; //! use std::io::timer::Timer; //! use std::time::Duration; //! @@ -143,6 +149,7 @@ //! has been inactive for 5 seconds: //! //! ```no_run +//! use std::comm::channel; //! use std::io::timer::Timer; //! use std::time::Duration; //! @@ -328,22 +335,6 @@ use self::select::StartResult; use self::select::StartResult::*; use self::blocking::SignalToken; -macro_rules! test { - { fn $name:ident() $b:block $(#[$a:meta])*} => ( - mod $name { - #![allow(unused_imports)] - - use super::*; - use comm::*; - use thread::Thread; - use prelude::{Ok, Err, spawn, range, drop, Box, Some, None, Option}; - use prelude::{Vec, Buffer, from_str, Clone}; - - $(#[$a])* #[test] fn f() { $b } - } - ) -} - mod blocking; mod oneshot; mod select; @@ -458,6 +449,7 @@ impl UnsafeFlavor for Receiver { /// # Example /// /// ``` +/// use std::comm::channel; /// use std::thread::Thread; /// /// // tx is is the sending half (tx for transmission), and rx is the receiving @@ -499,6 +491,7 @@ pub fn channel() -> (Sender, Receiver) { /// # Example /// /// ``` +/// use std::comm::sync_channel; /// use std::thread::Thread; /// /// let (tx, rx) = sync_channel(1); @@ -580,6 +573,8 @@ impl Sender { /// # Example /// /// ``` + /// use std::comm::channel; + /// /// let (tx, rx) = channel(); /// /// // This send is always successful @@ -1046,9 +1041,12 @@ unsafe impl kinds::Sync for RacyCell { } // Oh dear #[cfg(test)] mod test { - use super::*; - use prelude::{spawn, range, Some, None, from_str, Clone, Str}; + use prelude::v1::*; + use os; + use super::*; + use thread::Thread; + use str::from_str; pub fn stress_factor() -> uint { match os::getenv("RUST_TEST_STRESS") { @@ -1057,121 +1055,144 @@ mod test { } } - test! { fn smoke() { + #[test] + fn smoke() { let (tx, rx) = channel::(); tx.send(1); assert_eq!(rx.recv(), 1); - } } + } - test! { fn drop_full() { + #[test] + fn drop_full() { let (tx, _rx) = channel(); tx.send(box 1i); - } } + } - test! { fn drop_full_shared() { + #[test] + fn drop_full_shared() { let (tx, _rx) = channel(); drop(tx.clone()); drop(tx.clone()); tx.send(box 1i); - } } + } - test! { fn smoke_shared() { + #[test] + fn smoke_shared() { let (tx, rx) = channel::(); tx.send(1); assert_eq!(rx.recv(), 1); let tx = tx.clone(); tx.send(1); assert_eq!(rx.recv(), 1); - } } + } - test! { fn smoke_threads() { + #[test] + fn smoke_threads() { let (tx, rx) = channel::(); - spawn(move|| { + let _t = Thread::spawn(move|| { tx.send(1); }); assert_eq!(rx.recv(), 1); - } } + } - test! { fn smoke_port_gone() { + #[test] + #[should_fail] + fn smoke_port_gone() { let (tx, rx) = channel::(); drop(rx); tx.send(1); - } #[should_fail] } + } - test! { fn smoke_shared_port_gone() { + #[test] + #[should_fail] + fn smoke_shared_port_gone() { let (tx, rx) = channel::(); drop(rx); tx.send(1); - } #[should_fail] } + } - test! { fn smoke_shared_port_gone2() { + #[test] + #[should_fail] + fn smoke_shared_port_gone2() { let (tx, rx) = channel::(); drop(rx); let tx2 = tx.clone(); drop(tx); tx2.send(1); - } #[should_fail] } + } - test! { fn port_gone_concurrent() { + #[test] + #[should_fail] + fn port_gone_concurrent() { let (tx, rx) = channel::(); - spawn(move|| { + Thread::spawn(move|| { rx.recv(); - }); + }).detach(); loop { tx.send(1) } - } #[should_fail] } + } - test! { fn port_gone_concurrent_shared() { + #[test] + #[should_fail] + fn port_gone_concurrent_shared() { let (tx, rx) = channel::(); let tx2 = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { rx.recv(); - }); + }).detach(); loop { tx.send(1); tx2.send(1); } - } #[should_fail] } + } - test! { fn smoke_chan_gone() { + #[test] + #[should_fail] + fn smoke_chan_gone() { let (tx, rx) = channel::(); drop(tx); rx.recv(); - } #[should_fail] } + } - test! { fn smoke_chan_gone_shared() { + #[test] + #[should_fail] + fn smoke_chan_gone_shared() { let (tx, rx) = channel::<()>(); let tx2 = tx.clone(); drop(tx); drop(tx2); rx.recv(); - } #[should_fail] } + } - test! { fn chan_gone_concurrent() { + #[test] + #[should_fail] + fn chan_gone_concurrent() { let (tx, rx) = channel::(); - spawn(move|| { + Thread::spawn(move|| { tx.send(1); tx.send(1); - }); + }).detach(); loop { rx.recv(); } - } #[should_fail] } + } - test! { fn stress() { + #[test] + fn stress() { let (tx, rx) = channel::(); - spawn(move|| { + let t = Thread::spawn(move|| { for _ in range(0u, 10000) { tx.send(1i); } }); for _ in range(0u, 10000) { assert_eq!(rx.recv(), 1); } - } } + t.join().ok().unwrap(); + } - test! { fn stress_shared() { + #[test] + fn stress_shared() { static AMT: uint = 10000; static NTHREADS: uint = 8; let (tx, rx) = channel::(); - let (dtx, drx) = channel::<()>(); - spawn(move|| { + let t = Thread::spawn(move|| { for _ in range(0, AMT * NTHREADS) { assert_eq!(rx.recv(), 1); } @@ -1179,99 +1200,93 @@ mod test { Ok(..) => panic!(), _ => {} } - dtx.send(()); }); for _ in range(0, NTHREADS) { let tx = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { for _ in range(0, AMT) { tx.send(1); } - }); + }).detach(); } drop(tx); - drx.recv(); - } } + t.join().ok().unwrap(); + } #[test] fn send_from_outside_runtime() { let (tx1, rx1) = channel::<()>(); let (tx2, rx2) = channel::(); - let (tx3, rx3) = channel::<()>(); - let tx4 = tx3.clone(); - spawn(move|| { + let t1 = Thread::spawn(move|| { tx1.send(()); for _ in range(0i, 40) { assert_eq!(rx2.recv(), 1); } - tx3.send(()); }); rx1.recv(); - spawn(move|| { + let t2 = Thread::spawn(move|| { for _ in range(0i, 40) { tx2.send(1); } - tx4.send(()); }); - rx3.recv(); - rx3.recv(); + t1.join().ok().unwrap(); + t2.join().ok().unwrap(); } #[test] fn recv_from_outside_runtime() { let (tx, rx) = channel::(); - let (dtx, drx) = channel(); - spawn(move|| { + let t = Thread::spawn(move|| { for _ in range(0i, 40) { assert_eq!(rx.recv(), 1); } - dtx.send(()); }); for _ in range(0u, 40) { tx.send(1); } - drx.recv(); + t.join().ok().unwrap(); } #[test] fn no_runtime() { let (tx1, rx1) = channel::(); let (tx2, rx2) = channel::(); - let (tx3, rx3) = channel::<()>(); - let tx4 = tx3.clone(); - spawn(move|| { + let t1 = Thread::spawn(move|| { assert_eq!(rx1.recv(), 1); tx2.send(2); - tx4.send(()); }); - spawn(move|| { + let t2 = Thread::spawn(move|| { tx1.send(1); assert_eq!(rx2.recv(), 2); - tx3.send(()); }); - rx3.recv(); - rx3.recv(); + t1.join().ok().unwrap(); + t2.join().ok().unwrap(); } - test! { fn oneshot_single_thread_close_port_first() { + #[test] + fn oneshot_single_thread_close_port_first() { // Simple test of closing without sending let (_tx, rx) = channel::(); drop(rx); - } } + } - test! { fn oneshot_single_thread_close_chan_first() { + #[test] + fn oneshot_single_thread_close_chan_first() { // Simple test of closing without sending let (tx, _rx) = channel::(); drop(tx); - } } + } - test! { fn oneshot_single_thread_send_port_close() { + #[test] + #[should_fail] + fn oneshot_single_thread_send_port_close() { // Testing that the sender cleans up the payload if receiver is closed let (tx, rx) = channel::>(); drop(rx); tx.send(box 0); - } #[should_fail] } + } - test! { fn oneshot_single_thread_recv_chan_close() { + #[test] + fn oneshot_single_thread_recv_chan_close() { // Receiving on a closed chan will panic let res = Thread::spawn(move|| { let (tx, rx) = channel::(); @@ -1280,129 +1295,142 @@ mod test { }).join(); // What is our res? assert!(res.is_err()); - } } + } - test! { fn oneshot_single_thread_send_then_recv() { + #[test] + fn oneshot_single_thread_send_then_recv() { let (tx, rx) = channel::>(); tx.send(box 10); assert!(rx.recv() == box 10); - } } + } - test! { fn oneshot_single_thread_try_send_open() { + #[test] + fn oneshot_single_thread_try_send_open() { let (tx, rx) = channel::(); assert!(tx.send_opt(10).is_ok()); assert!(rx.recv() == 10); - } } + } - test! { fn oneshot_single_thread_try_send_closed() { + #[test] + fn oneshot_single_thread_try_send_closed() { let (tx, rx) = channel::(); drop(rx); assert!(tx.send_opt(10).is_err()); - } } + } - test! { fn oneshot_single_thread_try_recv_open() { + #[test] + fn oneshot_single_thread_try_recv_open() { let (tx, rx) = channel::(); tx.send(10); assert!(rx.recv_opt() == Ok(10)); - } } + } - test! { fn oneshot_single_thread_try_recv_closed() { + #[test] + fn oneshot_single_thread_try_recv_closed() { let (tx, rx) = channel::(); drop(tx); assert!(rx.recv_opt() == Err(())); - } } + } - test! { fn oneshot_single_thread_peek_data() { + #[test] + fn oneshot_single_thread_peek_data() { let (tx, rx) = channel::(); assert_eq!(rx.try_recv(), Err(Empty)); tx.send(10); assert_eq!(rx.try_recv(), Ok(10)); - } } + } - test! { fn oneshot_single_thread_peek_close() { + #[test] + fn oneshot_single_thread_peek_close() { let (tx, rx) = channel::(); drop(tx); assert_eq!(rx.try_recv(), Err(Disconnected)); assert_eq!(rx.try_recv(), Err(Disconnected)); - } } + } - test! { fn oneshot_single_thread_peek_open() { + #[test] + fn oneshot_single_thread_peek_open() { let (_tx, rx) = channel::(); assert_eq!(rx.try_recv(), Err(Empty)); - } } + } - test! { fn oneshot_multi_task_recv_then_send() { + #[test] + fn oneshot_multi_task_recv_then_send() { let (tx, rx) = channel::>(); - spawn(move|| { + let _t = Thread::spawn(move|| { assert!(rx.recv() == box 10); }); tx.send(box 10); - } } + } - test! { fn oneshot_multi_task_recv_then_close() { + #[test] + fn oneshot_multi_task_recv_then_close() { let (tx, rx) = channel::>(); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(tx); }); let res = Thread::spawn(move|| { assert!(rx.recv() == box 10); }).join(); assert!(res.is_err()); - } } + } - test! { fn oneshot_multi_thread_close_stress() { + #[test] + fn oneshot_multi_thread_close_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = channel::(); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(rx); }); drop(tx); } - } } + } - test! { fn oneshot_multi_thread_send_close_stress() { + #[test] + fn oneshot_multi_thread_send_close_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = channel::(); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(rx); }); let _ = Thread::spawn(move|| { tx.send(1); }).join(); } - } } + } - test! { fn oneshot_multi_thread_recv_close_stress() { + #[test] + fn oneshot_multi_thread_recv_close_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = channel::(); - spawn(move|| { + Thread::spawn(move|| { let res = Thread::spawn(move|| { rx.recv(); }).join(); assert!(res.is_err()); - }); - spawn(move|| { - spawn(move|| { + }).detach(); + let _t = Thread::spawn(move|| { + Thread::spawn(move|| { drop(tx); - }); + }).detach(); }); } - } } + } - test! { fn oneshot_multi_thread_send_recv_stress() { + #[test] + fn oneshot_multi_thread_send_recv_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { tx.send(box 10i); }); - spawn(move|| { - assert!(rx.recv() == box 10i); - }); + assert!(rx.recv() == box 10i); } - } } + } - test! { fn stream_send_recv_stress() { + #[test] + fn stream_send_recv_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = channel(); @@ -1412,50 +1440,53 @@ mod test { fn send(tx: Sender>, i: int) { if i == 10 { return } - spawn(move|| { + Thread::spawn(move|| { tx.send(box i); send(tx, i + 1); - }); + }).detach(); } fn recv(rx: Receiver>, i: int) { if i == 10 { return } - spawn(move|| { + Thread::spawn(move|| { assert!(rx.recv() == box i); recv(rx, i + 1); - }); + }).detach(); } } - } } + } - test! { fn recv_a_lot() { + #[test] + fn recv_a_lot() { // Regression test that we don't run out of stack in scheduler context let (tx, rx) = channel(); for _ in range(0i, 10000) { tx.send(()); } for _ in range(0i, 10000) { rx.recv(); } - } } + } - test! { fn shared_chan_stress() { + #[test] + fn shared_chan_stress() { let (tx, rx) = channel(); let total = stress_factor() + 100; for _ in range(0, total) { let tx = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { tx.send(()); - }); + }).detach(); } for _ in range(0, total) { rx.recv(); } - } } + } - test! { fn test_nested_recv_iter() { + #[test] + fn test_nested_recv_iter() { let (tx, rx) = channel::(); let (total_tx, total_rx) = channel::(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut acc = 0; for x in rx.iter() { acc += x; @@ -1468,13 +1499,14 @@ mod test { tx.send(2); drop(tx); assert_eq!(total_rx.recv(), 6); - } } + } - test! { fn test_recv_iter_break() { + #[test] + fn test_recv_iter_break() { let (tx, rx) = channel::(); let (count_tx, count_rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut count = 0; for x in rx.iter() { if count >= 3 { @@ -1492,13 +1524,14 @@ mod test { let _ = tx.send_opt(2); drop(tx); assert_eq!(count_rx.recv(), 4); - } } + } - test! { fn try_recv_states() { + #[test] + fn try_recv_states() { let (tx1, rx1) = channel::(); let (tx2, rx2) = channel::<()>(); let (tx3, rx3) = channel::<()>(); - spawn(move|| { + let _t = Thread::spawn(move|| { rx2.recv(); tx1.send(1); tx3.send(()); @@ -1515,14 +1548,15 @@ mod test { tx2.send(()); rx3.recv(); assert_eq!(rx1.try_recv(), Err(Disconnected)); - } } + } // This bug used to end up in a livelock inside of the Receiver destructor // because the internal state of the Shared packet was corrupted - test! { fn destroy_upgraded_shared_port_when_sender_still_active() { + #[test] + fn destroy_upgraded_shared_port_when_sender_still_active() { let (tx, rx) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { rx.recv(); // wait on a oneshot drop(rx); // destroy a shared tx2.send(()); @@ -1537,13 +1571,16 @@ mod test { // wait for the child task to exit before we exit rx2.recv(); - }} + } } #[cfg(test)] mod sync_tests { - use prelude::*; + use prelude::v1::*; use os; + use thread::Thread; + use super::*; + use str::from_str; pub fn stress_factor() -> uint { match os::getenv("RUST_TEST_STRESS") { @@ -1552,108 +1589,128 @@ mod sync_tests { } } - test! { fn smoke() { + #[test] + fn smoke() { let (tx, rx) = sync_channel::(1); tx.send(1); assert_eq!(rx.recv(), 1); - } } + } - test! { fn drop_full() { + #[test] + fn drop_full() { let (tx, _rx) = sync_channel(1); tx.send(box 1i); - } } + } - test! { fn smoke_shared() { + #[test] + fn smoke_shared() { let (tx, rx) = sync_channel::(1); tx.send(1); assert_eq!(rx.recv(), 1); let tx = tx.clone(); tx.send(1); assert_eq!(rx.recv(), 1); - } } + } - test! { fn smoke_threads() { + #[test] + fn smoke_threads() { let (tx, rx) = sync_channel::(0); - spawn(move|| { + let _t = Thread::spawn(move|| { tx.send(1); }); assert_eq!(rx.recv(), 1); - } } + } - test! { fn smoke_port_gone() { + #[test] + #[should_fail] + fn smoke_port_gone() { let (tx, rx) = sync_channel::(0); drop(rx); tx.send(1); - } #[should_fail] } + } - test! { fn smoke_shared_port_gone2() { + #[test] + #[should_fail] + fn smoke_shared_port_gone2() { let (tx, rx) = sync_channel::(0); drop(rx); let tx2 = tx.clone(); drop(tx); tx2.send(1); - } #[should_fail] } + } - test! { fn port_gone_concurrent() { + #[test] + #[should_fail] + fn port_gone_concurrent() { let (tx, rx) = sync_channel::(0); - spawn(move|| { + Thread::spawn(move|| { rx.recv(); - }); + }).detach(); loop { tx.send(1) } - } #[should_fail] } + } - test! { fn port_gone_concurrent_shared() { + #[test] + #[should_fail] + fn port_gone_concurrent_shared() { let (tx, rx) = sync_channel::(0); let tx2 = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { rx.recv(); - }); + }).detach(); loop { tx.send(1); tx2.send(1); } - } #[should_fail] } + } - test! { fn smoke_chan_gone() { + #[test] + #[should_fail] + fn smoke_chan_gone() { let (tx, rx) = sync_channel::(0); drop(tx); rx.recv(); - } #[should_fail] } + } - test! { fn smoke_chan_gone_shared() { + #[test] + #[should_fail] + fn smoke_chan_gone_shared() { let (tx, rx) = sync_channel::<()>(0); let tx2 = tx.clone(); drop(tx); drop(tx2); rx.recv(); - } #[should_fail] } + } - test! { fn chan_gone_concurrent() { + #[test] + #[should_fail] + fn chan_gone_concurrent() { let (tx, rx) = sync_channel::(0); - spawn(move|| { + Thread::spawn(move|| { tx.send(1); tx.send(1); - }); + }).detach(); loop { rx.recv(); } - } #[should_fail] } + } - test! { fn stress() { + #[test] + fn stress() { let (tx, rx) = sync_channel::(0); - spawn(move|| { + Thread::spawn(move|| { for _ in range(0u, 10000) { tx.send(1); } - }); + }).detach(); for _ in range(0u, 10000) { assert_eq!(rx.recv(), 1); } - } } + } - test! { fn stress_shared() { + #[test] + fn stress_shared() { static AMT: uint = 1000; static NTHREADS: uint = 8; let (tx, rx) = sync_channel::(0); let (dtx, drx) = sync_channel::<()>(0); - spawn(move|| { + Thread::spawn(move|| { for _ in range(0, AMT * NTHREADS) { assert_eq!(rx.recv(), 1); } @@ -1662,38 +1719,43 @@ mod sync_tests { _ => {} } dtx.send(()); - }); + }).detach(); for _ in range(0, NTHREADS) { let tx = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { for _ in range(0, AMT) { tx.send(1); } - }); + }).detach(); } drop(tx); drx.recv(); - } } + } - test! { fn oneshot_single_thread_close_port_first() { + #[test] + fn oneshot_single_thread_close_port_first() { // Simple test of closing without sending let (_tx, rx) = sync_channel::(0); drop(rx); - } } + } - test! { fn oneshot_single_thread_close_chan_first() { + #[test] + fn oneshot_single_thread_close_chan_first() { // Simple test of closing without sending let (tx, _rx) = sync_channel::(0); drop(tx); - } } + } - test! { fn oneshot_single_thread_send_port_close() { + #[test] + #[should_fail] + fn oneshot_single_thread_send_port_close() { // Testing that the sender cleans up the payload if receiver is closed let (tx, rx) = sync_channel::>(0); drop(rx); tx.send(box 0); - } #[should_fail] } + } - test! { fn oneshot_single_thread_recv_chan_close() { + #[test] + fn oneshot_single_thread_recv_chan_close() { // Receiving on a closed chan will panic let res = Thread::spawn(move|| { let (tx, rx) = sync_channel::(0); @@ -1702,134 +1764,148 @@ mod sync_tests { }).join(); // What is our res? assert!(res.is_err()); - } } + } - test! { fn oneshot_single_thread_send_then_recv() { + #[test] + fn oneshot_single_thread_send_then_recv() { let (tx, rx) = sync_channel::>(1); tx.send(box 10); assert!(rx.recv() == box 10); - } } + } - test! { fn oneshot_single_thread_try_send_open() { + #[test] + fn oneshot_single_thread_try_send_open() { let (tx, rx) = sync_channel::(1); assert_eq!(tx.try_send(10), Ok(())); assert!(rx.recv() == 10); - } } + } - test! { fn oneshot_single_thread_try_send_closed() { + #[test] + fn oneshot_single_thread_try_send_closed() { let (tx, rx) = sync_channel::(0); drop(rx); assert_eq!(tx.try_send(10), Err(RecvDisconnected(10))); - } } + } - test! { fn oneshot_single_thread_try_send_closed2() { + #[test] + fn oneshot_single_thread_try_send_closed2() { let (tx, _rx) = sync_channel::(0); assert_eq!(tx.try_send(10), Err(Full(10))); - } } + } - test! { fn oneshot_single_thread_try_recv_open() { + #[test] + fn oneshot_single_thread_try_recv_open() { let (tx, rx) = sync_channel::(1); tx.send(10); assert!(rx.recv_opt() == Ok(10)); - } } + } - test! { fn oneshot_single_thread_try_recv_closed() { + #[test] + fn oneshot_single_thread_try_recv_closed() { let (tx, rx) = sync_channel::(0); drop(tx); assert!(rx.recv_opt() == Err(())); - } } + } - test! { fn oneshot_single_thread_peek_data() { + #[test] + fn oneshot_single_thread_peek_data() { let (tx, rx) = sync_channel::(1); assert_eq!(rx.try_recv(), Err(Empty)); tx.send(10); assert_eq!(rx.try_recv(), Ok(10)); - } } + } - test! { fn oneshot_single_thread_peek_close() { + #[test] + fn oneshot_single_thread_peek_close() { let (tx, rx) = sync_channel::(0); drop(tx); assert_eq!(rx.try_recv(), Err(Disconnected)); assert_eq!(rx.try_recv(), Err(Disconnected)); - } } + } - test! { fn oneshot_single_thread_peek_open() { + #[test] + fn oneshot_single_thread_peek_open() { let (_tx, rx) = sync_channel::(0); assert_eq!(rx.try_recv(), Err(Empty)); - } } + } - test! { fn oneshot_multi_task_recv_then_send() { + #[test] + fn oneshot_multi_task_recv_then_send() { let (tx, rx) = sync_channel::>(0); - spawn(move|| { + let _t = Thread::spawn(move|| { assert!(rx.recv() == box 10); }); tx.send(box 10); - } } + } - test! { fn oneshot_multi_task_recv_then_close() { + #[test] + fn oneshot_multi_task_recv_then_close() { let (tx, rx) = sync_channel::>(0); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(tx); }); let res = Thread::spawn(move|| { assert!(rx.recv() == box 10); }).join(); assert!(res.is_err()); - } } + } - test! { fn oneshot_multi_thread_close_stress() { + #[test] + fn oneshot_multi_thread_close_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = sync_channel::(0); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(rx); }); drop(tx); } - } } + } - test! { fn oneshot_multi_thread_send_close_stress() { + #[test] + fn oneshot_multi_thread_send_close_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = sync_channel::(0); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(rx); }); let _ = Thread::spawn(move || { tx.send(1); }).join(); } - } } + } - test! { fn oneshot_multi_thread_recv_close_stress() { + #[test] + fn oneshot_multi_thread_recv_close_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = sync_channel::(0); - spawn(move|| { + let _t = Thread::spawn(move|| { let res = Thread::spawn(move|| { rx.recv(); }).join(); assert!(res.is_err()); }); - spawn(move|| { - spawn(move|| { + let _t = Thread::spawn(move|| { + Thread::spawn(move|| { drop(tx); - }); + }).detach(); }); } - } } + } - test! { fn oneshot_multi_thread_send_recv_stress() { + #[test] + fn oneshot_multi_thread_send_recv_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = sync_channel::>(0); - spawn(move|| { + let _t = Thread::spawn(move|| { tx.send(box 10i); }); - spawn(move|| { - assert!(rx.recv() == box 10i); - }); + assert!(rx.recv() == box 10i); } - } } + } - test! { fn stream_send_recv_stress() { + #[test] + fn stream_send_recv_stress() { for _ in range(0, stress_factor()) { let (tx, rx) = sync_channel::>(0); @@ -1839,50 +1915,53 @@ mod sync_tests { fn send(tx: SyncSender>, i: int) { if i == 10 { return } - spawn(move|| { + Thread::spawn(move|| { tx.send(box i); send(tx, i + 1); - }); + }).detach(); } fn recv(rx: Receiver>, i: int) { if i == 10 { return } - spawn(move|| { + Thread::spawn(move|| { assert!(rx.recv() == box i); recv(rx, i + 1); - }); + }).detach(); } } - } } + } - test! { fn recv_a_lot() { + #[test] + fn recv_a_lot() { // Regression test that we don't run out of stack in scheduler context let (tx, rx) = sync_channel(10000); for _ in range(0u, 10000) { tx.send(()); } for _ in range(0u, 10000) { rx.recv(); } - } } + } - test! { fn shared_chan_stress() { + #[test] + fn shared_chan_stress() { let (tx, rx) = sync_channel(0); let total = stress_factor() + 100; for _ in range(0, total) { let tx = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { tx.send(()); - }); + }).detach(); } for _ in range(0, total) { rx.recv(); } - } } + } - test! { fn test_nested_recv_iter() { + #[test] + fn test_nested_recv_iter() { let (tx, rx) = sync_channel::(0); let (total_tx, total_rx) = sync_channel::(0); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut acc = 0; for x in rx.iter() { acc += x; @@ -1895,13 +1974,14 @@ mod sync_tests { tx.send(2); drop(tx); assert_eq!(total_rx.recv(), 6); - } } + } - test! { fn test_recv_iter_break() { + #[test] + fn test_recv_iter_break() { let (tx, rx) = sync_channel::(0); let (count_tx, count_rx) = sync_channel(0); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut count = 0; for x in rx.iter() { if count >= 3 { @@ -1919,13 +1999,14 @@ mod sync_tests { let _ = tx.try_send(2); drop(tx); assert_eq!(count_rx.recv(), 4); - } } + } - test! { fn try_recv_states() { + #[test] + fn try_recv_states() { let (tx1, rx1) = sync_channel::(1); let (tx2, rx2) = sync_channel::<()>(1); let (tx3, rx3) = sync_channel::<()>(1); - spawn(move|| { + let _t = Thread::spawn(move|| { rx2.recv(); tx1.send(1); tx3.send(()); @@ -1942,14 +2023,15 @@ mod sync_tests { tx2.send(()); rx3.recv(); assert_eq!(rx1.try_recv(), Err(Disconnected)); - } } + } // This bug used to end up in a livelock inside of the Receiver destructor // because the internal state of the Shared packet was corrupted - test! { fn destroy_upgraded_shared_port_when_sender_still_active() { + #[test] + fn destroy_upgraded_shared_port_when_sender_still_active() { let (tx, rx) = sync_channel::<()>(0); let (tx2, rx2) = sync_channel::<()>(0); - spawn(move|| { + let _t = Thread::spawn(move|| { rx.recv(); // wait on a oneshot drop(rx); // destroy a shared tx2.send(()); @@ -1964,78 +2046,77 @@ mod sync_tests { // wait for the child task to exit before we exit rx2.recv(); - } } + } - test! { fn send_opt1() { + #[test] + fn send_opt1() { let (tx, rx) = sync_channel::(0); - spawn(move|| { rx.recv(); }); + let _t = Thread::spawn(move|| { rx.recv(); }); assert_eq!(tx.send_opt(1), Ok(())); - } } + } - test! { fn send_opt2() { + #[test] + fn send_opt2() { let (tx, rx) = sync_channel::(0); - spawn(move|| { drop(rx); }); + let _t = Thread::spawn(move|| { drop(rx); }); assert_eq!(tx.send_opt(1), Err(1)); - } } + } - test! { fn send_opt3() { + #[test] + fn send_opt3() { let (tx, rx) = sync_channel::(1); assert_eq!(tx.send_opt(1), Ok(())); - spawn(move|| { drop(rx); }); + let _t = Thread::spawn(move|| { drop(rx); }); assert_eq!(tx.send_opt(1), Err(1)); - } } + } - test! { fn send_opt4() { + #[test] + fn send_opt4() { let (tx, rx) = sync_channel::(0); let tx2 = tx.clone(); let (done, donerx) = channel(); let done2 = done.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { assert_eq!(tx.send_opt(1), Err(1)); done.send(()); }); - spawn(move|| { + let _t = Thread::spawn(move|| { assert_eq!(tx2.send_opt(2), Err(2)); done2.send(()); }); drop(rx); donerx.recv(); donerx.recv(); - } } + } - test! { fn try_send1() { + #[test] + fn try_send1() { let (tx, _rx) = sync_channel::(0); assert_eq!(tx.try_send(1), Err(Full(1))); - } } + } - test! { fn try_send2() { + #[test] + fn try_send2() { let (tx, _rx) = sync_channel::(1); assert_eq!(tx.try_send(1), Ok(())); assert_eq!(tx.try_send(1), Err(Full(1))); - } } + } - test! { fn try_send3() { + #[test] + fn try_send3() { let (tx, rx) = sync_channel::(1); assert_eq!(tx.try_send(1), Ok(())); drop(rx); assert_eq!(tx.try_send(1), Err(RecvDisconnected(1))); - } } - - test! { fn try_send4() { - let (tx, rx) = sync_channel::(0); - spawn(move|| { - for _ in range(0u, 1000) { Thread::yield_now(); } - assert_eq!(tx.try_send(1), Ok(())); - }); - assert_eq!(rx.recv(), 1); - } #[ignore(reason = "flaky on libnative")] } + } - test! { fn issue_15761() { + #[test] + fn issue_15761() { fn repro() { let (tx1, rx1) = sync_channel::<()>(3); let (tx2, rx2) = sync_channel::<()>(3); - spawn(move|| { + let _t = Thread::spawn(move|| { rx1.recv(); tx2.try_send(()).unwrap(); }); @@ -2047,5 +2128,5 @@ mod sync_tests { for _ in range(0u, 100) { repro() } - } } + } } diff --git a/src/libstd/comm/mpsc_queue.rs b/src/libstd/comm/mpsc_queue.rs index cddef23666434..d1b6d0d697cf2 100644 --- a/src/libstd/comm/mpsc_queue.rs +++ b/src/libstd/comm/mpsc_queue.rs @@ -153,11 +153,12 @@ impl Drop for Queue { #[cfg(test)] mod tests { - use prelude::*; - - use alloc::arc::Arc; + use prelude::v1::*; + use comm::channel; use super::{Queue, Data, Empty, Inconsistent}; + use sync::Arc; + use thread::Thread; #[test] fn test_full() { @@ -181,12 +182,12 @@ mod tests { for _ in range(0, nthreads) { let tx = tx.clone(); let q = q.clone(); - spawn(move|| { + Thread::spawn(move|| { for i in range(0, nmsgs) { q.push(i); } tx.send(()); - }); + }).detach(); } let mut i = 0u; diff --git a/src/libstd/comm/select.rs b/src/libstd/comm/select.rs index 690b5861c2239..a0a8e40b4150e 100644 --- a/src/libstd/comm/select.rs +++ b/src/libstd/comm/select.rs @@ -27,6 +27,8 @@ //! # Example //! //! ```rust +//! use std::comm::channel; +//! //! let (tx1, rx1) = channel(); //! let (tx2, rx2) = channel(); //! @@ -335,9 +337,10 @@ impl Iterator<*mut Handle<'static, ()>> for Packets { #[cfg(test)] #[allow(unused_imports)] mod test { - use prelude::*; + use prelude::v1::*; - use super::*; + use comm::*; + use thread::Thread; // Don't use the libstd version so we can pull in the right Select structure // (std::comm points at the wrong one) @@ -357,7 +360,8 @@ mod test { }) } - test! { fn smoke() { + #[test] + fn smoke() { let (tx1, rx1) = channel::(); let (tx2, rx2) = channel::(); tx1.send(1); @@ -379,9 +383,10 @@ mod test { select! { bar = rx2.recv_opt() => { assert_eq!(bar, Err(())); } } - } } + } - test! { fn smoke2() { + #[test] + fn smoke2() { let (_tx1, rx1) = channel::(); let (_tx2, rx2) = channel::(); let (_tx3, rx3) = channel::(); @@ -395,9 +400,10 @@ mod test { _foo = rx4.recv() => { panic!("4") }, foo = rx5.recv() => { assert_eq!(foo, 4); } } - } } + } - test! { fn closed() { + #[test] + fn closed() { let (_tx1, rx1) = channel::(); let (tx2, rx2) = channel::(); drop(tx2); @@ -406,14 +412,15 @@ mod test { _a1 = rx1.recv_opt() => { panic!() }, a2 = rx2.recv_opt() => { assert_eq!(a2, Err(())); } } - } } + } - test! { fn unblocks() { + #[test] + fn unblocks() { let (tx1, rx1) = channel::(); let (_tx2, rx2) = channel::(); let (tx3, rx3) = channel::(); - spawn(move|| { + let _t = Thread::spawn(move|| { for _ in range(0u, 20) { Thread::yield_now(); } tx1.send(1); rx3.recv(); @@ -429,14 +436,15 @@ mod test { a = rx1.recv_opt() => { assert_eq!(a, Err(())); }, _b = rx2.recv() => { panic!() } } - } } + } - test! { fn both_ready() { + #[test] + fn both_ready() { let (tx1, rx1) = channel::(); let (tx2, rx2) = channel::(); let (tx3, rx3) = channel::<()>(); - spawn(move|| { + let _t = Thread::spawn(move|| { for _ in range(0u, 20) { Thread::yield_now(); } tx1.send(1); tx2.send(2); @@ -454,15 +462,16 @@ mod test { assert_eq!(rx1.try_recv(), Err(Empty)); assert_eq!(rx2.try_recv(), Err(Empty)); tx3.send(()); - } } + } - test! { fn stress() { + #[test] + fn stress() { static AMT: int = 10000; let (tx1, rx1) = channel::(); let (tx2, rx2) = channel::(); let (tx3, rx3) = channel::<()>(); - spawn(move|| { + let _t = Thread::spawn(move|| { for i in range(0, AMT) { if i % 2 == 0 { tx1.send(i); @@ -480,14 +489,15 @@ mod test { } tx3.send(()); } - } } + } - test! { fn cloning() { + #[test] + fn cloning() { let (tx1, rx1) = channel::(); let (_tx2, rx2) = channel::(); let (tx3, rx3) = channel::<()>(); - spawn(move|| { + let _t = Thread::spawn(move|| { rx3.recv(); tx1.clone(); assert_eq!(rx3.try_recv(), Err(Empty)); @@ -501,14 +511,15 @@ mod test { _i2 = rx2.recv() => panic!() } tx3.send(()); - } } + } - test! { fn cloning2() { + #[test] + fn cloning2() { let (tx1, rx1) = channel::(); let (_tx2, rx2) = channel::(); let (tx3, rx3) = channel::<()>(); - spawn(move|| { + let _t = Thread::spawn(move|| { rx3.recv(); tx1.clone(); assert_eq!(rx3.try_recv(), Err(Empty)); @@ -522,13 +533,14 @@ mod test { _i2 = rx2.recv() => panic!() } tx3.send(()); - } } + } - test! { fn cloning3() { + #[test] + fn cloning3() { let (tx1, rx1) = channel::<()>(); let (tx2, rx2) = channel::<()>(); let (tx3, rx3) = channel::<()>(); - spawn(move|| { + let _t = Thread::spawn(move|| { let s = Select::new(); let mut h1 = s.handle(&rx1); let mut h2 = s.handle(&rx2); @@ -542,44 +554,49 @@ mod test { drop(tx1.clone()); tx2.send(()); rx3.recv(); - } } + } - test! { fn preflight1() { + #[test] + fn preflight1() { let (tx, rx) = channel(); tx.send(()); select! { () = rx.recv() => {} } - } } + } - test! { fn preflight2() { + #[test] + fn preflight2() { let (tx, rx) = channel(); tx.send(()); tx.send(()); select! { () = rx.recv() => {} } - } } + } - test! { fn preflight3() { + #[test] + fn preflight3() { let (tx, rx) = channel(); drop(tx.clone()); tx.send(()); select! { () = rx.recv() => {} } - } } + } - test! { fn preflight4() { + #[test] + fn preflight4() { let (tx, rx) = channel(); tx.send(()); let s = Select::new(); let mut h = s.handle(&rx); unsafe { h.add(); } assert_eq!(s.wait2(false), h.id); - } } + } - test! { fn preflight5() { + #[test] + fn preflight5() { let (tx, rx) = channel(); tx.send(()); tx.send(()); @@ -587,9 +604,10 @@ mod test { let mut h = s.handle(&rx); unsafe { h.add(); } assert_eq!(s.wait2(false), h.id); - } } + } - test! { fn preflight6() { + #[test] + fn preflight6() { let (tx, rx) = channel(); drop(tx.clone()); tx.send(()); @@ -597,18 +615,20 @@ mod test { let mut h = s.handle(&rx); unsafe { h.add(); } assert_eq!(s.wait2(false), h.id); - } } + } - test! { fn preflight7() { + #[test] + fn preflight7() { let (tx, rx) = channel::<()>(); drop(tx); let s = Select::new(); let mut h = s.handle(&rx); unsafe { h.add(); } assert_eq!(s.wait2(false), h.id); - } } + } - test! { fn preflight8() { + #[test] + fn preflight8() { let (tx, rx) = channel(); tx.send(()); drop(tx); @@ -617,9 +637,10 @@ mod test { let mut h = s.handle(&rx); unsafe { h.add(); } assert_eq!(s.wait2(false), h.id); - } } + } - test! { fn preflight9() { + #[test] + fn preflight9() { let (tx, rx) = channel(); drop(tx.clone()); tx.send(()); @@ -629,12 +650,13 @@ mod test { let mut h = s.handle(&rx); unsafe { h.add(); } assert_eq!(s.wait2(false), h.id); - } } + } - test! { fn oneshot_data_waiting() { + #[test] + fn oneshot_data_waiting() { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { select! { () = rx1.recv() => {} } @@ -644,16 +666,17 @@ mod test { for _ in range(0u, 100) { Thread::yield_now() } tx1.send(()); rx2.recv(); - } } + } - test! { fn stream_data_waiting() { + #[test] + fn stream_data_waiting() { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); tx1.send(()); tx1.send(()); rx1.recv(); rx1.recv(); - spawn(move|| { + let _t = Thread::spawn(move|| { select! { () = rx1.recv() => {} } @@ -663,15 +686,16 @@ mod test { for _ in range(0u, 100) { Thread::yield_now() } tx1.send(()); rx2.recv(); - } } + } - test! { fn shared_data_waiting() { + #[test] + fn shared_data_waiting() { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); drop(tx1.clone()); tx1.send(()); rx1.recv(); - spawn(move|| { + let _t = Thread::spawn(move|| { select! { () = rx1.recv() => {} } @@ -681,32 +705,35 @@ mod test { for _ in range(0u, 100) { Thread::yield_now() } tx1.send(()); rx2.recv(); - } } + } - test! { fn sync1() { + #[test] + fn sync1() { let (tx, rx) = sync_channel::(1); tx.send(1); select! { n = rx.recv() => { assert_eq!(n, 1); } } - } } + } - test! { fn sync2() { + #[test] + fn sync2() { let (tx, rx) = sync_channel::(0); - spawn(move|| { + let _t = Thread::spawn(move|| { for _ in range(0u, 100) { Thread::yield_now() } tx.send(1); }); select! { n = rx.recv() => { assert_eq!(n, 1); } } - } } + } - test! { fn sync3() { + #[test] + fn sync3() { let (tx1, rx1) = sync_channel::(0); let (tx2, rx2): (Sender, Receiver) = channel(); - spawn(move|| { tx1.send(1); }); - spawn(move|| { tx2.send(2); }); + let _t = Thread::spawn(move|| { tx1.send(1); }); + let _t = Thread::spawn(move|| { tx2.send(2); }); select! { n = rx1.recv() => { assert_eq!(n, 1); @@ -717,5 +744,5 @@ mod test { assert_eq!(rx1.recv(), 1); } } - } } + } } diff --git a/src/libstd/comm/spsc_queue.rs b/src/libstd/comm/spsc_queue.rs index becb78063aeb5..1e2f5222d8b1a 100644 --- a/src/libstd/comm/spsc_queue.rs +++ b/src/libstd/comm/spsc_queue.rs @@ -240,10 +240,12 @@ impl Drop for Queue { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use sync::Arc; use super::Queue; + use thread::Thread; + use comm::channel; #[test] fn smoke() { @@ -320,7 +322,7 @@ mod test { let (tx, rx) = channel(); let q2 = q.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { for _ in range(0u, 100000) { loop { match q2.pop() { diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index 368abe7cb1244..ecfe2d15ae1c2 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -15,7 +15,9 @@ #![experimental] #![allow(missing_docs)] -use prelude::*; +use prelude::v1::*; + +use c_str::ToCStr; use mem; use os; use str; @@ -146,7 +148,7 @@ impl DynamicLibrary { #[cfg(all(test, not(target_os = "ios")))] mod test { use super::*; - use prelude::*; + use prelude::v1::*; use libc; use mem; @@ -202,8 +204,8 @@ mod test { pub mod dl { use self::Rtld::*; - use prelude::*; - use c_str::CString; + use prelude::v1::*; + use c_str::{CString, ToCStr}; use libc; use ptr; diff --git a/src/libstd/error.rs b/src/libstd/error.rs index 9a46a500a4b47..32e1922ae74fd 100644 --- a/src/libstd/error.rs +++ b/src/libstd/error.rs @@ -78,7 +78,7 @@ //! } //! ``` -use prelude::*; +use prelude::v1::*; use str::Utf8Error; use string::{FromUtf8Error, FromUtf16Error}; diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs index 7010eae6dba0d..3d98b6ec40e49 100644 --- a/src/libstd/failure.rs +++ b/src/libstd/failure.rs @@ -10,7 +10,7 @@ #![experimental] -use prelude::*; +use prelude::v1::*; use any::{Any, AnyRefExt}; use cell::RefCell; diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index c5405601048ce..57dc62084e33e 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -410,7 +410,7 @@ impl Writer for BufferedStream { mod test { extern crate test; use io; - use prelude::*; + use prelude::v1::*; use super::*; use super::super::{IoResult, EndOfFile}; use super::super::mem::MemReader; diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs index 077f75e2edd6f..ebadecfebb522 100644 --- a/src/libstd/io/comm_adapters.rs +++ b/src/libstd/io/comm_adapters.rs @@ -23,6 +23,7 @@ use vec::Vec; /// # Example /// /// ``` +/// use std::comm::channel; /// use std::io::ChanReader; /// /// let (tx, rx) = channel(); @@ -114,6 +115,7 @@ impl Reader for ChanReader { /// /// ``` /// # #![allow(unused_must_use)] +/// use std::comm::channel; /// use std::io::ChanWriter; /// /// let (tx, rx) = channel(); @@ -154,7 +156,9 @@ impl Writer for ChanWriter { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; + + use comm::channel; use super::*; use io; use thread::Thread; diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index 51e09e547e3ee..94dba1f7cc70a 100644 --- a/src/libstd/io/extensions.rs +++ b/src/libstd/io/extensions.rs @@ -175,7 +175,7 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use io; use io::{MemReader, BytesReader}; @@ -507,7 +507,7 @@ mod test { mod bench { extern crate test; - use prelude::*; + use prelude::v1::*; use self::test::Bencher; // why is this a macro? wouldn't an inlined function work just as well? diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index 7fa6ebc6e3bac..7fa5b3cfac7e2 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -819,7 +819,7 @@ fn access_string(access: FileAccess) -> &'static str { #[allow(unused_variables)] #[allow(unused_mut)] mod test { - use prelude::*; + use prelude::v1::*; use io::{SeekSet, SeekCur, SeekEnd, Read, Open, ReadWrite, FileType}; use io; use str; diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index f8ea373f8f456..ad921e43c0cc5 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -399,9 +399,10 @@ impl<'a> Buffer for BufReader<'a> { #[cfg(test)] mod test { extern crate "test" as test_crate; + use prelude::v1::*; + use super::*; - use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek}; - use prelude::{Ok, Err, range, Vec, Buffer, AsSlice, SliceExt, IteratorExt, CloneSliceExt}; + use io::{SeekSet, SeekCur, SeekEnd}; use io; use self::test_crate::Bencher; diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index e8b852ee492b9..9eb860d7ec3a3 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -233,7 +233,7 @@ use fmt; use int; use iter::{Iterator, IteratorExt}; use mem::transmute; -use ops::{BitOr, BitXor, BitAnd, Sub, Not, FnOnce}; +use ops::FnOnce; use option::Option; use option::Option::{Some, None}; use os; @@ -1918,8 +1918,8 @@ impl fmt::Show for FilePermission { #[cfg(test)] mod tests { use self::BadReaderBehavior::*; - use super::{IoResult, Reader, MemReader, NoProgress, InvalidInput, Writer}; - use prelude::{Ok, Vec, Buffer, CloneSliceExt}; + use super::{IoResult, MemReader, NoProgress, InvalidInput}; + use prelude::v1::*; use uint; #[deriving(Clone, PartialEq, Show)] diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs index e8fbb12118199..d86cb841f96ce 100644 --- a/src/libstd/io/net/addrinfo.rs +++ b/src/libstd/io/net/addrinfo.rs @@ -112,7 +112,7 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option) // permission without help of apk #[cfg(all(test, not(target_os = "android")))] mod test { - use prelude::*; + use prelude::v1::*; use super::*; use io::net::ip::*; diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index 49ab9ddb92487..7ce1d1fc13bcb 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -544,7 +544,7 @@ impl<'a> ToSocketAddr for &'a str { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use super::*; use str::FromStr; diff --git a/src/libstd/io/net/pipe.rs b/src/libstd/io/net/pipe.rs index 6ce66c3273bd6..95147c52a6910 100644 --- a/src/libstd/io/net/pipe.rs +++ b/src/libstd/io/net/pipe.rs @@ -20,14 +20,14 @@ #![allow(missing_docs)] -use prelude::*; +use prelude::v1::*; +use c_str::ToCStr; use io::{Listener, Acceptor, IoResult, TimedOut, standard_error}; -use time::Duration; - -use sys::pipe::UnixStream as UnixStreamImp; -use sys::pipe::UnixListener as UnixListenerImp; use sys::pipe::UnixAcceptor as UnixAcceptorImp; +use sys::pipe::UnixListener as UnixListenerImp; +use sys::pipe::UnixStream as UnixStreamImp; +use time::Duration; use sys_common; @@ -264,13 +264,17 @@ impl sys_common::AsInner for UnixAcceptor { } #[cfg(test)] -#[allow(experimental)] mod tests { - use super::*; - use io::*; - use io::test::*; - use prelude::{Ok, Err, spawn, range, drop, Some, None, channel, Send, FnOnce, Clone}; + use prelude::v1::*; + + use comm::channel; use io::fs::PathExtensions; + use io::{EndOfFile, TimedOut, ShortWrite, IoError, ConnectionReset}; + use io::{NotConnected, BrokenPipe, OtherIoError, FileNotFound, InvalidInput}; + use io::{PermissionDenied, Acceptor, Listener}; + use io::test::*; + use super::*; + use thread::Thread; use time::Duration; pub fn smalltest(server: F, client: G) @@ -282,7 +286,7 @@ mod tests { let mut acceptor = UnixListener::bind(&path1).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { match UnixStream::connect(&path2) { Ok(c) => client(c), Err(e) => panic!("failed connect: {}", e), @@ -377,7 +381,7 @@ mod tests { Err(e) => panic!("failed listen: {}", e), }; - spawn(move|| { + let _t = Thread::spawn(move|| { for _ in range(0u, times) { let mut stream = UnixStream::connect(&path2); match stream.write(&[100]) { @@ -411,7 +415,7 @@ mod tests { let addr = next_test_unix(); let mut acceptor = UnixListener::bind(&addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s = UnixStream::connect(&addr); let mut buf = [0, 0]; debug!("client reading"); @@ -427,7 +431,7 @@ mod tests { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; rx1.recv(); debug!("writer writing"); @@ -450,7 +454,7 @@ mod tests { let (tx1, rx) = channel(); let tx2 = tx1.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s = UnixStream::connect(&addr); s.write(&[1]).unwrap(); rx.recv(); @@ -462,7 +466,7 @@ mod tests { let s2 = s1.clone(); let (done, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; let mut buf = [0, 0]; s2.read(&mut buf).unwrap(); @@ -481,7 +485,7 @@ mod tests { let addr = next_test_unix(); let mut acceptor = UnixListener::bind(&addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s = UnixStream::connect(&addr); let buf = &mut [0, 1]; s.read(buf).unwrap(); @@ -492,7 +496,7 @@ mod tests { let s2 = s1.clone(); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; s2.write(&[1]).unwrap(); tx.send(()); @@ -539,7 +543,7 @@ mod tests { // continue to receive any pending connections. let (tx, rx) = channel(); let addr2 = addr.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { tx.send(UnixStream::connect(&addr2).unwrap()); }); let l = rx.recv(); @@ -557,7 +561,7 @@ mod tests { // Unset the timeout and make sure that this always blocks. a.set_timeout(None); let addr2 = addr.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(UnixStream::connect(&addr2).unwrap()); }); a.accept().unwrap(); @@ -595,11 +599,11 @@ mod tests { let addr = next_test_unix(); let a = UnixListener::bind(&addr).listen().unwrap(); let (_tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut a = a; let _s = a.accept().unwrap(); let _ = rx.recv_opt(); - }); + }).detach(); let mut b = [0]; let mut s = UnixStream::connect(&addr).unwrap(); @@ -632,16 +636,16 @@ mod tests { let addr = next_test_unix(); let a = UnixListener::bind(&addr).listen().unwrap(); let (_tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut a = a; let _s = a.accept().unwrap(); let _ = rx.recv_opt(); - }); + }).detach(); let mut s = UnixStream::connect(&addr).unwrap(); let s2 = s.clone(); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; assert!(s2.read(&mut [0]).is_err()); tx.send(()); @@ -658,12 +662,12 @@ mod tests { let addr = next_test_unix(); let mut a = UnixListener::bind(&addr).listen().unwrap(); let (tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut s = UnixStream::connect(&addr).unwrap(); rx.recv(); assert!(s.write(&[0]).is_ok()); let _ = rx.recv_opt(); - }); + }).detach(); let mut s = a.accept().unwrap(); s.set_timeout(Some(20)); @@ -696,7 +700,7 @@ mod tests { let addr = next_test_unix(); let mut a = UnixListener::bind(&addr).listen().unwrap(); let (tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut s = UnixStream::connect(&addr).unwrap(); rx.recv(); let mut amt = 0; @@ -707,7 +711,7 @@ mod tests { } } let _ = rx.recv_opt(); - }); + }).detach(); let mut s = a.accept().unwrap(); s.set_read_timeout(Some(20)); @@ -725,12 +729,12 @@ mod tests { let addr = next_test_unix(); let mut a = UnixListener::bind(&addr).listen().unwrap(); let (tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut s = UnixStream::connect(&addr).unwrap(); rx.recv(); assert!(s.write(&[0]).is_ok()); let _ = rx.recv_opt(); - }); + }).detach(); let mut s = a.accept().unwrap(); s.set_write_timeout(Some(20)); @@ -752,17 +756,17 @@ mod tests { let addr = next_test_unix(); let mut a = UnixListener::bind(&addr).listen().unwrap(); let (tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut s = UnixStream::connect(&addr).unwrap(); rx.recv(); assert!(s.write(&[0]).is_ok()); let _ = rx.recv_opt(); - }); + }).detach(); let mut s = a.accept().unwrap(); let s2 = s.clone(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; assert!(s2.read(&mut [0]).is_ok()); tx2.send(()); @@ -784,10 +788,10 @@ mod tests { let mut a2 = a.clone(); let addr2 = addr.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _ = UnixStream::connect(&addr2); }); - spawn(move|| { + let _t = Thread::spawn(move|| { let _ = UnixStream::connect(&addr); }); @@ -807,14 +811,14 @@ mod tests { let (tx, rx) = channel(); let tx2 = tx.clone(); - spawn(move|| { let mut a = a; tx.send(a.accept()) }); - spawn(move|| { let mut a = a2; tx2.send(a.accept()) }); + let _t = Thread::spawn(move|| { let mut a = a; tx.send(a.accept()) }); + let _t = Thread::spawn(move|| { let mut a = a2; tx2.send(a.accept()) }); let addr2 = addr.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _ = UnixStream::connect(&addr2); }); - spawn(move|| { + let _t = Thread::spawn(move|| { let _ = UnixStream::connect(&addr); }); @@ -840,7 +844,7 @@ mod tests { let mut a2 = a.clone(); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut a = a; tx.send(a.accept()); }); diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs index 826f492d85d31..4492e679cd5f1 100644 --- a/src/libstd/io/net/tcp.rs +++ b/src/libstd/io/net/tcp.rs @@ -141,7 +141,7 @@ impl TcpStream { /// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap(); /// let stream2 = stream.clone(); /// - /// Thread::spawn(move|| { + /// let _t = Thread::spawn(move|| { /// // close this stream after one second /// timer::sleep(Duration::seconds(1)); /// let mut stream = stream2; @@ -282,10 +282,10 @@ impl sys_common::AsInner for TcpStream { /// use std::io::{Acceptor, Listener}; /// use std::thread::Thread; /// -/// let listener = TcpListener::bind("127.0.0.1:80"); +/// let listener = TcpListener::bind("127.0.0.1:80").unwrap(); /// /// // bind the listener to the specified address -/// let mut acceptor = listener.listen(); +/// let mut acceptor = listener.listen().unwrap(); /// /// fn handle_client(mut stream: TcpStream) { /// // ... @@ -423,7 +423,7 @@ impl TcpAcceptor { /// let mut a = TcpListener::bind("127.0.0.1:8482").listen().unwrap(); /// let a2 = a.clone(); /// - /// Thread::spawn(move|| { + /// let _t = Thread::spawn(move|| { /// let mut a2 = a2; /// for socket in a2.incoming() { /// match socket { @@ -482,14 +482,16 @@ impl sys_common::AsInner for TcpAcceptor { #[cfg(test)] #[allow(experimental)] mod test { + use prelude::v1::*; + + use comm::channel; + use thread::Thread; use io::net::tcp::*; use io::net::ip::*; use io::{EndOfFile, TimedOut, IoError, ShortWrite, OtherIoError, ConnectionAborted}; use io::{ConnectionRefused, ConnectionReset, BrokenPipe, NotConnected}; use io::{PermissionDenied, Listener, Acceptor}; use io::test::*; - use prelude::{Ok, Err, spawn, range, drop, Some, None, channel, Clone}; - use prelude::{Reader, Writer, IteratorExt}; // FIXME #11530 this fails on android because tests are run as root #[cfg_attr(any(windows, target_os = "android"), ignore)] @@ -515,7 +517,7 @@ mod test { let listener = TcpListener::bind(socket_addr); let mut acceptor = listener.listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = TcpStream::connect(("localhost", socket_addr.port)); stream.write(&[144]).unwrap(); }); @@ -531,7 +533,7 @@ mod test { let addr = next_test_ip4(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = TcpStream::connect(("localhost", addr.port)); stream.write(&[64]).unwrap(); }); @@ -547,7 +549,7 @@ mod test { let addr = next_test_ip4(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = TcpStream::connect(("127.0.0.1", addr.port)); stream.write(&[44]).unwrap(); }); @@ -563,7 +565,7 @@ mod test { let addr = next_test_ip6(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = TcpStream::connect(("::1", addr.port)); stream.write(&[66]).unwrap(); }); @@ -579,7 +581,7 @@ mod test { let addr = next_test_ip4(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = TcpStream::connect(addr); stream.write(&[99]).unwrap(); }); @@ -595,7 +597,7 @@ mod test { let addr = next_test_ip6(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = TcpStream::connect(addr); stream.write(&[99]).unwrap(); }); @@ -611,7 +613,7 @@ mod test { let addr = next_test_ip4(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _stream = TcpStream::connect(addr); // Close }); @@ -627,7 +629,7 @@ mod test { let addr = next_test_ip6(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _stream = TcpStream::connect(addr); // Close }); @@ -643,7 +645,7 @@ mod test { let addr = next_test_ip4(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _stream = TcpStream::connect(addr); // Close }); @@ -667,7 +669,7 @@ mod test { let addr = next_test_ip6(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _stream = TcpStream::connect(addr); // Close }); @@ -692,7 +694,7 @@ mod test { let mut acceptor = TcpListener::bind(addr).listen(); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(TcpStream::connect(addr)); tx.send(()); }); @@ -717,7 +719,7 @@ mod test { let mut acceptor = TcpListener::bind(addr).listen(); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(TcpStream::connect(addr)); tx.send(()); }); @@ -742,7 +744,7 @@ mod test { let max = 10u; let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { for _ in range(0, max) { let mut stream = TcpStream::connect(addr); stream.write(&[99]).unwrap(); @@ -762,7 +764,7 @@ mod test { let max = 10u; let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { for _ in range(0, max) { let mut stream = TcpStream::connect(addr); stream.write(&[99]).unwrap(); @@ -782,11 +784,11 @@ mod test { static MAX: int = 10; let acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut acceptor = acceptor; for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) { // Start another task to handle the connection - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = stream; let mut buf = [0]; stream.read(&mut buf).unwrap(); @@ -801,7 +803,7 @@ mod test { fn connect(i: int, addr: SocketAddr) { if i == MAX { return } - spawn(move|| { + let _t = Thread::spawn(move|| { debug!("connecting"); let mut stream = TcpStream::connect(addr); // Connect again before writing @@ -818,11 +820,11 @@ mod test { static MAX: int = 10; let acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut acceptor = acceptor; for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) { // Start another task to handle the connection - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = stream; let mut buf = [0]; stream.read(&mut buf).unwrap(); @@ -837,7 +839,7 @@ mod test { fn connect(i: int, addr: SocketAddr) { if i == MAX { return } - spawn(move|| { + let _t = Thread::spawn(move|| { debug!("connecting"); let mut stream = TcpStream::connect(addr); // Connect again before writing @@ -854,11 +856,11 @@ mod test { let addr = next_test_ip4(); let acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut acceptor = acceptor; for stream in acceptor.incoming().take(MAX as uint) { // Start another task to handle the connection - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = stream; let mut buf = [0]; stream.read(&mut buf).unwrap(); @@ -873,7 +875,7 @@ mod test { fn connect(i: int, addr: SocketAddr) { if i == MAX { return } - spawn(move|| { + let _t = Thread::spawn(move|| { debug!("connecting"); let mut stream = TcpStream::connect(addr); // Connect again before writing @@ -890,11 +892,11 @@ mod test { let addr = next_test_ip6(); let acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut acceptor = acceptor; for stream in acceptor.incoming().take(MAX as uint) { // Start another task to handle the connection - spawn(move|| { + let _t = Thread::spawn(move|| { let mut stream = stream; let mut buf = [0]; stream.read(&mut buf).unwrap(); @@ -909,7 +911,7 @@ mod test { fn connect(i: int, addr: SocketAddr) { if i == MAX { return } - spawn(move|| { + let _t = Thread::spawn(move|| { debug!("connecting"); let mut stream = TcpStream::connect(addr); // Connect again before writing @@ -932,7 +934,7 @@ mod test { pub fn peer_name(addr: SocketAddr) { let acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut acceptor = acceptor; acceptor.accept().unwrap(); }); @@ -967,7 +969,7 @@ mod test { fn partial_read() { let addr = next_test_ip4(); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut srv = TcpListener::bind(addr).listen().unwrap(); tx.send(()); let mut cl = srv.accept().unwrap(); @@ -1004,7 +1006,7 @@ mod test { let addr = next_test_ip4(); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { rx.recv(); let _stream = TcpStream::connect(addr).unwrap(); // Close @@ -1029,7 +1031,7 @@ mod test { let addr = next_test_ip4(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s = TcpStream::connect(addr); let mut buf = [0, 0]; assert_eq!(s.read(&mut buf), Ok(1)); @@ -1042,7 +1044,7 @@ mod test { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; rx1.recv(); s2.write(&[1]).unwrap(); @@ -1061,7 +1063,7 @@ mod test { let (tx1, rx) = channel(); let tx2 = tx1.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s = TcpStream::connect(addr); s.write(&[1]).unwrap(); rx.recv(); @@ -1073,7 +1075,7 @@ mod test { let s2 = s1.clone(); let (done, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; let mut buf = [0, 0]; s2.read(&mut buf).unwrap(); @@ -1092,7 +1094,7 @@ mod test { let addr = next_test_ip4(); let mut acceptor = TcpListener::bind(addr).listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s = TcpStream::connect(addr); let mut buf = [0, 1]; s.read(&mut buf).unwrap(); @@ -1103,7 +1105,7 @@ mod test { let s2 = s1.clone(); let (done, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; s2.write(&[1]).unwrap(); done.send(()); @@ -1117,7 +1119,7 @@ mod test { fn shutdown_smoke() { let addr = next_test_ip4(); let a = TcpListener::bind(addr).unwrap().listen(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut a = a; let mut c = a.accept().unwrap(); assert_eq!(c.read_to_end(), Ok(vec!())); @@ -1151,7 +1153,7 @@ mod test { // flakiness. if !cfg!(target_os = "freebsd") { let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { tx.send(TcpStream::connect(addr).unwrap()); }); let _l = rx.recv(); @@ -1168,7 +1170,7 @@ mod test { // Unset the timeout and make sure that this always blocks. a.set_timeout(None); - spawn(move|| { + let _t = Thread::spawn(move|| { drop(TcpStream::connect(addr).unwrap()); }); a.accept().unwrap(); @@ -1179,11 +1181,11 @@ mod test { let addr = next_test_ip4(); let a = TcpListener::bind(addr).listen().unwrap(); let (_tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut a = a; let _s = a.accept().unwrap(); let _ = rx.recv_opt(); - }); + }).detach(); let mut b = [0]; let mut s = TcpStream::connect(addr).unwrap(); @@ -1216,16 +1218,16 @@ mod test { let addr = next_test_ip4(); let a = TcpListener::bind(addr).listen().unwrap(); let (_tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut a = a; let _s = a.accept().unwrap(); let _ = rx.recv_opt(); - }); + }).detach(); let mut s = TcpStream::connect(addr).unwrap(); let s2 = s.clone(); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; assert!(s2.read(&mut [0]).is_err()); tx.send(()); @@ -1242,12 +1244,12 @@ mod test { let addr = next_test_ip6(); let mut a = TcpListener::bind(addr).listen().unwrap(); let (tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut s = TcpStream::connect(addr).unwrap(); rx.recv(); assert!(s.write(&[0]).is_ok()); let _ = rx.recv_opt(); - }); + }).detach(); let mut s = a.accept().unwrap(); s.set_timeout(Some(20)); @@ -1275,7 +1277,7 @@ mod test { let addr = next_test_ip6(); let mut a = TcpListener::bind(addr).listen().unwrap(); let (tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut s = TcpStream::connect(addr).unwrap(); rx.recv(); let mut amt = 0; @@ -1286,7 +1288,7 @@ mod test { } } let _ = rx.recv_opt(); - }); + }).detach(); let mut s = a.accept().unwrap(); s.set_read_timeout(Some(20)); @@ -1304,12 +1306,12 @@ mod test { let addr = next_test_ip6(); let mut a = TcpListener::bind(addr).listen().unwrap(); let (tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut s = TcpStream::connect(addr).unwrap(); rx.recv(); assert!(s.write(&[0]).is_ok()); let _ = rx.recv_opt(); - }); + }).detach(); let mut s = a.accept().unwrap(); s.set_write_timeout(Some(20)); @@ -1332,17 +1334,17 @@ mod test { let addr = next_test_ip6(); let mut a = TcpListener::bind(addr).listen().unwrap(); let (tx, rx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let mut s = TcpStream::connect(addr).unwrap(); rx.recv(); assert_eq!(s.write(&[0]), Ok(())); let _ = rx.recv_opt(); - }); + }).detach(); let mut s = a.accept().unwrap(); let s2 = s.clone(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut s2 = s2; assert_eq!(s2.read(&mut [0]), Ok(1)); tx2.send(()); @@ -1365,7 +1367,7 @@ mod test { let (tx, rx) = channel(); let (txdone, rxdone) = channel(); let txdone2 = txdone.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut tcp = TcpStream::connect(addr).unwrap(); rx.recv(); tcp.write_u8(0).unwrap(); @@ -1376,7 +1378,7 @@ mod test { let tcp = accept.accept().unwrap(); let tcp2 = tcp.clone(); let txdone3 = txdone.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut tcp2 = tcp2; tcp2.read_u8().unwrap(); txdone3.send(()); @@ -1402,10 +1404,10 @@ mod test { let mut a = l.listen().unwrap(); let mut a2 = a.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _ = TcpStream::connect(addr); }); - spawn(move|| { + let _t = Thread::spawn(move|| { let _ = TcpStream::connect(addr); }); @@ -1423,13 +1425,13 @@ mod test { let (tx, rx) = channel(); let tx2 = tx.clone(); - spawn(move|| { let mut a = a; tx.send(a.accept()) }); - spawn(move|| { let mut a = a2; tx2.send(a.accept()) }); + let _t = Thread::spawn(move|| { let mut a = a; tx.send(a.accept()) }); + let _t = Thread::spawn(move|| { let mut a = a2; tx2.send(a.accept()) }); - spawn(move|| { + let _t = Thread::spawn(move|| { let _ = TcpStream::connect(addr); }); - spawn(move|| { + let _t = Thread::spawn(move|| { let _ = TcpStream::connect(addr); }); @@ -1455,7 +1457,7 @@ mod test { let mut a2 = a.clone(); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut a = a; tx.send(a.accept()); }); diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs index 11c2f956c3552..2e366c7e27ba7 100644 --- a/src/libstd/io/net/udp.rs +++ b/src/libstd/io/net/udp.rs @@ -248,11 +248,14 @@ impl Writer for UdpStream { #[cfg(test)] #[allow(experimental)] mod test { - use super::*; + use prelude::v1::*; + + use comm::channel; use io::net::ip::*; - use io::{ShortWrite, IoError, TimedOut, PermissionDenied}; + use io::{IoError, ShortWrite, TimedOut, PermissionDenied}; use io::test::*; - use prelude::{Ok, Err, spawn, range, drop, Some, None, channel, Clone, Reader, Writer}; + use super::*; + use thread::Thread; // FIXME #11530 this fails on android because tests are run as root #[cfg_attr(any(windows, target_os = "android"), ignore)] @@ -272,7 +275,7 @@ mod test { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { match UdpSocket::bind(client_ip) { Ok(ref mut client) => { rx1.recv(); @@ -307,7 +310,7 @@ mod test { let client_ip = next_test_ip6(); let (tx, rx) = channel::<()>(); - spawn(move|| { + let _t = Thread::spawn(move|| { match UdpSocket::bind(client_ip) { Ok(ref mut client) => { rx.recv(); @@ -343,8 +346,8 @@ mod test { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { - let send_as = |&: ip, val: &[u8]| { + let _t = Thread::spawn(move|| { + let send_as = |&:ip, val: &[u8]| { match UdpSocket::bind(ip) { Ok(client) => { let client = box client; @@ -387,7 +390,7 @@ mod test { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { match UdpSocket::bind(client_ip) { Ok(client) => { let client = box client; @@ -449,7 +452,7 @@ mod test { let mut sock1 = UdpSocket::bind(addr1).unwrap(); let sock2 = UdpSocket::bind(addr2).unwrap(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut sock2 = sock2; let mut buf = [0, 0]; assert_eq!(sock2.recv_from(&mut buf), Ok((1, addr1))); @@ -461,7 +464,7 @@ mod test { let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut sock3 = sock3; rx1.recv(); sock3.send_to(&[1], addr2).unwrap(); @@ -482,7 +485,7 @@ mod test { let (tx1, rx) = channel(); let tx2 = tx1.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut sock2 = sock2; sock2.send_to(&[1], addr1).unwrap(); rx.recv(); @@ -493,7 +496,7 @@ mod test { let sock3 = sock1.clone(); let (done, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut sock3 = sock3; let mut buf = [0, 0]; sock3.recv_from(&mut buf).unwrap(); @@ -517,7 +520,7 @@ mod test { let (tx, rx) = channel(); let (serv_tx, serv_rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut sock2 = sock2; let mut buf = [0, 1]; @@ -533,7 +536,7 @@ mod test { let (done, rx) = channel(); let tx2 = tx.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut sock3 = sock3; match sock3.send_to(&[1], addr2) { Ok(..) => { let _ = tx2.send_opt(()); } @@ -561,7 +564,7 @@ mod test { let (tx, rx) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut a = a2; assert_eq!(a.recv_from(&mut [0]), Ok((1, addr1))); assert_eq!(a.send_to(&[0], addr1), Ok(())); diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs index 93465d5510b87..ee86eae058da0 100644 --- a/src/libstd/io/pipe.rs +++ b/src/libstd/io/pipe.rs @@ -15,7 +15,7 @@ #![allow(missing_docs)] -use prelude::*; +use prelude::v1::*; use io::IoResult; use libc; @@ -112,7 +112,10 @@ impl Writer for PipeStream { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; + + use comm::channel; + use thread::Thread; #[test] fn partial_read() { @@ -123,7 +126,7 @@ mod test { let out = PipeStream::open(writer); let mut input = PipeStream::open(reader); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut out = out; out.write(&[10]).unwrap(); rx.recv(); // don't close the pipe until the other read has finished diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index b127507f048d2..b93e091af7e88 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -16,25 +16,25 @@ pub use self::StdioContainer::*; pub use self::ProcessExit::*; -use prelude::*; +use prelude::v1::*; +use c_str::{CString, ToCStr}; +use collections::HashMap; +use comm::{channel, Receiver}; use fmt; -use os; +use hash::Hash; +use io::pipe::{PipeStream, PipePair}; use io::{IoResult, IoError}; use io; use libc; -use c_str::CString; -use collections::HashMap; -use hash::Hash; -#[cfg(windows)] -use std::hash::sip::SipState; -use io::pipe::{PipeStream, PipePair}; +use os; use path::BytesContainer; -use thread::Thread; - -use sys; use sys::fs::FileDesc; use sys::process::Process as ProcessImp; +use sys; +use thread::Thread; + +#[cfg(windows)] use std::hash::sip::SipState; /// Signal a process to exit, without forcibly killing it. Corresponds to /// SIGTERM on unix platforms. @@ -741,18 +741,17 @@ impl Drop for Process { #[cfg(test)] mod tests { - #![allow(unused_imports)] + use prelude::v1::*; - use super::*; + use comm::channel; + use io::fs::PathExtensions; use io::timer::*; use io::{Truncate, Write, TimedOut, timer, process, FileNotFound}; - use prelude::{Ok, Err, spawn, range, drop, Box, Some, None, Option, Vec, Buffer}; - use prelude::{from_str, Path, String, channel, Reader, Writer, Clone, Slice}; - use prelude::{SliceExt, Str, StrExt, AsSlice, ToString, GenericPath}; - use io::fs::PathExtensions; - use time::Duration; - use str; use rt::running_on_valgrind; + use str; + use super::*; + use thread::Thread; + use time::Duration; // FIXME(#10380) these tests should not all be ignored on android. @@ -1156,14 +1155,14 @@ mod tests { fn wait_timeout2() { let (tx, rx) = channel(); let tx2 = tx.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut p = sleeper(); p.set_timeout(Some(10)); assert_eq!(p.wait().err().unwrap().kind, TimedOut); p.signal_kill().unwrap(); tx.send(()); }); - spawn(move|| { + let _t = Thread::spawn(move|| { let mut p = sleeper(); p.set_timeout(Some(10)); assert_eq!(p.wait().err().unwrap().kind, TimedOut); diff --git a/src/libstd/io/result.rs b/src/libstd/io/result.rs index 32965d23971ed..c1474650f1eb4 100644 --- a/src/libstd/io/result.rs +++ b/src/libstd/io/result.rs @@ -78,7 +78,7 @@ impl> Acceptor for IoResult { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use super::super::mem::*; use io; diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index b7d069eb19e58..789fdeba8a2cb 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -520,8 +520,11 @@ impl Writer for StdWriter { #[cfg(test)] mod tests { + use prelude::v1::*; + use super::*; - use prelude::*; + use comm::channel; + use thread::Thread; #[test] fn smoke() { @@ -537,7 +540,7 @@ mod tests { let (tx, rx) = channel(); let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx)); - spawn(move|| { + let _t = Thread::spawn(move|| { set_stdout(box w); println!("hello!"); }); @@ -550,7 +553,7 @@ mod tests { let (tx, rx) = channel(); let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx)); - spawn(move|| { + let _t = Thread::spawn(move || -> () { set_stderr(box w); panic!("my special message"); }); diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs index 40941fda79c93..7592e7692db0d 100644 --- a/src/libstd/io/test.rs +++ b/src/libstd/io/test.rs @@ -12,9 +12,10 @@ #![macro_escape] +use prelude::v1::*; + use libc; use os; -use prelude::*; use std::io::net::ip::*; use sync::atomic::{AtomicUint, INIT_ATOMIC_UINT, Relaxed}; diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs index 953effe4345ce..2067a97fdacf9 100644 --- a/src/libstd/io/timer.rs +++ b/src/libstd/io/timer.rs @@ -225,9 +225,10 @@ fn in_ms_u64(d: Duration) -> u64 { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use super::Timer; + use thread::Thread; use time::Duration; #[test] @@ -357,9 +358,9 @@ mod test { let mut timer = Timer::new().unwrap(); let timer_rx = timer.periodic(Duration::milliseconds(1000)); - spawn(move|| { + Thread::spawn(move|| { let _ = timer_rx.recv_opt(); - }); + }).detach(); // when we drop the TimerWatcher we're going to destroy the channel, // which must wake up the task on the other end @@ -371,9 +372,9 @@ mod test { let mut timer = Timer::new().unwrap(); let timer_rx = timer.periodic(Duration::milliseconds(1000)); - spawn(move|| { + Thread::spawn(move|| { let _ = timer_rx.recv_opt(); - }); + }).detach(); timer.oneshot(Duration::milliseconds(1)); } @@ -384,9 +385,9 @@ mod test { let mut timer = Timer::new().unwrap(); let timer_rx = timer.periodic(Duration::milliseconds(1000)); - spawn(move|| { + Thread::spawn(move|| { let _ = timer_rx.recv_opt(); - }); + }).detach(); timer.sleep(Duration::milliseconds(1)); } diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index 9840412160d9f..36986b8fdc5e5 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -10,7 +10,7 @@ //! Utility implementations of Reader and Writer -use prelude::*; +use prelude::v1::*; use cmp; use io; use slice::bytes::MutableByteVector; @@ -278,11 +278,11 @@ impl> Reader for IterReader { #[cfg(test)] mod test { + use prelude::v1::*; + use io::{MemReader, ByRefReader}; use io; - use boxed::Box; use super::*; - use prelude::{Ok, range, Vec, Buffer, Writer, Reader, ToString, AsSlice}; #[test] fn test_limit_reader_unlimited() { diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 74c387c5eeaf1..8beb002cf4899 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -265,6 +265,7 @@ mod std { pub use cell; // used for tls! pub use thread_local; // used for thread_local! pub use kinds; // used for tls! + pub use ops; // used for bitflags! // The test runner calls ::std::os::args() but really wants realstd #[cfg(test)] pub use realstd::os as os; diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index ebb64bc2f2d51..fa77ae6418dd3 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -334,6 +334,7 @@ macro_rules! vec { /// /// ``` /// use std::thread::Thread; +/// use std::comm::channel; /// /// let (tx1, rx1) = channel(); /// let (tx2, rx2) = channel(); diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 1f76382ce8a41..6de49c38b732e 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -15,7 +15,7 @@ #![allow(unsigned_negation)] #![doc(primitive = "f32")] -use prelude::*; +use prelude::v1::*; use intrinsics; use libc::c_int; diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 221ecf62c058d..50855d21b4ab8 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -14,7 +14,7 @@ #![allow(missing_docs)] #![doc(primitive = "f64")] -use prelude::*; +use prelude::v1::*; use intrinsics; use libc::c_int; diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 48ff1a364e93c..01aa21c692bf5 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -147,10 +147,8 @@ pub fn test_num(ten: T, two: T) where #[cfg(test)] mod tests { - use prelude::{range, Some, None, Option, IteratorExt}; - use super::{from_int, from_uint, from_i32, from_i64, from_u64, from_u32}; - use super::{from_f64, from_f32, from_u16, from_i16, from_u8, from_i8, Int}; - use super::{cast, NumCast, ToPrimitive, FromPrimitive, UnsignedInt}; + use prelude::v1::*; + use super::*; use i8; use i16; use i32; @@ -802,7 +800,7 @@ mod bench { extern crate test; use self::test::Bencher; use num::Int; - use prelude::*; + use prelude::v1::*; #[bench] fn bench_pow_function(b: &mut Bencher) { diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index e74f45f8f0a15..b52e4fda7af2c 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -49,8 +49,9 @@ pub fn to_str_bytes(n: $T, radix: uint, f: F) -> U where #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; use num::FromStrRadix; + use str::from_str; #[test] pub fn test_from_str() { diff --git a/src/libstd/os.rs b/src/libstd/os.rs index df50b7f81afcf..bceae6102165e 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -1427,7 +1427,7 @@ mod arch_consts { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; use option; use os::{env, getcwd, getenv, make_absolute}; use os::{split_paths, join_paths, setenv, unsetenv}; diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 30f3f56bc1c10..024dc56073d04 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -931,7 +931,9 @@ fn contains_nul(v: &T) -> bool { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; + use c_str::ToCStr; + use path::{WindowsPath, PosixPath}; #[test] fn test_cstring() { diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index bd4031e623085..102da31a2933a 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -448,10 +448,15 @@ static dot_dot_static: &'static [u8] = b".."; #[cfg(test)] mod tests { use super::*; - use prelude::Option::{mod, Some, None}; - use prelude::{Vec, Clone, AsSlice, SliceExt, CloneSliceExt, IteratorExt}; - use prelude::{DoubleEndedIteratorExt, Str, StrExt, ToString, GenericPath}; - use str; + + use clone::Clone; + use iter::{IteratorExt, DoubleEndedIteratorExt}; + use option::Option::{mod, Some, None}; + use path::GenericPath; + use slice::{AsSlice, SliceExt, CloneSliceExt}; + use str::{mod, Str, StrExt}; + use string::ToString; + use vec::Vec; macro_rules! t { (s: $path:expr, $exp:expr) => ( @@ -1239,7 +1244,7 @@ mod bench { extern crate test; use self::test::Bencher; use super::*; - use prelude::{Clone, GenericPath}; + use prelude::v1::{Clone, GenericPath}; #[bench] fn join_home_dir(b: &mut Bencher) { diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 751ed4b70fb38..107e9d80fc3d3 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -1120,12 +1120,18 @@ fn prefix_len(p: Option) -> uint { #[cfg(test)] mod tests { use super::*; - use prelude::Option::{mod, Some, None}; - use prelude::{Vec, Clone, AsSlice, SliceExt, CloneSliceExt, IteratorExt}; - use prelude::{DoubleEndedIteratorExt, Str, ToString, GenericPath}; use super::PathPrefix::*; use super::parse_prefix; + use clone::Clone; + use iter::{IteratorExt, DoubleEndedIteratorExt}; + use option::Option::{mod, Some, None}; + use path::GenericPath; + use slice::{AsSlice, SliceExt, CloneSliceExt}; + use str::Str; + use string::ToString; + use vec::Vec; + macro_rules! t { (s: $path:expr, $exp:expr) => ( { diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs deleted file mode 100644 index f016683e3d0a9..0000000000000 --- a/src/libstd/prelude.rs +++ /dev/null @@ -1,94 +0,0 @@ -// Copyright 2013 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! The Rust prelude -//! -//! Because `std` is required by most serious Rust software, it is -//! imported at the topmost level of every crate by default, as if the -//! first line of each crate was -//! -//! ```ignore -//! extern crate std; -//! ``` -//! -//! This means that the contents of std can be accessed from any context -//! with the `std::` path prefix, as in `use std::vec`, `use std::task::spawn`, -//! etc. -//! -//! Additionally, `std` contains a `prelude` module that reexports many of the -//! most common traits, types and functions. The contents of the prelude are -//! imported into every *module* by default. Implicitly, all modules behave as if -//! they contained the following prologue: -//! -//! ```ignore -//! use std::prelude::*; -//! ``` -//! -//! The prelude is primarily concerned with exporting *traits* that are so -//! pervasive that it would be obnoxious to import for every use, particularly -//! those that define methods on primitive types. It does include a few -//! particularly useful standalone functions, like `from_str`, `range`, and -//! `drop`, `spawn`, and `channel`. - -#![experimental] - -// Reexported core operators -#[doc(no_inline)] pub use kinds::{Copy, Send, Sized, Sync}; -#[doc(no_inline)] pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not}; -#[doc(no_inline)] pub use ops::{BitAnd, BitOr, BitXor}; -#[doc(no_inline)] pub use ops::{Drop, Deref, DerefMut}; -#[doc(no_inline)] pub use ops::{Shl, Shr}; -#[doc(no_inline)] pub use ops::{Index, IndexMut}; -#[doc(no_inline)] pub use ops::{Slice, SliceMut}; -#[doc(no_inline)] pub use ops::{Fn, FnMut, FnOnce}; - -// Reexported functions -#[doc(no_inline)] pub use iter::range; -#[doc(no_inline)] pub use mem::drop; -#[doc(no_inline)] pub use str::from_str; - -// Reexported types and traits - -#[doc(no_inline)] pub use borrow::IntoCow; -#[doc(no_inline)] pub use c_str::ToCStr; -#[doc(no_inline)] pub use char::{Char, UnicodeChar}; -#[doc(no_inline)] pub use clone::Clone; -#[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, Eq, Ord}; -#[doc(no_inline)] pub use cmp::{Ordering, Equiv}; -#[doc(no_inline)] pub use cmp::Ordering::{Less, Equal, Greater}; -#[doc(no_inline)] pub use iter::{FromIterator, Extend, ExactSizeIterator}; -#[doc(no_inline)] pub use iter::{Iterator, IteratorExt, DoubleEndedIterator}; -#[doc(no_inline)] pub use iter::{DoubleEndedIteratorExt, CloneIteratorExt}; -#[doc(no_inline)] pub use iter::{RandomAccessIterator, IteratorCloneExt, IteratorPairExt}; -#[doc(no_inline)] pub use iter::{IteratorOrdExt, MutableDoubleEndedIterator}; -#[doc(no_inline)] pub use num::{ToPrimitive, FromPrimitive}; -#[doc(no_inline)] pub use boxed::Box; -#[doc(no_inline)] pub use option::Option; -#[doc(no_inline)] pub use option::Option::{Some, None}; -#[doc(no_inline)] pub use path::{GenericPath, Path, PosixPath, WindowsPath}; -#[doc(no_inline)] pub use ptr::{PtrExt, MutPtrExt}; -#[doc(no_inline)] pub use result::Result; -#[doc(no_inline)] pub use result::Result::{Ok, Err}; -#[doc(no_inline)] pub use io::{Buffer, Writer, Reader, Seek, BufferPrelude}; -#[doc(no_inline)] pub use core::prelude::{Tuple1, Tuple2, Tuple3, Tuple4}; -#[doc(no_inline)] pub use core::prelude::{Tuple5, Tuple6, Tuple7, Tuple8}; -#[doc(no_inline)] pub use core::prelude::{Tuple9, Tuple10, Tuple11, Tuple12}; -#[doc(no_inline)] pub use str::{Str, StrExt}; -#[doc(no_inline)] pub use slice::AsSlice; -#[doc(no_inline)] pub use slice::{SliceConcatExt, PartialEqSliceExt}; -#[doc(no_inline)] pub use slice::{CloneSliceExt, OrdSliceExt, SliceExt}; -#[doc(no_inline)] pub use slice::{BoxedSliceExt}; -#[doc(no_inline)] pub use string::{IntoString, String, ToString}; -#[doc(no_inline)] pub use vec::Vec; - -// Reexported runtime types -#[doc(no_inline)] pub use comm::{sync_channel, channel}; -#[doc(no_inline)] pub use comm::{SyncSender, Sender, Receiver}; -#[doc(no_inline)] pub use task::spawn; diff --git a/src/libstd/prelude/mod.rs b/src/libstd/prelude/mod.rs new file mode 100644 index 0000000000000..da945b4c9fa08 --- /dev/null +++ b/src/libstd/prelude/mod.rs @@ -0,0 +1,42 @@ +// Copyright 2014 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! The Rust prelude +//! +//! Because `std` is required by most serious Rust software, it is +//! imported at the topmost level of every crate by default, as if the +//! first line of each crate was +//! +//! ```ignore +//! extern crate std; +//! ``` +//! +//! This means that the contents of std can be accessed from any context +//! with the `std::` path prefix, as in `use std::vec`, `use std::task::spawn`, +//! etc. +//! +//! Additionally, `std` contains a `prelude` module that reexports many of the +//! most common traits, types and functions. The contents of the prelude are +//! imported into every *module* by default. Implicitly, all modules behave as if +//! they contained the following prologue: +//! +//! ```ignore +//! use std::prelude::v1::*; +//! ``` +//! +//! The prelude is primarily concerned with exporting *traits* that are so +//! pervasive that it would be obnoxious to import for every use, particularly +//! those that define methods on primitive types. + +#[cfg(stage0)] +pub use self::v1::*; + +#[stable] +pub mod v1; diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs new file mode 100644 index 0000000000000..33146f5e622ea --- /dev/null +++ b/src/libstd/prelude/v1.rs @@ -0,0 +1,51 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! The first version of the prelude of the standard library. + +#![stable] + +// Reexported core operators +#[stable] #[doc(no_inline)] pub use kinds::{Copy, Send, Sized, Sync}; +#[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce}; + +// Reexported functions +#[stable] #[doc(no_inline)] pub use mem::drop; + +// Reexported types and traits + +#[stable] #[doc(no_inline)] pub use boxed::Box; +#[stable] #[doc(no_inline)] pub use char::{Char, UnicodeChar}; +#[stable] #[doc(no_inline)] pub use clone::Clone; +#[stable] #[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, Eq, Ord}; +#[stable] #[doc(no_inline)] pub use iter::CloneIteratorExt; +#[stable] #[doc(no_inline)] pub use iter::DoubleEndedIterator; +#[stable] #[doc(no_inline)] pub use iter::DoubleEndedIteratorExt; +#[stable] #[doc(no_inline)] pub use iter::ExactSizeIterator; +#[stable] #[doc(no_inline)] pub use iter::{Iterator, IteratorExt, Extend}; +#[stable] #[doc(no_inline)] pub use iter::{IteratorCloneExt, IteratorOrdExt}; +#[stable] #[doc(no_inline)] pub use iter::IteratorPairExt; +#[stable] #[doc(no_inline)] pub use option::Option::{mod, Some, None}; +#[stable] #[doc(no_inline)] pub use ptr::{PtrExt, MutPtrExt}; +#[stable] #[doc(no_inline)] pub use result::Result::{mod, Ok, Err}; +#[stable] #[doc(no_inline)] pub use slice::AsSlice; +#[stable] #[doc(no_inline)] pub use slice::{BoxedSliceExt, SliceExt}; +#[stable] #[doc(no_inline)] pub use slice::{CloneSliceExt, OrdSliceExt}; +#[stable] #[doc(no_inline)] pub use slice::{PartialEqSliceExt, SliceConcatExt}; +#[stable] #[doc(no_inline)] pub use str::{Str, StrExt}; +#[stable] #[doc(no_inline)] pub use string::{String, ToString}; +#[stable] #[doc(no_inline)] pub use vec::Vec; + +// NB: remove when path reform lands +#[doc(no_inline)] pub use path::{Path, GenericPath}; +// NB: remove when I/O reform lands +#[doc(no_inline)] pub use io::{Buffer, Writer, Reader, Seek, BufferPrelude}; +// NB: remove when range syntax lands +#[doc(no_inline)] pub use iter::range; diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index f665d150f3878..86b8bfc73709d 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -419,7 +419,7 @@ pub fn sample, R: Rng>(rng: &mut R, #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use super::{Rng, thread_rng, random, SeedableRng, StdRng, sample}; use iter::order; @@ -615,7 +615,7 @@ static RAND_BENCH_N: u64 = 100; #[cfg(test)] mod bench { extern crate test; - use prelude::*; + use prelude::v1::*; use self::test::Bencher; use super::{XorShiftRng, StdRng, IsaacRng, Isaac64Rng, Rng, RAND_BENCH_N}; diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index ca36f2d8997b1..6576f1b65261e 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -338,10 +338,11 @@ mod imp { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; - use super::OsRng; + use comm::channel; use rand::Rng; + use super::OsRng; use thread::Thread; #[test] diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs index 15e63aa19eabc..48d7f2e7854da 100644 --- a/src/libstd/rand/reader.rs +++ b/src/libstd/rand/reader.rs @@ -74,7 +74,7 @@ impl Rng for ReaderRng { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use super::ReaderRng; use io::MemReader; diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs index 98eff621ce0f3..4734a39c83542 100644 --- a/src/libstd/rt/args.rs +++ b/src/libstd/rt/args.rs @@ -44,7 +44,7 @@ pub fn clone() -> Option>> { imp::clone() } target_os = "freebsd", target_os = "dragonfly"))] mod imp { - use prelude::*; + use prelude::v1::*; use mem; use slice; @@ -107,7 +107,7 @@ mod imp { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; use finally::Finally; use super::*; diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index 3eeb0ad3968fe..4abef6ee91046 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -12,7 +12,7 @@ #![allow(non_camel_case_types)] -use prelude::*; +use prelude::v1::*; use os; use sync::atomic; @@ -39,7 +39,7 @@ pub fn log_enabled() -> bool { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use sys_common; macro_rules! t { ($a:expr, $b:expr) => ({ let mut m = Vec::new(); diff --git a/src/libstd/rt/exclusive.rs b/src/libstd/rt/exclusive.rs index 88bdb29caecad..eb6b365544457 100644 --- a/src/libstd/rt/exclusive.rs +++ b/src/libstd/rt/exclusive.rs @@ -83,7 +83,7 @@ impl<'a, T: Send> DerefMut for ExclusiveGuard<'a, T> { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; use sync::Arc; use super::Exclusive; use task; diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index e877dd5c6aab8..68aaa1b3ae55d 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -23,14 +23,10 @@ #![allow(dead_code)] -use os; -use thunk::Thunk; use kinds::Send; -use thread::Thread; use ops::FnOnce; use sys; -use sys_common; -use sys_common::thread_info::{mod, NewThread}; +use thunk::Thunk; // Reexport some of our utilities which are expected by other crates. pub use self::util::{default_sched_threads, min_stack, running_on_valgrind}; @@ -65,9 +61,14 @@ const OS_DEFAULT_STACK_ESTIMATE: uint = 2 * (1 << 20); #[cfg(not(test))] #[lang = "start"] fn lang_start(main: *const u8, argc: int, argv: *const *const u8) -> int { + use prelude::v1::*; + use mem; - use prelude::*; + use os; use rt; + use sys_common::thread_info::{mod, NewThread}; + use sys_common; + use thread::Thread; let something_around_the_top_of_the_stack = 1; let addr = &something_around_the_top_of_the_stack as *const int; diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index 41e91d1b6ef9b..48cdfc20a351a 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -496,7 +496,7 @@ impl Death { #[cfg(test)] mod test { use super::*; - use prelude::*; + use prelude::v1::*; use task; use rt::unwind; diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index e0c512706e6a9..dcd967a774cf6 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -57,7 +57,7 @@ //! //! Currently Rust uses unwind runtime provided by libgcc. -use prelude::*; +use prelude::v1::*; use any::Any; use cell::Cell; diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index fee86e33455d4..2a8deccb5dc93 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -10,13 +10,12 @@ // // ignore-lexer-test FIXME #15677 -use prelude::*; +use prelude::v1::*; use cmp; use fmt; use intrinsics; -use libc::uintptr_t; -use libc; +use libc::{mod, uintptr_t}; use os; use slice; use str; diff --git a/src/libstd/sync/atomic.rs b/src/libstd/sync/atomic.rs index 18c917aca8a4a..a88932f21cba3 100644 --- a/src/libstd/sync/atomic.rs +++ b/src/libstd/sync/atomic.rs @@ -180,7 +180,7 @@ impl Drop for AtomicOption { #[cfg(test)] mod test { - use prelude::{Some, None}; + use prelude::v1::*; use super::*; #[test] diff --git a/src/libstd/sync/barrier.rs b/src/libstd/sync/barrier.rs index 4091f0df39597..1c73bf7cf3565 100644 --- a/src/libstd/sync/barrier.rs +++ b/src/libstd/sync/barrier.rs @@ -89,10 +89,11 @@ impl Barrier { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; use sync::{Arc, Barrier}; - use comm::Empty; + use comm::{channel, Empty}; + use thread::Thread; #[test] fn test_barrier() { @@ -102,10 +103,10 @@ mod tests { for _ in range(0u, 9) { let c = barrier.clone(); let tx = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { c.wait(); tx.send(true); - }); + }).detach(); } // At this point, all spawned tasks should be blocked, diff --git a/src/libstd/sync/condvar.rs b/src/libstd/sync/condvar.rs index 15faf5be258f5..df3f2e5cf6279 100644 --- a/src/libstd/sync/condvar.rs +++ b/src/libstd/sync/condvar.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use prelude::*; +use prelude::v1::*; use sync::atomic::{mod, AtomicUint}; use sync::poison::{mod, LockResult}; @@ -279,11 +279,13 @@ impl StaticCondvar { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; - use time::Duration; + use comm::channel; use super::{StaticCondvar, CONDVAR_INIT}; use sync::{StaticMutex, MUTEX_INIT, Condvar, Mutex, Arc}; + use thread::Thread; + use time::Duration; #[test] fn smoke() { @@ -305,8 +307,8 @@ mod tests { static C: StaticCondvar = CONDVAR_INIT; static M: StaticMutex = MUTEX_INIT; - let g = M.lock().unwrap(); - spawn(move|| { + let mut g = M.lock().unwrap(); + let _t = Thread::spawn(move|| { let _g = M.lock().unwrap(); C.notify_one(); }); @@ -324,7 +326,7 @@ mod tests { for _ in range(0, N) { let data = data.clone(); let tx = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { let &(ref lock, ref cond) = &*data; let mut cnt = lock.lock().unwrap(); *cnt += 1; @@ -335,7 +337,7 @@ mod tests { cnt = cond.wait(cnt).unwrap(); } tx.send(()); - }); + }).detach(); } drop(tx); @@ -359,7 +361,7 @@ mod tests { let g = M.lock().unwrap(); let (g, success) = C.wait_timeout(g, Duration::nanoseconds(1000)).unwrap(); assert!(!success); - spawn(move|| { + let _t = Thread::spawn(move || { let _g = M.lock().unwrap(); C.notify_one(); }); @@ -377,7 +379,7 @@ mod tests { static C: StaticCondvar = CONDVAR_INIT; let mut g = M1.lock().unwrap(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _g = M1.lock().unwrap(); C.notify_one(); }); @@ -385,6 +387,5 @@ mod tests { drop(g); C.wait(M2.lock().unwrap()).unwrap(); - } } diff --git a/src/libstd/sync/future.rs b/src/libstd/sync/future.rs index 51899a87a325d..a0e7236b8d29a 100644 --- a/src/libstd/sync/future.rs +++ b/src/libstd/sync/future.rs @@ -150,9 +150,10 @@ impl Future { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; + use comm::channel; use sync::Future; - use task; + use thread::Thread; #[test] fn test_from_value() { @@ -210,7 +211,7 @@ mod test { let expected = "schlorf"; let (tx, rx) = channel(); let f = Future::spawn(move|| { expected }); - task::spawn(move|| { + let _t = Thread::spawn(move|| { let mut f = f; tx.send(f.get()); }); diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index 52004bb4a8f5f..98425f26c1af4 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -8,10 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use prelude::*; +use prelude::v1::*; use cell::UnsafeCell; use kinds::marker; +use ops::{Deref, DerefMut}; use sync::poison::{mod, TryLockError, TryLockResult, LockResult}; use sys_common::mutex as sys; @@ -47,6 +48,8 @@ use sys_common::mutex as sys; /// ```rust /// use std::sync::{Arc, Mutex}; /// use std::thread::Thread; +/// use std::comm::channel; +/// /// const N: uint = 10; /// /// // Spawn a few threads to increment a shared variable (non-atomically), and @@ -320,10 +323,11 @@ pub fn guard_poison<'a, T>(guard: &MutexGuard<'a, T>) -> &'a poison::Flag { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; - use thread::Thread; + use comm::channel; use sync::{Arc, Mutex, StaticMutex, MUTEX_INIT, Condvar}; + use thread::Thread; struct Packet(Arc<(Mutex, Condvar)>); @@ -366,9 +370,9 @@ mod test { let (tx, rx) = channel(); for _ in range(0, K) { let tx2 = tx.clone(); - spawn(move|| { inc(); tx2.send(()); }); + Thread::spawn(move|| { inc(); tx2.send(()); }).detach(); let tx2 = tx.clone(); - spawn(move|| { inc(); tx2.send(()); }); + Thread::spawn(move|| { inc(); tx2.send(()); }).detach(); } drop(tx); @@ -392,7 +396,7 @@ mod test { let packet = Packet(Arc::new((Mutex::new(false), Condvar::new()))); let packet2 = Packet(packet.0.clone()); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { // wait until parent gets in rx.recv(); let &(ref lock, ref cvar) = &*packet2.0; @@ -416,7 +420,7 @@ mod test { let packet2 = Packet(packet.0.clone()); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move || -> () { rx.recv(); let &(ref lock, ref cvar) = &*packet2.0; let _g = lock.lock().unwrap(); @@ -457,9 +461,9 @@ mod test { let arc = Arc::new(Mutex::new(1i)); let arc2 = Arc::new(Mutex::new(arc)); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let lock = arc2.lock().unwrap(); - let lock2 = lock.deref().lock().unwrap(); + let lock2 = lock.lock().unwrap(); assert_eq!(*lock2, 1); tx.send(()); }); diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs index 4d9fbb5990840..fe25eca03d7cf 100644 --- a/src/libstd/sync/once.rs +++ b/src/libstd/sync/once.rs @@ -122,10 +122,11 @@ impl Once { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use thread::Thread; use super::{ONCE_INIT, Once}; + use comm::channel; #[test] fn smoke_once() { @@ -145,7 +146,7 @@ mod test { let (tx, rx) = channel(); for _ in range(0u, 10) { let tx = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { for _ in range(0u, 4) { Thread::yield_now() } unsafe { O.doit(|| { @@ -155,7 +156,7 @@ mod test { assert!(run); } tx.send(()); - }); + }).detach(); } unsafe { diff --git a/src/libstd/sync/poison.rs b/src/libstd/sync/poison.rs index edf16d99f4966..6e4df1182091f 100644 --- a/src/libstd/sync/poison.rs +++ b/src/libstd/sync/poison.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use prelude::*; +use prelude::v1::*; use cell::UnsafeCell; use error::FromError; diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs index 7f3c77c97adef..efdd894a806de 100644 --- a/src/libstd/sync/rwlock.rs +++ b/src/libstd/sync/rwlock.rs @@ -8,10 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use prelude::*; +use prelude::v1::*; use cell::UnsafeCell; use kinds::marker; +use ops::{Deref, DerefMut}; use sync::poison::{mod, LockResult, TryLockError, TryLockResult}; use sys_common::rwlock as sys; @@ -355,9 +356,10 @@ impl<'a, T> Drop for RWLockWriteGuard<'a, T> { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; use rand::{mod, Rng}; + use comm::channel; use thread::Thread; use sync::{Arc, RWLock, StaticRWLock, RWLOCK_INIT}; @@ -389,7 +391,7 @@ mod tests { let (tx, rx) = channel::<()>(); for _ in range(0, N) { let tx = tx.clone(); - spawn(move|| { + Thread::spawn(move|| { let mut rng = rand::thread_rng(); for _ in range(0, M) { if rng.gen_weighted_bool(N) { @@ -399,7 +401,7 @@ mod tests { } } drop(tx); - }); + }).detach(); } drop(tx); let _ = rx.recv_opt(); diff --git a/src/libstd/sync/semaphore.rs b/src/libstd/sync/semaphore.rs index e3b683a6ccb38..a283626a408ba 100644 --- a/src/libstd/sync/semaphore.rs +++ b/src/libstd/sync/semaphore.rs @@ -104,10 +104,12 @@ impl<'a> Drop for SemaphoreGuard<'a> { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; use sync::Arc; use super::Semaphore; + use comm::channel; + use thread::Thread; #[test] fn test_sem_acquire_release() { @@ -127,7 +129,7 @@ mod tests { fn test_sem_as_mutex() { let s = Arc::new(Semaphore::new(1)); let s2 = s.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _g = s2.access(); }); let _g = s.access(); @@ -139,7 +141,7 @@ mod tests { let (tx, rx) = channel(); let s = Arc::new(Semaphore::new(0)); let s2 = s.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { s2.acquire(); tx.send(()); }); @@ -150,7 +152,7 @@ mod tests { let (tx, rx) = channel(); let s = Arc::new(Semaphore::new(0)); let s2 = s.clone(); - spawn(move|| { + let _t = Thread::spawn(move|| { s2.release(); let _ = rx.recv(); }); @@ -166,7 +168,7 @@ mod tests { let s2 = s.clone(); let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { let _g = s2.access(); let _ = rx2.recv(); tx1.send(()); @@ -183,11 +185,11 @@ mod tests { let (tx, rx) = channel(); { let _g = s.access(); - spawn(move|| { + Thread::spawn(move|| { tx.send(()); drop(s2.access()); tx.send(()); - }); + }).detach(); rx.recv(); // wait for child to come alive } rx.recv(); // wait for child to be done diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs index ee534f6cdde3e..63c10c1804659 100644 --- a/src/libstd/sync/task_pool.rs +++ b/src/libstd/sync/task_pool.rs @@ -53,8 +53,9 @@ impl<'a> Drop for Sentinel<'a> { /// # Example /// /// ```rust -/// # use std::sync::TaskPool; -/// # use std::iter::AdditiveIterator; +/// use std::sync::TaskPool; +/// use std::iter::AdditiveIterator; +/// use std::comm::channel; /// /// let pool = TaskPool::new(4u); /// @@ -131,8 +132,9 @@ fn spawn_in_pool(jobs: Arc>>) { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; use super::*; + use comm::channel; const TEST_TASKS: uint = 4u; diff --git a/src/libstd/sys/common/backtrace.rs b/src/libstd/sys/common/backtrace.rs index 866bf1d8a7d63..d4039fd96ff20 100644 --- a/src/libstd/sys/common/backtrace.rs +++ b/src/libstd/sys/common/backtrace.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use prelude::*; +use prelude::v1::*; use io::IoResult; diff --git a/src/libstd/sys/common/helper_thread.rs b/src/libstd/sys/common/helper_thread.rs index 9ef1c33312fc8..c4c093dcb328f 100644 --- a/src/libstd/sys/common/helper_thread.rs +++ b/src/libstd/sys/common/helper_thread.rs @@ -20,12 +20,13 @@ //! can be created in the future and there must be no active timers at that //! time. -use prelude::*; +use prelude::v1::*; use cell::UnsafeCell; +use comm::{channel, Sender, Receiver}; use mem; -use sync::{StaticMutex, StaticCondvar}; use rt; +use sync::{StaticMutex, StaticCondvar}; use sys::helper_signal; use thread::Thread; diff --git a/src/libstd/sys/common/mod.rs b/src/libstd/sys/common/mod.rs index dc0ad08cdbef6..97015f74a4a10 100644 --- a/src/libstd/sys/common/mod.rs +++ b/src/libstd/sys/common/mod.rs @@ -12,7 +12,7 @@ #![allow(dead_code)] use io::{mod, IoError, IoResult}; -use prelude::*; +use prelude::v1::*; use sys::{last_error, retry}; use c_str::CString; use num::Int; diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs index 259c15b5f0634..cb0c5581abd8b 100644 --- a/src/libstd/sys/common/net.rs +++ b/src/libstd/sys/common/net.rs @@ -8,24 +8,24 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use prelude::v1::*; use self::SocketStatus::*; use self::InAddr::*; -use alloc::arc::Arc; +use c_str::ToCStr; +use io::net::addrinfo; +use io::net::ip::{SocketAddr, IpAddr, Ipv4Addr, Ipv6Addr}; +use io::{IoResult, IoError}; use libc::{mod, c_char, c_int}; use c_str::CString; use mem; use num::Int; use ptr::{mod, null, null_mut}; -use io::net::ip::{SocketAddr, IpAddr, Ipv4Addr, Ipv6Addr}; -use io::net::addrinfo; -use io::{IoResult, IoError}; use sys::{mod, retry, c, sock_t, last_error, last_net_error, last_gai_error, close_sock, wrlen, msglen_t, os, wouldblock, set_nonblocking, timer, ms_to_timeval, decode_error_detailed}; -use sync::{Mutex, MutexGuard}; +use sync::{Arc, Mutex, MutexGuard}; use sys_common::{mod, keep_going, short_write, timeout}; -use prelude::*; use cmp; use io; diff --git a/src/libstd/sys/common/thread_local.rs b/src/libstd/sys/common/thread_local.rs index fe7a7d8d03716..405dd4eacf399 100644 --- a/src/libstd/sys/common/thread_local.rs +++ b/src/libstd/sys/common/thread_local.rs @@ -56,7 +56,7 @@ #![allow(non_camel_case_types)] -use prelude::*; +use prelude::v1::*; use sync::atomic::{mod, AtomicUint}; use sync::{Mutex, Once, ONCE_INIT}; @@ -246,7 +246,7 @@ impl Drop for Key { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; use super::{Key, StaticKey, INIT_INNER}; fn assert_sync() {} diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs index 8de4ffa7022a9..e3e0b279c12c7 100644 --- a/src/libstd/sys/unix/fs.rs +++ b/src/libstd/sys/unix/fs.rs @@ -10,16 +10,15 @@ //! Blocking posix-based file I/O -use libc::{mod, c_int, c_void}; -use c_str::CString; -use mem; -use io; - -use prelude::*; +use prelude::v1::*; +use c_str::{CString, ToCStr}; use io::{FilePermission, Write, UnstableFileStat, Open, FileAccess, FileMode}; use io::{IoResult, FileStat, SeekStyle}; use io::{Read, Truncate, SeekCur, SeekSet, ReadWrite, SeekEnd, Append}; +use io; +use libc::{mod, c_int, c_void}; +use mem; use sys::retry; use sys_common::{keep_going, eof, mkerr_libc}; @@ -360,7 +359,7 @@ mod tests { use super::FileDesc; use libc; use os; - use prelude::*; + use prelude::v1::*; #[cfg_attr(target_os = "freebsd", ignore)] // hmm, maybe pipes have a tiny buffer #[test] diff --git a/src/libstd/sys/unix/mod.rs b/src/libstd/sys/unix/mod.rs index c82dacf1e44e9..4199cbc1bb9f5 100644 --- a/src/libstd/sys/unix/mod.rs +++ b/src/libstd/sys/unix/mod.rs @@ -19,7 +19,7 @@ extern crate libc; use num; use num::{Int, SignedInt}; -use prelude::*; +use prelude::v1::*; use io::{mod, IoResult, IoError}; use sys_common::mkerr_libc; diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index 595191db3b282..6d145e47516c7 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -10,17 +10,18 @@ //! Implementation of `std::os` functionality for unix systems -use prelude::*; +use prelude::v1::*; +use c_str::ToCStr; use error::{FromError, Error}; use fmt; use io::{IoError, IoResult}; use libc::{mod, c_int, c_char, c_void}; -use path::BytesContainer; +use os; +use path::{BytesContainer}; use ptr; use sync::atomic::{AtomicInt, INIT_ATOMIC_INT, SeqCst}; use sys::fs::FileDesc; -use os; use os::TMPBUF_SZ; diff --git a/src/libstd/sys/unix/pipe.rs b/src/libstd/sys/unix/pipe.rs index 868b460aa5ed3..e46814ef4a27d 100644 --- a/src/libstd/sys/unix/pipe.rs +++ b/src/libstd/sys/unix/pipe.rs @@ -8,13 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use alloc::arc::Arc; +use prelude::v1::*; + use libc; use c_str::CString; use mem; -use sync::{atomic, Mutex}; +use sync::{atomic, Arc, Mutex}; use io::{mod, IoResult, IoError}; -use prelude::*; use sys::{mod, timer, retry, c, set_nonblocking, wouldblock}; use sys::fs::{fd_t, FileDesc}; diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs index c1c28bd5fc4df..13191961fb7b0 100644 --- a/src/libstd/sys/unix/process.rs +++ b/src/libstd/sys/unix/process.rs @@ -7,22 +7,23 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. + +use prelude::v1::*; use self::Req::*; -use libc::{mod, pid_t, c_void, c_int}; -use c_str::CString; +use c_str::{CString, ToCStr}; +use collections; +use comm::{channel, Sender, Receiver}; +use hash::Hash; +use io::process::{ProcessExit, ExitStatus, ExitSignal}; use io::{mod, IoResult, IoError, EndOfFile}; +use libc::{mod, pid_t, c_void, c_int}; use mem; use os; -use ptr; -use prelude::*; -use io::process::{ProcessExit, ExitStatus, ExitSignal}; -use collections; use path::BytesContainer; -use hash::Hash; - -use sys::{mod, retry, c, wouldblock, set_nonblocking, ms_to_timeval}; +use ptr; use sys::fs::FileDesc; +use sys::{mod, retry, c, wouldblock, set_nonblocking, ms_to_timeval}; use sys_common::helper_thread::Helper; use sys_common::{AsInner, mkerr_libc, timeout}; diff --git a/src/libstd/sys/unix/tcp.rs b/src/libstd/sys/unix/tcp.rs index e2a78947e167a..13ccf685fd7fc 100644 --- a/src/libstd/sys/unix/tcp.rs +++ b/src/libstd/sys/unix/tcp.rs @@ -8,12 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use prelude::v1::*; + use io::net::ip; use io::IoResult; use libc; use mem; use ptr; -use prelude::*; use super::{last_error, last_net_error, retry, sock_t}; use sync::{Arc, atomic}; use sys::fs::FileDesc; diff --git a/src/libstd/sys/unix/thread_local.rs b/src/libstd/sys/unix/thread_local.rs index b300e93eeb602..e507377a8fcdd 100644 --- a/src/libstd/sys/unix/thread_local.rs +++ b/src/libstd/sys/unix/thread_local.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use prelude::*; +use prelude::v1::*; use libc::c_int; pub type Key = pthread_key_t; diff --git a/src/libstd/sys/unix/timer.rs b/src/libstd/sys/unix/timer.rs index c0ef89666c0f5..c9160a032ecf7 100644 --- a/src/libstd/sys/unix/timer.rs +++ b/src/libstd/sys/unix/timer.rs @@ -46,19 +46,19 @@ //! //! Note that all time units in this file are in *milliseconds*. +use prelude::v1::*; use self::Req::*; +use comm::{mod, channel, Sender, Receiver}; +use io::IoResult; use libc; use mem; use os; use ptr; use sync::atomic; -use comm; use sys::c; use sys::fs::FileDesc; use sys_common::helper_thread::Helper; -use prelude::*; -use io::IoResult; helper_init! { static HELPER: Helper } diff --git a/src/libstd/sys/unix/tty.rs b/src/libstd/sys/unix/tty.rs index 28c17fd4966c0..4ef687d41d8ee 100644 --- a/src/libstd/sys/unix/tty.rs +++ b/src/libstd/sys/unix/tty.rs @@ -8,8 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use prelude::v1::*; + use sys::fs::FileDesc; -use prelude::*; use libc::{mod, c_int}; use io::{mod, IoResult, IoError}; use sys_common; diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index 6cccefbe89064..d28d0fe26b943 100644 --- a/src/libstd/sys/windows/c.rs +++ b/src/libstd/sys/windows/c.rs @@ -15,7 +15,7 @@ #![allow(non_camel_case_types)] use libc; -use prelude::*; +use prelude::v1::*; pub const WSADESCRIPTION_LEN: uint = 256; pub const WSASYS_STATUS_LEN: uint = 128; @@ -132,7 +132,9 @@ extern "system" { pub mod compat { use intrinsics::{atomic_store_relaxed, transmute}; use libc::types::os::arch::extra::{LPCWSTR, HMODULE, LPCSTR, LPVOID}; - use prelude::*; + use prelude::v1::*; + + use c_str::ToCStr; extern "system" { fn GetModuleHandleW(lpModuleName: LPCWSTR) -> HMODULE; diff --git a/src/libstd/sys/windows/fs.rs b/src/libstd/sys/windows/fs.rs index 3ad439078b9a1..523d60c71aa8b 100644 --- a/src/libstd/sys/windows/fs.rs +++ b/src/libstd/sys/windows/fs.rs @@ -21,7 +21,7 @@ use ptr; use str; use io; -use prelude::*; +use prelude::v1::*; use sys; use sys::os; use sys_common::{keep_going, eof, mkerr_libc}; diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index 57c284ed6a326..c354e7b3ece29 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -18,11 +18,13 @@ extern crate libc; +use prelude::v1::*; + use num; use mem; -use prelude::*; use io::{mod, IoResult, IoError}; use sync::{Once, ONCE_INIT}; +use comm::Sender; macro_rules! helper_init { (static $name:ident: Helper<$m:ty>) => ( static $name: Helper<$m> = Helper { diff --git a/src/libstd/sys/windows/mutex.rs b/src/libstd/sys/windows/mutex.rs index 3ac7c09154e35..c7b4a4cec09ec 100644 --- a/src/libstd/sys/windows/mutex.rs +++ b/src/libstd/sys/windows/mutex.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use prelude::*; +use prelude::v1::*; use sync::atomic; use alloc::{mod, heap}; diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index 09003f87ff0c1..dfdee0e0385c5 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -13,7 +13,7 @@ // FIXME: move various extern bindings from here into liblibc or // something similar -use prelude::*; +use prelude::v1::*; use fmt; use io::{IoResult, IoError}; diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs index fc3640f260437..f173d5fc6d4cb 100644 --- a/src/libstd/sys/windows/pipe.rs +++ b/src/libstd/sys/windows/pipe.rs @@ -84,14 +84,14 @@ //! the test suite passing (the suite is in libstd), and that's good enough for //! me! -use alloc::arc::Arc; +use prelude::v1::*; + use libc; use c_str::CString; use mem; use ptr; -use sync::{atomic, Mutex}; +use sync::{atomic, Arc, Mutex}; use io::{mod, IoError, IoResult}; -use prelude::*; use sys_common::{mod, eof}; diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index b03c62395d1a0..cb99a886ce4fc 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -8,14 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use prelude::v1::*; + use libc::{pid_t, c_void, c_int}; use libc; -use c_str::CString; +use c_str::{CString, ToCStr}; use io; use mem; use os; use ptr; -use prelude::*; use io::process::{ProcessExit, ExitStatus, ExitSignal}; use collections; use path::BytesContainer; @@ -466,10 +467,11 @@ fn free_handle(handle: *mut ()) { #[cfg(test)] mod tests { + use c_str::ToCStr; #[test] fn test_make_command_line() { - use prelude::*; + use prelude::v1::*; use str; use c_str::CString; use super::make_command_line; diff --git a/src/libstd/sys/windows/tcp.rs b/src/libstd/sys/windows/tcp.rs index 513c1d38e3634..5a929f6b2b5ff 100644 --- a/src/libstd/sys/windows/tcp.rs +++ b/src/libstd/sys/windows/tcp.rs @@ -13,7 +13,7 @@ use io::IoResult; use libc; use mem; use ptr; -use prelude::*; +use prelude::v1::*; use super::{last_error, last_net_error, retry, sock_t}; use sync::{Arc, atomic}; use sys::fs::FileDesc; diff --git a/src/libstd/sys/windows/thread_local.rs b/src/libstd/sys/windows/thread_local.rs index 60b0d584db3a7..b96e26c7a86a6 100644 --- a/src/libstd/sys/windows/thread_local.rs +++ b/src/libstd/sys/windows/thread_local.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use prelude::*; +use prelude::v1::*; use libc::types::os::arch::extra::{DWORD, LPVOID, BOOL}; diff --git a/src/libstd/sys/windows/timer.rs b/src/libstd/sys/windows/timer.rs index 874838950cd12..485dc25105014 100644 --- a/src/libstd/sys/windows/timer.rs +++ b/src/libstd/sys/windows/timer.rs @@ -21,16 +21,17 @@ //! the other two implementations of timers with nothing *that* new showing up. use self::Req::*; +use prelude::v1::*; use libc; use ptr; use comm; +use comm::{channel, Sender, Receiver}; +use io::IoResult; use sys::c; use sys::fs::FileDesc; use sys_common::helper_thread::Helper; -use prelude::*; -use io::IoResult; helper_init! { static HELPER: Helper } diff --git a/src/libstd/sys/windows/tty.rs b/src/libstd/sys/windows/tty.rs index a88d11eed22bd..7591025d76d6f 100644 --- a/src/libstd/sys/windows/tty.rs +++ b/src/libstd/sys/windows/tty.rs @@ -25,19 +25,20 @@ //! wrapper that performs encoding/decoding, this implementation should switch //! to working in raw UTF-16, with such a wrapper around it. -use super::c::{ReadConsoleW, WriteConsoleW, GetConsoleMode, SetConsoleMode}; -use super::c::{ERROR_ILLEGAL_CHARACTER}; -use super::c::{ENABLE_ECHO_INPUT, ENABLE_EXTENDED_FLAGS}; -use super::c::{ENABLE_INSERT_MODE, ENABLE_LINE_INPUT}; -use super::c::{ENABLE_PROCESSED_INPUT, ENABLE_QUICK_EDIT_MODE}; -use libc::{c_int, HANDLE, LPDWORD, DWORD, LPVOID}; -use libc::{get_osfhandle, CloseHandle}; -use libc::types::os::arch::extra::LPCVOID; +use prelude::v1::*; + use io::{mod, IoError, IoResult, MemReader}; use iter::repeat; -use prelude::*; +use libc::types::os::arch::extra::LPCVOID; +use libc::{c_int, HANDLE, LPDWORD, DWORD, LPVOID}; +use libc::{get_osfhandle, CloseHandle}; use ptr; use str::from_utf8; +use super::c::{ENABLE_ECHO_INPUT, ENABLE_EXTENDED_FLAGS}; +use super::c::{ENABLE_INSERT_MODE, ENABLE_LINE_INPUT}; +use super::c::{ENABLE_PROCESSED_INPUT, ENABLE_QUICK_EDIT_MODE}; +use super::c::{ERROR_ILLEGAL_CHARACTER}; +use super::c::{ReadConsoleW, WriteConsoleW, GetConsoleMode, SetConsoleMode}; fn invalid_encoding() -> IoError { IoError { diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index a7b3ee996a34d..b6e16a8e6abf3 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -440,13 +440,15 @@ impl Drop for JoinGuard { #[cfg(test)] mod test { - use prelude::*; + use prelude::v1::*; + use any::{Any, AnyRefExt}; use boxed::BoxAny; + use comm::{channel, Sender}; use result; use std::io::{ChanReader, ChanWriter}; - use thunk::Thunk; use super::{Thread, Builder}; + use thunk::Thunk; // !!! These tests are dangerous. If something is buggy, they will hang, !!! // !!! instead of exiting cleanly. This might wedge the buildbots. !!! diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs index 14dd2a1ac9b58..9d4e7936de21b 100644 --- a/src/libstd/thread_local/mod.rs +++ b/src/libstd/thread_local/mod.rs @@ -37,7 +37,7 @@ #![macro_escape] #![experimental] -use prelude::*; +use prelude::v1::*; use cell::UnsafeCell; @@ -248,7 +248,7 @@ impl Key { #[cfg(any(target_os = "macos", target_os = "linux"))] mod imp { - use prelude::*; + use prelude::v1::*; use cell::UnsafeCell; use intrinsics; @@ -380,7 +380,7 @@ mod imp { #[cfg(not(any(target_os = "macos", target_os = "linux")))] mod imp { - use prelude::*; + use prelude::v1::*; use cell::UnsafeCell; use mem; @@ -453,8 +453,9 @@ mod imp { #[cfg(test)] mod tests { - use prelude::*; + use prelude::v1::*; + use comm::{channel, Sender}; use cell::UnsafeCell; use thread::Thread; @@ -476,7 +477,7 @@ mod tests { *f.get() = 2; }); let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| { FOO.with(|f| unsafe { assert_eq!(*f.get(), 1); }); @@ -496,7 +497,7 @@ mod tests { }); let (tx, rx) = channel(); - spawn(move|| unsafe { + let _t = Thread::spawn(move|| unsafe { let mut tx = Some(tx); FOO.with(|f| { *f.get() = Some(Foo(tx.take().unwrap())); @@ -546,7 +547,7 @@ mod tests { Thread::spawn(move|| { drop(S1); - }).join(); + }).join().ok().unwrap(); } #[test] @@ -564,7 +565,7 @@ mod tests { Thread::spawn(move|| unsafe { K1.with(|s| *s.get() = Some(S1)); - }).join(); + }).join().ok().unwrap(); } #[test] @@ -589,7 +590,7 @@ mod tests { } let (tx, rx) = channel(); - spawn(move|| unsafe { + let _t = Thread::spawn(move|| unsafe { let mut tx = Some(tx); K1.with(|s| *s.get() = Some(S1(tx.take().unwrap()))); }); @@ -599,7 +600,7 @@ mod tests { #[cfg(test)] mod dynamic_tests { - use prelude::*; + use prelude::v1::*; use cell::RefCell; use collections::HashMap; diff --git a/src/libstd/thread_local/scoped.rs b/src/libstd/thread_local/scoped.rs index 5f96548c0530a..a2e2bd43849e2 100644 --- a/src/libstd/thread_local/scoped.rs +++ b/src/libstd/thread_local/scoped.rs @@ -40,7 +40,7 @@ #![macro_escape] -use prelude::*; +use prelude::v1::*; // macro hygiene sure would be nice, wouldn't it? #[doc(hidden)] pub use self::imp::KeyInner; @@ -238,7 +238,7 @@ mod imp { #[cfg(test)] mod tests { use cell::Cell; - use prelude::*; + use prelude::v1::*; scoped_thread_local!(static FOO: uint); diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs index 5cd60d6e153ea..fc90bffa03c2f 100644 --- a/src/libstd/tuple.rs +++ b/src/libstd/tuple.rs @@ -35,14 +35,14 @@ //! //! # Examples //! -//! Using methods: +//! Using fields: //! //! ``` //! #[allow(deprecated)] //! # fn main() { //! let pair = ("pi", 3.14f64); -//! assert_eq!(pair.val0(), "pi"); -//! assert_eq!(pair.val1(), 3.14f64); +//! assert_eq!(pair.0, "pi"); +//! assert_eq!(pair.1, 3.14f64); //! # } //! ``` //! diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index e61afb8b193af..5eac6546c6b82 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -10,19 +10,24 @@ // // ignore-lexer-test FIXME #15679 -//! The CodeMap tracks all the source code used within a single crate, mapping from integer byte -//! positions to the original source code location. Each bit of source parsed during crate parsing -//! (typically files, in-memory strings, or various bits of macro expansion) cover a continuous -//! range of bytes in the CodeMap and are represented by FileMaps. Byte positions are stored in -//! `spans` and used pervasively in the compiler. They are absolute positions within the CodeMap, -//! which upon request can be converted to line and column information, source code snippets, etc. +//! The CodeMap tracks all the source code used within a single crate, mapping +//! from integer byte positions to the original source code location. Each bit +//! of source parsed during crate parsing (typically files, in-memory strings, +//! or various bits of macro expansion) cover a continuous range of bytes in the +//! CodeMap and are represented by FileMaps. Byte positions are stored in +//! `spans` and used pervasively in the compiler. They are absolute positions +//! within the CodeMap, which upon request can be converted to line and column +//! information, source code snippets, etc. pub use self::MacroFormat::*; -use serialize::{Encodable, Decodable, Encoder, Decoder}; use std::cell::RefCell; +use std::num::ToPrimitive; +use std::ops::{Add, Sub}; use std::rc::Rc; + use libc::c_uint; +use serialize::{Encodable, Decodable, Encoder, Decoder}; pub trait Pos { fn from_uint(n: uint) -> Self; diff --git a/src/libsyntax/ext/bytes.rs b/src/libsyntax/ext/bytes.rs index 2844c0b523e5d..9f225d55b444f 100644 --- a/src/libsyntax/ext/bytes.rs +++ b/src/libsyntax/ext/bytes.rs @@ -17,7 +17,6 @@ use ext::base; use ext::build::AstBuilder; use std::ascii::AsciiExt; - pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index d87960ebdb82a..e46bd7ac4bc73 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -50,8 +50,7 @@ pub mod rt { impl ToTokens for Vec { fn to_tokens(&self, cx: &ExtCtxt) -> Vec { - let a = self.iter().flat_map(|t| t.to_tokens(cx).into_iter()); - FromIterator::from_iter(a) + self.iter().flat_map(|t| t.to_tokens(cx).into_iter()).collect() } } diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs index 3023c547fb053..f7d2331c9ec58 100644 --- a/src/libsyntax/owned_slice.rs +++ b/src/libsyntax/owned_slice.rs @@ -8,8 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::fmt; use std::default::Default; +use std::fmt; +use std::iter::FromIterator; +use std::ops::Deref; use std::vec; use serialize::{Encodable, Decodable, Encoder, Decoder}; diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 13d020f6ae31b..0f5ff33021cc9 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -16,6 +16,7 @@ use ext::tt::transcribe::tt_next_token; use parse::token; use parse::token::{str_to_ident}; +use std::borrow::IntoCow; use std::char; use std::fmt; use std::mem::replace; @@ -358,7 +359,7 @@ impl<'a> StringReader<'a> { pub fn nextnextch(&self) -> Option { let offset = self.byte_offset(self.pos).to_uint(); - let s = self.filemap.deref().src[]; + let s = self.filemap.src.as_slice(); if offset >= s.len() { return None } let str::CharRange { next, .. } = s.char_range_at(offset); if next < s.len() { diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 457085f5cc848..832b112921e49 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -84,11 +84,12 @@ use owned_slice::OwnedSlice; use std::collections::HashSet; use std::io::fs::PathExtensions; +use std::iter; use std::mem; use std::num::Float; use std::rc::Rc; -use std::iter; use std::slice; +use std::str::from_str; bitflags! { flags Restrictions: u8 { diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index f22a4b5c6ed10..9c6644c520452 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -22,8 +22,10 @@ use util::interner::{RcStr, StrInterner}; use util::interner; use serialize::{Decodable, Decoder, Encodable, Encoder}; +use std::cmp::Equiv; use std::fmt; use std::mem; +use std::ops::Deref; use std::path::BytesContainer; use std::rc::Rc; diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs index 1b3ebde2461e6..8b1aed483c34f 100644 --- a/src/libsyntax/ptr.rs +++ b/src/libsyntax/ptr.rs @@ -10,16 +10,18 @@ //! The AST pointer //! -//! Provides `P`, a frozen owned smart pointer, as a replacement for `@T` in the AST. +//! Provides `P`, a frozen owned smart pointer, as a replacement for `@T` in +//! the AST. //! //! # Motivations and benefits //! -//! * **Identity**: sharing AST nodes is problematic for the various analysis passes -//! (e.g. one may be able to bypass the borrow checker with a shared `ExprAddrOf` -//! node taking a mutable borrow). The only reason `@T` in the AST hasn't caused -//! issues is because of inefficient folding passes which would always deduplicate -//! any such shared nodes. Even if the AST were to switch to an arena, this would -//! still hold, i.e. it couldn't use `&'a T`, but rather a wrapper like `P<'a, T>`. +//! * **Identity**: sharing AST nodes is problematic for the various analysis +//! passes (e.g. one may be able to bypass the borrow checker with a shared +//! `ExprAddrOf` node taking a mutable borrow). The only reason `@T` in the +//! AST hasn't caused issues is because of inefficient folding passes which +//! would always deduplicate any such shared nodes. Even if the AST were to +//! switch to an arena, this would still hold, i.e. it couldn't use `&'a T`, +//! but rather a wrapper like `P<'a, T>`. //! //! * **Immutability**: `P` disallows mutating its inner `T`, unlike `Box` //! (unless it contains an `Unsafe` interior, but that may be denied later). @@ -34,9 +36,9 @@ //! implementation changes (using a special thread-local heap, for example). //! Moreover, a switch to, e.g. `P<'a, T>` would be easy and mostly automated. -use std::fmt; -use std::fmt::Show; +use std::fmt::{mod, Show}; use std::hash::Hash; +use std::ops::Deref; use std::ptr; use serialize::{Encodable, Decodable, Encoder, Decoder}; diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs index c1823231e24f7..5a4d0cc3bd896 100644 --- a/src/libsyntax/std_inject.rs +++ b/src/libsyntax/std_inject.rs @@ -152,7 +152,7 @@ impl<'a> fold::Folder for PreludeInjector<'a> { let prelude_path = ast::Path { span: DUMMY_SP, global: false, - segments: vec!( + segments: vec![ ast::PathSegment { identifier: token::str_to_ident("std"), parameters: ast::PathParameters::none(), @@ -160,7 +160,12 @@ impl<'a> fold::Folder for PreludeInjector<'a> { ast::PathSegment { identifier: token::str_to_ident("prelude"), parameters: ast::PathParameters::none(), - }), + }, + ast::PathSegment { + identifier: token::str_to_ident("v1"), + parameters: ast::PathParameters::none(), + }, + ], }; let (crates, uses): (Vec<_>, _) = view_items.iter().cloned().partition(|x| { diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index 97eb43165833a..d25161a12a741 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -15,10 +15,12 @@ use ast::Name; use std::borrow::BorrowFrom; -use std::collections::HashMap; use std::cell::RefCell; +use std::cmp::Ordering; +use std::collections::HashMap; use std::fmt; use std::hash::Hash; +use std::ops::Deref; use std::rc::Rc; pub struct Interner { diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs index 946181770c8e9..953a7ae960e8c 100644 --- a/src/libsyntax/util/small_vector.rs +++ b/src/libsyntax/util/small_vector.rs @@ -7,9 +7,11 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. + use self::SmallVectorRepr::*; use self::IntoIterRepr::*; +use std::iter::FromIterator; use std::mem; use std::slice; use std::vec; diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index 19821ecb7ca7a..87f791e699233 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -49,8 +49,6 @@ use self::TestEvent::*; use self::NamePadding::*; use self::OutputLocation::*; -use std::any::{Any, AnyRefExt}; -use std::collections::BTreeMap; use stats::Stats; use getopts::{OptGroup, optflag, optopt}; use regex::Regex; @@ -58,7 +56,10 @@ use serialize::{json, Decodable, Encodable}; use term::Terminal; use term::color::{Color, RED, YELLOW, GREEN, CYAN}; +use std::any::{Any, AnyRefExt}; use std::cmp; +use std::collections::BTreeMap; +use std::comm::{channel, Sender}; use std::f64; use std::fmt::Show; use std::fmt; @@ -69,11 +70,10 @@ use std::io; use std::iter::repeat; use std::num::{Float, FloatMath, Int}; use std::os; -use std::str::FromStr; -use std::string::String; +use std::str::{FromStr, from_str}; use std::thread::{mod, Thread}; -use std::time::Duration; use std::thunk::{Thunk, Invoke}; +use std::time::Duration; // to be used by rustc to compile tests in libtest pub mod test { @@ -1466,6 +1466,7 @@ mod tests { StaticTestName, DynTestName, DynTestFn, ShouldFail}; use std::io::TempDir; use std::thunk::Thunk; + use std::comm::channel; #[test] pub fn do_not_run_ignored_tests() { diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index 41146cded704c..ed6a00a8e9115 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -10,13 +10,14 @@ #![allow(missing_docs)] -use std::collections::hash_map; +use std::cmp::Ordering::{mod, Less, Greater, Equal}; use std::collections::hash_map::Entry::{Occupied, Vacant}; +use std::collections::hash_map; use std::fmt::Show; use std::hash::Hash; use std::io; use std::mem; -use std::num::{Float, FloatMath}; +use std::num::{Float, FloatMath, FromPrimitive}; fn local_cmp(x: T, y: T) -> Ordering { // arbitrarily decide that NaNs are larger than everything. diff --git a/src/libtime/lib.rs b/src/libtime/lib.rs index 87a00334c478f..a6d9a542a49ed 100644 --- a/src/libtime/lib.rs +++ b/src/libtime/lib.rs @@ -30,10 +30,9 @@ extern crate libc; pub use self::ParseError::*; use self::Fmt::*; -use std::fmt::Show; -use std::fmt; +use std::fmt::{mod, Show}; use std::num::SignedInt; -use std::string::String; +use std::ops::{Add, Sub}; use std::time::Duration; static NSEC_PER_SEC: i32 = 1_000_000_000_i32; @@ -1274,6 +1273,7 @@ mod tests { #[cfg(windows)] fn set_time_zone() { use libc; + use std::c_str::ToCStr; // Windows crt doesn't see any environment variable set by // `SetEnvironmentVariable`, which `os::setenv` internally uses. // It is why we use `putenv` here. diff --git a/src/test/auxiliary/cci_capture_clause.rs b/src/test/auxiliary/cci_capture_clause.rs index 1cccb0f7ccbe6..e3dbe3c7e225a 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::task; +use std::comm::{Receiver, channel}; pub fn foo(x: T) -> Receiver { let (tx, rx) = channel(); diff --git a/src/test/auxiliary/static-methods-crate.rs b/src/test/auxiliary/static-methods-crate.rs index 811d8f1169239..ea4751bf4ed20 100644 --- a/src/test/auxiliary/static-methods-crate.rs +++ b/src/test/auxiliary/static-methods-crate.rs @@ -12,6 +12,7 @@ #![crate_type = "lib"] use std::int; +use std::str::from_str; pub trait read { fn readMaybe(s: String) -> Option; diff --git a/src/test/auxiliary/trait_inheritance_overloading_xc.rs b/src/test/auxiliary/trait_inheritance_overloading_xc.rs index 61854aba2790d..7de34d52f513c 100644 --- a/src/test/auxiliary/trait_inheritance_overloading_xc.rs +++ b/src/test/auxiliary/trait_inheritance_overloading_xc.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::cmp::PartialEq; +use std::ops::{Add, Sub, Mul}; pub trait MyNum : Add + Sub + Mul + PartialEq + Clone { } diff --git a/src/test/auxiliary/unboxed-closures-cross-crate.rs b/src/test/auxiliary/unboxed-closures-cross-crate.rs index 9a6a2c7495b79..0b65fa913cb77 100644 --- a/src/test/auxiliary/unboxed-closures-cross-crate.rs +++ b/src/test/auxiliary/unboxed-closures-cross-crate.rs @@ -10,6 +10,8 @@ #![feature(unboxed_closures)] +use std::ops::Add; + #[inline] pub fn has_closures() -> uint { let x = 1u; diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index 60331dfb5505a..0ada1cb991c6b 100644 --- a/src/test/bench/core-map.rs +++ b/src/test/bench/core-map.rs @@ -13,6 +13,7 @@ use std::collections::{BTreeMap, HashMap, HashSet}; use std::os; use std::rand::{Rng, IsaacRng, SeedableRng}; +use std::str::from_str; use std::time::Duration; use std::uint; diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs index 49f5c7751d9a0..52380001c6c0d 100644 --- a/src/test/bench/core-set.rs +++ b/src/test/bench/core-set.rs @@ -15,11 +15,12 @@ extern crate collections; extern crate rand; +use std::collections::BTreeSet; use std::collections::BitvSet; use std::collections::HashSet; -use std::collections::BTreeSet; use std::hash::Hash; use std::os; +use std::str::from_str; use std::time::Duration; use std::uint; diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs index 98113cb834767..08637b4bf1c1c 100644 --- a/src/test/bench/core-uint-to-str.rs +++ b/src/test/bench/core-uint-to-str.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::os; +use std::str::from_str; use std::uint; fn main() { diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index 645c029f935a7..94b7e58a54c1c 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -18,8 +18,10 @@ // different scalability characteristics compared to the select // version. +use std::comm::{channel, Sender, Receiver}; use std::comm; use std::os; +use std::str::from_str; use std::thread::Thread; use std::time::Duration; use std::uint; diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index ed96c6406d836..4fb84c8610695 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -14,7 +14,9 @@ // // I *think* it's the same, more or less. +use std::comm::{channel, Sender, Receiver}; use std::os; +use std::str::from_str; use std::thread::Thread; use std::time::Duration; use std::uint; diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs index 8ec44b2dd3c14..3ead5ef64fd99 100644 --- a/src/test/bench/msgsend-ring-mutex-arcs.rs +++ b/src/test/bench/msgsend-ring-mutex-arcs.rs @@ -19,6 +19,7 @@ // ignore-lexer-test FIXME #15679 use std::os; +use std::str::from_str; use std::sync::{Arc, Future, Mutex, Condvar}; use std::time::Duration; use std::uint; diff --git a/src/test/bench/rt-messaging-ping-pong.rs b/src/test/bench/rt-messaging-ping-pong.rs index 73d54372b274f..d3a340d488b57 100644 --- a/src/test/bench/rt-messaging-ping-pong.rs +++ b/src/test/bench/rt-messaging-ping-pong.rs @@ -17,7 +17,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::channel; use std::os; +use std::str::from_str; +use std::thread::Thread; use std::uint; // This is a simple bench that creates M pairs of tasks. These @@ -34,21 +37,21 @@ fn ping_pong_bench(n: uint, m: uint) { // Create a stream B->A let (btx, brx) = channel::<()>(); - spawn(move|| { + Thread::spawn(move|| { let (tx, rx) = (atx, brx); for _ in range(0, n) { tx.send(()); rx.recv(); } - }); + }).detach(); - spawn(move|| { + Thread::spawn(move|| { let (tx, rx) = (btx, arx); for _ in range(0, n) { rx.recv(); tx.send(()); } - }); + }).detach(); } for _ in range(0, m) { diff --git a/src/test/bench/rt-parfib.rs b/src/test/bench/rt-parfib.rs index bdf22cd739588..0a513c32aafc8 100644 --- a/src/test/bench/rt-parfib.rs +++ b/src/test/bench/rt-parfib.rs @@ -8,7 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::channel; use std::os; +use std::str::from_str; +use std::thread::Thread; use std::uint; // A simple implementation of parfib. One subtree is found in a new @@ -21,9 +24,9 @@ fn parfib(n: uint) -> uint { } let (tx, rx) = channel(); - spawn(move|| { + Thread::spawn(move|| { tx.send(parfib(n-1)); - }); + }).detach(); let m2 = parfib(n-2); return (rx.recv() + m2); } diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs index e7a50382c9469..f7810d5d740c0 100644 --- a/src/test/bench/shootout-ackermann.rs +++ b/src/test/bench/shootout-ackermann.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::os; +use std::str::from_str; fn ack(m: int, n: int) -> int { if m == 0 { diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs index 0b16e8011e832..2f25c37a911df 100644 --- a/src/test/bench/shootout-binarytrees.rs +++ b/src/test/bench/shootout-binarytrees.rs @@ -41,7 +41,9 @@ extern crate arena; use std::iter::range_step; +use std::str::from_str; use std::sync::Future; + use arena::TypedArena; enum Tree<'a> { diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index dcdb90a11c88c..6bbf6cde4ea29 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -41,8 +41,10 @@ // no-pretty-expanded use self::Color::{Red, Yellow, Blue}; -use std::string::String; +use std::comm::{channel, Sender, Receiver}; use std::fmt; +use std::str::from_str; +use std::thread::Thread; fn print_complements() { let all = [Blue, Red, Yellow]; @@ -188,13 +190,13 @@ fn rendezvous(nn: uint, set: Vec) { let to_rendezvous = to_rendezvous.clone(); let to_rendezvous_log = to_rendezvous_log.clone(); let (to_creature, from_rendezvous) = channel(); - spawn(move|| { + Thread::spawn(move|| { creature(ii, col, from_rendezvous, to_rendezvous, to_rendezvous_log); - }); + }).detach(); to_creature }).collect(); diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs index ef38f5ef74341..ec1268c90803b 100644 --- a/src/test/bench/shootout-fannkuch-redux.rs +++ b/src/test/bench/shootout-fannkuch-redux.rs @@ -40,8 +40,9 @@ #![feature(slicing_syntax)] -use std::{cmp, iter, mem}; +use std::str::from_str; use std::sync::Future; +use std::{cmp, iter, mem}; fn rotate(x: &mut [i32]) { let mut prev = x[0]; diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index 178d6777939d8..09f7f236f19a7 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -44,6 +44,7 @@ use std::cmp::min; use std::io::{stdout, IoResult}; use std::os; use std::slice::bytes::copy_memory; +use std::str::from_str; const LINE_LEN: uint = 60; const LOOKUP_SIZE: uint = 4 * 1024; diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index 2de61cf3572c9..7009dd4c1a76f 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -40,11 +40,12 @@ #![feature(slicing_syntax)] -use std::io; -use std::io::{BufferedWriter, File}; use std::cmp::min; +use std::io::{BufferedWriter, File}; +use std::io; use std::num::Float; use std::os; +use std::str::from_str; const LINE_LENGTH: uint = 60; const IM: u32 = 139968; diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs index 10c0d0a8044cb..cbacf415f6f7f 100644 --- a/src/test/bench/shootout-fibo.rs +++ b/src/test/bench/shootout-fibo.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::os; +use std::str::from_str; fn fib(n: int) -> int { if n < 2 { diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index f49b648e21579..b59eef916dc09 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -18,12 +18,15 @@ extern crate collections; use std::ascii::{AsciiExt, OwnedAsciiExt}; +use std::cmp::Ordering::{mod, Less, Greater, Equal}; use std::collections::HashMap; +use std::comm::{channel, Sender, Receiver}; use std::mem::replace; use std::num::Float; use std::option; use std::os; -use std::string::String; +use std::string::IntoString; +use std::thread::Thread; fn f64_cmp(x: f64, y: f64) -> Ordering { // arbitrarily decide that NaNs are larger than everything. @@ -167,9 +170,9 @@ fn main() { let (to_child, from_parent) = channel(); - spawn(move|| { + Thread::spawn(move|| { make_sequence_processor(sz, &from_parent, &to_parent_); - }); + }).detach(); to_child }).collect:: >> >(); diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index a0ef392ed3af2..3dc5180591712 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -43,7 +43,6 @@ #![feature(slicing_syntax)] use std::ascii::OwnedAsciiExt; -use std::string::String; use std::slice; use std::sync::{Arc, Future}; diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index bb0e09370d8e9..51ce4cbaa841d 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -47,6 +47,7 @@ use std::io; use std::os; use std::simd::f64x2; +use std::str::from_str; use std::sync::{Arc, Future}; const ITER: int = 50; diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs index 9a3b6953062b4..2e229a50d16ef 100644 --- a/src/test/bench/shootout-meteor.rs +++ b/src/test/bench/shootout-meteor.rs @@ -40,7 +40,9 @@ // no-pretty-expanded FIXME #15189 +use std::comm::channel; use std::sync::Arc; +use std::thread::Thread; // // Utilities. @@ -310,11 +312,11 @@ fn par_search(masks: Vec>>) -> Data { let masks = masks.clone(); let tx = tx.clone(); let m = *m; - spawn(move|| { + Thread::spawn(move|| { let mut data = Data::new(); search(&*masks, m, 1, List::Cons(m, &List::Nil), &mut data); tx.send(data); - }); + }).detach(); } // collecting the results diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index dab67331120a9..6a325798f5805 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -39,6 +39,7 @@ // OF THE POSSIBILITY OF SUCH DAMAGE. use std::num::Float; +use std::str::from_str; const PI: f64 = 3.141592653589793; const SOLAR_MASS: f64 = 4.0 * PI * PI; diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index f7e8fc8fe1b7a..e58303a724adb 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -20,8 +20,10 @@ extern crate getopts; +use std::comm::{channel, Sender}; use std::os; use std::result::Result::{Ok, Err}; +use std::str::from_str; use std::thread::Thread; use std::time::Duration; diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs index 909f8afc34a9f..d9dfd65d5b34b 100644 --- a/src/test/bench/shootout-reverse-complement.rs +++ b/src/test/bench/shootout-reverse-complement.rs @@ -45,9 +45,10 @@ extern crate libc; use std::io::stdio::{stdin_raw, stdout_raw}; +use std::io::{IoResult, EndOfFile}; use std::num::{div_rem}; use std::ptr::{copy_memory, Unique}; -use std::io::{IoResult, EndOfFile}; +use std::thread::Thread; struct Tables { table8: [u8;1 << 8], @@ -229,26 +230,20 @@ unsafe impl Send for Racy {} fn parallel<'a, I, T, F>(mut iter: I, f: F) where T: 'a+Send + Sync, I: Iterator<&'a mut [T]>, - F: Fn(&'a mut [T]) + Sync { + F: Fn(&mut [T]) + Sync { use std::mem; use std::raw::Repr; - let (tx, rx) = channel(); - for chunk in iter { - let tx = tx.clone(); - + iter.map(|chunk| { // Need to convert `f` and `chunk` to something that can cross the task // boundary. let f = Racy(&f as *const F as *const uint); let raw = Racy(chunk.repr()); - spawn(move|| { + Thread::spawn(move|| { let f = f.0 as *const F; unsafe { (*f)(mem::transmute(raw.0)) } - drop(tx) - }); - } - drop(tx); - for () in rx.iter() {} + }) + }).collect::>(); } fn main() { diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index df388fbdde54f..a5af1227a165d 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -44,11 +44,13 @@ #![feature(unboxed_closures)] use std::iter::AdditiveIterator; +use std::thread::Thread; use std::mem; use std::num::Float; use std::os; use std::raw::Repr; use std::simd::f64x2; +use std::str::from_str; fn main() { let args = os::args(); @@ -80,14 +82,15 @@ fn mult_AtAv(v: &[f64], out: &mut [f64], tmp: &mut [f64]) { } fn mult_Av(v: &[f64], out: &mut [f64]) { - parallel(out, |&: start, out| mult(v, out, start, |i, j| A(i, j))); + parallel(out, |start, out| mult(v, out, start, |i, j| A(i, j))); } fn mult_Atv(v: &[f64], out: &mut [f64]) { - parallel(out, |&: start, out| mult(v, out, start, |i, j| A(j, i))); + parallel(out, |start, out| mult(v, out, start, |i, j| A(j, i))); } -fn mult(v: &[f64], out: &mut [f64], start: uint, a: |uint, uint| -> f64) { +fn mult(v: &[f64], out: &mut [f64], start: uint, a: F) + where F: Fn(uint, uint) -> f64 { for (i, slot) in out.iter_mut().enumerate().map(|(i, s)| (i + start, s)) { let mut sum = f64x2(0.0, 0.0); for (j, chunk) in v.chunks(2).enumerate().map(|(j, s)| (2 * j, s)) { @@ -116,25 +119,19 @@ unsafe impl Send for Racy {} // Executes a closure in parallel over the given mutable slice. The closure `f` // is run in parallel and yielded the starting index within `v` as well as a // sub-slice of `v`. -fn parallel<'a, T, F>(v: &'a mut [T], f: F) - where T: Send + Sync, - F: Fn(uint, &'a mut [T]) + Sync { - let (tx, rx) = channel(); +fn parallel(v: &mut [T], f: F) + where T: Send + Sync, + F: Fn(uint, &mut [T]) + Sync { let size = v.len() / os::num_cpus() + 1; - for (i, chunk) in v.chunks_mut(size).enumerate() { - let tx = tx.clone(); - + v.chunks_mut(size).enumerate().map(|(i, chunk)| { // Need to convert `f` and `chunk` to something that can cross the task // boundary. let f = Racy(&f as *const _ as *const uint); let raw = Racy(chunk.repr()); - spawn(move|| { + Thread::spawn(move|| { let f = f.0 as *const F; unsafe { (*f)(i * size, mem::transmute(raw.0)) } - drop(tx) - }); - } - drop(tx); - for () in rx.iter() {} + }) + }).collect::>(); } diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs index 111a92b083aa3..94d958ea8d524 100644 --- a/src/test/bench/shootout-threadring.rs +++ b/src/test/bench/shootout-threadring.rs @@ -38,15 +38,19 @@ // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED // OF THE POSSIBILITY OF SUCH DAMAGE. +use std::comm::{channel, Sender, Receiver}; +use std::str::from_str; +use std::thread::Thread; + fn start(n_tasks: int, token: int) { let (tx, mut rx) = channel(); tx.send(token); for i in range(2, n_tasks + 1) { let (tx, next_rx) = channel(); - spawn(move|| roundtrip(i, tx, rx)); + Thread::spawn(move|| roundtrip(i, tx, rx)).detach(); rx = next_rx; } - spawn(move|| roundtrip(1, tx, rx)); + Thread::spawn(move|| roundtrip(1, tx, rx)).detach(); } fn roundtrip(id: int, tx: Sender, rx: Receiver) { diff --git a/src/test/bench/spawnone.rs b/src/test/bench/spawnone.rs deleted file mode 100644 index ca36d99014cf4..0000000000000 --- a/src/test/bench/spawnone.rs +++ /dev/null @@ -1,14 +0,0 @@ -// 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// Useful for checking syscall usage of baseline scheduler usage -fn main() { - spawn(move|| {}); -} diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index 576d96ba2a355..035b222e6ce62 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -12,6 +12,7 @@ use std::collections::VecMap; use std::os; +use std::str::from_str; use std::time::Duration; use std::uint; diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index 5fb7e2c3a8498..cccc9362a729b 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -12,11 +12,12 @@ #![allow(non_snake_case)] -use std::io; -use std::io::stdio::StdReader; use std::io::BufferedReader; +use std::io::stdio::StdReader; +use std::io; use std::num::Int; use std::os; +use std::str::from_str; // Computes a single solution to a given 9x9 sudoku // diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs index 789ccb6142a11..287b3fc6c460d 100644 --- a/src/test/bench/task-perf-jargon-metal-smoke.rs +++ b/src/test/bench/task-perf-jargon-metal-smoke.rs @@ -17,16 +17,18 @@ // ignore-pretty very bad with line comments -use std::comm; +use std::comm::{mod, channel}; use std::os; +use std::str::from_str; use std::task; +use std::thread::Thread; use std::uint; fn child_generation(gens_left: uint, tx: comm::Sender<()>) { // This used to be O(n^2) in the number of generations that ever existed. // With this code, only as many generations are alive at a time as tasks // alive at a time, - spawn(move|| { + Thread::spawn(move|| { if gens_left & 1 == 1 { task::deschedule(); // shake things up a bit } @@ -35,7 +37,7 @@ fn child_generation(gens_left: uint, tx: comm::Sender<()>) { } else { tx.send(()) } - }); + }).detach(); } fn main() { diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs index a6852d396d9cf..7e2c6fcf0ecd4 100644 --- a/src/test/bench/task-perf-spawnalot.rs +++ b/src/test/bench/task-perf-spawnalot.rs @@ -11,6 +11,7 @@ use std::os; use std::task; use std::uint; +use std::str::from_str; fn f(n: uint) { let mut i = 0u; 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 18534db0dd5a0..90d5072f412e7 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::channel; + fn main() { let (tx, rx) = channel(); let x = Some(rx); diff --git a/src/test/compile-fail/binop-consume-args.rs b/src/test/compile-fail/binop-consume-args.rs index 2bdd148b99bd0..afa255be699e7 100644 --- a/src/test/compile-fail/binop-consume-args.rs +++ b/src/test/compile-fail/binop-consume-args.rs @@ -10,6 +10,8 @@ // Test that binary operators consume their arguments +use std::ops::{Add, Sub, Mul, Div, Rem, BitAnd, BitXor, BitOr, Shl, Shr}; + fn add, B>(lhs: A, rhs: B) { lhs + rhs; drop(lhs); //~ ERROR use of moved value: `lhs` diff --git a/src/test/compile-fail/binop-move-semantics.rs b/src/test/compile-fail/binop-move-semantics.rs index d9440e1837572..e48c88a49f0bf 100644 --- a/src/test/compile-fail/binop-move-semantics.rs +++ b/src/test/compile-fail/binop-move-semantics.rs @@ -10,6 +10,8 @@ // Test that move restrictions are enforced on overloaded binary operations +use std::ops::Add; + fn double_move>(x: T) { x + diff --git a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs index 692303fc1e481..af9a18acbf2ad 100644 --- a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs +++ b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::Add; #[deriving(Clone)] struct foo(Box); 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 b83e1544c96d3..b571af2425a5c 100644 --- a/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs +++ b/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::Add; + #[deriving(Copy)] struct Point { x: int, diff --git a/src/test/compile-fail/borrowck-overloaded-index-2.rs b/src/test/compile-fail/borrowck-overloaded-index-2.rs index d9d7a43d46c41..01afe405d5e12 100644 --- a/src/test/compile-fail/borrowck-overloaded-index-2.rs +++ b/src/test/compile-fail/borrowck-overloaded-index-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::Index; + struct MyVec { data: Vec, } diff --git a/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs b/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs index 2253d7512c053..e8949d4b30bef 100644 --- a/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs +++ b/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs @@ -11,6 +11,8 @@ // Test that we still see borrowck errors of various kinds when using // indexing and autoderef in combination. +use std::ops::{Index, IndexMut}; + struct Foo { x: int, y: int, diff --git a/src/test/compile-fail/borrowck-overloaded-index.rs b/src/test/compile-fail/borrowck-overloaded-index.rs index 0422f6381dc3d..933d0f15e4e70 100644 --- a/src/test/compile-fail/borrowck-overloaded-index.rs +++ b/src/test/compile-fail/borrowck-overloaded-index.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::{Index, IndexMut}; + struct Foo { x: int, y: int, diff --git a/src/test/compile-fail/builtin-superkinds-self-type.rs b/src/test/compile-fail/builtin-superkinds-self-type.rs index 4c7ff60fbdd0f..6228b92472924 100644 --- a/src/test/compile-fail/builtin-superkinds-self-type.rs +++ b/src/test/compile-fail/builtin-superkinds-self-type.rs @@ -11,6 +11,8 @@ // Tests (negatively) the ability for the Self type in default methods // to use capabilities granted by builtin kinds as supertraits. +use std::comm::{channel, Sender}; + trait Foo : Sync+'static { fn foo(self, mut chan: Sender) { } } diff --git a/src/test/compile-fail/comm-not-freeze-receiver.rs b/src/test/compile-fail/comm-not-freeze-receiver.rs index 8cb4b6328c490..83e329db0da2e 100644 --- a/src/test/compile-fail/comm-not-freeze-receiver.rs +++ b/src/test/compile-fail/comm-not-freeze-receiver.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::Receiver; + fn test() {} fn main() { diff --git a/src/test/compile-fail/comm-not-freeze.rs b/src/test/compile-fail/comm-not-freeze.rs index 8c17895eb8a02..296b4187a1f53 100644 --- a/src/test/compile-fail/comm-not-freeze.rs +++ b/src/test/compile-fail/comm-not-freeze.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::Sender; + fn test() {} fn main() { diff --git a/src/test/compile-fail/issue-12041.rs b/src/test/compile-fail/issue-12041.rs index 1878b5f5dea8d..f42e1a1bc15ed 100644 --- a/src/test/compile-fail/issue-12041.rs +++ b/src/test/compile-fail/issue-12041.rs @@ -8,9 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::channel; +use std::thread::Thread; + fn main() { let (tx, rx) = channel(); - spawn(move|| { + let _t = Thread::spawn(move|| -> () { loop { let tx = tx; //~^ ERROR: use of moved value: `tx` diff --git a/src/test/compile-fail/issue-16709.rs b/src/test/compile-fail/issue-16709.rs index fc15801eb75b9..327f50ee059f9 100644 --- a/src/test/compile-fail/issue-16709.rs +++ b/src/test/compile-fail/issue-16709.rs @@ -11,6 +11,8 @@ use std::ptr; use std::raw; +trait Slice {} + fn main() { unsafe { let nil: *const u8 = ptr::null(); diff --git a/src/test/compile-fail/issue-18566.rs b/src/test/compile-fail/issue-18566.rs index f64d8fee2d8b3..c2e4629e14de0 100644 --- a/src/test/compile-fail/issue-18566.rs +++ b/src/test/compile-fail/issue-18566.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::Deref; + struct MyPtr<'a>(&'a mut uint); impl<'a> Deref for MyPtr<'a> { fn deref<'b>(&'b self) -> &'b uint { self.0 } diff --git a/src/test/compile-fail/issue-3702-2.rs b/src/test/compile-fail/issue-3702-2.rs index 54100d543dda0..1e80fd7a7e910 100644 --- a/src/test/compile-fail/issue-3702-2.rs +++ b/src/test/compile-fail/issue-3702-2.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::num::ToPrimitive; + trait Add { fn to_int(&self) -> int; fn add_dynamic(&self, other: &Add) -> int; diff --git a/src/test/compile-fail/unop-move-semantics.rs b/src/test/compile-fail/unop-move-semantics.rs index ccdc7b833e714..c458c539c0766 100644 --- a/src/test/compile-fail/unop-move-semantics.rs +++ b/src/test/compile-fail/unop-move-semantics.rs @@ -10,6 +10,8 @@ // Test that move restrictions are enforced on overloaded unary operations +use std::ops::Not; + fn move_then_borrow + Clone>(x: T) { !x; diff --git a/src/test/compile-fail/unsendable-class.rs b/src/test/compile-fail/unsendable-class.rs index cd5918e2f47ff..312f26394b24d 100644 --- a/src/test/compile-fail/unsendable-class.rs +++ b/src/test/compile-fail/unsendable-class.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::channel; // Test that a class with an unsendable field can't be // sent diff --git a/src/test/compile-fail/wrong-mul-method-signature.rs b/src/test/compile-fail/wrong-mul-method-signature.rs index b5e4cac75550f..bde5b853078f2 100644 --- a/src/test/compile-fail/wrong-mul-method-signature.rs +++ b/src/test/compile-fail/wrong-mul-method-signature.rs @@ -13,6 +13,8 @@ // (In this case the mul method should take &f64 and not f64) // See: #11450 +use std::ops::Mul; + struct Vec1 { x: f64 } diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp index c2ebd764ad6b9..35bd22880cef7 100644 --- a/src/test/pretty/issue-4264.pp +++ b/src/test/pretty/issue-4264.pp @@ -4,7 +4,7 @@ #[phase(plugin, link)] extern crate "std" as std; #[prelude_import] -use std::prelude::*; +use std::prelude::v1::*; // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. diff --git a/src/test/run-pass/bool.rs b/src/test/run-pass/bool.rs index 238d0ecdca7f8..b3c4802530ed3 100644 --- a/src/test/run-pass/bool.rs +++ b/src/test/run-pass/bool.rs @@ -10,6 +10,9 @@ // Basic boolean tests +use std::cmp::Ordering::{Equal, Greater, Less}; +use std::ops::{BitAnd, BitOr, BitXor}; + fn main() { assert_eq!(false.eq(&true), false); assert_eq!(false == false, true); diff --git a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs index 2abc58d8a4954..83c1696f7b2ab 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs @@ -14,6 +14,8 @@ // a Send. Basically this just makes sure rustc is using // each_bound_trait_and_supertraits in type_contents correctly. +use std::comm::{channel, Sender}; + trait Bar : Send { } trait Foo : Bar { } diff --git a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs index c2b874c61a77f..1f002ec79c61e 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs @@ -15,6 +15,8 @@ // even when using them cross-crate. extern crate trait_superkinds_in_metadata; + +use std::comm::{channel, Sender, Receiver}; use trait_superkinds_in_metadata::{RequiresRequiresShareAndSend, RequiresShare}; #[deriving(PartialEq)] diff --git a/src/test/run-pass/builtin-superkinds-capabilities.rs b/src/test/run-pass/builtin-superkinds-capabilities.rs index fb3e1b0272858..46ad3f93b0bb7 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities.rs @@ -12,6 +12,8 @@ // builtin-kinds, e.g., if a trait requires Send to implement, then // at usage site of that trait, we know we have the Send capability. +use std::comm::{channel, Sender, Receiver}; + trait Foo : Send { } impl Foo for T { } diff --git a/src/test/run-pass/builtin-superkinds-self-type.rs b/src/test/run-pass/builtin-superkinds-self-type.rs index 1c156f6551c8d..27a7cd909fefe 100644 --- a/src/test/run-pass/builtin-superkinds-self-type.rs +++ b/src/test/run-pass/builtin-superkinds-self-type.rs @@ -11,6 +11,8 @@ // Tests the ability for the Self type in default methods to use // capabilities granted by builtin kinds as supertraits. +use std::comm::{Sender, channel}; + trait Foo : Send { fn foo(self, tx: Sender) { tx.send(self); diff --git a/src/test/run-pass/c-stack-returning-int64.rs b/src/test/run-pass/c-stack-returning-int64.rs index 597e067b8b6ae..c95cf0bfdee45 100644 --- a/src/test/run-pass/c-stack-returning-int64.rs +++ b/src/test/run-pass/c-stack-returning-int64.rs @@ -12,6 +12,8 @@ extern crate libc; +use std::c_str::ToCStr; + mod mlibc { use libc::{c_char, c_long, c_longlong}; diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs index f2df5ef38c382..4ed444f92ac92 100644 --- a/src/test/run-pass/capturing-logging.rs +++ b/src/test/run-pass/capturing-logging.rs @@ -17,8 +17,10 @@ extern crate log; use log::{set_logger, Logger, LogRecord}; +use std::comm::channel; use std::fmt; use std::io::{ChanReader, ChanWriter}; +use std::thread::Thread; struct MyWriter(ChanWriter); @@ -32,7 +34,7 @@ impl Logger for MyWriter { fn main() { let (tx, rx) = channel(); let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx)); - spawn(move|| { + let _t = Thread::spawn(move|| { set_logger(box MyWriter(w) as Box); debug!("debug"); info!("info"); diff --git a/src/test/run-pass/closure-bounds-can-capture-chan.rs b/src/test/run-pass/closure-bounds-can-capture-chan.rs index cdcdad47ea497..e1dc5802162eb 100644 --- a/src/test/run-pass/closure-bounds-can-capture-chan.rs +++ b/src/test/run-pass/closure-bounds-can-capture-chan.rs @@ -10,7 +10,7 @@ #![feature(unboxed_closures)] -use std::comm; +use std::comm::channel; fn foo(blk: F) { blk(); diff --git a/src/test/run-pass/cmp-default.rs b/src/test/run-pass/cmp-default.rs index cfba87c3f6994..fd040d109108f 100644 --- a/src/test/run-pass/cmp-default.rs +++ b/src/test/run-pass/cmp-default.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::cmp::Ordering; + // Test default methods in PartialOrd and PartialEq // struct Fool(bool); diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index edd4d5642b5bf..119bdaff98ee8 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::task; +use std::comm::{channel, Sender}; pub fn main() { let (tx, rx) = channel(); diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs index d6f0296619ab4..e0e8ca5618e50 100644 --- a/src/test/run-pass/const-str-ptr.rs +++ b/src/test/run-pass/const-str-ptr.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::{str, string}; +use std::c_str::ToCStr; const A: [u8; 2] = ['h' as u8, 'i' as u8]; const B: &'static [u8; 2] = &A; diff --git a/src/test/run-pass/core-run-destroy.rs b/src/test/run-pass/core-run-destroy.rs index a0fa2d178b949..198915fe02ed8 100644 --- a/src/test/run-pass/core-run-destroy.rs +++ b/src/test/run-pass/core-run-destroy.rs @@ -23,6 +23,8 @@ extern crate libc; use std::io::{Process, Command, timer}; use std::time::Duration; use std::str; +use std::comm::channel; +use std::thread::Thread; macro_rules! succeed( ($e:expr) => ( match $e { Ok(..) => {}, Err(e) => panic!("panic: {}", e) } @@ -84,12 +86,12 @@ pub fn test_destroy_actually_kills(force: bool) { let (tx, rx1) = channel(); let mut t = timer::Timer::new().unwrap(); let rx2 = t.oneshot(Duration::milliseconds(1000)); - spawn(move|| { + Thread::spawn(move|| { select! { () = rx2.recv() => unsafe { libc::exit(1) }, () = rx1.recv() => {} } - }); + }).detach(); match p.wait().unwrap() { ExitStatus(..) => panic!("expected a signal"), ExitSignal(..) => tx.send(()), diff --git a/src/test/run-pass/deref-mut-on-ref.rs b/src/test/run-pass/deref-mut-on-ref.rs index dcf7c483b2cdc..5a98952c127d8 100644 --- a/src/test/run-pass/deref-mut-on-ref.rs +++ b/src/test/run-pass/deref-mut-on-ref.rs @@ -10,6 +10,8 @@ // Test that `&mut T` implements `DerefMut` +use std::ops::DerefMut; + fn inc>(mut t: T) { *t += 1; } diff --git a/src/test/run-pass/deref-on-ref.rs b/src/test/run-pass/deref-on-ref.rs index 27e7d8f3ba2a4..f245c11f0904b 100644 --- a/src/test/run-pass/deref-on-ref.rs +++ b/src/test/run-pass/deref-on-ref.rs @@ -10,6 +10,8 @@ // Test that `&T` and `&mut T` implement `Deref` +use std::ops::Deref; + fn deref>(t: T) -> U { *t } diff --git a/src/test/run-pass/deriving-cmp-shortcircuit.rs b/src/test/run-pass/deriving-cmp-shortcircuit.rs index b68d8058381d2..fb81dd558d2c4 100644 --- a/src/test/run-pass/deriving-cmp-shortcircuit.rs +++ b/src/test/run-pass/deriving-cmp-shortcircuit.rs @@ -12,6 +12,8 @@ // where possible, by having a type that panics when compared as the // second element, so this passes iff the instances shortcircuit. +use std::cmp::Ordering; + pub struct FailCmp; impl PartialEq for FailCmp { fn eq(&self, _: &FailCmp) -> bool { panic!("eq") } diff --git a/src/test/run-pass/deriving-zero.rs b/src/test/run-pass/deriving-zero.rs index 88f3e5775b78b..b8903d05cd899 100644 --- a/src/test/run-pass/deriving-zero.rs +++ b/src/test/run-pass/deriving-zero.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +use std::ops::Add; use std::num::Zero; #[deriving(Zero)] diff --git a/src/test/run-pass/drop-trait-enum.rs b/src/test/run-pass/drop-trait-enum.rs index 24915d84e7eb1..bca61ab1bd387 100644 --- a/src/test/run-pass/drop-trait-enum.rs +++ b/src/test/run-pass/drop-trait-enum.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::task; +use std::comm::{channel, Sender}; #[deriving(PartialEq, Show)] enum Message { diff --git a/src/test/run-pass/dst-deref-mut.rs b/src/test/run-pass/dst-deref-mut.rs index c2707a1ae6e90..0cbcee3e253e1 100644 --- a/src/test/run-pass/dst-deref-mut.rs +++ b/src/test/run-pass/dst-deref-mut.rs @@ -10,6 +10,8 @@ // Test that a custom deref with a fat pointer return type does not ICE +use std::ops::{Deref, DerefMut}; + pub struct Arr { ptr: Box<[uint]> } diff --git a/src/test/run-pass/dst-deref.rs b/src/test/run-pass/dst-deref.rs index 43b7d116d3038..96a9c117dea46 100644 --- a/src/test/run-pass/dst-deref.rs +++ b/src/test/run-pass/dst-deref.rs @@ -10,6 +10,8 @@ // Test that a custom deref with a fat pointer return type does not ICE +use std::ops::Deref; + pub struct Arr { ptr: Box<[uint]> } diff --git a/src/test/run-pass/fixup-deref-mut.rs b/src/test/run-pass/fixup-deref-mut.rs index d2812ce1d2ce9..70d14ba362323 100644 --- a/src/test/run-pass/fixup-deref-mut.rs +++ b/src/test/run-pass/fixup-deref-mut.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::{Deref, DerefMut}; + // Generic unique/owned smaht pointer. struct Own { value: *mut T diff --git a/src/test/run-pass/foreign-fn-linkname.rs b/src/test/run-pass/foreign-fn-linkname.rs index 750c0c8ed682a..8a75fdd685dd1 100644 --- a/src/test/run-pass/foreign-fn-linkname.rs +++ b/src/test/run-pass/foreign-fn-linkname.rs @@ -11,10 +11,10 @@ // ignore-fast doesn't like extern crate extern crate libc; +use std::c_str::ToCStr; mod mlibc { - extern crate libc; - use self::libc::{c_char, size_t}; + use libc::{c_char, size_t}; extern { #[link_name = "strlen"] diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index a92b361dd3355..6155ca6357237 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -9,9 +9,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - -extern crate collections; - /** A somewhat reduced test case to expose some Valgrind issues. @@ -24,6 +21,7 @@ pub fn map(filename: String, emit: map_reduce::putter) { mod map_reduce { use std::collections::HashMap; + use std::comm::{channel, Sender}; use std::str; use std::task; diff --git a/src/test/run-pass/issue-13264.rs b/src/test/run-pass/issue-13264.rs index 06ab67f2f3e97..33377d1f21726 100644 --- a/src/test/run-pass/issue-13264.rs +++ b/src/test/run-pass/issue-13264.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::Deref; + struct Root { jsref: JSRef } diff --git a/src/test/run-pass/issue-13494.rs b/src/test/run-pass/issue-13494.rs index be851ddefc645..e6da859c110e7 100644 --- a/src/test/run-pass/issue-13494.rs +++ b/src/test/run-pass/issue-13494.rs @@ -11,6 +11,9 @@ // This test may not always fail, but it can be flaky if the race it used to // expose is still present. +use std::comm::{channel, Sender, Receiver}; +use std::thread::Thread; + fn helper(rx: Receiver>) { for tx in rx.iter() { let _ = tx.send_opt(()); @@ -19,7 +22,7 @@ fn helper(rx: Receiver>) { fn main() { let (tx, rx) = channel(); - spawn(move|| { helper(rx) }); + let _t = Thread::spawn(move|| { helper(rx) }).detach(); let (snd, rcv) = channel::(); for _ in range(1i, 100000i) { snd.send(1i); diff --git a/src/test/run-pass/issue-15734.rs b/src/test/run-pass/issue-15734.rs index ea5bd550d53da..8aa7447ccd2e9 100644 --- a/src/test/run-pass/issue-15734.rs +++ b/src/test/run-pass/issue-15734.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::Index; + struct Mat { data: Vec, cols: uint, } impl Mat { diff --git a/src/test/run-pass/issue-16560.rs b/src/test/run-pass/issue-16560.rs index f329e7eed0d5d..b2b819a110305 100644 --- a/src/test/run-pass/issue-16560.rs +++ b/src/test/run-pass/issue-16560.rs @@ -10,6 +10,7 @@ #![feature(unboxed_closures)] +use std::thread::Thread; use std::mem; fn main() { @@ -19,7 +20,7 @@ fn main() { // Check that both closures are capturing by value assert_eq!(1, mem::size_of_val(&closure)); - spawn(move|| { + Thread::spawn(move|| { let ok = closure; - }) + }).join().ok().unwrap(); } diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs index ebc879d82fbb1..0b9a85851c591 100644 --- a/src/test/run-pass/issue-16774.rs +++ b/src/test/run-pass/issue-16774.rs @@ -10,6 +10,8 @@ #![feature(unboxed_closures)] +use std::ops::{Deref, DerefMut}; + struct X(Box); static mut DESTRUCTOR_RAN: bool = false; diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs index f17f9411d15e8..df2a9e6bfa909 100644 --- a/src/test/run-pass/issue-3609.rs +++ b/src/test/run-pass/issue-3609.rs @@ -11,6 +11,7 @@ #![feature(default_type_params)] use std::task; +use std::comm::Sender; use std::thunk::Invoke; type RingBuffer = Vec ; diff --git a/src/test/run-pass/issue-3743.rs b/src/test/run-pass/issue-3743.rs index 80d3d29bc004d..c88022f3eb706 100644 --- a/src/test/run-pass/issue-3743.rs +++ b/src/test/run-pass/issue-3743.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::Mul; + struct Vec2 { x: f64, y: f64 diff --git a/src/test/run-pass/issue-3979-generics.rs b/src/test/run-pass/issue-3979-generics.rs index 86cdd6135ecf2..93c72e2e35091 100644 --- a/src/test/run-pass/issue-3979-generics.rs +++ b/src/test/run-pass/issue-3979-generics.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::Add; + trait Positioned { fn SetX(&mut self, S); fn X(&self) -> S; diff --git a/src/test/run-pass/issue-4446.rs b/src/test/run-pass/issue-4446.rs index daa80aec28c04..871e52e363954 100644 --- a/src/test/run-pass/issue-4446.rs +++ b/src/test/run-pass/issue-4446.rs @@ -9,13 +9,15 @@ // except according to those terms. use std::io::println; +use std::comm::channel; +use std::thread::Thread; pub fn main() { let (tx, rx) = channel(); tx.send("hello, world"); - spawn(move|| { + Thread::spawn(move|| { println(rx.recv()); - }); + }).join().ok().unwrap(); } diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs index 3ea968c416f45..6692988f6da29 100644 --- a/src/test/run-pass/issue-4448.rs +++ b/src/test/run-pass/issue-4448.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::task; +use std::comm::channel; pub fn main() { let (tx, rx) = channel::<&'static str>(); diff --git a/src/test/run-pass/issue-7784.rs b/src/test/run-pass/issue-7784.rs index b936eb322fc5f..43785edc2eb03 100644 --- a/src/test/run-pass/issue-7784.rs +++ b/src/test/run-pass/issue-7784.rs @@ -10,6 +10,8 @@ #![feature(advanced_slice_patterns)] +use std::ops::Add; + fn foo + Clone>([x, y, z]: [T; 3]) -> (T, T, T) { (x.clone(), x.clone() + y.clone(), x + y + z) } diff --git a/src/test/run-pass/issue-8827.rs b/src/test/run-pass/issue-8827.rs index 7397ad744950e..4163ebf4573fc 100644 --- a/src/test/run-pass/issue-8827.rs +++ b/src/test/run-pass/issue-8827.rs @@ -8,9 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::thread::Thread; +use std::comm::{channel, Receiver}; + fn periodical(n: int) -> Receiver { let (chan, port) = channel(); - spawn(move|| { + Thread::spawn(move|| { loop { for _ in range(1, n) { match chan.send_opt(false) { @@ -23,13 +26,13 @@ fn periodical(n: int) -> Receiver { Err(..) => break } } - }); + }).detach(); return port; } fn integers() -> Receiver { let (chan, port) = channel(); - spawn(move|| { + Thread::spawn(move|| { let mut i = 1; loop { match chan.send_opt(i) { @@ -38,7 +41,7 @@ fn integers() -> Receiver { } i = i + 1; } - }); + }).detach(); return port; } diff --git a/src/test/run-pass/issue-9396.rs b/src/test/run-pass/issue-9396.rs index 588e0c1cf16cf..d3cbd55677640 100644 --- a/src/test/run-pass/issue-9396.rs +++ b/src/test/run-pass/issue-9396.rs @@ -8,13 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::comm; +use std::comm::{mod, channel}; use std::io::timer::Timer; +use std::thread::Thread; use std::time::Duration; pub fn main() { let (tx, rx) = channel(); - spawn(move||{ + let _t = Thread::spawn(move||{ let mut timer = Timer::new().unwrap(); timer.sleep(Duration::milliseconds(10)); tx.send(()); diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs index 1f7edcf43b887..2e6127541a1a1 100644 --- a/src/test/run-pass/ivec-tag.rs +++ b/src/test/run-pass/ivec-tag.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::task; +use std::comm::{channel, Sender}; fn producer(tx: &Sender>) { tx.send( diff --git a/src/test/run-pass/logging-only-prints-once.rs b/src/test/run-pass/logging-only-prints-once.rs index 1e05c05cc0dd1..509afff3d133b 100644 --- a/src/test/run-pass/logging-only-prints-once.rs +++ b/src/test/run-pass/logging-only-prints-once.rs @@ -13,6 +13,7 @@ use std::cell::Cell; use std::fmt; +use std::thread::Thread; struct Foo(Cell); @@ -26,13 +27,10 @@ impl fmt::Show for Foo { } pub fn main() { - let (tx, rx) = channel(); - spawn(move|| { + Thread::spawn(move|| { let mut f = Foo(Cell::new(0)); println!("{}", f); let Foo(ref mut f) = f; assert!(f.get() == 1); - tx.send(()); - }); - rx.recv(); + }).join().ok().unwrap(); } diff --git a/src/test/run-pass/macro-with-braces-in-expr-position.rs b/src/test/run-pass/macro-with-braces-in-expr-position.rs index 024dc4c03e1b7..a6e579ddff304 100644 --- a/src/test/run-pass/macro-with-braces-in-expr-position.rs +++ b/src/test/run-pass/macro-with-braces-in-expr-position.rs @@ -10,11 +10,13 @@ #![feature(macro_rules)] +use std::thread::Thread; + macro_rules! expr (($e: expr) => { $e }); macro_rules! spawn { ($($code: tt)*) => { - expr!(spawn(move|| {$($code)*})) + expr!(Thread::spawn(move|| {$($code)*}).detach()) } } diff --git a/src/test/run-pass/match-with-ret-arm.rs b/src/test/run-pass/match-with-ret-arm.rs index 2109f7ef1eafc..2cba1dec2dc99 100644 --- a/src/test/run-pass/match-with-ret-arm.rs +++ b/src/test/run-pass/match-with-ret-arm.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::uint; +use std::str::from_str; pub fn main() { // sometimes we have had trouble finding diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs index f8184d248ff01..b4d079d79d650 100644 --- a/src/test/run-pass/numeric-method-autoexport.rs +++ b/src/test/run-pass/numeric-method-autoexport.rs @@ -15,6 +15,9 @@ // necessary. Testing the methods of the impls is done within the source // file for each numeric type. +use std::ops::Add; +use std::num::ToPrimitive; + pub fn main() { // ints // num diff --git a/src/test/run-pass/out-of-stack-new-thread-no-split.rs b/src/test/run-pass/out-of-stack-new-thread-no-split.rs index 674d0dc86da1c..7aac2d705a854 100644 --- a/src/test/run-pass/out-of-stack-new-thread-no-split.rs +++ b/src/test/run-pass/out-of-stack-new-thread-no-split.rs @@ -17,6 +17,7 @@ use std::io::process::Command; use std::os; +use std::thread::Thread; // lifted from the test module // Inlining to avoid llvm turning the recursive functions into tail calls, @@ -36,12 +37,7 @@ fn main() { let args = os::args(); let args = args.as_slice(); if args.len() > 1 && args[1].as_slice() == "recurse" { - let (tx, rx) = channel(); - spawn(move|| { - recurse(); - tx.send(()); - }); - rx.recv(); + let _t = Thread::spawn(recurse); } else { let recurse = Command::new(args[0].as_slice()).arg("recurse").output().unwrap(); assert!(!recurse.status.success()); diff --git a/src/test/run-pass/overloaded-autoderef-indexing.rs b/src/test/run-pass/overloaded-autoderef-indexing.rs index 5c4befcd0c825..d1fb69b87a30e 100644 --- a/src/test/run-pass/overloaded-autoderef-indexing.rs +++ b/src/test/run-pass/overloaded-autoderef-indexing.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::Deref; + struct DerefArray<'a, T:'a> { inner: &'a [T] } diff --git a/src/test/run-pass/overloaded-autoderef-order.rs b/src/test/run-pass/overloaded-autoderef-order.rs index f0daf371ca79e..23a8285063ffb 100644 --- a/src/test/run-pass/overloaded-autoderef-order.rs +++ b/src/test/run-pass/overloaded-autoderef-order.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::rc::Rc; +use std::ops::Deref; struct DerefWrapper { x: X, @@ -30,6 +31,8 @@ impl Deref for DerefWrapper { } mod priv_test { + use std::ops::Deref; + pub struct DerefWrapperHideX { x: X, pub y: Y diff --git a/src/test/run-pass/overloaded-autoderef.rs b/src/test/run-pass/overloaded-autoderef.rs index 2975b209d0690..222e2825c0404 100644 --- a/src/test/run-pass/overloaded-autoderef.rs +++ b/src/test/run-pass/overloaded-autoderef.rs @@ -10,7 +10,7 @@ use std::cell::RefCell; use std::rc::Rc; -use std::string::String; +use std::num::ToPrimitive; #[deriving(PartialEq, Show)] struct Point { @@ -31,7 +31,6 @@ pub fn main() { assert_eq!((i_value, *i.borrow()), (2, 5)); let s = Rc::new("foo".to_string()); - assert!(s.equiv(&("foo"))); assert_eq!(s.as_slice(), "foo"); let mut_s = Rc::new(RefCell::new(String::from_str("foo"))); diff --git a/src/test/run-pass/overloaded-calls-param-vtables.rs b/src/test/run-pass/overloaded-calls-param-vtables.rs index 2e8ec3916bd89..95df1ed0d837e 100644 --- a/src/test/run-pass/overloaded-calls-param-vtables.rs +++ b/src/test/run-pass/overloaded-calls-param-vtables.rs @@ -13,6 +13,7 @@ #![feature(unboxed_closures)] use std::ops::Fn; +use std::ops::Add; struct G; diff --git a/src/test/run-pass/overloaded-index-autoderef.rs b/src/test/run-pass/overloaded-index-autoderef.rs index d51956da89409..dcb0c40c6088a 100644 --- a/src/test/run-pass/overloaded-index-autoderef.rs +++ b/src/test/run-pass/overloaded-index-autoderef.rs @@ -10,6 +10,8 @@ // Test overloaded indexing combined with autoderef. +use std::ops::{Index, IndexMut}; + struct Foo { x: int, y: int, diff --git a/src/test/run-pass/overloaded-index-in-field.rs b/src/test/run-pass/overloaded-index-in-field.rs index e8b0408ca0dc0..1c06ed64fc7b8 100644 --- a/src/test/run-pass/overloaded-index-in-field.rs +++ b/src/test/run-pass/overloaded-index-in-field.rs @@ -11,6 +11,8 @@ // Test using overloaded indexing when the "map" is stored in a // field. This caused problems at some point. +use std::ops::Index; + struct Foo { x: int, y: int, diff --git a/src/test/run-pass/overloaded-index.rs b/src/test/run-pass/overloaded-index.rs index 23bebfa35d7f3..fdf7e7e2cbb13 100644 --- a/src/test/run-pass/overloaded-index.rs +++ b/src/test/run-pass/overloaded-index.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::ops::{Index, IndexMut}; + struct Foo { x: int, y: int, diff --git a/src/test/run-pass/rename-directory.rs b/src/test/run-pass/rename-directory.rs index b5cee20232b63..c7aa405b513e4 100644 --- a/src/test/run-pass/rename-directory.rs +++ b/src/test/run-pass/rename-directory.rs @@ -14,6 +14,7 @@ extern crate libc; use std::io::TempDir; +use std::c_str::ToCStr; use std::io::fs::PathExtensions; use std::io::fs; use std::io; diff --git a/src/test/run-pass/running-with-no-runtime.rs b/src/test/run-pass/running-with-no-runtime.rs index 4cf8c52f2bb44..0aeade935dadb 100644 --- a/src/test/run-pass/running-with-no-runtime.rs +++ b/src/test/run-pass/running-with-no-runtime.rs @@ -10,12 +10,12 @@ use std::io::process::{Command, ProcessOutput}; use std::os; -use std::str; +use std::rt::unwind::try; use std::rt; +use std::str; +use std::thread::Thread; use std::thunk::Thunk; -use std::rt::unwind::try; - #[start] fn start(argc: int, argv: *const *const u8) -> int { if argc > 1 { @@ -25,8 +25,7 @@ fn start(argc: int, argv: *const *const u8) -> int { 2 => println!("foo"), 3 => assert!(try(|| {}).is_ok()), 4 => assert!(try(|| panic!()).is_err()), - 5 => assert!(try(|| spawn(move|| {})).is_err()), - 6 => assert!(Command::new("test").spawn().is_err()), + 5 => assert!(Command::new("test").spawn().is_err()), _ => panic!() } } @@ -50,8 +49,6 @@ fn start(argc: int, argv: *const *const u8) -> int { pass(Command::new(me).arg(x).output().unwrap()); let x: &[u8] = &[5u8]; pass(Command::new(me).arg(x).output().unwrap()); - let x: &[u8] = &[6u8]; - pass(Command::new(me).arg(x).output().unwrap()); 0 } diff --git a/src/test/run-pass/rust-log-filter.rs b/src/test/run-pass/rust-log-filter.rs index 88d30318f2a99..8e547527f7297 100644 --- a/src/test/run-pass/rust-log-filter.rs +++ b/src/test/run-pass/rust-log-filter.rs @@ -14,6 +14,9 @@ #[phase(plugin,link)] extern crate log; +use std::comm::{channel, Sender, Receiver}; +use std::thread::Thread; + pub struct ChannelLogger { tx: Sender } @@ -34,7 +37,7 @@ impl log::Logger for ChannelLogger { pub fn main() { let (logger, rx) = ChannelLogger::new(); - spawn(move|| { + let _t = Thread::spawn(move|| { log::set_logger(logger); // our regex is "f.o" diff --git a/src/test/run-pass/send-resource.rs b/src/test/run-pass/send-resource.rs index 6001c360ab99f..71620d05e014b 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::task; +use std::comm::channel; struct test { f: int, diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs index 508bd99d77d7c..181874705da67 100644 --- a/src/test/run-pass/send-type-inference.rs +++ b/src/test/run-pass/send-type-inference.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::{channel, Sender}; + // tests that ctrl's type gets inferred properly struct Command { key: K, diff --git a/src/test/run-pass/send_str_hashmap.rs b/src/test/run-pass/send_str_hashmap.rs index 1b0f2ec0a327f..bfeff58b802df 100644 --- a/src/test/run-pass/send_str_hashmap.rs +++ b/src/test/run-pass/send_str_hashmap.rs @@ -11,8 +11,8 @@ extern crate collections; use std::collections::HashMap; -use std::option::Option::Some; use std::str::SendStr; +use std::borrow::IntoCow; pub fn main() { let mut map: HashMap = HashMap::new(); diff --git a/src/test/run-pass/send_str_treemap.rs b/src/test/run-pass/send_str_treemap.rs index 24480d8527205..8c70738de48f1 100644 --- a/src/test/run-pass/send_str_treemap.rs +++ b/src/test/run-pass/send_str_treemap.rs @@ -11,9 +11,8 @@ extern crate collections; use self::collections::BTreeMap; -use std::option::Option::Some; use std::str::SendStr; -use std::string::ToString; +use std::borrow::IntoCow; pub fn main() { let mut map: BTreeMap = BTreeMap::new(); diff --git a/src/test/run-pass/sendable-class.rs b/src/test/run-pass/sendable-class.rs index 007a83d2c8878..3d5f0af0e3f40 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::channel; + struct foo { i: int, j: char, diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs index 9b533c69f3209..e3b2a2903bcba 100644 --- a/src/test/run-pass/spawn-types.rs +++ b/src/test/run-pass/spawn-types.rs @@ -15,6 +15,7 @@ */ use std::task; +use std::comm::{channel, Sender}; type ctx = Sender; diff --git a/src/test/run-pass/supertrait-default-generics.rs b/src/test/run-pass/supertrait-default-generics.rs index 873941395fead..4465561f874eb 100644 --- a/src/test/run-pass/supertrait-default-generics.rs +++ b/src/test/run-pass/supertrait-default-generics.rs @@ -10,6 +10,8 @@ // There is some other borrowck bug, so we make the stuff not mut. +use std::ops::Add; + trait Positioned { fn SetX(&mut self, S); fn X(&self) -> S; diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs index 9e3511ba6034f..7c664b21fade5 100644 --- a/src/test/run-pass/task-comm-0.rs +++ b/src/test/run-pass/task-comm-0.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - use std::task; +use std::comm::{channel, Sender}; pub fn main() { test05(); } diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs index dd3c90991f627..c35e2f2f37a40 100644 --- a/src/test/run-pass/task-comm-10.rs +++ b/src/test/run-pass/task-comm-10.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - use std::task; +use std::comm::{channel, Sender}; fn start(tx: &Sender>) { let (tx2, rx) = channel(); diff --git a/src/test/run-pass/task-comm-11.rs b/src/test/run-pass/task-comm-11.rs index aefc91df4e780..10b4e51631176 100644 --- a/src/test/run-pass/task-comm-11.rs +++ b/src/test/run-pass/task-comm-11.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +use std::comm::{channel, Sender}; use std::task; fn start(tx: &Sender>) { diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs index c6c0691b74989..31da1168bf7eb 100644 --- a/src/test/run-pass/task-comm-13.rs +++ b/src/test/run-pass/task-comm-13.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +use std::comm::{channel, Sender}; use std::task; fn start(tx: &Sender, start: int, number_of_messages: int) { diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs index 0e48381366555..8ec589d5db5fc 100644 --- a/src/test/run-pass/task-comm-14.rs +++ b/src/test/run-pass/task-comm-14.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +use std::comm::{channel, Sender}; use std::task; pub fn main() { diff --git a/src/test/run-pass/task-comm-15.rs b/src/test/run-pass/task-comm-15.rs index 3095c2098ff33..b69644244ab4c 100644 --- a/src/test/run-pass/task-comm-15.rs +++ b/src/test/run-pass/task-comm-15.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +use std::comm::{channel, Sender}; use std::task; fn start(tx: &Sender, i0: int) { diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index 9143385254095..5e71ed3ba06eb 100644 --- a/src/test/run-pass/task-comm-16.rs +++ b/src/test/run-pass/task-comm-16.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::channel; use std::cmp; // Tests of ports and channels on various types diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs index 73f6eb563c1ce..c7a6da6a79417 100644 --- a/src/test/run-pass/task-comm-3.rs +++ b/src/test/run-pass/task-comm-3.rs @@ -11,6 +11,7 @@ // no-pretty-expanded FIXME #15189 use std::thread::Thread; +use std::comm::{channel, Sender}; pub fn main() { println!("===== WITHOUT THREADS ====="); test00(); } diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs index 2e2b1fbff0ff7..0e75479046be6 100644 --- a/src/test/run-pass/task-comm-4.rs +++ b/src/test/run-pass/task-comm-4.rs @@ -10,6 +10,8 @@ #![allow(dead_assignment)] +use std::comm::channel; + 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 e51e14f7fbe82..d4edbf85cd833 100644 --- a/src/test/run-pass/task-comm-5.rs +++ b/src/test/run-pass/task-comm-5.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::channel; + 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 e783cd9b6beaf..4c18e5dc31357 100644 --- a/src/test/run-pass/task-comm-6.rs +++ b/src/test/run-pass/task-comm-6.rs @@ -10,6 +10,8 @@ #![allow(dead_assignment)] +use std::comm::channel; + pub fn main() { test00(); } fn test00() { diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs index 9d8caa426269b..e7e5c04e1954e 100644 --- a/src/test/run-pass/task-comm-7.rs +++ b/src/test/run-pass/task-comm-7.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - #![allow(dead_assignment)] +use std::comm::{channel, Sender}; use std::task; pub fn main() { test00(); } diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs index 69d70050437f1..5a271f9dc05fd 100644 --- a/src/test/run-pass/task-comm-9.rs +++ b/src/test/run-pass/task-comm-9.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::thread::Thread; +use std::comm::{channel, Sender}; pub fn main() { test00(); } diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs index 3ea17898eada2..368cac1d27dfa 100644 --- a/src/test/run-pass/task-comm-chan-nil.rs +++ b/src/test/run-pass/task-comm-chan-nil.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::channel; + // 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-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs index 8d6b6005a63ba..1e10a4186fba9 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,7 @@ // except according to those terms. use std::task; +use std::comm::channel; pub fn main() { let (tx, rx) = channel::(); diff --git a/src/test/run-pass/task-stderr.rs b/src/test/run-pass/task-stderr.rs index ddeffcdf72204..048d7b2be7225 100644 --- a/src/test/run-pass/task-stderr.rs +++ b/src/test/run-pass/task-stderr.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::channel; use std::io::{ChanReader, ChanWriter}; use std::thread; diff --git a/src/test/run-pass/tcp-accept-stress.rs b/src/test/run-pass/tcp-accept-stress.rs index 780cf23446639..8f5a45cd1dd8c 100644 --- a/src/test/run-pass/tcp-accept-stress.rs +++ b/src/test/run-pass/tcp-accept-stress.rs @@ -13,8 +13,10 @@ // quite quickly and it takes a few seconds for the sockets to get // recycled. +use std::comm::channel; use std::io::{TcpListener, Listener, Acceptor, EndOfFile, TcpStream}; use std::sync::{atomic, Arc}; +use std::thread::Thread; static N: uint = 8; static M: uint = 20; @@ -35,7 +37,7 @@ fn test() { let a = a.clone(); let cnt = cnt.clone(); let srv_tx = srv_tx.clone(); - spawn(move|| { + Thread::spawn(move|| { let mut a = a; loop { match a.accept() { @@ -49,17 +51,17 @@ fn test() { } } srv_tx.send(()); - }); + }).detach(); } for _ in range(0, N) { let cli_tx = cli_tx.clone(); - spawn(move|| { + Thread::spawn(move|| { for _ in range(0, M) { let _s = TcpStream::connect(addr).unwrap(); } cli_tx.send(()); - }); + }).detach(); } drop((cli_tx, srv_tx)); diff --git a/src/test/run-pass/tcp-connect-timeouts.rs b/src/test/run-pass/tcp-connect-timeouts.rs index 2d087406fd6f7..ea0141a049694 100644 --- a/src/test/run-pass/tcp-connect-timeouts.rs +++ b/src/test/run-pass/tcp-connect-timeouts.rs @@ -26,6 +26,7 @@ use std::io::*; use std::io::test::*; use std::io; use std::time::Duration; +use std::comm::channel; #[cfg_attr(target_os = "freebsd", ignore)] fn eventual_timeout() { diff --git a/src/test/run-pass/tcp-stress.rs b/src/test/run-pass/tcp-stress.rs index b3391669d35d0..7a061f5b99c51 100644 --- a/src/test/run-pass/tcp-stress.rs +++ b/src/test/run-pass/tcp-stress.rs @@ -17,22 +17,23 @@ extern crate log; extern crate libc; +use std::comm::channel; use std::io::net::tcp::{TcpListener, TcpStream}; use std::io::{Acceptor, Listener}; -use std::thread::Builder; +use std::thread::{Builder, Thread}; use std::time::Duration; fn main() { // This test has a chance to time out, try to not let it time out - spawn(move|| { + Thread::spawn(move|| -> () { use std::io::timer; timer::sleep(Duration::milliseconds(30 * 1000)); println!("timed out!"); unsafe { libc::exit(1) } - }); + }).detach(); let (tx, rx) = channel(); - spawn(move|| { + Thread::spawn(move || -> () { let mut listener = TcpListener::bind("127.0.0.1:0").unwrap(); tx.send(listener.socket_name().unwrap()); let mut acceptor = listener.listen(); @@ -47,7 +48,7 @@ fn main() { stream.read_byte(); stream.write(&[2]); } - }); + }).detach(); let addr = rx.recv(); let (tx, rx) = channel(); diff --git a/src/test/run-pass/tempfile.rs b/src/test/run-pass/tempfile.rs index a866f497b8615..4fcdf49d971a1 100644 --- a/src/test/run-pass/tempfile.rs +++ b/src/test/run-pass/tempfile.rs @@ -23,6 +23,7 @@ use std::io::{fs, TempDir}; use std::io; use std::os; use std::task; +use std::comm::channel; fn test_tempdir() { let path = { diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs index d2c1461d65d0b..dd16514d83a61 100644 --- a/src/test/run-pass/trait-bounds-in-arc.rs +++ b/src/test/run-pass/trait-bounds-in-arc.rs @@ -11,8 +11,8 @@ // Tests that a heterogeneous list of existential types can be put inside an Arc // and shared between tasks as long as all types fulfill Send. - use std::sync::Arc; +use std::comm::channel; use std::task; trait Pet { diff --git a/src/test/run-pass/trait-inheritance-overloading.rs b/src/test/run-pass/trait-inheritance-overloading.rs index 5f8e945cce860..1cd6e3ecebeb1 100644 --- a/src/test/run-pass/trait-inheritance-overloading.rs +++ b/src/test/run-pass/trait-inheritance-overloading.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::cmp::PartialEq; +use std::ops::{Add, Sub, Mul}; trait MyNum : Add + Sub + Mul + PartialEq + Clone { } diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs index 464ab1352281e..1ff3ba3106b37 100644 --- a/src/test/run-pass/trivial-message.rs +++ b/src/test/run-pass/trivial-message.rs @@ -13,6 +13,8 @@ message. */ +use std::comm::channel; + pub fn main() { let (tx, rx) = channel(); tx.send(42i); diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs index 465c324122a44..fdd85b71cd270 100644 --- a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs +++ b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs @@ -13,6 +13,8 @@ #![feature(unboxed_closures)] +use std::num::ToPrimitive; + fn doit(val: T, f: &F) where F : Fn(T) { diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs index 440292d202e48..cce8cd64a14db 100644 --- a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs +++ b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs @@ -13,6 +13,8 @@ #![feature(unboxed_closures)] +use std::num::ToPrimitive; + fn doit(val: T, f: &Fn(T)) { f.call((val,)) } pub fn main() { diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs index b279eb5fbba90..8497bf7f987a0 100644 --- a/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs +++ b/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs @@ -13,6 +13,8 @@ #![feature(unboxed_closures)] +use std::num::ToPrimitive; + fn doit(val: T, f: &F) where F : Fn(&T) { diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs index 672cd2d00e8bd..e66c8730898f8 100644 --- a/src/test/run-pass/unique-send-2.rs +++ b/src/test/run-pass/unique-send-2.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::task; +use std::comm::{channel, Sender}; fn child(tx: &Sender>, i: uint) { tx.send(box i); diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs index 22b5a8cdaa4bf..0a661a51bf16c 100644 --- a/src/test/run-pass/unique-send.rs +++ b/src/test/run-pass/unique-send.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::comm::channel; + pub fn main() { let (tx, rx) = channel(); tx.send(box 100i); diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs index 9789deef63649..1284c938d5540 100644 --- a/src/test/run-pass/unwind-resource.rs +++ b/src/test/run-pass/unwind-resource.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - +use std::comm::{channel, Sender}; use std::task; struct complainer { diff --git a/src/test/run-pass/variadic-ffi.rs b/src/test/run-pass/variadic-ffi.rs index f8eef98856114..ec320c1f8a309 100644 --- a/src/test/run-pass/variadic-ffi.rs +++ b/src/test/run-pass/variadic-ffi.rs @@ -9,7 +9,8 @@ // except according to those terms. extern crate libc; -use std::c_str::CString; + +use std::c_str::{CString, ToCStr}; use libc::{c_char, c_int}; // ignore-fast doesn't like extern crate diff --git a/src/test/run-pass/wait-forked-but-failed-child.rs b/src/test/run-pass/wait-forked-but-failed-child.rs index 577e114945c66..624b41767049c 100644 --- a/src/test/run-pass/wait-forked-but-failed-child.rs +++ b/src/test/run-pass/wait-forked-but-failed-child.rs @@ -12,10 +12,10 @@ extern crate libc; use std::io::process::Command; use std::iter::IteratorExt; +use std::str::from_str; use libc::funcs::posix88::unistd; - // The output from "ps -A -o pid,ppid,args" should look like this: // PID PPID COMMAND // 1 0 /sbin/init