From 56290a004493a5d2e211f056601533253497df60 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Mon, 22 Dec 2014 09:04:23 -0800 Subject: [PATCH 1/2] std: Stabilize the prelude module This commit is an implementation of [RFC 503][rfc] which is a stabilization story for the prelude. Most of the RFC was directly applied, removing reexports. Some reexports are kept around, however: * `range` remains until range syntax has landed to reduce churn. * `Path` and `GenericPath` remain until path reform lands. This is done to prevent many imports of `GenericPath` which will soon be removed. * All `io` traits remain until I/O reform lands so imports can be rewritten all at once to `std::io::prelude::*`. This is a breaking change because many prelude reexports have been removed, and the RFC can be consulted for the exact list of removed reexports, as well as to find the locations of where to import them. [rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0503-prelude-stabilization.md [breaking-change] Closes #20068 --- src/compiletest/compiletest.rs | 4 +- src/doc/guide-ffi.md | 2 + src/doc/guide.md | 173 +++-- src/doc/reference.md | 4 +- src/libcollections/binary_heap.rs | 2 + src/libcollections/bit.rs | 12 +- src/libcollections/btree/map.rs | 19 +- src/libcollections/btree/node.rs | 6 +- src/libcollections/btree/set.rs | 11 +- src/libcollections/dlist.rs | 5 +- src/libcollections/enum_set.rs | 2 + src/libcollections/ring_buf.rs | 8 +- src/libcollections/slice.rs | 14 +- src/libcollections/string.rs | 4 +- src/libcollections/vec.rs | 4 +- src/libcollections/vec_map.rs | 4 +- src/libcore/cmp.rs | 5 +- src/libcore/ops.rs | 46 +- src/libcore/prelude.rs | 33 +- src/libcore/tuple.rs | 29 - src/libcoretest/cmp.rs | 3 +- src/libcoretest/num/int_macros.rs | 1 + src/libcoretest/num/mod.rs | 2 + src/libcoretest/num/uint_macros.rs | 1 + src/libcoretest/str.rs | 2 + src/libcoretest/tuple.rs | 2 + src/libgraphviz/lib.rs | 5 + src/libgraphviz/maybe_owned_vec.rs | 4 +- src/librand/chacha.rs | 2 +- src/librand/distributions/exponential.rs | 4 +- src/librand/distributions/gamma.rs | 4 +- src/librand/distributions/mod.rs | 2 +- src/librand/distributions/normal.rs | 4 +- src/librand/distributions/range.rs | 2 +- src/librand/isaac.rs | 2 +- src/librand/rand_impls.rs | 2 +- src/librand/reseeding.rs | 2 +- src/libregex/re.rs | 1 + src/libregex/vm.rs | 1 + src/librustc/lint/builtin.rs | 3 +- src/librustc/metadata/decoder.rs | 4 +- src/librustc/metadata/tydecode.rs | 1 - src/librustc/middle/cfg/graphviz.rs | 4 +- src/librustc/middle/check_match.rs | 3 +- src/librustc/middle/const_eval.rs | 2 +- .../middle/infer/region_inference/mod.rs | 3 +- src/librustc/middle/lang_items.rs | 1 + src/librustc/middle/ty.rs | 2 +- src/librustc/session/config.rs | 1 + .../borrowck/gather_loans/move_error.rs | 2 +- src/librustc_borrowck/graphviz.rs | 1 + src/librustc_driver/lib.rs | 2 + src/librustc_llvm/archive_ro.rs | 3 +- src/librustc_resolve/build_reduced_graph.rs | 3 +- src/librustc_resolve/check_unused.rs | 2 + src/librustc_resolve/record_exports.rs | 1 + src/librustc_trans/back/lto.rs | 1 + src/librustc_trans/back/write.rs | 1 + src/librustc_trans/save/mod.rs | 3 +- src/librustc_trans/trans/builder.rs | 2 +- src/librustc_trans/trans/foreign.rs | 1 + src/librustdoc/flock.rs | 2 +- src/librustdoc/html/markdown.rs | 3 +- src/librustdoc/html/render.rs | 1 + src/librustdoc/stability_summary.rs | 3 +- src/librustdoc/test.rs | 4 +- src/libstd/ascii.rs | 2 +- src/libstd/bitflags.rs | 10 +- src/libstd/c_str.rs | 17 +- src/libstd/c_vec.rs | 2 +- src/libstd/collections/hash/bench.rs | 2 +- src/libstd/collections/hash/map.rs | 5 +- src/libstd/collections/hash/set.rs | 2 +- src/libstd/comm/mod.rs | 681 ++++++++++-------- src/libstd/comm/mpsc_queue.rs | 11 +- src/libstd/comm/select.rs | 151 ++-- src/libstd/comm/spsc_queue.rs | 6 +- src/libstd/dynamic_lib.rs | 10 +- src/libstd/error.rs | 2 +- src/libstd/failure.rs | 2 +- src/libstd/io/buffered.rs | 2 +- src/libstd/io/comm_adapters.rs | 6 +- src/libstd/io/extensions.rs | 4 +- src/libstd/io/fs.rs | 2 +- src/libstd/io/mem.rs | 5 +- src/libstd/io/mod.rs | 6 +- src/libstd/io/net/addrinfo.rs | 2 +- src/libstd/io/net/ip.rs | 2 +- src/libstd/io/net/pipe.rs | 86 +-- src/libstd/io/net/tcp.rs | 136 ++-- src/libstd/io/net/udp.rs | 33 +- src/libstd/io/pipe.rs | 9 +- src/libstd/io/process.rs | 41 +- src/libstd/io/result.rs | 2 +- src/libstd/io/stdio.rs | 9 +- src/libstd/io/test.rs | 3 +- src/libstd/io/timer.rs | 15 +- src/libstd/io/util.rs | 6 +- src/libstd/lib.rs | 1 + src/libstd/macros.rs | 1 + src/libstd/num/f32.rs | 2 +- src/libstd/num/f64.rs | 2 +- src/libstd/num/mod.rs | 8 +- src/libstd/num/uint_macros.rs | 3 +- src/libstd/os.rs | 2 +- src/libstd/path/mod.rs | 4 +- src/libstd/path/posix.rs | 15 +- src/libstd/path/windows.rs | 12 +- src/libstd/prelude.rs | 94 --- src/libstd/prelude/mod.rs | 42 ++ src/libstd/prelude/v1.rs | 51 ++ src/libstd/rand/mod.rs | 4 +- src/libstd/rand/os.rs | 5 +- src/libstd/rand/reader.rs | 2 +- src/libstd/rt/args.rs | 4 +- src/libstd/rt/backtrace.rs | 4 +- src/libstd/rt/exclusive.rs | 2 +- src/libstd/rt/mod.rs | 13 +- src/libstd/rt/task.rs | 2 +- src/libstd/rt/unwind.rs | 2 +- src/libstd/rt/util.rs | 5 +- src/libstd/sync/atomic.rs | 2 +- src/libstd/sync/barrier.rs | 9 +- src/libstd/sync/condvar.rs | 21 +- src/libstd/sync/future.rs | 7 +- src/libstd/sync/mutex.rs | 22 +- src/libstd/sync/once.rs | 7 +- src/libstd/sync/poison.rs | 2 +- src/libstd/sync/rwlock.rs | 10 +- src/libstd/sync/semaphore.rs | 16 +- src/libstd/sync/task_pool.rs | 8 +- src/libstd/sys/common/backtrace.rs | 2 +- src/libstd/sys/common/helper_thread.rs | 5 +- src/libstd/sys/common/mod.rs | 2 +- src/libstd/sys/common/net.rs | 12 +- src/libstd/sys/common/thread_local.rs | 4 +- src/libstd/sys/unix/fs.rs | 13 +- src/libstd/sys/unix/mod.rs | 2 +- src/libstd/sys/unix/os.rs | 7 +- src/libstd/sys/unix/pipe.rs | 6 +- src/libstd/sys/unix/process.rs | 19 +- src/libstd/sys/unix/tcp.rs | 3 +- src/libstd/sys/unix/thread_local.rs | 2 +- src/libstd/sys/unix/timer.rs | 6 +- src/libstd/sys/unix/tty.rs | 3 +- src/libstd/sys/windows/c.rs | 6 +- src/libstd/sys/windows/fs.rs | 2 +- src/libstd/sys/windows/mod.rs | 4 +- src/libstd/sys/windows/mutex.rs | 2 +- src/libstd/sys/windows/os.rs | 2 +- src/libstd/sys/windows/pipe.rs | 6 +- src/libstd/sys/windows/process.rs | 7 +- src/libstd/sys/windows/tcp.rs | 2 +- src/libstd/sys/windows/thread_local.rs | 2 +- src/libstd/sys/windows/timer.rs | 5 +- src/libstd/sys/windows/tty.rs | 21 +- src/libstd/thread.rs | 6 +- src/libstd/thread_local/mod.rs | 21 +- src/libstd/thread_local/scoped.rs | 4 +- src/libstd/tuple.rs | 6 +- src/libsyntax/codemap.rs | 19 +- src/libsyntax/ext/bytes.rs | 1 - src/libsyntax/ext/quote.rs | 3 +- src/libsyntax/owned_slice.rs | 4 +- src/libsyntax/parse/lexer/mod.rs | 3 +- src/libsyntax/parse/parser.rs | 3 +- src/libsyntax/parse/token.rs | 2 + src/libsyntax/ptr.rs | 20 +- src/libsyntax/std_inject.rs | 9 +- src/libsyntax/util/interner.rs | 4 +- src/libsyntax/util/small_vector.rs | 2 + src/libtest/lib.rs | 11 +- src/libtest/stats.rs | 5 +- src/libtime/lib.rs | 6 +- src/test/auxiliary/cci_capture_clause.rs | 1 + src/test/auxiliary/static-methods-crate.rs | 1 + .../trait_inheritance_overloading_xc.rs | 1 + .../auxiliary/unboxed-closures-cross-crate.rs | 2 + src/test/bench/core-map.rs | 1 + src/test/bench/core-set.rs | 3 +- src/test/bench/core-uint-to-str.rs | 1 + src/test/bench/msgsend-pipes-shared.rs | 2 + src/test/bench/msgsend-pipes.rs | 2 + src/test/bench/msgsend-ring-mutex-arcs.rs | 1 + src/test/bench/rt-messaging-ping-pong.rs | 11 +- src/test/bench/rt-parfib.rs | 7 +- src/test/bench/shootout-ackermann.rs | 1 + src/test/bench/shootout-binarytrees.rs | 2 + src/test/bench/shootout-chameneos-redux.rs | 8 +- src/test/bench/shootout-fannkuch-redux.rs | 3 +- src/test/bench/shootout-fasta-redux.rs | 1 + src/test/bench/shootout-fasta.rs | 5 +- src/test/bench/shootout-fibo.rs | 1 + src/test/bench/shootout-k-nucleotide-pipes.rs | 9 +- src/test/bench/shootout-k-nucleotide.rs | 1 - src/test/bench/shootout-mandelbrot.rs | 1 + src/test/bench/shootout-meteor.rs | 6 +- src/test/bench/shootout-nbody.rs | 1 + src/test/bench/shootout-pfib.rs | 2 + src/test/bench/shootout-reverse-complement.rs | 19 +- src/test/bench/shootout-spectralnorm.rs | 29 +- src/test/bench/shootout-threadring.rs | 8 +- src/test/bench/spawnone.rs | 14 - src/test/bench/std-smallintmap.rs | 1 + src/test/bench/sudoku.rs | 5 +- .../bench/task-perf-jargon-metal-smoke.rs | 8 +- src/test/bench/task-perf-spawnalot.rs | 1 + .../compile-fail/bind-by-move-no-guards.rs | 2 + src/test/compile-fail/binop-consume-args.rs | 2 + src/test/compile-fail/binop-move-semantics.rs | 2 + .../borrowck-loan-in-overloaded-op.rs | 1 + .../borrowck-loan-rcvr-overloaded-op.rs | 2 + .../borrowck-overloaded-index-2.rs | 2 + .../borrowck-overloaded-index-autoderef.rs | 2 + .../compile-fail/borrowck-overloaded-index.rs | 2 + .../builtin-superkinds-self-type.rs | 2 + .../compile-fail/comm-not-freeze-receiver.rs | 2 + src/test/compile-fail/comm-not-freeze.rs | 2 + src/test/compile-fail/issue-12041.rs | 5 +- src/test/compile-fail/issue-16709.rs | 2 + src/test/compile-fail/issue-18566.rs | 2 + src/test/compile-fail/issue-3702-2.rs | 2 + src/test/compile-fail/unop-move-semantics.rs | 2 + src/test/compile-fail/unsendable-class.rs | 1 + .../wrong-mul-method-signature.rs | 2 + src/test/pretty/issue-4264.pp | 2 +- src/test/run-pass/bool.rs | 3 + ...ltin-superkinds-capabilities-transitive.rs | 2 + .../builtin-superkinds-capabilities-xc.rs | 2 + .../builtin-superkinds-capabilities.rs | 2 + .../run-pass/builtin-superkinds-self-type.rs | 2 + src/test/run-pass/c-stack-returning-int64.rs | 2 + src/test/run-pass/capturing-logging.rs | 4 +- .../closure-bounds-can-capture-chan.rs | 2 +- src/test/run-pass/cmp-default.rs | 2 + src/test/run-pass/comm.rs | 1 + src/test/run-pass/const-str-ptr.rs | 1 + src/test/run-pass/core-run-destroy.rs | 6 +- src/test/run-pass/deref-mut-on-ref.rs | 2 + src/test/run-pass/deref-on-ref.rs | 2 + .../run-pass/deriving-cmp-shortcircuit.rs | 2 + src/test/run-pass/deriving-zero.rs | 2 +- src/test/run-pass/drop-trait-enum.rs | 1 + src/test/run-pass/dst-deref-mut.rs | 2 + src/test/run-pass/dst-deref.rs | 2 + src/test/run-pass/fixup-deref-mut.rs | 2 + src/test/run-pass/foreign-fn-linkname.rs | 4 +- src/test/run-pass/hashmap-memory.rs | 4 +- src/test/run-pass/issue-13264.rs | 2 + src/test/run-pass/issue-13494.rs | 5 +- src/test/run-pass/issue-15734.rs | 2 + src/test/run-pass/issue-16560.rs | 5 +- src/test/run-pass/issue-16774.rs | 2 + src/test/run-pass/issue-3609.rs | 1 + src/test/run-pass/issue-3743.rs | 2 + src/test/run-pass/issue-3979-generics.rs | 2 + src/test/run-pass/issue-4446.rs | 6 +- src/test/run-pass/issue-4448.rs | 1 + src/test/run-pass/issue-7784.rs | 2 + src/test/run-pass/issue-8827.rs | 11 +- src/test/run-pass/issue-9396.rs | 5 +- src/test/run-pass/ivec-tag.rs | 1 + src/test/run-pass/logging-only-prints-once.rs | 8 +- .../macro-with-braces-in-expr-position.rs | 4 +- src/test/run-pass/match-with-ret-arm.rs | 1 + .../run-pass/numeric-method-autoexport.rs | 3 + .../out-of-stack-new-thread-no-split.rs | 8 +- .../run-pass/overloaded-autoderef-indexing.rs | 2 + .../run-pass/overloaded-autoderef-order.rs | 3 + src/test/run-pass/overloaded-autoderef.rs | 3 +- .../overloaded-calls-param-vtables.rs | 1 + .../run-pass/overloaded-index-autoderef.rs | 2 + .../run-pass/overloaded-index-in-field.rs | 2 + src/test/run-pass/overloaded-index.rs | 2 + src/test/run-pass/rename-directory.rs | 1 + src/test/run-pass/running-with-no-runtime.rs | 13 +- src/test/run-pass/rust-log-filter.rs | 5 +- src/test/run-pass/send-resource.rs | 1 + src/test/run-pass/send-type-inference.rs | 2 + src/test/run-pass/send_str_hashmap.rs | 2 +- src/test/run-pass/send_str_treemap.rs | 3 +- src/test/run-pass/sendable-class.rs | 2 + src/test/run-pass/spawn-types.rs | 1 + .../run-pass/supertrait-default-generics.rs | 2 + src/test/run-pass/task-comm-0.rs | 2 +- src/test/run-pass/task-comm-10.rs | 2 +- src/test/run-pass/task-comm-11.rs | 2 +- src/test/run-pass/task-comm-13.rs | 2 +- src/test/run-pass/task-comm-14.rs | 2 +- src/test/run-pass/task-comm-15.rs | 2 +- src/test/run-pass/task-comm-16.rs | 1 + src/test/run-pass/task-comm-3.rs | 1 + src/test/run-pass/task-comm-4.rs | 2 + src/test/run-pass/task-comm-5.rs | 2 + src/test/run-pass/task-comm-6.rs | 2 + src/test/run-pass/task-comm-7.rs | 2 +- src/test/run-pass/task-comm-9.rs | 1 + src/test/run-pass/task-comm-chan-nil.rs | 2 + src/test/run-pass/task-spawn-move-and-copy.rs | 1 + src/test/run-pass/task-stderr.rs | 1 + src/test/run-pass/tcp-accept-stress.rs | 10 +- src/test/run-pass/tcp-connect-timeouts.rs | 1 + src/test/run-pass/tempfile.rs | 1 + src/test/run-pass/trait-bounds-in-arc.rs | 2 +- .../run-pass/trait-inheritance-overloading.rs | 1 + src/test/run-pass/trivial-message.rs | 2 + ...nfer-argument-types-from-expected-bound.rs | 2 + ...rgument-types-from-expected-object-type.rs | 2 + ...-with-bound-regions-from-expected-bound.rs | 2 + src/test/run-pass/unique-send-2.rs | 1 + src/test/run-pass/unique-send.rs | 2 + src/test/run-pass/unwind-resource.rs | 2 +- src/test/run-pass/variadic-ffi.rs | 3 +- .../run-pass/wait-forked-but-failed-child.rs | 2 +- 314 files changed, 1650 insertions(+), 1200 deletions(-) delete mode 100644 src/libstd/prelude.rs create mode 100644 src/libstd/prelude/mod.rs create mode 100644 src/libstd/prelude/v1.rs delete mode 100644 src/test/bench/spawnone.rs diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index bdbfbfd7c89..ad1264828cb 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 3a87271ede7..b8808eaf57d 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 f4ec787a794..e90f30cb864 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 @@ -1109,10 +1109,11 @@ An `Ordering` can only be _one_ of `Less`, `Equal`, or `Greater` at any given time. Here's an example: ```{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,11 +1122,11 @@ 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"); } } @@ -1280,10 +1281,11 @@ 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 +1294,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 +1307,11 @@ 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 +1319,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 +1368,11 @@ 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 +1380,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 +2143,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 +2162,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 +2198,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 +2217,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 +2296,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 +2315,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 +2346,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 +2374,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 +2413,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 +2441,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 +2487,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 +2517,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 +2563,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 +2593,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 +2604,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 +2619,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 +2649,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 +2660,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 +2698,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 +2726,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 +2737,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 +5230,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 f3ad19bbd2a..7b3a0b74b8a 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 64e10e69a2e..f748c8ad1eb 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 d8dfc02c97a..0b3de113042 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 87b40aa1cee..6d41883dc8d 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 3907f28092a..05356368365 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 f3f6727f1c0..3e8988530e6 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 8b7b7176b80..68acbfcb3c3 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 b484fc41ff6..ea3d8659f54 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 12148947a19..e4c9e51a845 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 61111d96bd0..9e2b4b77910 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 37a6e690f5d..ae038a9f089 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 a1952352bad..4b7aa896870 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 7c30912cf91..172fd56ed39 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 367c794e84b..38906892a33 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 af07869e95f..15016562699 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 cecb4938153..210850be13a 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 576989fabe7..ad2323296d9 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 716300f652d..992c99f1f9f 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 55e0f10c865..e409dc61510 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 acc593d7be9..82e91c5b712 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 b21ac11e6a0..2311c19d557 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 63d6e14a4a6..fc02f46724f 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 f7b714757f8..c3bc38a6614 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 7dd0649e483..01e55fb2edd 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 ddda2b38c22..573f0926e29 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 49577cd279b..8e6c7de305f 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 f31f3468a4c..981b0eeee53 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 618db380db8..378029d1f9b 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 54cb8ae1907..d0123d9c76c 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 3507282ec48..543e236f96d 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 20ba3566d5b..558fa201256 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 1fe435a59ad..1ea47844075 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 e50153076c3..c331807c1b9 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 94a11c040e4..46371d427e6 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 51c23463155..3171966a596 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 72e0e559c80..603ca57d15d 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 692ecf75091..5e74b90dba3 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 d079d0e52aa..70325294743 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 88c7ccf1b1e..2d3ff95ffa6 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 13bd22a67c4..06fef66c1e0 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 4c5d76a2c40..d16224ec5b8 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 5b89912dd03..9fc5cb03353 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 7372bb267b0..6ac1c5470cc 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 2aef4307199..78fabcd588a 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 7bc5d3d0708..07ff0ed67a6 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 19ac6d466fb..f6f46017f37 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 73b345a70af..8d3aa397f30 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 e2813c8e988..ac6b962d647 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 181f38d8993..f3013d2066c 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 6c3778787e2..53992d4567a 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 7dbcc810b57..8553a209005 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 78527315199..b3d0d30726c 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 9c2437c376d..4f314291da6 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 1271330897e..7cf4bafe032 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 a6f2c7dfed0..f74f0abc186 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 51ea0af8e10..b877a771bbc 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 b39dbd71117..97f0b92a290 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 83765270ef1..99dc971ed94 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 a89b20c949b..0f0dbf6a24d 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 2c05524ea7f..468fed1d339 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 f8a0b88b408..ceb66be2d66 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 2e3adf8e767..058a7acd455 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 ba66c51b8fc..b7b8360fced 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 2c2b7313a7b..857a7072009 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 aeb4df402a2..72220926c0d 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 46498610e56..6418841eda8 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 0aa51ee66ed..de60f06efd2 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 87aebb24f98..28689767cb0 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 f6063df5434..c0536fc5ca4 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 a405627aecc..dcef24c62bd 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 cddef236664..d1b6d0d697c 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 690b5861c22..a0a8e40b415 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 becb78063ae..1e2f5222d8b 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 368abe7cb12..ecfe2d15ae1 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 9a46a500a4b..32e1922ae74 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 7010eae6dba..3d98b6ec40e 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 c5405601048..57dc62084e3 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 077f75e2edd..ebadecfebb5 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 51e09e547e3..94dba1f7cc7 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 7fa6ebc6e3b..7fa5b3cfac7 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 f8ea373f8f4..ad921e43c0c 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 e8b852ee492..9eb860d7ec3 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 e8fbb121181..d86cb841f96 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 49ab9ddb924..7ce1d1fc13b 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 6ce66c3273b..95147c52a69 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 826f492d85d..4492e679cd5 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 11c2f956c35..2e366c7e27b 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 93465d5510b..ee86eae058d 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 b127507f048..b93e091af7e 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 32965d23971..c1474650f1e 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 b7d069eb19e..789fdeba8a2 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 40941fda79c..7592e7692db 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 953effe4345..2067a97fdac 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 9840412160d..36986b8fdc5 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 74c387c5eea..8beb002cf48 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 ebb64bc2f2d..fa77ae6418d 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 1f76382ce8a..6de49c38b73 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 221ecf62c05..50855d21b4a 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 48ff1a364e9..01aa21c692b 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 e74f45f8f0a..b52e4fda7af 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 df50b7f81af..bceae610216 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 30f3f56bc1c..024dc56073d 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 bd4031e6230..102da31a293 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 751ed4b70fb..107e9d80fc3 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 f016683e3d0..00000000000 --- 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 00000000000..da945b4c9fa --- /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 00000000000..33146f5e622 --- /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 f665d150f38..86b8bfc7370 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 ca36f2d8997..6576f1b6526 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 15e63aa19ea..48d7f2e7854 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 98eff621ce0..4734a39c835 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 3eeb0ad3968..4abef6ee910 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 88bdb29caec..eb6b3655444 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 e877dd5c6aa..68aaa1b3ae5 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 41e91d1b6ef..48cdfc20a35 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 e0c512706e6..dcd967a774c 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 fee86e33455..2a8deccb5dc 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 18c917aca8a..a88932f21cb 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 4091f0df395..1c73bf7cf35 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 15faf5be258..df3f2e5cf62 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 51899a87a32..a0e7236b8d2 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 52004bb4a8f..98425f26c1a 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 4d9fbb59908..fe25eca03d7 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 edf16d99f49..6e4df118209 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 7f3c77c97ad..efdd894a806 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 e3b683a6ccb..a283626a408 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 ee534f6cdde..63c10c18046 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 866bf1d8a7d..d4039fd96ff 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 9ef1c33312f..c4c093dcb32 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 dc0ad08cdbe..97015f74a4a 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 259c15b5f06..cb0c5581abd 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 fe7a7d8d037..405dd4eacf3 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 8de4ffa7022..e3e0b279c12 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 c82dacf1e44..4199cbc1bb9 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 595191db3b2..6d145e47516 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 868b460aa5e..e46814ef4a2 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 c1c28bd5fc4..13191961fb7 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 e2a78947e16..13ccf685fd7 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 b300e93eeb6..e507377a8fc 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 c0ef89666c0..c9160a032ec 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 28c17fd4966..4ef687d41d8 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 6cccefbe890..d28d0fe26b9 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 3ad439078b9..523d60c71aa 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 57c284ed6a3..c354e7b3ece 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 3ac7c09154e..c7b4a4cec09 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 09003f87ff0..dfdee0e0385 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 fc3640f2604..f173d5fc6d4 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 b03c62395d1..00c1ca7fe1a 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; @@ -469,7 +470,7 @@ mod tests { #[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 513c1d38e36..5a929f6b2b5 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 60b0d584db3..b96e26c7a86 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 874838950cd..485dc251050 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 a88d11eed22..7591025d76d 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 prelude::v1::*; + +use io::{mod, IoError, IoResult, MemReader}; +use iter::repeat; +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 libc::{c_int, HANDLE, LPDWORD, DWORD, LPVOID}; -use libc::{get_osfhandle, CloseHandle}; -use libc::types::os::arch::extra::LPCVOID; -use io::{mod, IoError, IoResult, MemReader}; -use iter::repeat; -use prelude::*; -use ptr; -use str::from_utf8; +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 a7b3ee996a3..b6e16a8e6ab 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 14dd2a1ac9b..9d4e7936de2 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 5f96548c053..a2e2bd43849 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 5cd60d6e153..fc90bffa03c 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 e61afb8b193..5eac6546c6b 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 2844c0b523e..9f225d55b44 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 d87960ebdb8..e46bd7ac4bc 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 3023c547fb0..f7d2331c9ec 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 13d020f6ae3..0f5ff33021c 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 457085f5cc8..832b112921e 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 f22a4b5c6ed..9c6644c5204 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 1b3ebde2461..8b1aed483c3 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 c1823231e24..5a4d0cc3bd8 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 97eb4316583..d25161a12a7 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 946181770c8..953a7ae960e 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 19821ecb7ca..87f791e6992 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 41146cded70..ed6a00a8e91 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 87a00334c47..a6d9a542a49 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 1cccb0f7ccb..e3dbe3c7e22 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 811d8f11692..ea4751bf4ed 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 61854aba279..7de34d52f51 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 9a6a2c7495b..0b65fa913cb 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 60331dfb550..0ada1cb991c 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 49f5c7751d9..52380001c6c 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 98113cb8347..08637b4bf1c 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 645c029f935..94b7e58a54c 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 ed96c6406d8..4fb84c86106 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 8ec44b2dd3c..3ead5ef64fd 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 73d54372b27..d3a340d488b 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 bdf22cd7395..0a513c32aaf 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 e7a50382c94..f7810d5d740 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 0b16e8011e8..2f25c37a911 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 dcdb90a11c8..6bbf6cde4ea 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 ef38f5ef743..ec1268c9080 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 178d6777939..09f7f236f19 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 2de61cf3572..7009dd4c1a7 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 10c0d0a8044..cbacf415f6f 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 f49b648e215..b59eef916dc 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 a0ef392ed3a..3dc51805917 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 bb0e09370d8..51ce4cbaa84 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 9a3b6953062..2e229a50d16 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 dab67331120..6a325798f58 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 f7e8fc8fe1b..e58303a724a 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 909f8afc34a..d9dfd65d5b3 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 df388fbdde5..a5af1227a16 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 111a92b083a..94d958ea8d5 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 ca36d99014c..00000000000 --- 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 576d96ba2a3..035b222e6ce 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 5fb7e2c3a84..cccc9362a72 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 789ccb6142a..287b3fc6c46 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 a6852d396d9..7e2c6fcf0ec 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 18534db0dd5..90d5072f412 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 2bdd148b99b..afa255be699 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 d9440e18375..e48c88a49f0 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 692303fc1e4..af9a18acbf2 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 b83e1544c96..b571af2425a 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 d9d7a43d46c..01afe405d5e 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 2253d7512c0..e8949d4b30b 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 0422f6381dc..933d0f15e4e 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 4c7ff60fbdd..6228b924729 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 8cb4b6328c4..83e329db0da 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 8c17895eb8a..296b4187a1f 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 1878b5f5dea..f42e1a1bc15 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 fc15801eb75..327f50ee059 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 f64d8fee2d8..c2e4629e14d 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 54100d543dd..1e80fd7a7e9 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 ccdc7b833e7..c458c539c07 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 cd5918e2f47..312f26394b2 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 b5e4cac7555..bde5b853078 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 c2ebd764ad6..35bd22880ce 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 238d0ecdca7..45710408172 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::{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 2abc58d8a49..83c1696f7b2 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 c2b874c61a7..1f002ec79c6 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 fb3e1b02728..46ad3f93b0b 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 1c156f6551c..27a7cd909fe 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 597e067b8b6..c95cf0bfdee 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 f2df5ef38c3..4ed444f92ac 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 cdcdad47ea4..e1dc5802162 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 cfba87c3f69..fd040d10910 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 edd4d5642b5..119bdaff98e 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 d6f0296619a..e0e8ca5618e 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 a0fa2d178b9..198915fe02e 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 dcf7c483b2c..5a98952c127 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 27e7d8f3ba2..f245c11f090 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 b68d8058381..fb81dd558d2 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 88f3e5775b7..b8903d05cd8 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 24915d84e7e..bca61ab1bd3 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 c2707a1ae6e..0cbcee3e253 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 43b7d116d30..96a9c117dea 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 d2812ce1d2c..70d14ba3623 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 750c0c8ed68..8a75fdd685d 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 a92b361dd33..6155ca63572 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 06ab67f2f3e..33377d1f217 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 be851ddefc6..e6da859c110 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 ea5bd550d53..8aa7447ccd2 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 f329e7eed0d..b2b819a1103 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 ebc879d82fb..0b9a85851c5 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 f17f9411d15..df2a9e6bfa9 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 80d3d29bc00..c88022f3eb7 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 86cdd6135ec..93c72e2e350 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 daa80aec28c..871e52e3639 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 3ea968c416f..6692988f6da 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 b936eb322fc..43785edc2eb 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 7397ad74495..4163ebf4573 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 588e0c1cf16..d3cbd556776 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 1f7edcf43b8..2e6127541a1 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 1e05c05cc0d..509afff3d13 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 024dc4c03e1..a6e579ddff3 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 2109f7ef1ea..2cba1dec2dc 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 f8184d248ff..b4d079d79d6 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 674d0dc86da..7aac2d705a8 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 5c4befcd0c8..d1fb69b87a3 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 f0daf371ca7..23a8285063f 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 2975b209d06..222e2825c04 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 2e8ec3916bd..95df1ed0d83 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 d51956da894..dcb0c40c608 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 e8b0408ca0d..1c06ed64fc7 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 23bebfa35d7..fdf7e7e2cbb 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 b5cee20232b..c7aa405b513 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 4cf8c52f2bb..0aeade935da 100644 --- a/src/test/run-pass/running-with-no-runtime.rs +++ b/src/test/run-pass/running-with-no-runtime.rs @@ -10,11 +10,11 @@ use std::io::process::{Command, ProcessOutput}; use std::os; -use std::str; -use std::rt; -use std::thunk::Thunk; - use std::rt::unwind::try; +use std::rt; +use std::str; +use std::thread::Thread; +use std::thunk::Thunk; #[start] fn start(argc: int, argv: *const *const u8) -> int { @@ -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 88d30318f2a..8e547527f72 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 6001c360ab9..71620d05e01 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 508bd99d77d..181874705da 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 1b0f2ec0a32..bfeff58b802 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 24480d85272..8c70738de48 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 007a83d2c88..3d5f0af0e3f 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 9b533c69f32..e3b2a2903bc 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 873941395fe..4465561f874 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 9e3511ba603..7c664b21fad 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 dd3c90991f6..c35e2f2f37a 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 aefc91df4e7..10b4e516311 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 c6c0691b749..31da1168bf7 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 0e483813665..8ec589d5db5 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 3095c2098ff..b69644244ab 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 91433852540..5e71ed3ba06 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 73f6eb563c1..c7a6da6a794 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 2e2b1fbff0f..0e75479046b 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 e51e14f7fbe..d4edbf85cd8 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 e783cd9b6be..4c18e5dc313 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 9d8caa42626..e7e5c04e195 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 69d70050437..5a271f9dc05 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 3ea17898ead..368cac1d27d 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 8d6b6005a63..1e10a4186fb 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 ddeffcdf722..048d7b2be72 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 780cf234466..8f5a45cd1dd 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 2d087406fd6..ea0141a0496 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/tempfile.rs b/src/test/run-pass/tempfile.rs index a866f497b86..4fcdf49d971 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 d2c1461d65d..dd16514d83a 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 5f8e945cce8..1cd6e3ecebe 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 464ab135228..1ff3ba3106b 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 465c324122a..fdd85b71cd2 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 440292d202e..cce8cd64a14 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 b279eb5fbba..8497bf7f987 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 672cd2d00e8..e66c8730898 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 22b5a8cdaa4..0a661a51bf1 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 9789deef636..1284c938d55 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 f8eef988561..ec320c1f8a3 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 577e114945c..624b4176704 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 From 76e3bc23388e268438e4318b0580149619a9d1ac Mon Sep 17 00:00:00 2001 From: Steve Klabnik Date: Tue, 23 Dec 2014 13:31:43 -0500 Subject: [PATCH 2/2] Properly deal with Ordering in the guide Now that it's been removed from the prelude, we need to treat things differently. Fixes #17967 --- src/doc/guide.md | 82 ++++++++++++++++++------------- src/libstd/sys/windows/process.rs | 1 + src/test/run-pass/bool.rs | 2 +- src/test/run-pass/tcp-stress.rs | 11 +++-- 4 files changed, 56 insertions(+), 40 deletions(-) diff --git a/src/doc/guide.md b/src/doc/guide.md index e90f30cb864..a3a24abeb2e 100644 --- a/src/doc/guide.md +++ b/src/doc/guide.md @@ -1106,10 +1106,17 @@ 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; +use std::cmp::Ordering; + fn cmp(a: int, b: int) -> Ordering { if a < b { Ordering::Less } else if a > b { Ordering::Greater } @@ -1132,18 +1139,25 @@ fn main() { } ``` -`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. + +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`. 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. +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: @@ -1176,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()) @@ -1197,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; @@ -1222,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, @@ -1281,7 +1292,8 @@ for every possible value of `x`, and so our program will compile successfully. section on enums? ```{rust} -# use std::cmp::Ordering; +use std::cmp::Ordering; + fn cmp(a: int, b: int) -> Ordering { if a < b { Ordering::Less } else if a > b { Ordering::Greater } @@ -1307,7 +1319,8 @@ fn main() { We can re-write this as a `match`: ```{rust} -# use std::cmp::Ordering; +use std::cmp::Ordering; + fn cmp(a: int, b: int) -> Ordering { if a < b { Ordering::Less } else if a > b { Ordering::Greater } @@ -1368,7 +1381,8 @@ 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; +use std::cmp::Ordering; + fn cmp(a: int, b: int) -> Ordering { if a < b { Ordering::Less } else if a > b { Ordering::Greater } diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index 00c1ca7fe1a..cb99a886ce4 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -467,6 +467,7 @@ fn free_handle(handle: *mut ()) { #[cfg(test)] mod tests { + use c_str::ToCStr; #[test] fn test_make_command_line() { diff --git a/src/test/run-pass/bool.rs b/src/test/run-pass/bool.rs index 45710408172..b3c4802530e 100644 --- a/src/test/run-pass/bool.rs +++ b/src/test/run-pass/bool.rs @@ -10,7 +10,7 @@ // Basic boolean tests -use std::cmp::{Equal, Greater, Less}; +use std::cmp::Ordering::{Equal, Greater, Less}; use std::ops::{BitAnd, BitOr, BitXor}; fn main() { diff --git a/src/test/run-pass/tcp-stress.rs b/src/test/run-pass/tcp-stress.rs index b3391669d35..7a061f5b99c 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();