From 7d8d06f86b48520814596bd5363d2b82bc619774 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 1 Jan 2015 23:53:35 -0800 Subject: [PATCH] Remove deprecated functionality This removes a large array of deprecated functionality, regardless of how recently it was deprecated. The purpose of this commit is to clean out the standard libraries and compiler for the upcoming alpha release. Some notable compiler changes were to enable warnings for all now-deprecated command line arguments (previously the deprecated versions were silently accepted) as well as removing deriving(Zero) entirely (the trait was removed). The distribution no longer contains the libtime or libregex_macros crates. Both of these have been deprecated for some time and are available externally. --- mk/crates.mk | 16 +- mk/grammar.mk | 2 +- mk/tests.mk | 28 - src/compiletest/compiletest.rs | 2 +- src/doc/reference.md | 6 +- src/grammar/verify.rs | 7 +- src/liballoc/arc.rs | 6 +- src/liballoc/lib.rs | 6 - src/libcollections/bench.rs | 3 +- src/libcollections/bit.rs | 29 +- src/libcollections/btree/map.rs | 28 +- src/libcollections/dlist.rs | 262 +-- src/libcollections/enum_set.rs | 25 - src/libcollections/lib.rs | 7 +- src/libcollections/ring_buf.rs | 13 - src/libcollections/slice.rs | 253 +-- src/libcollections/str.rs | 636 +----- src/libcollections/string.rs | 150 +- src/libcollections/vec.rs | 144 +- src/libcollections/vec_map.rs | 75 - src/libcore/atomic.rs | 178 +- src/libcore/cell.rs | 8 - src/libcore/char.rs | 121 -- src/libcore/cmp.rs | 10 - src/libcore/iter.rs | 11 - src/libcore/num/f32.rs | 76 - src/libcore/num/f64.rs | 76 - src/libcore/num/mod.rs | 209 +- src/libcore/ptr.rs | 47 +- src/libcore/slice.rs | 78 +- src/libcore/str/mod.rs | 119 +- src/libcore/tuple.rs | 38 - src/libcoretest/char.rs | 62 +- src/libcoretest/iter.rs | 2 +- src/libcoretest/nonzero.rs | 2 +- src/libcoretest/num/int_macros.rs | 4 +- src/libcoretest/num/mod.rs | 34 +- src/libcoretest/ptr.rs | 9 +- src/libcoretest/str.rs | 10 +- src/libgraphviz/lib.rs | 6 +- src/libgraphviz/maybe_owned_vec.rs | 9 +- src/librand/chacha.rs | 4 +- src/librand/isaac.rs | 8 +- src/librand/reseeding.rs | 4 +- src/librbml/io.rs | 3 +- src/librbml/lib.rs | 16 +- src/libregex/lib.rs | 351 +--- src/libregex/re.rs | 270 +-- src/libregex/test/mod.rs | 18 - src/libregex_macros/lib.rs | 643 ------ .../middle/infer/region_inference/graphviz.rs | 8 +- src/librustc/session/config.rs | 48 +- src/librustc/util/lev_distance.rs | 2 +- src/librustdoc/stability_summary.rs | 3 +- src/libserialize/base64.rs | 2 +- src/libserialize/json.rs | 2 +- src/libstd/ascii.rs | 1 - src/libstd/c_str.rs | 4 - src/libstd/c_vec.rs | 4 - src/libstd/collections/hash/map.rs | 136 +- src/libstd/collections/hash/set.rs | 9 +- src/libstd/collections/mod.rs | 8 - src/libstd/io/buffered.rs | 16 - src/libstd/io/extensions.rs | 2 +- src/libstd/io/mem.rs | 18 +- src/libstd/io/mod.rs | 94 - src/libstd/io/net/udp.rs | 157 +- src/libstd/io/tempfile.rs | 10 +- src/libstd/io/test.rs | 6 +- src/libstd/io/util.rs | 8 - src/libstd/lib.rs | 1 - src/libstd/num/mod.rs | 13 +- src/libstd/num/u16.rs | 2 - src/libstd/num/u32.rs | 2 - src/libstd/num/u64.rs | 2 - src/libstd/num/u8.rs | 2 - src/libstd/num/uint.rs | 2 - src/libstd/num/uint_macros.rs | 35 +- src/libstd/os.rs | 6 +- src/libstd/path/mod.rs | 20 +- src/libstd/rand/mod.rs | 4 +- src/libstd/rand/os.rs | 10 +- src/libstd/rt/backtrace.rs | 6 +- src/libstd/rt/unwind.rs | 12 +- src/libstd/rt/util.rs | 6 +- src/libstd/sync/atomic.rs | 227 --- src/libstd/sync/condvar.rs | 6 +- src/libstd/sync/future.rs | 4 - src/libstd/sync/mod.rs | 2 +- src/libstd/sync/mpsc/mpsc_queue.rs | 12 +- src/libstd/sync/mpsc/oneshot.rs | 34 +- src/libstd/sync/mpsc/shared.rs | 95 +- src/libstd/sync/mpsc/spsc_queue.rs | 41 +- src/libstd/sync/mpsc/stream.rs | 64 +- src/libstd/sync/mpsc/sync.rs | 13 +- src/libstd/sync/once.rs | 24 +- src/libstd/sys/common/thread_local.rs | 8 +- src/libstd/sys/unix/os.rs | 1 - src/libstd/sys/unix/pipe.rs | 11 +- src/libstd/sys/unix/tcp.rs | 11 +- src/libstd/sys/unix/timer.rs | 4 +- src/libstd/sys/windows/mutex.rs | 16 +- src/libstd/sys/windows/pipe.rs | 27 +- src/libstd/sys/windows/tcp.rs | 11 +- src/libstd/task.rs | 44 - src/libstd/thread.rs | 7 - src/libstd/tuple.rs | 11 - src/libsyntax/ext/deriving/mod.rs | 2 - src/libsyntax/ext/deriving/zero.rs | 102 - src/libsyntax/parse/lexer/mod.rs | 3 +- src/libsyntax/parse/parser.rs | 1 - src/libsyntax/parse/token.rs | 8 - src/libtest/lib.rs | 2 +- src/libtest/stats.rs | 2 +- src/libtime/lib.rs | 1773 ----------------- src/libunicode/lib.rs | 11 +- src/libunicode/u_char.rs | 161 -- src/test/auxiliary/cci_capture_clause.rs | 6 +- src/test/auxiliary/static-methods-crate.rs | 3 +- src/test/bench/core-map.rs | 3 +- src/test/bench/core-set.rs | 3 +- src/test/bench/core-std.rs | 17 +- src/test/bench/core-uint-to-str.rs | 3 +- src/test/bench/msgsend-pipes-shared.rs | 5 +- src/test/bench/msgsend-ring-mutex-arcs.rs | 5 +- src/test/bench/rt-messaging-ping-pong.rs | 5 +- src/test/bench/shootout-ackermann.rs | 3 +- src/test/bench/shootout-chameneos-redux.rs | 5 +- src/test/bench/shootout-fasta-redux.rs | 6 +- src/test/bench/shootout-fasta.rs | 3 +- src/test/bench/shootout-fibo.rs | 3 +- src/test/bench/shootout-k-nucleotide-pipes.rs | 17 +- src/test/bench/shootout-k-nucleotide.rs | 18 +- src/test/bench/shootout-mandelbrot.rs | 22 +- src/test/bench/shootout-meteor.rs | 5 +- src/test/bench/shootout-nbody.rs | 3 +- src/test/bench/shootout-pfib.rs | 3 +- src/test/bench/shootout-regex-dna.rs | 5 +- src/test/bench/shootout-reverse-complement.rs | 4 +- src/test/bench/shootout-spectralnorm.rs | 11 +- src/test/bench/shootout-threadring.rs | 5 +- src/test/bench/std-smallintmap.rs | 5 +- src/test/bench/sudoku.rs | 18 +- src/test/bench/task-perf-alloc-unwind.rs | 6 +- .../bench/task-perf-jargon-metal-smoke.rs | 6 +- src/test/bench/task-perf-spawnalot.rs | 9 +- .../syntax-extension-regex-invalid.rs | 26 - .../syntax-extension-regex-unused-static.rs | 31 - .../syntax-extension-regex-unused.rs | 26 - .../compile-fail/atomicoption-not-send-ref.rs | 16 - .../compile-fail/atomicoption-not-send.rs | 16 - .../borrowck-for-loop-head-linkage.rs | 4 +- .../borrowck-loan-blocks-move-cc.rs | 6 +- .../borrowck-multiple-captures.rs | 10 +- .../compile-fail/deriving-span-Zero-struct.rs | 23 - .../deriving-span-Zero-tuple-struct.rs | 23 - src/test/compile-fail/future_not_copyable.rs | 2 +- src/test/compile-fail/hashmap-lifetimes.rs | 2 +- src/test/compile-fail/issue-11374.rs | 2 +- src/test/compile-fail/issue-15783.rs | 2 +- src/test/compile-fail/issue-17728.rs | 2 +- .../moves-based-on-type-capture-clause-bad.rs | 4 +- src/test/compile-fail/no-capture-arc.rs | 4 +- src/test/compile-fail/no-reuse-move-arc.rs | 4 +- src/test/compile-fail/no-send-res-ports.rs | 4 +- src/test/compile-fail/spawn-non-nil-fn.rs | 17 - .../compile-fail/std-uncopyable-atomics.rs | 2 - .../run-fail/rt-set-exit-status-panic2.rs | 4 +- src/test/run-fail/task-spawn-barefn.rs | 4 +- .../run-make/lto-syntax-extension/main.rs | 7 +- src/test/run-make/static-unwinding/main.rs | 6 +- .../run-make/unicode-input/span_length.rs | 6 +- src/test/run-pass/child-outlives-parent.rs | 4 +- src/test/run-pass/clone-with-exterior.rs | 4 +- src/test/run-pass/comm.rs | 4 +- src/test/run-pass/const-str-ptr.rs | 8 +- src/test/run-pass/deriving-zero.rs | 71 - src/test/run-pass/drop-trait-enum.rs | 12 +- src/test/run-pass/extern-call-deep2.rs | 4 +- src/test/run-pass/extern-call-scrub.rs | 4 +- src/test/run-pass/extern-stress.rs | 12 +- src/test/run-pass/extern-yield.rs | 12 +- src/test/run-pass/hashmap-memory.rs | 4 +- src/test/run-pass/issue-13323.rs | 2 +- src/test/run-pass/issue-15149.rs | 1 - src/test/run-pass/issue-17718.rs | 22 +- src/test/run-pass/issue-2383.rs | 2 +- src/test/run-pass/issue-2718.rs | 4 +- src/test/run-pass/issue-2804.rs | 2 +- src/test/run-pass/issue-2989.rs | 6 +- src/test/run-pass/issue-3563-3.rs | 27 +- src/test/run-pass/issue-3609.rs | 4 +- src/test/run-pass/issue-8460.rs | 42 +- src/test/run-pass/ivec-tag.rs | 4 +- .../kindck-implicit-close-over-mut-var.rs | 8 +- src/test/run-pass/match-with-ret-arm.rs | 3 +- src/test/run-pass/mod-view-items.rs | 2 +- .../moves-based-on-type-capture-clause.rs | 4 +- src/test/run-pass/no-landing-pads.rs | 6 +- .../run-pass/panic-in-dtor-drops-fields.rs | 6 +- src/test/run-pass/realloc-16687.rs | 3 +- src/test/run-pass/running-with-no-runtime.rs | 4 +- src/test/run-pass/send-resource.rs | 4 +- src/test/run-pass/send_str_hashmap.rs | 5 +- src/test/run-pass/send_str_treemap.rs | 5 +- src/test/run-pass/sendfn-spawn-with-fn-arg.rs | 6 +- src/test/run-pass/sepcomp-unwind.rs | 4 +- src/test/run-pass/slice-panic-1.rs | 4 +- src/test/run-pass/slice-panic-2.rs | 4 +- src/test/run-pass/spawn-fn.rs | 10 +- src/test/run-pass/spawn-types.rs | 5 +- src/test/run-pass/spawn.rs | 4 +- src/test/run-pass/spawn2.rs | 7 +- src/test/run-pass/task-comm-0.rs | 4 +- src/test/run-pass/task-comm-1.rs | 4 +- src/test/run-pass/task-comm-10.rs | 6 +- src/test/run-pass/task-comm-11.rs | 8 +- src/test/run-pass/task-comm-13.rs | 6 +- src/test/run-pass/task-comm-14.rs | 8 +- src/test/run-pass/task-comm-15.rs | 6 +- src/test/run-pass/task-comm-17.rs | 4 +- src/test/run-pass/task-comm-7.rs | 10 +- src/test/run-pass/task-life-0.rs | 4 +- src/test/run-pass/task-spawn-move-and-copy.rs | 4 +- src/test/run-pass/tcp-accept-stress.rs | 11 +- src/test/run-pass/tcp-connect-timeouts.rs | 3 +- src/test/run-pass/tempfile.rs | 22 +- src/test/run-pass/terminate-in-initializer.rs | 6 +- src/test/run-pass/threads.rs | 7 +- src/test/run-pass/trait-bounds-in-arc.rs | 8 +- src/test/run-pass/unique-send-2.rs | 6 +- .../run-pass/unit-like-struct-drop-run.rs | 6 +- src/test/run-pass/unwind-resource.rs | 4 +- src/test/run-pass/unwind-unique.rs | 4 +- src/test/run-pass/utf8_chars.rs | 34 +- src/test/run-pass/vector-sort-panic-safe.rs | 36 +- .../run-pass/wait-forked-but-failed-child.rs | 13 +- src/test/run-pass/weak-lang-item.rs | 4 +- src/test/run-pass/yield2.rs | 4 +- 239 files changed, 1104 insertions(+), 7460 deletions(-) delete mode 100644 src/libregex_macros/lib.rs delete mode 100644 src/libstd/sync/atomic.rs delete mode 100644 src/libstd/task.rs delete mode 100644 src/libsyntax/ext/deriving/zero.rs delete mode 100644 src/libtime/lib.rs delete mode 100644 src/test/compile-fail-fulldeps/syntax-extension-regex-invalid.rs delete mode 100644 src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs delete mode 100644 src/test/compile-fail-fulldeps/syntax-extension-regex-unused.rs delete mode 100644 src/test/compile-fail/atomicoption-not-send-ref.rs delete mode 100644 src/test/compile-fail/atomicoption-not-send.rs delete mode 100644 src/test/compile-fail/deriving-span-Zero-struct.rs delete mode 100644 src/test/compile-fail/deriving-span-Zero-tuple-struct.rs delete mode 100644 src/test/compile-fail/spawn-non-nil-fn.rs delete mode 100644 src/test/run-pass/deriving-zero.rs diff --git a/mk/crates.mk b/mk/crates.mk index c3b31e60f19ad..cea92e19a2682 100644 --- a/mk/crates.mk +++ b/mk/crates.mk @@ -50,12 +50,12 @@ ################################################################################ TARGET_CRATES := libc std flate arena term \ - serialize getopts collections test time rand \ + serialize getopts collections test rand \ log regex graphviz core rbml alloc \ unicode RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \ rustc_trans rustc_back rustc_llvm -HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc regex_macros fmt_macros +HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc fmt_macros CRATES := $(TARGET_CRATES) $(HOST_CRATES) TOOLS := compiletest rustdoc rustc @@ -75,11 +75,11 @@ DEPS_rustc_typeck := rustc syntax DEPS_rustc_borrowck := rustc log graphviz syntax DEPS_rustc_resolve := rustc log syntax DEPS_rustc := syntax flate arena serialize getopts rbml \ - time log graphviz rustc_llvm rustc_back + log graphviz rustc_llvm rustc_back DEPS_rustc_llvm := native:rustllvm libc std DEPS_rustc_back := std syntax rustc_llvm flate log libc DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \ - test time + test DEPS_flate := std native:miniz DEPS_arena := std DEPS_graphviz := std @@ -90,12 +90,10 @@ DEPS_term := std log DEPS_getopts := std DEPS_collections := core alloc unicode DEPS_num := std -DEPS_test := std getopts serialize rbml term time regex native:rust_test_helpers -DEPS_time := std serialize +DEPS_test := std getopts serialize rbml term regex native:rust_test_helpers DEPS_rand := core DEPS_log := std regex DEPS_regex := std -DEPS_regex_macros = rustc syntax std regex DEPS_fmt_macros = std TOOL_DEPS_compiletest := test getopts @@ -124,10 +122,8 @@ DOC_CRATES := $(filter-out rustc, \ $(filter-out rustc_driver, \ $(filter-out log, \ $(filter-out regex, \ - $(filter-out regex_macros, \ $(filter-out getopts, \ - $(filter-out time, \ - $(filter-out syntax, $(CRATES))))))))))))) + $(filter-out syntax, $(CRATES))))))))))) COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_resolve \ rustc_typeck rustc_driver syntax diff --git a/mk/grammar.mk b/mk/grammar.mk index 08461f9dcc2b7..93e40302f5176 100644 --- a/mk/grammar.mk +++ b/mk/grammar.mk @@ -37,7 +37,7 @@ $(BG)RustLexer.class: $(BG) $(SG)RustLexer.g4 check-build-lexer-verifier: $(BG)verify ifeq ($(NO_REBUILD),) -VERIFY_DEPS := rustc-stage2-H-$(CFG_BUILD) $(LD)stamp.regex_macros $(LD)stamp.rustc +VERIFY_DEPS := rustc-stage2-H-$(CFG_BUILD) $(LD)stamp.rustc else VERIFY_DEPS := endif diff --git a/mk/tests.mk b/mk/tests.mk index bf07d6de0e026..714a9f8900547 100644 --- a/mk/tests.mk +++ b/mk/tests.mk @@ -373,15 +373,6 @@ TESTDEP_$(1)_$(2)_$(3)_$(4) = $$(SREQ$(1)_T_$(2)_H_$(3)) \ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)) \ $$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4)) -# The regex crate depends on the regex_macros crate during testing, but it -# notably depend on the *host* regex_macros crate, not the target version. -# Additionally, this is not a dependency in stage1, only in stage2. -ifeq ($(4),regex) -ifneq ($(1),1) -TESTDEP_$(1)_$(2)_$(3)_$(4) += $$(TLIB$(1)_T_$(3)_H_$(3))/stamp.regex_macros -endif -endif - else TESTDEP_$(1)_$(2)_$(3)_$(4) = $$(RSINPUTS_$(4)) endif @@ -843,27 +834,8 @@ else CRATEDOCTESTDEP_$(1)_$(2)_$(3)_$(4) = $$(RSINPUTS_$(4)) endif -# (Issues #13732, #13983, #14000) The doc for the regex crate includes -# uses of the `regex!` macro from the regex_macros crate. There is -# normally a dependence injected that makes the target's regex depend -# upon the host's regex_macros (see #13845), but that dependency -# injection is currently skipped for stage1 as a special case. -# -# Therefore, as a further special case, this conditional skips -# attempting to run the doc tests for the regex crate atop stage1, -# (since there is no regex_macros crate for the stage1 rustc to load). -# -# (Another approach for solving this would be to inject the desired -# dependence for stage1 as well, by setting things up to generate a -# regex_macros crate that was compatible with the stage1 rustc and -# thus re-enable our ability to run this test.) -ifeq (stage$(1)-crate-$(4),stage1-crate-regex) -check-stage$(1)-T-$(2)-H-$(3)-doc-crate-$(4)-exec: - @$$(call E, skipping doc-crate-$(4) as it uses macros and cannot run at stage$(1)) -else check-stage$(1)-T-$(2)-H-$(3)-doc-crate-$(4)-exec: \ $$(call TEST_OK_FILE,$(1),$(2),$(3),doc-crate-$(4)) -endif ifeq ($(2),$$(CFG_BUILD)) $$(call TEST_OK_FILE,$(1),$(2),$(3),doc-crate-$(4)): $$(CRATEDOCTESTDEP_$(1)_$(2)_$(3)_$(4)) diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index ad1264828cb96..350a10ce4832a 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -22,7 +22,7 @@ extern crate regex; use std::os; use std::io; use std::io::fs; -use std::str::{FromStr, from_str}; +use std::str::FromStr; use std::thunk::Thunk; use getopts::{optopt, optflag, reqopt}; use common::Config; diff --git a/src/doc/reference.md b/src/doc/reference.md index 8c2c5ab7b8580..d793028526052 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -1478,11 +1478,11 @@ Constants should in general be preferred over statics, unless large amounts of data are being stored, or single-address and mutability properties are required. ``` -use std::sync::atomic; +use std::sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT};; // Note that ATOMIC_UINT_INIT is a *const*, but it may be used to initialize a // static. This static can be modified, so it is not placed in read-only memory. -static COUNTER: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT; +static COUNTER: AtomicUint = ATOMIC_UINT_INIT; // This table is a candidate to be placed in read-only memory. static TABLE: &'static [uint] = &[1, 2, 3, /* ... */]; @@ -1490,7 +1490,7 @@ static TABLE: &'static [uint] = &[1, 2, 3, /* ... */]; for slot in TABLE.iter() { println!("{}", slot); } -COUNTER.fetch_add(1, atomic::SeqCst); +COUNTER.fetch_add(1, Ordering::SeqCst); ``` #### Mutable statics diff --git a/src/grammar/verify.rs b/src/grammar/verify.rs index 56e1736196ece..db26ca6ffa5d5 100644 --- a/src/grammar/verify.rs +++ b/src/grammar/verify.rs @@ -19,10 +19,9 @@ extern crate regex; #[phase(link, plugin)] extern crate log; -#[phase(plugin)] extern crate regex_macros; - use std::collections::HashMap; use std::io::File; +use regex::Regex; use syntax::parse; use syntax::parse::lexer; @@ -168,9 +167,9 @@ fn count(lit: &str) -> uint { } fn parse_antlr_token(s: &str, tokens: &HashMap) -> TokenAndSpan { - let re = regex!( + let re = Regex::new( r"\[@(?P\d+),(?P\d+):(?P\d+)='(?P.+?)',<(?P-?\d+)>,\d+:\d+]" - ); + ).unwrap(); let m = re.captures(s).expect(format!("The regex didn't match {}", s).as_slice()); let start = m.name("start").unwrap_or(""); diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 0a81418334674..88f02d6573eac 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -600,11 +600,9 @@ mod tests { use std::ops::Drop; use std::option::Option; use std::option::Option::{Some, None}; - use std::str::Str; use std::sync::atomic; use std::sync::atomic::Ordering::{Acquire, SeqCst}; - use std::task; - use std::kinds::Send; + use std::thread::Thread; use std::vec::Vec; use super::{Arc, Weak, weak_count, strong_count}; use std::sync::Mutex; @@ -631,7 +629,7 @@ mod tests { let (tx, rx) = channel(); - task::spawn(move || { + let _t = Thread::spawn(move || { let arc_v: Arc> = rx.recv().unwrap(); assert_eq!((*arc_v)[3], 4); }); diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index aab513ddeb7b1..d040f8ff86390 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -77,12 +77,6 @@ extern crate libc; #[cfg(test)] #[phase(plugin, link)] extern crate std; #[cfg(test)] #[phase(plugin, link)] extern crate log; -// The deprecated name of the boxed module - -#[deprecated = "use boxed instead"] -#[cfg(not(test))] -pub use boxed as owned; - // Heaps provided for low-level allocation strategies pub mod heap; diff --git a/src/libcollections/bench.rs b/src/libcollections/bench.rs index fbaebd0125d0d..c7164b8199cc3 100644 --- a/src/libcollections/bench.rs +++ b/src/libcollections/bench.rs @@ -68,7 +68,8 @@ pub fn find_rand_n(n: uint, { // setup let mut rng = rand::weak_rng(); - let mut keys = Vec::from_fn(n, |_| rng.gen::() % n); + let mut keys = range(0, n).map(|_| rng.gen::() % n) + .collect::>(); for k in keys.iter() { insert(map, *k); diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index 9f005a327b17c..5e7089bb7aca2 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -685,12 +685,6 @@ impl Bitv { ).collect() } - /// Deprecated: Use `iter().collect()`. - #[deprecated = "Use `iter().collect()`"] - pub fn to_bools(&self) -> Vec { - self.iter().collect() - } - /// Compares a `Bitv` to a slice of `bool`s. /// Both the `Bitv` and slice must have the same length. /// @@ -935,18 +929,6 @@ impl Bitv { } } -/// Deprecated: Now a static method on Bitv. -#[deprecated = "Now a static method on Bitv"] -pub fn from_bytes(bytes: &[u8]) -> Bitv { - Bitv::from_bytes(bytes) -} - -/// Deprecated: Now a static method on Bitv. -#[deprecated = "Now a static method on Bitv"] -pub fn from_fn(len: uint, f: F) -> Bitv where F: FnMut(uint) -> bool { - Bitv::from_fn(len, f) -} - #[stable] impl Default for Bitv { #[inline] @@ -1907,14 +1889,9 @@ impl<'a> Iterator for SymmetricDifference<'a> { #[cfg(test)] mod tests { use prelude::*; - use core::iter::range_step; use core::u32; - use std::rand; - use std::rand::Rng; - use test::{Bencher, black_box}; - use super::{Bitv, BitvSet, from_fn, from_bytes}; - use bitv; + use super::Bitv; #[test] fn test_to_str() { @@ -1928,7 +1905,7 @@ mod tests { #[test] fn test_0_elements() { let act = Bitv::new(); - let exp = Vec::from_elem(0u, false); + let exp = Vec::new(); assert!(act.eq_vec(exp.as_slice())); assert!(act.none() && act.all()); } @@ -2318,7 +2295,7 @@ mod tests { assert_eq!(bitv.iter().collect::>(), bools); - let long = Vec::from_fn(10000, |i| i % 2 == 0); + let long = range(0, 10000).map(|i| i % 2 == 0).collect::>(); let bitv: Bitv = long.iter().map(|n| *n).collect(); assert_eq!(bitv.iter().collect::>(), long) } diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 159f572319394..3a722178bc02c 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -187,12 +187,6 @@ impl BTreeMap { for _ in mem::replace(self, BTreeMap::with_b(b)).into_iter() {}; } - /// Deprecated: renamed to `get`. - #[deprecated = "renamed to `get`"] - pub fn find(&self, key: &K) -> Option<&V> { - self.get(key) - } - // Searching in a B-Tree is pretty straightforward. // // Start at the root. Try to find the key in the current node. If we find it, return it. @@ -253,12 +247,6 @@ impl BTreeMap { self.get(key).is_some() } - /// Deprecated: renamed to `get_mut`. - #[deprecated = "renamed to `get_mut`"] - pub fn find_mut(&mut self, key: &K) -> Option<&mut V> { - self.get_mut(key) - } - /// Returns a mutable reference to the value corresponding to the key. /// /// The key may be any borrowed form of the map's key type, but the ordering @@ -297,12 +285,6 @@ impl BTreeMap { } } - /// Deprecated: renamed to `insert`. - #[deprecated = "renamed to `insert`"] - pub fn swap(&mut self, key: K, value: V) -> Option { - self.insert(key, value) - } - // Insertion in a B-Tree is a bit complicated. // // First we do the same kind of search described in `find`. But we need to maintain a stack of @@ -438,12 +420,6 @@ impl BTreeMap { // the underflow handling process on the parent. If merging merges the last two children // of the root, then we replace the root with the merged node. - /// Deprecated: renamed to `remove`. - #[deprecated = "renamed to `remove`"] - pub fn pop(&mut self, key: &K) -> Option { - self.remove(key) - } - /// Removes a key from the map, returning the value at the key if the key /// was previously in the map. /// @@ -1506,7 +1482,7 @@ mod test { let size = 10000u; // Forwards - let mut map: BTreeMap = Vec::from_fn(size, |i| (i, i)).into_iter().collect(); + let mut map: BTreeMap = range(0, size).map(|i| (i, i)).collect(); { let mut iter = map.iter(); @@ -1545,7 +1521,7 @@ mod test { let size = 10000u; // Forwards - let mut map: BTreeMap = Vec::from_fn(size, |i| (i, i)).into_iter().collect(); + let mut map: BTreeMap = range(0, size).map(|i| (i, i)).collect(); { let mut iter = map.iter().rev(); diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 6d7e6778ec989..ca8e75ac43c8d 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -219,22 +219,6 @@ impl DList { DList{list_head: None, list_tail: Rawlink::none(), length: 0} } - /// Deprecated: Not clearly useful enough; use split and append when available. - #[deprecated = "Not clearly useful enough; use split and append when available"] - pub fn rotate_forward(&mut self) { - self.pop_back_node().map(|tail| { - self.push_front_node(tail) - }); - } - - /// Deprecated: Not clearly useful enough; use split and append when available. - #[deprecated = "Not clearly useful enough; use split and append when available"] - pub fn rotate_backward(&mut self) { - self.pop_front_node().map(|head| { - self.push_back_node(head) - }); - } - /// Adds all elements from `other` to the end of the list. /// /// This operation should compute in O(1) time. @@ -277,49 +261,6 @@ impl DList { } } - /// Deprecated: Use append and a swap instead. - #[deprecated = "Use append and a swap instead"] - pub fn prepend(&mut self, mut other: DList) { - mem::swap(self, &mut other); - self.append(other); - } - - /// Deprecated: Use custom methods on IterMut. - #[deprecated = "Use custom methods on IterMut"] - pub fn insert_when(&mut self, elt: T, mut f: F) where F: FnMut(&T, &T) -> bool { - let mut it = self.iter_mut(); - loop { - match it.peek_next() { - None => break, - Some(x) => if f(x, &elt) { break } - } - it.next(); - } - it.insert_next(elt); - } - - /// Deprecated: Use custom methods on IterMut. - #[deprecated = "Use custom methods on IterMut"] - pub fn merge(&mut self, mut other: DList, mut f: F) where F: FnMut(&T, &T) -> bool { - { - let mut it = self.iter_mut(); - loop { - let take_a = match (it.peek_next(), other.front()) { - (_ , None) => return, - (None, _ ) => break, - (Some(ref mut x), Some(y)) => f(*x, y), - }; - if take_a { - it.next(); - } else { - it.insert_next_node(other.pop_front_node().unwrap()); - } - } - } - self.append(other); - } - - /// Provides a forward iterator. #[inline] #[stable] @@ -426,12 +367,6 @@ impl DList { self.pop_front_node().map(|box Node{value, ..}| value) } - /// Deprecated: Renamed to `push_back`. - #[deprecated = "Renamed to `push_back`"] - pub fn push(&mut self, elt: T) { - self.push_back(elt) - } - /// Appends an element to the back of a list /// /// # Examples @@ -449,12 +384,6 @@ impl DList { self.push_back_node(box Node::new(elt)) } - /// Deprecated: Renamed to `pop_back`. - #[deprecated = "Renamed to `pop_back`"] - pub fn pop(&mut self) -> Option { - self.pop_back() - } - /// Removes the last element from a list and returns it, or `None` if /// it is empty. /// @@ -475,15 +404,6 @@ impl DList { } } -impl DList { - /// Deprecated: Why are you maintaining a sorted DList? - #[deprecated = "Why are you maintaining a sorted DList?"] - #[allow(deprecated)] - pub fn insert_ordered(&mut self, elt: T) { - self.insert_when(elt, |a, b| a >= b) - } -} - #[unsafe_destructor] #[stable] impl Drop for DList { @@ -589,19 +509,6 @@ impl<'a, A> DoubleEndedIterator for IterMut<'a, A> { #[stable] impl<'a, A> ExactSizeIterator for IterMut<'a, A> {} -/// Allows mutating a `DList` while iterating. -#[deprecated = "Trait is deprecated, use inherent methods on the iterator instead"] -pub trait ListInsertion { - /// Inserts `elt` just after to the element most recently returned by - /// `.next()` - /// - /// The inserted element does not appear in the iteration. - fn insert_next(&mut self, elt: A); - - /// Provides a reference to the next element, without changing the iterator - fn peek_next<'a>(&'a mut self) -> Option<&'a mut A>; -} - // private methods for IterMut impl<'a, A> IterMut<'a, A> { fn insert_next_node(&mut self, mut ins_node: Box>) { @@ -780,7 +687,7 @@ mod tests { use prelude::*; use std::rand; use std::hash; - use std::task::spawn; + use std::thread::Thread; use test::Bencher; use test; @@ -868,88 +775,6 @@ mod tests { v.iter().map(|x| (*x).clone()).collect() } - #[test] - #[allow(deprecated)] - fn test_append() { - { - let mut m = DList::new(); - let mut n = DList::new(); - n.push_back(2i); - m.append(n); - assert_eq!(m.len(), 1); - assert_eq!(m.pop_back(), Some(2)); - check_links(&m); - } - { - let mut m = DList::new(); - let n = DList::new(); - m.push_back(2i); - m.append(n); - assert_eq!(m.len(), 1); - assert_eq!(m.pop_back(), Some(2)); - check_links(&m); - } - - let v = vec![1i,2,3,4,5]; - let u = vec![9i,8,1,2,3,4,5]; - let mut m = list_from(v.as_slice()); - m.append(list_from(u.as_slice())); - check_links(&m); - let mut sum = v; - sum.push_all(u.as_slice()); - assert_eq!(sum.len(), m.len()); - for elt in sum.into_iter() { - assert_eq!(m.pop_front(), Some(elt)) - } - } - - #[test] - fn test_prepend() { - { - let mut m = DList::new(); - let mut n = DList::new(); - n.push_back(2i); - m.prepend(n); - assert_eq!(m.len(), 1); - assert_eq!(m.pop_back(), Some(2)); - check_links(&m); - } - - let v = vec![1i,2,3,4,5]; - let mut u = vec![9i,8,1,2,3,4,5]; - let mut m = list_from(v.as_slice()); - m.prepend(list_from(u.as_slice())); - check_links(&m); - u.extend(v.iter().map(|&b| b)); - assert_eq!(u.len(), m.len()); - for elt in u.into_iter() { - assert_eq!(m.pop_front(), Some(elt)) - } - } - - #[test] - fn test_rotate() { - let mut n: DList = DList::new(); - n.rotate_backward(); check_links(&n); - assert_eq!(n.len(), 0); - n.rotate_forward(); check_links(&n); - assert_eq!(n.len(), 0); - - let v = vec![1i,2,3,4,5]; - let mut m = list_from(v.as_slice()); - m.rotate_backward(); check_links(&m); - m.rotate_forward(); check_links(&m); - assert_eq!(v.iter().collect::>(), m.iter().collect::>()); - m.rotate_forward(); check_links(&m); - m.rotate_forward(); check_links(&m); - m.pop_front(); check_links(&m); - m.rotate_forward(); check_links(&m); - m.rotate_backward(); check_links(&m); - m.push_front(9); check_links(&m); - m.rotate_forward(); check_links(&m); - assert_eq!(vec![3i,9,5,1,2], m.into_iter().collect::>()); - } - #[test] fn test_iterator() { let m = generate_test(); @@ -1080,33 +905,6 @@ mod tests { assert_eq!(m.into_iter().collect::>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]); } - #[test] - fn test_merge() { - let mut m = list_from(&[0i, 1, 3, 5, 6, 7, 2]); - let n = list_from(&[-1i, 0, 0, 7, 7, 9]); - let len = m.len() + n.len(); - m.merge(n, |a, b| a <= b); - assert_eq!(m.len(), len); - check_links(&m); - let res = m.into_iter().collect::>(); - assert_eq!(res, vec![-1, 0, 0, 0, 1, 3, 5, 6, 7, 2, 7, 7, 9]); - } - - #[test] - fn test_insert_ordered() { - let mut n = DList::new(); - n.insert_ordered(1i); - assert_eq!(n.len(), 1); - assert_eq!(n.pop_front(), Some(1)); - - let mut m = DList::new(); - m.push_back(2i); - m.push_back(4); - m.insert_ordered(3); - check_links(&m); - assert_eq!(vec![2,3,4], m.into_iter().collect::>()); - } - #[test] fn test_mut_rev_iter() { let mut m = generate_test(); @@ -1124,11 +922,11 @@ mod tests { #[test] fn test_send() { let n = list_from(&[1i,2,3]); - spawn(move || { + Thread::spawn(move || { check_links(&n); let a: &[_] = &[&1,&2,&3]; assert_eq!(a, n.iter().collect::>()); - }); + }).join().ok().unwrap(); } #[test] @@ -1265,6 +1063,40 @@ mod tests { assert_eq!(i, v.len()); } + #[allow(deprecated)] + fn test_append() { + { + let mut m = DList::new(); + let mut n = DList::new(); + n.push_back(2i); + m.append(n); + assert_eq!(m.len(), 1); + assert_eq!(m.pop_back(), Some(2)); + check_links(&m); + } + { + let mut m = DList::new(); + let n = DList::new(); + m.push_back(2i); + m.append(n); + assert_eq!(m.len(), 1); + assert_eq!(m.pop_back(), Some(2)); + check_links(&m); + } + + let v = vec![1i,2,3,4,5]; + let u = vec![9i,8,1,2,3,4,5]; + let mut m = list_from(v.as_slice()); + m.append(list_from(u.as_slice())); + check_links(&m); + let mut sum = v; + sum.push_all(u.as_slice()); + assert_eq!(sum.len(), m.len()); + for elt in sum.into_iter() { + assert_eq!(m.pop_front(), Some(elt)) + } + } + #[bench] fn bench_collect_into(b: &mut test::Bencher) { let v = &[0i; 64]; @@ -1307,26 +1139,6 @@ mod tests { }) } - #[bench] - fn bench_rotate_forward(b: &mut test::Bencher) { - let mut m: DList = DList::new(); - m.push_front(0i); - m.push_front(1); - b.iter(|| { - m.rotate_forward(); - }) - } - - #[bench] - fn bench_rotate_backward(b: &mut test::Bencher) { - let mut m: DList = DList::new(); - m.push_front(0i); - m.push_front(1); - b.iter(|| { - m.rotate_backward(); - }) - } - #[bench] fn bench_iter(b: &mut test::Bencher) { let v = &[0i; 128]; diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 324e0cb2b7ba9..4b94348e87ae3 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -81,12 +81,6 @@ fn bit(e: &E) -> uint { } impl EnumSet { - /// Deprecated: Renamed to `new`. - #[deprecated = "Renamed to `new`"] - pub fn empty() -> EnumSet { - EnumSet::new() - } - /// Returns an empty `EnumSet`. #[unstable = "matches collection reform specification, waiting for dust to settle"] pub fn new() -> EnumSet { @@ -109,13 +103,6 @@ impl EnumSet { self.bits = 0; } - /// Returns `true` if the `EnumSet` contains any enum of the given `EnumSet`. - /// Deprecated: Use `is_disjoint`. - #[deprecated = "Use `is_disjoint`"] - pub fn intersects(&self, e: EnumSet) -> bool { - !self.is_disjoint(&e) - } - /// Returns `false` if the `EnumSet` contains any enum of the given `EnumSet`. #[unstable = "matches collection reform specification, waiting for dust to settle"] pub fn is_disjoint(&self, other: &EnumSet) -> bool { @@ -144,12 +131,6 @@ impl EnumSet { EnumSet {bits: self.bits & e.bits} } - /// Deprecated: Use `insert`. - #[deprecated = "Use `insert`"] - pub fn add(&mut self, e: E) { - self.insert(e); - } - /// Adds an enum to the `EnumSet`, and returns `true` if it wasn't there before #[unstable = "matches collection reform specification, waiting for dust to settle"] pub fn insert(&mut self, e: E) -> bool { @@ -166,12 +147,6 @@ impl EnumSet { result } - /// Deprecated: use `contains`. - #[deprecated = "use `contains"] - pub fn contains_elem(&self, e: E) -> bool { - self.contains(&e) - } - /// Returns `true` if an `EnumSet` contains a given enum. #[unstable = "matches collection reform specification, waiting for dust to settle"] pub fn contains(&self, e: &E) -> bool { diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index fb9530882db35..944b224fed854 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -66,7 +66,7 @@ pub mod vec; pub mod vec_map; pub mod bitv { - pub use bit::{Bitv, Iter, from_fn, from_bytes}; + pub use bit::{Bitv, Iter}; } pub mod bitv_set { @@ -105,7 +105,7 @@ mod prelude { pub use core::borrow::IntoCow; pub use core::char::Char; pub use core::clone::Clone; - pub use core::cmp::{PartialEq, Eq, Equiv, PartialOrd, Ord}; + pub use core::cmp::{PartialEq, Eq, PartialOrd, Ord}; pub use core::cmp::Ordering::{Less, Equal, Greater}; pub use core::iter::range; pub use core::iter::{FromIterator, Extend, IteratorExt}; @@ -123,7 +123,7 @@ mod prelude { // in core and collections (may differ). pub use slice::{AsSlice, SliceExt}; - pub use str::{from_str, Str, StrExt}; + pub use str::{Str, StrExt}; // from other crates. pub use alloc::boxed::Box; @@ -131,7 +131,6 @@ mod prelude { // from collections. pub use slice::SliceConcatExt; - pub use str::IntoMaybeOwned; pub use string::{String, ToString}; pub use vec::Vec; } diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 77f41a2b0a7e5..e86c40bed212f 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -681,12 +681,6 @@ impl RingBuf { unsafe { self.buffer_write(tail, t); } } - /// Deprecated: Renamed to `push_back`. - #[deprecated = "Renamed to `push_back`"] - pub fn push(&mut self, t: T) { - self.push_back(t) - } - /// Appends an element to the back of a buffer /// /// # Examples @@ -711,12 +705,6 @@ impl RingBuf { unsafe { self.buffer_write(head, t) } } - /// Deprecated: Renamed to `pop_back`. - #[deprecated = "Renamed to `pop_back`"] - pub fn pop(&mut self) -> Option { - self.pop_back() - } - /// Removes the last element from a buffer and returns it, or `None` if /// it is empty. /// @@ -1452,7 +1440,6 @@ mod tests { use self::Taggy::*; use self::Taggypar::*; use prelude::*; - use core::cmp; use core::iter; use std::fmt::Show; use std::hash; diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 510be24befd1c..3602bfc10c307 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -92,7 +92,7 @@ use core::borrow::{BorrowFrom, BorrowFromMut, ToOwned}; use core::clone::Clone; use core::cmp::Ordering::{self, Greater, Less}; use core::cmp::{self, Ord, PartialEq}; -use core::iter::{Iterator, IteratorExt, IteratorCloneExt}; +use core::iter::{Iterator, IteratorExt}; use core::iter::{range, range_step, MultiplicativeIterator}; use core::kinds::Sized; use core::mem::size_of; @@ -114,12 +114,6 @@ pub use core::slice::{SplitN, RSplitN, SplitNMut, RSplitNMut}; pub use core::slice::{bytes, mut_ref_slice, ref_slice}; pub use core::slice::{from_raw_buf, from_raw_mut_buf}; -#[deprecated = "use Iter instead"] -pub type Items<'a, T:'a> = Iter<'a, T>; - -#[deprecated = "use IterMut instead"] -pub type MutItems<'a, T:'a> = IterMut<'a, T>; - //////////////////////////////////////////////////////////////////////////////// // Basic slice extension methods //////////////////////////////////////////////////////////////////////////////// @@ -287,10 +281,6 @@ pub trait SliceExt for Sized? { #[stable] fn first(&self) -> Option<&Self::Item>; - /// Deprecated: renamed to `first`. - #[deprecated = "renamed to `first`"] - fn head(&self) -> Option<&Self::Item> { self.first() } - /// Returns all but the first element of a slice. #[experimental = "likely to be renamed"] fn tail(&self) -> &[Self::Item]; @@ -308,12 +298,6 @@ pub trait SliceExt for Sized? { #[stable] unsafe fn get_unchecked(&self, index: uint) -> &Self::Item; - /// Deprecated: renamed to `get_unchecked`. - #[deprecated = "renamed to get_unchecked"] - unsafe fn unsafe_get(&self, index: uint) -> &Self::Item { - self.get_unchecked(index) - } - /// Returns an unsafe pointer to the slice's buffer /// /// The caller must ensure that the slice outlives the pointer this @@ -425,12 +409,6 @@ pub trait SliceExt for Sized? { #[stable] fn first_mut(&mut self) -> Option<&mut Self::Item>; - /// Depreated: renamed to `first_mut`. - #[deprecated = "renamed to first_mut"] - fn head_mut(&mut self) -> Option<&mut Self::Item> { - self.first_mut() - } - /// Returns all but the first element of a mutable slice #[experimental = "likely to be renamed or removed"] fn tail_mut(&mut self) -> &mut [Self::Item]; @@ -549,12 +527,6 @@ pub trait SliceExt for Sized? { #[stable] unsafe fn get_unchecked_mut(&mut self, index: uint) -> &mut Self::Item; - /// Deprecated: renamed to `get_unchecked_mut`. - #[deprecated = "renamed to get_unchecked_mut"] - unsafe fn unchecked_mut(&mut self, index: uint) -> &mut Self::Item { - self.get_unchecked_mut(index) - } - /// Return an unsafe mutable pointer to the slice's buffer. /// /// The caller must ensure that the slice outlives the pointer this @@ -570,12 +542,6 @@ pub trait SliceExt for Sized? { #[stable] fn to_vec(&self) -> Vec where Self::Item: Clone; - /// Deprecated: use `iter().cloned().partition(f)` instead. - #[deprecated = "use iter().cloned().partition(f) instead"] - fn partitioned(&self, f: F) -> (Vec, Vec) where - Self::Item: Clone, - F: FnMut(&Self::Item) -> bool; - /// Creates an iterator that yields every possible permutation of the /// vector in succession. /// @@ -960,12 +926,6 @@ impl SliceExt for [T] { vector } - - #[inline] - fn partitioned(&self, f: F) -> (Vec, Vec) where F: FnMut(&T) -> bool, T: Clone { - self.iter().cloned().partition(f) - } - /// Returns an iterator over all permutations of a vector. fn permutations(&self) -> Permutations where T: Clone { Permutations{ @@ -1034,20 +994,10 @@ pub trait SliceConcatExt for Sized? { #[stable] fn concat(&self) -> U; - #[deprecated = "renamed to concat"] - fn concat_vec(&self) -> U { - self.concat() - } - /// Flattens a slice of `T` into a single value `U`, placing a /// given seperator between each. #[stable] fn connect(&self, sep: &T) -> U; - - #[deprecated = "renamed to connect"] - fn connect_vec(&self, sep: &T) -> U { - self.connect(sep) - } } impl> SliceConcatExt> for [V] { @@ -1438,21 +1388,12 @@ fn merge_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order } } -/// Deprecated, unsafe operations -#[deprecated] -pub mod raw { - pub use core::slice::raw::{buf_as_slice, mut_buf_as_slice}; - pub use core::slice::raw::{shift_ptr, pop_ptr}; -} - #[cfg(test)] mod tests { - use std::boxed::Box; use prelude::{Some, None, range, Vec, ToString, Clone, Greater, Less, Equal}; use prelude::{SliceExt, Iterator, IteratorExt}; use prelude::AsSlice; use prelude::{RandomAccessIterator, Ord, SliceConcatExt}; - use core::cell::Cell; use core::default::Default; use core::mem; use std::rand::{Rng, thread_rng}; @@ -1466,7 +1407,7 @@ mod tests { #[test] fn test_from_fn() { // Test on-stack from_fn. - let mut v = Vec::from_fn(3u, square); + let mut v = range(0, 3).map(square).collect::>(); { let v = v.as_slice(); assert_eq!(v.len(), 3u); @@ -1476,7 +1417,7 @@ mod tests { } // Test on-heap from_fn. - v = Vec::from_fn(5u, square); + v = range(0, 5).map(square).collect::>(); { let v = v.as_slice(); assert_eq!(v.len(), 5u); @@ -1491,7 +1432,7 @@ mod tests { #[test] fn test_from_elem() { // Test on-stack from_elem. - let mut v = Vec::from_elem(2u, 10u); + let mut v = vec![10u, 10u]; { let v = v.as_slice(); assert_eq!(v.len(), 2u); @@ -1500,7 +1441,7 @@ mod tests { } // Test on-heap from_elem. - v = Vec::from_elem(6u, 20u); + v = vec![20u, 20u, 20u, 20u, 20u, 20u]; { let v = v.as_slice(); assert_eq!(v[0], 20u); @@ -1542,23 +1483,23 @@ mod tests { } #[test] - fn test_head() { + fn test_first() { let mut a = vec![]; - assert_eq!(a.as_slice().head(), None); + assert_eq!(a.as_slice().first(), None); a = vec![11i]; - assert_eq!(a.as_slice().head().unwrap(), &11); + assert_eq!(a.as_slice().first().unwrap(), &11); a = vec![11i, 12]; - assert_eq!(a.as_slice().head().unwrap(), &11); + assert_eq!(a.as_slice().first().unwrap(), &11); } #[test] - fn test_head_mut() { + fn test_first_mut() { let mut a = vec![]; - assert_eq!(a.head_mut(), None); + assert_eq!(a.first_mut(), None); a = vec![11i]; - assert_eq!(*a.head_mut().unwrap(), 11); + assert_eq!(*a.first_mut().unwrap(), 11); a = vec![11i, 12]; - assert_eq!(*a.head_mut().unwrap(), 11); + assert_eq!(*a.first_mut().unwrap(), 11); } #[test] @@ -1762,42 +1703,6 @@ mod tests { assert_eq!(v.as_slice()[1], 2); } - #[test] - fn test_grow() { - // Test on-stack grow(). - let mut v = vec![]; - v.grow(2u, 1i); - { - let v = v.as_slice(); - assert_eq!(v.len(), 2u); - assert_eq!(v[0], 1); - assert_eq!(v[1], 1); - } - - // Test on-heap grow(). - v.grow(3u, 2i); - { - let v = v.as_slice(); - assert_eq!(v.len(), 5u); - assert_eq!(v[0], 1); - assert_eq!(v[1], 1); - assert_eq!(v[2], 2); - assert_eq!(v[3], 2); - assert_eq!(v[4], 2); - } - } - - #[test] - fn test_grow_fn() { - let mut v = vec![]; - v.grow_fn(3u, square); - let v = v.as_slice(); - assert_eq!(v.len(), 3u); - assert_eq!(v[0], 0u); - assert_eq!(v[1], 1u); - assert_eq!(v[2], 4u); - } - #[test] fn test_truncate() { let mut v = vec![box 6i,box 5,box 4]; @@ -2130,22 +2035,6 @@ mod tests { } } - #[test] - fn test_partition() { - assert_eq!((vec![]).partition(|x: &int| *x < 3), (vec![], vec![])); - assert_eq!((vec![1i, 2, 3]).partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![])); - assert_eq!((vec![1i, 2, 3]).partition(|x: &int| *x < 2), (vec![1], vec![2, 3])); - assert_eq!((vec![1i, 2, 3]).partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3])); - } - - #[test] - fn test_partitioned() { - assert_eq!(([]).partitioned(|x: &int| *x < 3), (vec![], vec![])); - assert_eq!(([1i, 2, 3]).partitioned(|x: &int| *x < 4), (vec![1, 2, 3], vec![])); - assert_eq!(([1i, 2, 3]).partitioned(|x: &int| *x < 2), (vec![1], vec![2, 3])); - assert_eq!(([1i, 2, 3]).partitioned(|x: &int| *x < 0), (vec![], vec![1, 2, 3])); - } - #[test] fn test_concat() { let v: [Vec; 0] = []; @@ -2163,14 +2052,14 @@ mod tests { #[test] fn test_connect() { let v: [Vec; 0] = []; - assert_eq!(v.connect_vec(&0), vec![]); - assert_eq!([vec![1i], vec![2i, 3]].connect_vec(&0), vec![1, 0, 2, 3]); - assert_eq!([vec![1i], vec![2i], vec![3i]].connect_vec(&0), vec![1, 0, 2, 0, 3]); + assert_eq!(v.connect(&0), vec![]); + assert_eq!([vec![1i], vec![2i, 3]].connect(&0), vec![1, 0, 2, 3]); + assert_eq!([vec![1i], vec![2i], vec![3i]].connect(&0), vec![1, 0, 2, 0, 3]); let v: [&[int]; 2] = [&[1], &[2, 3]]; - assert_eq!(v.connect_vec(&0), vec![1, 0, 2, 3]); + assert_eq!(v.connect(&0), vec![1, 0, 2, 3]); let v: [&[int]; 3] = [&[1], &[2], &[3]]; - assert_eq!(v.connect_vec(&0), vec![1, 0, 2, 0, 3]); + assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]); } #[test] @@ -2243,55 +2132,6 @@ mod tests { assert_eq!(v[1], 3); } - - #[test] - #[should_fail] - fn test_from_fn_fail() { - Vec::from_fn(100, |v| { - if v == 50 { panic!() } - box 0i - }); - } - - #[test] - #[should_fail] - fn test_from_elem_fail() { - - struct S { - f: Cell, - boxes: (Box, Rc) - } - - impl Clone for S { - fn clone(&self) -> S { - self.f.set(self.f.get() + 1); - if self.f.get() == 10 { panic!() } - S { - f: self.f.clone(), - boxes: self.boxes.clone(), - } - } - } - - let s = S { - f: Cell::new(0), - boxes: (box 0, Rc::new(0)), - }; - let _ = Vec::from_elem(100, s); - } - - #[test] - #[should_fail] - fn test_grow_fn_fail() { - let mut v = vec![]; - v.grow_fn(100, |i| { - if i == 50 { - panic!() - } - (box 0i, Rc::new(0i)) - }) - } - #[test] #[should_fail] fn test_permute_fail() { @@ -2880,6 +2720,7 @@ mod bench { use prelude::*; use core::mem; use core::ptr; + use core::iter::repeat; use std::rand::{weak_rng, Rng}; use test::{Bencher, black_box}; @@ -2887,7 +2728,7 @@ mod bench { fn iterator(b: &mut Bencher) { // peculiar numbers to stop LLVM from optimising the summation // out. - let v = Vec::from_fn(100, |i| i ^ (i << 1) ^ (i >> 1)); + let v = range(0u, 100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect::>(); b.iter(|| { let mut sum = 0; @@ -2901,7 +2742,7 @@ mod bench { #[bench] fn mut_iterator(b: &mut Bencher) { - let mut v = Vec::from_elem(100, 0i); + let mut v = repeat(0i).take(100).collect::>(); b.iter(|| { let mut i = 0i; @@ -2915,7 +2756,7 @@ mod bench { #[bench] fn concat(b: &mut Bencher) { let xss: Vec> = - Vec::from_fn(100, |i| range(0u, i).collect()); + range(0, 100u).map(|i| range(0, i).collect()).collect(); b.iter(|| { xss.as_slice().concat(); }); @@ -2924,9 +2765,9 @@ mod bench { #[bench] fn connect(b: &mut Bencher) { let xss: Vec> = - Vec::from_fn(100, |i| range(0u, i).collect()); + range(0, 100u).map(|i| range(0, i).collect()).collect(); b.iter(|| { - xss.as_slice().connect_vec(&0) + xss.as_slice().connect(&0) }); } @@ -2941,7 +2782,7 @@ mod bench { #[bench] fn starts_with_same_vector(b: &mut Bencher) { - let vec: Vec = Vec::from_fn(100, |i| i); + let vec: Vec = range(0, 100).collect(); b.iter(|| { vec.as_slice().starts_with(vec.as_slice()) }) @@ -2957,8 +2798,8 @@ mod bench { #[bench] fn starts_with_diff_one_element_at_end(b: &mut Bencher) { - let vec: Vec = Vec::from_fn(100, |i| i); - let mut match_vec: Vec = Vec::from_fn(99, |i| i); + let vec: Vec = range(0, 100).collect(); + let mut match_vec: Vec = range(0, 99).collect(); match_vec.push(0); b.iter(|| { vec.as_slice().starts_with(match_vec.as_slice()) @@ -2967,7 +2808,7 @@ mod bench { #[bench] fn ends_with_same_vector(b: &mut Bencher) { - let vec: Vec = Vec::from_fn(100, |i| i); + let vec: Vec = range(0, 100).collect(); b.iter(|| { vec.as_slice().ends_with(vec.as_slice()) }) @@ -2983,8 +2824,8 @@ mod bench { #[bench] fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) { - let vec: Vec = Vec::from_fn(100, |i| i); - let mut match_vec: Vec = Vec::from_fn(100, |i| i); + let vec: Vec = range(0, 100).collect(); + let mut match_vec: Vec = range(0, 100).collect(); match_vec.as_mut_slice()[0] = 200; b.iter(|| { vec.as_slice().starts_with(match_vec.as_slice()) @@ -2993,7 +2834,7 @@ mod bench { #[bench] fn contains_last_element(b: &mut Bencher) { - let vec: Vec = Vec::from_fn(100, |i| i); + let vec: Vec = range(0, 100).collect(); b.iter(|| { vec.contains(&99u) }) @@ -3002,7 +2843,7 @@ mod bench { #[bench] fn zero_1kb_from_elem(b: &mut Bencher) { b.iter(|| { - Vec::from_elem(1024, 0u8) + repeat(0u8).take(1024).collect::>() }); } @@ -3050,24 +2891,24 @@ mod bench { fn random_inserts(b: &mut Bencher) { let mut rng = weak_rng(); b.iter(|| { - let mut v = Vec::from_elem(30, (0u, 0u)); - for _ in range(0u, 100) { - let l = v.len(); - v.insert(rng.gen::() % (l + 1), - (1, 1)); - } - }) + let mut v = repeat((0u, 0u)).take(30).collect::>(); + for _ in range(0u, 100) { + let l = v.len(); + v.insert(rng.gen::() % (l + 1), + (1, 1)); + } + }) } #[bench] fn random_removes(b: &mut Bencher) { let mut rng = weak_rng(); b.iter(|| { - let mut v = Vec::from_elem(130, (0u, 0u)); - for _ in range(0u, 100) { - let l = v.len(); - v.remove(rng.gen::() % l); - } - }) + let mut v = repeat((0u, 0u)).take(130).collect::>(); + for _ in range(0u, 100) { + let l = v.len(); + v.remove(rng.gen::() % l); + } + }) } #[bench] @@ -3102,7 +2943,7 @@ mod bench { #[bench] fn sort_sorted(b: &mut Bencher) { - let mut v = Vec::from_fn(10000, |i| i); + let mut v = range(0u, 10000).collect::>(); b.iter(|| { v.sort(); }); @@ -3146,7 +2987,7 @@ mod bench { #[bench] fn sort_big_sorted(b: &mut Bencher) { - let mut v = Vec::from_fn(10000u, |i| (i, i, i, i)); + let mut v = range(0, 10000u).map(|i| (i, i, i, i)).collect::>(); b.iter(|| { v.sort(); }); diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index fe85d4a5a9307..ed6a957d2acfa 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -51,20 +51,14 @@ #![doc(primitive = "str")] -use self::MaybeOwned::*; use self::RecompositionState::*; use self::DecompositionType::*; -use core::borrow::{BorrowFrom, Cow, ToOwned}; +use core::borrow::{BorrowFrom, ToOwned}; use core::char::Char; use core::clone::Clone; -use core::cmp::{Equiv, PartialEq, Eq, PartialOrd, Ord, Ordering}; -use core::cmp; -use core::default::Default; -use core::fmt; -use core::hash; use core::iter::AdditiveIterator; -use core::iter::{self, range, Iterator, IteratorExt}; +use core::iter::{range, Iterator, IteratorExt}; use core::kinds::Sized; use core::ops; use core::option::Option::{self, Some, None}; @@ -79,16 +73,13 @@ use unicode; use vec::Vec; use slice::SliceConcatExt; -pub use core::str::{from_utf8, CharEq, Chars, CharIndices}; -pub use core::str::{Bytes, CharSplits, is_utf8}; -pub use core::str::{CharSplitsN, Lines, LinesAny, MatchIndices, StrSplits, SplitStr}; -pub use core::str::{CharRange}; -pub use core::str::{FromStr, from_str, Utf8Error}; -pub use core::str::Str; -pub use core::str::{from_utf8_unchecked, from_c_str}; -pub use unicode::str::{Words, Graphemes, GraphemeIndices}; +pub use core::str::{FromStr, Utf8Error, Str}; +pub use core::str::{Lines, LinesAny, MatchIndices, SplitStr, CharRange}; pub use core::str::{Split, SplitTerminator}; pub use core::str::{SplitN, RSplitN}; +pub use core::str::{from_utf8, CharEq, Chars, CharIndices, Bytes}; +pub use core::str::{from_utf8_unchecked, from_c_str}; +pub use unicode::str::{Words, Graphemes, GraphemeIndices}; /* Section: Creating a string @@ -371,32 +362,6 @@ impl<'a> Iterator for Utf16Units<'a> { fn size_hint(&self) -> (uint, Option) { self.encoder.size_hint() } } -/// Replaces all occurrences of one string with another. -/// -/// # Arguments -/// -/// * s - The string containing substrings to replace -/// * from - The string to replace -/// * to - The replacement string -/// -/// # Return value -/// -/// The original string with all occurrences of `from` replaced with `to`. -/// -/// # Examples -/// -/// ```rust -/// # #![allow(deprecated)] -/// use std::str; -/// let string = "orange"; -/// let new_string = str::replace(string, "or", "str"); -/// assert_eq!(new_string.as_slice(), "strange"); -/// ``` -#[deprecated = "call the inherent method instead"] -pub fn replace(s: &str, from: &str, to: &str) -> String { - s.replace(from, to) -} - /* Section: Misc */ @@ -413,215 +378,6 @@ macro_rules! utf8_acc_cont_byte { ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as u32) } -/* -Section: MaybeOwned -*/ - -/// A string type that can hold either a `String` or a `&str`. -/// This can be useful as an optimization when an allocation is sometimes -/// needed but not always. -#[deprecated = "use std::string::CowString"] -pub enum MaybeOwned<'a> { - /// A borrowed string. - Slice(&'a str), - /// An owned string. - Owned(String) -} - -/// A specialization of `CowString` to be sendable. -#[deprecated = "use std::string::CowString<'static>"] -pub type SendStr = CowString<'static>; - -#[deprecated = "use std::string::CowString"] -impl<'a> MaybeOwned<'a> { - /// Returns `true` if this `MaybeOwned` wraps an owned string. - /// - /// # Examples - /// - /// ``` ignore - /// let string = String::from_str("orange"); - /// let maybe_owned_string = string.into_maybe_owned(); - /// assert_eq!(true, maybe_owned_string.is_owned()); - /// ``` - #[inline] - pub fn is_owned(&self) -> bool { - match *self { - Slice(_) => false, - Owned(_) => true - } - } - - /// Returns `true` if this `MaybeOwned` wraps a borrowed string. - /// - /// # Examples - /// - /// ``` ignore - /// let string = "orange"; - /// let maybe_owned_string = string.as_slice().into_maybe_owned(); - /// assert_eq!(true, maybe_owned_string.is_slice()); - /// ``` - #[inline] - pub fn is_slice(&self) -> bool { - match *self { - Slice(_) => true, - Owned(_) => false - } - } - - /// Return the number of bytes in this string. - #[inline] - #[allow(deprecated)] - pub fn len(&self) -> uint { self.as_slice().len() } - - /// Returns true if the string contains no bytes - #[allow(deprecated)] - #[inline] - pub fn is_empty(&self) -> bool { self.len() == 0 } -} - -#[deprecated = "use std::borrow::IntoCow"] -/// Trait for moving into a `MaybeOwned`. -pub trait IntoMaybeOwned<'a> { - /// Moves `self` into a `MaybeOwned`. - fn into_maybe_owned(self) -> MaybeOwned<'a>; -} - -#[deprecated = "use std::borrow::IntoCow"] -#[allow(deprecated)] -impl<'a> IntoMaybeOwned<'a> for String { - /// # Examples - /// - /// ``` ignore - /// let owned_string = String::from_str("orange"); - /// let maybe_owned_string = owned_string.into_maybe_owned(); - /// assert_eq!(true, maybe_owned_string.is_owned()); - /// ``` - #[allow(deprecated)] - #[inline] - fn into_maybe_owned(self) -> MaybeOwned<'a> { - Owned(self) - } -} - -#[deprecated = "use std::borrow::IntoCow"] -#[allow(deprecated)] -impl<'a> IntoMaybeOwned<'a> for &'a str { - /// # Examples - /// - /// ``` ignore - /// let string = "orange"; - /// let maybe_owned_str = string.as_slice().into_maybe_owned(); - /// assert_eq!(false, maybe_owned_str.is_owned()); - /// ``` - #[allow(deprecated)] - #[inline] - fn into_maybe_owned(self) -> MaybeOwned<'a> { Slice(self) } -} - -#[allow(deprecated)] -#[deprecated = "use std::borrow::IntoCow"] -impl<'a> IntoMaybeOwned<'a> for MaybeOwned<'a> { - /// # Examples - /// - /// ``` ignore - /// let str = "orange"; - /// let maybe_owned_str = str.as_slice().into_maybe_owned(); - /// let maybe_maybe_owned_str = maybe_owned_str.into_maybe_owned(); - /// assert_eq!(false, maybe_maybe_owned_str.is_owned()); - /// ``` - #[inline] - fn into_maybe_owned(self) -> MaybeOwned<'a> { self } -} - -#[deprecated = "use std::string::CowString"] -#[allow(deprecated)] -impl<'a> PartialEq for MaybeOwned<'a> { - #[inline] - fn eq(&self, other: &MaybeOwned) -> bool { - self.as_slice() == other.as_slice() - } -} - -#[deprecated = "use std::string::CowString"] -impl<'a> Eq for MaybeOwned<'a> {} - -#[deprecated = "use std::string::CowString"] -impl<'a> PartialOrd for MaybeOwned<'a> { - #[inline] - fn partial_cmp(&self, other: &MaybeOwned) -> Option { - Some(self.cmp(other)) - } -} - -#[deprecated = "use std::string::CowString"] -impl<'a> Ord for MaybeOwned<'a> { - #[inline] - #[allow(deprecated)] - fn cmp(&self, other: &MaybeOwned) -> Ordering { - self.as_slice().cmp(other.as_slice()) - } -} - -#[allow(deprecated)] -#[deprecated = "use std::string::CowString"] -impl<'a, S: Str> Equiv for MaybeOwned<'a> { - #[inline] - fn equiv(&self, other: &S) -> bool { - self.as_slice() == other.as_slice() - } -} - -#[deprecated = "use std::string::CowString"] -#[allow(deprecated)] -impl<'a> Str for MaybeOwned<'a> { - #[inline] - fn as_slice<'b>(&'b self) -> &'b str { - match *self { - Slice(s) => s, - Owned(ref s) => s.as_slice() - } - } -} - -#[deprecated = "use std::string::CowString"] -impl<'a> Clone for MaybeOwned<'a> { - #[allow(deprecated)] - #[inline] - fn clone(&self) -> MaybeOwned<'a> { - match *self { - Slice(s) => Slice(s), - Owned(ref s) => Owned(String::from_str(s.as_slice())) - } - } -} - -#[deprecated = "use std::string::CowString"] -impl<'a> Default for MaybeOwned<'a> { - #[allow(deprecated)] - #[inline] - fn default() -> MaybeOwned<'a> { Slice("") } -} - -#[deprecated = "use std::string::CowString"] -#[allow(deprecated)] -impl<'a, H: hash::Writer> hash::Hash for MaybeOwned<'a> { - #[inline] - fn hash(&self, hasher: &mut H) { - self.as_slice().hash(hasher) - } -} - -#[deprecated = "use std::string::CowString"] -impl<'a> fmt::Show for MaybeOwned<'a> { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - Slice(ref s) => s.fmt(f), - Owned(ref s) => s.fmt(f) - } - } -} - #[unstable = "trait is unstable"] impl BorrowFrom for str { fn borrow_from(owned: &String) -> &str { owned[] } @@ -636,21 +392,10 @@ impl ToOwned for str { } } -/// Unsafe string operations. -#[deprecated] -pub mod raw { - pub use core::str::raw::{from_utf8, c_str_to_static_slice, slice_bytes}; - pub use core::str::raw::{slice_unchecked}; -} - /* Section: CowString */ -/// A clone-on-write string -#[deprecated = "use std::string::CowString instead"] -pub type CowString<'a> = Cow<'a, String, str>; - /* Section: Trait implementations */ @@ -706,46 +451,6 @@ pub trait StrExt for Sized?: ops::Slice { result } - /// Given a string, makes a new string with repeated copies of it. - #[deprecated = "use repeat(self).take(n).collect() instead"] - fn repeat(&self, nn: uint) -> String { - iter::repeat(self[]).take(nn).collect() - } - - /// Returns the Levenshtein Distance between two strings. - #[deprecated = "this function will be removed"] - fn lev_distance(&self, t: &str) -> uint { - let me = self[]; - if me.is_empty() { return t.chars().count(); } - if t.is_empty() { return me.chars().count(); } - - let mut dcol: Vec<_> = range(0, t.len() + 1).collect(); - let mut t_last = 0; - - for (i, sc) in me.chars().enumerate() { - - let mut current = i; - dcol[0] = current + 1; - - for (j, tc) in t.chars().enumerate() { - - let next = dcol[j + 1]; - - if sc == tc { - dcol[j + 1] = current; - } else { - dcol[j + 1] = cmp::min(current, next); - dcol[j + 1] = cmp::min(dcol[j + 1], dcol[j]) + 1; - } - - current = next; - t_last = j; - } - } - - dcol[t_last + 1] - } - /// Returns an iterator over the string in Unicode Normalization Form D /// (canonical decomposition). #[inline] @@ -1002,7 +707,7 @@ pub trait StrExt for Sized?: ops::Slice { /// assert_eq!(v, vec!["1", "", "2"]); /// ``` #[unstable = "might get removed in the future in favor of a more generic split()"] - fn split_str<'a>(&'a self, pat: &'a str) -> StrSplits<'a> { + fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> { core_str::StrExt::split_str(self[], pat) } @@ -1038,43 +743,6 @@ pub trait StrExt for Sized?: ops::Slice { core_str::StrExt::lines_any(self[]) } - /// Returns the number of Unicode code points (`char`) that a - /// string holds. - /// - /// This does not perform any normalization, and is `O(n)`, since - /// UTF-8 is a variable width encoding of code points. - /// - /// *Warning*: The number of code points in a string does not directly - /// correspond to the number of visible characters or width of the - /// visible text due to composing characters, and double- and - /// zero-width ones. - /// - /// See also `.len()` for the byte length. - /// - /// # Example - /// - /// ```rust - /// # #![allow(deprecated)] - /// // composed forms of `ö` and `é` - /// let c = "Löwe 老虎 Léopard"; // German, Simplified Chinese, French - /// // decomposed forms of `ö` and `é` - /// let d = "Lo\u{0308}we 老虎 Le\u{0301}opard"; - /// - /// assert_eq!(c.char_len(), 15); - /// assert_eq!(d.char_len(), 17); - /// - /// assert_eq!(c.len(), 21); - /// assert_eq!(d.len(), 23); - /// - /// // the two strings *look* the same - /// println!("{}", c); - /// println!("{}", d); - /// ``` - #[deprecated = "call .chars().count() instead"] - fn char_len(&self) -> uint { - core_str::StrExt::char_len(self[]) - } - /// Returns a slice of the given string from the byte range /// [`begin`..`end`). /// @@ -1220,12 +888,6 @@ pub trait StrExt for Sized?: ops::Slice { core_str::StrExt::trim_matches(self[], pat) } - /// Deprecated - #[deprecated = "Replaced by `trim_matches`"] - fn trim_chars<'a, C: CharEq>(&'a self, to_trim: C) -> &'a str { - self.trim_matches(to_trim) - } - /// Returns a string with all prefixes that match /// the pattern `pat` repeatedly removed. /// @@ -1246,12 +908,6 @@ pub trait StrExt for Sized?: ops::Slice { core_str::StrExt::trim_left_matches(self[], pat) } - /// Deprecated - #[deprecated = "Replaced by `trim_left_matches`"] - fn trim_left_chars<'a, C: CharEq>(&'a self, to_trim: C) -> &'a str { - self.trim_left_matches(to_trim) - } - /// Returns a string with all suffixes that match /// the pattern `pat` repeatedly removed. /// @@ -1272,12 +928,6 @@ pub trait StrExt for Sized?: ops::Slice { core_str::StrExt::trim_right_matches(self[], pat) } - /// Deprecated - #[deprecated = "Replaced by `trim_right_matches`"] - fn trim_right_chars<'a, C: CharEq>(&'a self, to_trim: C) -> &'a str { - self.trim_right_matches(to_trim) - } - /// Check that `index`-th byte lies at the start and/or end of a /// UTF-8 code point sequence. /// @@ -1599,7 +1249,7 @@ pub trait StrExt for Sized?: ops::Slice { #[inline] #[unstable = "this method was just created"] fn parse(&self) -> Option { - FromStr::from_str(self[]) + core_str::StrExt::parse(self[]) } /// Returns an iterator over the @@ -1657,43 +1307,6 @@ pub trait StrExt for Sized?: ops::Slice { UnicodeStr::words(self[]) } - /// Returns true if the string contains only whitespace. - /// - /// Whitespace characters are determined by `char::is_whitespace`. - /// - /// # Example - /// - /// ```rust - /// # #![allow(deprecated)] - /// assert!(" \t\n".is_whitespace()); - /// assert!("".is_whitespace()); - /// - /// assert!( !"abc".is_whitespace()); - /// ``` - #[deprecated = "use .chars().all(|c| c.is_whitespace())"] - fn is_whitespace(&self) -> bool { - UnicodeStr::is_whitespace(self[]) - } - - /// Returns true if the string contains only alphanumeric code - /// points. - /// - /// Alphanumeric characters are determined by `char::is_alphanumeric`. - /// - /// # Example - /// - /// ```rust - /// # #![allow(deprecated)] - /// assert!("Löwe老虎Léopard123".is_alphanumeric()); - /// assert!("".is_alphanumeric()); - /// - /// assert!( !" &*~".is_alphanumeric()); - /// ``` - #[deprecated = "use .chars().all(|c| c.is_alphanumeric())"] - fn is_alphanumeric(&self) -> bool { - UnicodeStr::is_alphanumeric(self[]) - } - /// Returns a string's displayed width in columns, treating control /// characters as zero-width. /// @@ -1725,13 +1338,6 @@ pub trait StrExt for Sized?: ops::Slice { fn trim_right(&self) -> &str { UnicodeStr::trim_right(self[]) } - - /// Deprecated, call `.to_owned()` instead from the `std::borrow::ToOwned` - /// trait. - #[deprecated = "call `.to_owned()` on `std::borrow::ToOwned` instead"] - fn into_string(&self) -> String { - self[].to_owned() - } } impl StrExt for str {} @@ -1740,10 +1346,8 @@ impl StrExt for str {} mod tests { use prelude::*; - use core::default::Default; use core::iter::AdditiveIterator; - use super::{from_utf8, is_utf8, raw}; - use super::MaybeOwned::{Owned, Slice}; + use super::from_utf8; use super::Utf8Error; #[test] @@ -1764,14 +1368,14 @@ mod tests { assert_eq!("\u{2620}".len(), 3u); assert_eq!("\u{1d11e}".len(), 4u); - assert_eq!("".char_len(), 0u); - assert_eq!("hello world".char_len(), 11u); - assert_eq!("\x63".char_len(), 1u); - assert_eq!("\u{a2}".char_len(), 1u); - assert_eq!("\u{3c0}".char_len(), 1u); - assert_eq!("\u{2620}".char_len(), 1u); - assert_eq!("\u{1d11e}".char_len(), 1u); - assert_eq!("ประเทศไทย中华Việt Nam".char_len(), 19u); + assert_eq!("".chars().count(), 0u); + assert_eq!("hello world".chars().count(), 11u); + assert_eq!("\x63".chars().count(), 1u); + assert_eq!("\u{a2}".chars().count(), 1u); + assert_eq!("\u{3c0}".chars().count(), 1u); + assert_eq!("\u{2620}".chars().count(), 1u); + assert_eq!("\u{1d11e}".chars().count(), 1u); + assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19u); assert_eq!("ｈｅｌｌｏ".width(false), 10u); assert_eq!("ｈｅｌｌｏ".width(true), 10u); @@ -1854,7 +1458,7 @@ mod tests { #[test] fn test_slice_chars() { fn t(a: &str, b: &str, start: uint) { - assert_eq!(a.slice_chars(start, start + b.char_len()), b); + assert_eq!(a.slice_chars(start, start + b.chars().count()), b); } t("", "", 0); t("hello", "llo", 2); @@ -1864,7 +1468,7 @@ mod tests { assert_eq!("ะเทศไท", "ประเทศไทย中华Việt Nam".slice_chars(2, 8)); } - fn s(x: &str) -> String { x.into_string() } + fn s(x: &str) -> String { x.to_string() } macro_rules! test_concat { ($expected: expr, $string: expr) => { @@ -1904,7 +1508,7 @@ mod tests { #[test] fn test_connect_for_different_types() { test_connect!("a-b", ["a", "b"], "-"); - let hyphen = "-".into_string(); + let hyphen = "-".to_string(); test_connect!("a-b", [s("a"), s("b")], hyphen.as_slice()); test_connect!("a-b", vec!["a", "b"], hyphen.as_slice()); test_connect!("a-b", vec!["a", "b"].as_slice(), "-"); @@ -1920,20 +1524,11 @@ mod tests { test_connect!("-a-bc", ["", "a", "bc"], "-"); } - #[test] - fn test_repeat() { - assert_eq!("x".repeat(4), String::from_str("xxxx")); - assert_eq!("hi".repeat(4), String::from_str("hihihihi")); - assert_eq!("ไท华".repeat(3), String::from_str("ไท华ไท华ไท华")); - assert_eq!("".repeat(4), String::from_str("")); - assert_eq!("hi".repeat(0), String::from_str("")); - } - #[test] fn test_unsafe_slice() { - assert_eq!("ab", unsafe {raw::slice_bytes("abc", 0, 2)}); - assert_eq!("bc", unsafe {raw::slice_bytes("abc", 1, 3)}); - assert_eq!("", unsafe {raw::slice_bytes("abc", 1, 1)}); + assert_eq!("ab", unsafe {"abc".slice_unchecked(0, 2)}); + assert_eq!("bc", unsafe {"abc".slice_unchecked(1, 3)}); + assert_eq!("", unsafe {"abc".slice_unchecked(1, 1)}); fn a_million_letter_a() -> String { let mut i = 0u; let mut rs = String::new(); @@ -1954,7 +1549,7 @@ mod tests { } let letters = a_million_letter_a(); assert!(half_a_million_letter_a() == - unsafe {String::from_str(raw::slice_bytes(letters.as_slice(), + unsafe {String::from_str(letters.slice_unchecked( 0u, 500000))}); } @@ -2120,48 +1715,48 @@ mod tests { } #[test] - fn test_trim_left_chars() { + fn test_trim_left_matches() { let v: &[char] = &[]; - assert_eq!(" *** foo *** ".trim_left_chars(v), " *** foo *** "); + assert_eq!(" *** foo *** ".trim_left_matches(v), " *** foo *** "); let chars: &[char] = &['*', ' ']; - assert_eq!(" *** foo *** ".trim_left_chars(chars), "foo *** "); - assert_eq!(" *** *** ".trim_left_chars(chars), ""); - assert_eq!("foo *** ".trim_left_chars(chars), "foo *** "); + assert_eq!(" *** foo *** ".trim_left_matches(chars), "foo *** "); + assert_eq!(" *** *** ".trim_left_matches(chars), ""); + assert_eq!("foo *** ".trim_left_matches(chars), "foo *** "); - assert_eq!("11foo1bar11".trim_left_chars('1'), "foo1bar11"); + assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11"); let chars: &[char] = &['1', '2']; - assert_eq!("12foo1bar12".trim_left_chars(chars), "foo1bar12"); - assert_eq!("123foo1bar123".trim_left_chars(|&: c: char| c.is_numeric()), "foo1bar123"); + assert_eq!("12foo1bar12".trim_left_matches(chars), "foo1bar12"); + assert_eq!("123foo1bar123".trim_left_matches(|&: c: char| c.is_numeric()), "foo1bar123"); } #[test] - fn test_trim_right_chars() { + fn test_trim_right_matches() { let v: &[char] = &[]; - assert_eq!(" *** foo *** ".trim_right_chars(v), " *** foo *** "); + assert_eq!(" *** foo *** ".trim_right_matches(v), " *** foo *** "); let chars: &[char] = &['*', ' ']; - assert_eq!(" *** foo *** ".trim_right_chars(chars), " *** foo"); - assert_eq!(" *** *** ".trim_right_chars(chars), ""); - assert_eq!(" *** foo".trim_right_chars(chars), " *** foo"); + assert_eq!(" *** foo *** ".trim_right_matches(chars), " *** foo"); + assert_eq!(" *** *** ".trim_right_matches(chars), ""); + assert_eq!(" *** foo".trim_right_matches(chars), " *** foo"); - assert_eq!("11foo1bar11".trim_right_chars('1'), "11foo1bar"); + assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar"); let chars: &[char] = &['1', '2']; - assert_eq!("12foo1bar12".trim_right_chars(chars), "12foo1bar"); - assert_eq!("123foo1bar123".trim_right_chars(|&: c: char| c.is_numeric()), "123foo1bar"); + assert_eq!("12foo1bar12".trim_right_matches(chars), "12foo1bar"); + assert_eq!("123foo1bar123".trim_right_matches(|&: c: char| c.is_numeric()), "123foo1bar"); } #[test] - fn test_trim_chars() { + fn test_trim_matches() { let v: &[char] = &[]; - assert_eq!(" *** foo *** ".trim_chars(v), " *** foo *** "); + assert_eq!(" *** foo *** ".trim_matches(v), " *** foo *** "); let chars: &[char] = &['*', ' ']; - assert_eq!(" *** foo *** ".trim_chars(chars), "foo"); - assert_eq!(" *** *** ".trim_chars(chars), ""); - assert_eq!("foo".trim_chars(chars), "foo"); + assert_eq!(" *** foo *** ".trim_matches(chars), "foo"); + assert_eq!(" *** *** ".trim_matches(chars), ""); + assert_eq!("foo".trim_matches(chars), "foo"); - assert_eq!("11foo1bar11".trim_chars('1'), "foo1bar"); + assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); let chars: &[char] = &['1', '2']; - assert_eq!("12foo1bar12".trim_chars(chars), "foo1bar"); - assert_eq!("123foo1bar123".trim_chars(|&: c: char| c.is_numeric()), "foo1bar"); + assert_eq!("12foo1bar12".trim_matches(chars), "foo1bar"); + assert_eq!("123foo1bar123".trim_matches(|&: c: char| c.is_numeric()), "foo1bar"); } #[test] @@ -2196,11 +1791,11 @@ mod tests { #[test] fn test_is_whitespace() { - assert!("".is_whitespace()); - assert!(" ".is_whitespace()); - assert!("\u{2009}".is_whitespace()); // Thin space - assert!(" \n\t ".is_whitespace()); - assert!(!" _ ".is_whitespace()); + assert!("".chars().all(|c| c.is_whitespace())); + assert!(" ".chars().all(|c| c.is_whitespace())); + assert!("\u{2009}".chars().all(|c| c.is_whitespace())); // Thin space + assert!(" \n\t ".chars().all(|c| c.is_whitespace())); + assert!(!" _ ".chars().all(|c| c.is_whitespace())); } #[test] @@ -2218,26 +1813,26 @@ mod tests { #[test] fn test_is_utf8() { // deny overlong encodings - assert!(!is_utf8(&[0xc0, 0x80])); - assert!(!is_utf8(&[0xc0, 0xae])); - assert!(!is_utf8(&[0xe0, 0x80, 0x80])); - assert!(!is_utf8(&[0xe0, 0x80, 0xaf])); - assert!(!is_utf8(&[0xe0, 0x81, 0x81])); - assert!(!is_utf8(&[0xf0, 0x82, 0x82, 0xac])); - assert!(!is_utf8(&[0xf4, 0x90, 0x80, 0x80])); + assert!(from_utf8(&[0xc0, 0x80]).is_err()); + assert!(from_utf8(&[0xc0, 0xae]).is_err()); + assert!(from_utf8(&[0xe0, 0x80, 0x80]).is_err()); + assert!(from_utf8(&[0xe0, 0x80, 0xaf]).is_err()); + assert!(from_utf8(&[0xe0, 0x81, 0x81]).is_err()); + assert!(from_utf8(&[0xf0, 0x82, 0x82, 0xac]).is_err()); + assert!(from_utf8(&[0xf4, 0x90, 0x80, 0x80]).is_err()); // deny surrogates - assert!(!is_utf8(&[0xED, 0xA0, 0x80])); - assert!(!is_utf8(&[0xED, 0xBF, 0xBF])); + assert!(from_utf8(&[0xED, 0xA0, 0x80]).is_err()); + assert!(from_utf8(&[0xED, 0xBF, 0xBF]).is_err()); - assert!(is_utf8(&[0xC2, 0x80])); - assert!(is_utf8(&[0xDF, 0xBF])); - assert!(is_utf8(&[0xE0, 0xA0, 0x80])); - assert!(is_utf8(&[0xED, 0x9F, 0xBF])); - assert!(is_utf8(&[0xEE, 0x80, 0x80])); - assert!(is_utf8(&[0xEF, 0xBF, 0xBF])); - assert!(is_utf8(&[0xF0, 0x90, 0x80, 0x80])); - assert!(is_utf8(&[0xF4, 0x8F, 0xBF, 0xBF])); + assert!(from_utf8(&[0xC2, 0x80]).is_ok()); + assert!(from_utf8(&[0xDF, 0xBF]).is_ok()); + assert!(from_utf8(&[0xE0, 0xA0, 0x80]).is_ok()); + assert!(from_utf8(&[0xED, 0x9F, 0xBF]).is_ok()); + assert!(from_utf8(&[0xEE, 0x80, 0x80]).is_ok()); + assert!(from_utf8(&[0xEF, 0xBF, 0xBF]).is_ok()); + assert!(from_utf8(&[0xF0, 0x90, 0x80, 0x80]).is_ok()); + assert!(from_utf8(&[0xF4, 0x8F, 0xBF, 0xBF]).is_ok()); } #[test] @@ -2411,7 +2006,7 @@ mod tests { let mut pos = 0; for ch in v.iter() { assert!(s.char_at(pos) == *ch); - pos += String::from_char(1, *ch).len(); + pos += ch.to_string().len(); } } @@ -2422,7 +2017,7 @@ mod tests { let mut pos = s.len(); for ch in v.iter().rev() { assert!(s.char_at_reverse(pos) == *ch); - pos -= String::from_char(1, *ch).len(); + pos -= ch.to_string().len(); } } @@ -3213,66 +2808,6 @@ mod tests { let xs = b"hello\xFF"; assert_eq!(from_utf8(xs), Err(Utf8Error::TooShort)); } - - #[test] - fn test_maybe_owned_traits() { - let s = Slice("abcde"); - assert_eq!(s.len(), 5); - assert_eq!(s.as_slice(), "abcde"); - assert_eq!(String::from_str(s.as_slice()).as_slice(), "abcde"); - assert_eq!(format!("{}", s).as_slice(), "abcde"); - assert!(s.lt(&Owned(String::from_str("bcdef")))); - assert_eq!(Slice(""), Default::default()); - - let o = Owned(String::from_str("abcde")); - assert_eq!(o.len(), 5); - assert_eq!(o.as_slice(), "abcde"); - assert_eq!(String::from_str(o.as_slice()).as_slice(), "abcde"); - assert_eq!(format!("{}", o).as_slice(), "abcde"); - assert!(o.lt(&Slice("bcdef"))); - assert_eq!(Owned(String::from_str("")), Default::default()); - - assert!(s.cmp(&o) == Equal); - assert!(s.equiv(&o)); - - assert!(o.cmp(&s) == Equal); - assert!(o.equiv(&s)); - } - - #[test] - fn test_maybe_owned_methods() { - let s = Slice("abcde"); - assert!(s.is_slice()); - assert!(!s.is_owned()); - - let o = Owned(String::from_str("abcde")); - assert!(!o.is_slice()); - assert!(o.is_owned()); - } - - #[test] - fn test_maybe_owned_clone() { - assert_eq!(Owned(String::from_str("abcde")), Slice("abcde").clone()); - assert_eq!(Owned(String::from_str("abcde")), Owned(String::from_str("abcde")).clone()); - assert_eq!(Slice("abcde"), Slice("abcde").clone()); - assert_eq!(Slice("abcde"), Owned(String::from_str("abcde")).clone()); - } - - #[test] - fn test_maybe_owned_into_string() { - assert_eq!(Slice("abcde").to_string(), String::from_str("abcde")); - assert_eq!(Owned(String::from_str("abcde")).to_string(), - String::from_str("abcde")); - } - - #[test] - fn test_into_maybe_owned() { - assert_eq!("abcde".into_maybe_owned(), Slice("abcde")); - assert_eq!((String::from_str("abcde")).into_maybe_owned(), Slice("abcde")); - assert_eq!("abcde".into_maybe_owned(), Owned(String::from_str("abcde"))); - assert_eq!((String::from_str("abcde")).into_maybe_owned(), - Owned(String::from_str("abcde"))); - } } #[cfg(test)] @@ -3329,7 +2864,7 @@ mod bench { #[bench] fn char_indicesator(b: &mut Bencher) { let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; - let len = s.char_len(); + let len = s.chars().count(); b.iter(|| assert_eq!(s.char_indices().count(), len)); } @@ -3337,7 +2872,7 @@ mod bench { #[bench] fn char_indicesator_rev(b: &mut Bencher) { let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; - let len = s.char_len(); + let len = s.chars().count(); b.iter(|| assert_eq!(s.char_indices().rev().count(), len)); } @@ -3416,27 +2951,6 @@ mod bench { b.iter(|| assert_eq!(s.split(c).count(), len)); } - #[bench] - fn is_utf8_100_ascii(b: &mut Bencher) { - - let s = b"Hello there, the quick brown fox jumped over the lazy dog! \ - Lorem ipsum dolor sit amet, consectetur. "; - - assert_eq!(100, s.len()); - b.iter(|| { - is_utf8(s) - }); - } - - #[bench] - fn is_utf8_100_multibyte(b: &mut Bencher) { - let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes(); - assert_eq!(100, s.len()); - b.iter(|| { - is_utf8(s) - }); - } - #[bench] fn bench_connect(b: &mut Bencher) { let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 0cd3770d39136..e7451331908ae 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -17,7 +17,6 @@ use core::prelude::*; use core::borrow::{Cow, IntoCow}; -use core::cmp::Equiv; use core::default::Default; use core::fmt; use core::hash; @@ -109,7 +108,6 @@ impl String { /// # Examples /// /// ```rust - /// # #![allow(deprecated)] /// use std::str::Utf8Error; /// /// let hello_vec = vec![104, 101, 108, 108, 111]; @@ -309,22 +307,6 @@ impl String { unicode_str::utf16_items(v).map(|c| c.to_char_lossy()).collect() } - /// Convert a vector of `char`s to a `String`. - /// - /// # Examples - /// - /// ```rust - /// # #![allow(deprecated)] - /// let chars = &['h', 'e', 'l', 'l', 'o']; - /// let s = String::from_chars(chars); - /// assert_eq!(s.as_slice(), "hello"); - /// ``` - #[inline] - #[deprecated = "use .collect() instead"] - pub fn from_chars(chs: &[char]) -> String { - chs.iter().map(|c| *c).collect() - } - /// Creates a new `String` from a length, capacity, and pointer. /// /// This is unsafe because: @@ -386,32 +368,6 @@ impl String { self.vec } - /// Creates a string buffer by repeating a character `length` times. - /// - /// # Examples - /// - /// ``` - /// # #![allow(deprecated)] - /// let s = String::from_char(5, 'a'); - /// assert_eq!(s.as_slice(), "aaaaa"); - /// ``` - #[inline] - #[deprecated = "use repeat(ch).take(length).collect() instead"] - pub fn from_char(length: uint, ch: char) -> String { - if length == 0 { - return String::new() - } - - let mut buf = String::new(); - buf.push(ch); - let size = buf.len() * (length - 1); - buf.reserve_exact(size); - for _ in range(1, length) { - buf.push(ch) - } - buf - } - /// Pushes the given string onto this string buffer. /// /// # Examples @@ -427,24 +383,6 @@ impl String { self.vec.push_all(string.as_bytes()) } - /// Pushes `ch` onto the given string `count` times. - /// - /// # Examples - /// - /// ``` - /// # #![allow(deprecated)] - /// let mut s = String::from_str("foo"); - /// s.grow(5, 'Z'); - /// assert_eq!(s.as_slice(), "fooZZZZZ"); - /// ``` - #[inline] - #[deprecated = "deprecated in favor of .extend(repeat(ch).take(count))"] - pub fn grow(&mut self, count: uint, ch: char) { - for _ in range(0, count) { - self.push(ch) - } - } - /// Returns the number of bytes that this string buffer can hold without /// reallocating. /// @@ -460,12 +398,6 @@ impl String { self.vec.capacity() } - /// Deprecated: Renamed to `reserve`. - #[deprecated = "Renamed to `reserve`"] - pub fn reserve_additional(&mut self, extra: uint) { - self.vec.reserve(extra) - } - /// Reserves capacity for at least `additional` more bytes to be inserted /// in the given `String`. The collection may reserve more space to avoid /// frequent reallocations. @@ -869,7 +801,6 @@ impl<'a, 'b> PartialEq> for &'b str { } #[experimental = "waiting on Str stabilization"] -#[allow(deprecated)] impl Str for String { #[inline] #[stable] @@ -901,15 +832,6 @@ impl hash::Hash for String { } } -#[allow(deprecated)] -#[deprecated = "Use overloaded `core::cmp::PartialEq`"] -impl<'a, S: Str> Equiv for String { - #[inline] - fn equiv(&self, other: &S) -> bool { - self.as_slice() == other.as_slice() - } -} - #[experimental = "waiting on Add stabilization"] impl<'a> Add<&'a str> for String { type Output = String; @@ -991,13 +913,6 @@ impl FromStr for String { } } -/// Trait for converting a type to a string, consuming it in the process. -#[deprecated = "trait will be removed"] -pub trait IntoString { - /// Consume and convert to a string. - fn into_string(self) -> String; -} - /// A generic trait for converting a value to a string pub trait ToString { /// Converts the value of `self` to an owned string @@ -1026,59 +941,10 @@ impl<'a> IntoCow<'a, String, str> for &'a str { } } -/// Unsafe operations -#[deprecated] -pub mod raw { - use super::String; - use vec::Vec; - - /// Creates a new `String` from a length, capacity, and pointer. - /// - /// This is unsafe because: - /// * We call `Vec::from_raw_parts` to get a `Vec`; - /// * We assume that the `Vec` contains valid UTF-8. - #[inline] - #[deprecated = "renamed to String::from_raw_parts"] - pub unsafe fn from_parts(buf: *mut u8, length: uint, capacity: uint) -> String { - String::from_raw_parts(buf, length, capacity) - } - - /// Creates a `String` from a `*const u8` buffer of the given length. - /// - /// This function is unsafe because of two reasons: - /// - /// * A raw pointer is dereferenced and transmuted to `&[u8]`; - /// * The slice is not checked to see whether it contains valid UTF-8. - #[deprecated = "renamed to String::from_raw_buf_len"] - pub unsafe fn from_buf_len(buf: *const u8, len: uint) -> String { - String::from_raw_buf_len(buf, len) - } - - /// Creates a `String` from a null-terminated `*const u8` buffer. - /// - /// This function is unsafe because we dereference memory until we find the NUL character, - /// which is not guaranteed to be present. Additionally, the slice is not checked to see - /// whether it contains valid UTF-8 - #[deprecated = "renamed to String::from_raw_buf"] - pub unsafe fn from_buf(buf: *const u8) -> String { - String::from_raw_buf(buf) - } - - /// Converts a vector of bytes to a new `String` without checking if - /// it contains valid UTF-8. This is unsafe because it assumes that - /// the UTF-8-ness of the vector has already been validated. - #[inline] - #[deprecated = "renamed to String::from_utf8_unchecked"] - pub unsafe fn from_utf8(bytes: Vec) -> String { - String::from_utf8_unchecked(bytes) - } -} - /// A clone-on-write string #[stable] pub type CowString<'a> = Cow<'a, String, str>; -#[allow(deprecated)] impl<'a> Str for CowString<'a> { #[inline] fn as_slice<'b>(&'b self) -> &'b str { @@ -1099,8 +965,8 @@ mod tests { use test::Bencher; use str::Utf8Error; - use str; - use super::as_string; + use core::iter::repeat; + use super::{as_string, CowString}; #[test] fn test_as_string() { @@ -1110,7 +976,7 @@ mod tests { #[test] fn test_from_str() { - let owned: Option<::std::string::String> = from_str("string"); + let owned: Option<::std::string::String> = "string".parse(); assert_eq!(owned.as_ref().map(|s| s.as_slice()), Some("string")); } @@ -1133,11 +999,11 @@ mod tests { #[test] fn test_from_utf8_lossy() { let xs = b"hello"; - let ys: str::CowString = "hello".into_cow(); + let ys: CowString = "hello".into_cow(); assert_eq!(String::from_utf8_lossy(xs), ys); let xs = "ศไทย中华Việt Nam".as_bytes(); - let ys: str::CowString = "ศไทย中华Việt Nam".into_cow(); + let ys: CowString = "ศไทย中华Việt Nam".into_cow(); assert_eq!(String::from_utf8_lossy(xs), ys); let xs = b"Hello\xC2 There\xFF Goodbye"; @@ -1264,7 +1130,7 @@ mod tests { fn test_from_buf_len() { unsafe { let a = vec![65u8, 65, 65, 65, 65, 65, 65, 0]; - assert_eq!(super::raw::from_buf_len(a.as_ptr(), 3), String::from_str("AAA")); + assert_eq!(String::from_raw_buf_len(a.as_ptr(), 3), String::from_str("AAA")); } } @@ -1273,7 +1139,7 @@ mod tests { unsafe { let a = vec![65, 65, 65, 65, 65, 65, 65, 0]; let b = a.as_ptr(); - let c = super::raw::from_buf(b); + let c = String::from_raw_buf(b); assert_eq!(c, String::from_str("AAAAAAA")); } } @@ -1530,7 +1396,7 @@ mod tests { #[bench] fn from_utf8_lossy_100_invalid(b: &mut Bencher) { - let s = Vec::from_elem(100, 0xF5u8); + let s = repeat(0xf5u8).take(100).collect::>(); b.iter(|| { let _ = String::from_utf8_lossy(s.as_slice()); }); diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 04bdd04bfaacf..b8f97799c9718 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -50,7 +50,7 @@ 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::cmp::{Ordering}; use core::default::Default; use core::fmt; use core::hash::{self, Hash}; @@ -207,13 +207,6 @@ impl Vec { } } - /// Deprecated: use `iter::range(0, length).map(op).collect()` instead - #[inline] - #[deprecated = "use iter::range(0, length).map(op).collect() instead"] - pub fn from_fn(length: uint, op: F) -> Vec where F: FnMut(uint) -> T { - range(0, length).map(op).collect() - } - /// Creates a `Vec` directly from the raw components of another vector. /// /// This is highly unsafe, due to the number of invariants that aren't checked. @@ -268,13 +261,6 @@ impl Vec { dst } - /// Deprecated: use `into_iter().partition(f)` instead. - #[inline] - #[deprecated = "use into_iter().partition(f) instead"] - pub fn partition(self, f: F) -> (Vec, Vec) where F: FnMut(&T) -> bool { - self.into_iter().partition(f) - } - /// Returns the number of elements the vector can hold without /// reallocating. /// @@ -290,12 +276,6 @@ impl Vec { self.cap } - /// Deprecated: Renamed to `reserve`. - #[deprecated = "Renamed to `reserve`"] - pub fn reserve_additional(&mut self, extra: uint) { - self.reserve(extra) - } - /// Reserves capacity for at least `additional` more elements to be inserted in the given /// `Vec`. The collection may reserve more space to avoid frequent reallocations. /// @@ -635,12 +615,6 @@ impl Vec { } } - /// Deprecated: use `extend(range(0, n).map(f))` instead. - #[deprecated = "use extend(range(0, n).map(f)) instead"] - pub fn grow_fn(&mut self, n: uint, f: F) where F: FnMut(uint) -> T { - self.extend(range(0, n).map(f)); - } - /// Appends an element to the back of a collection. /// /// # Panics @@ -979,13 +953,6 @@ impl Vec { } impl Vec { - /// Deprecated: use `repeat(value).take(length).collect()` instead. - #[inline] - #[deprecated = "use repeat(value).take(length).collect() instead"] - pub fn from_elem(length: uint, value: T) -> Vec { - repeat(value).take(length).collect() - } - /// Resizes the `Vec` in-place so that `len()` is equal to `new_len`. /// /// Calls either `extend()` or `truncate()` depending on whether `new_len` @@ -1044,18 +1011,6 @@ impl Vec { } } } - - /// Deprecated: use `extend(repeat(value).take(n))` instead - #[deprecated = "use extend(repeat(value).take(n)) instead"] - pub fn grow(&mut self, n: uint, value: T) { - self.extend(repeat(value).take(n)) - } - - /// Deprecated: use `iter().cloned().partition(f)` instead. - #[deprecated = "use iter().cloned().partition(f) instead"] - pub fn partitioned(&self, f: F) -> (Vec, Vec) where F: FnMut(&T) -> bool { - self.iter().cloned().partition(f) - } } impl Vec { @@ -1158,16 +1113,6 @@ impl Vec { } } -//////////////////////////////////////////////////////////////////////////////// -// Public free fns -//////////////////////////////////////////////////////////////////////////////// - -/// Deprecated: use `unzip` directly on the iterator instead. -#[deprecated = "use unzip directly on the iterator instead"] -pub fn unzip>(iter: V) -> (Vec, Vec) { - iter.unzip() -} - //////////////////////////////////////////////////////////////////////////////// // Internal methods and functions //////////////////////////////////////////////////////////////////////////////// @@ -1438,13 +1383,6 @@ impl PartialOrd for Vec { #[unstable = "waiting on Eq stability"] impl Eq for Vec {} -#[allow(deprecated)] -#[deprecated = "Use overloaded `core::cmp::PartialEq`"] -impl> Equiv for Vec { - #[inline] - fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() } -} - #[unstable = "waiting on Ord stability"] impl Ord for Vec { #[inline] @@ -1563,9 +1501,6 @@ pub struct IntoIter { end: *const T } -#[deprecated = "use IntoIter instead"] -pub type MoveItems = IntoIter; - impl IntoIter { #[inline] /// Drops all items that have not yet been moved and returns the empty vector. @@ -1578,10 +1513,6 @@ impl IntoIter { Vec { ptr: NonZero::new(allocation), cap: cap, len: 0 } } } - - /// Deprecated, use .into_inner() instead - #[deprecated = "use .into_inner() instead"] - pub fn unwrap(self) -> Vec { self.into_inner() } } impl Iterator for IntoIter { @@ -1780,26 +1711,6 @@ pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> { } } -//////////////////////////////////////////////////////////////////////////////// -// Raw module (deprecated) -//////////////////////////////////////////////////////////////////////////////// - -/// Unsafe vector operations. -#[deprecated] -pub mod raw { - use super::Vec; - - /// Constructs a vector from an unsafe pointer to a buffer. - /// - /// The elements of the buffer are copied into the vector without cloning, - /// as if `ptr::read()` were called on them. - #[inline] - #[deprecated = "renamed to Vec::from_raw_buf"] - pub unsafe fn from_buf(ptr: *const T, elts: uint) -> Vec { - Vec::from_raw_buf(ptr, elts) - } -} - //////////////////////////////////////////////////////////////////////////////// // Partial vec, used for map_in_place //////////////////////////////////////////////////////////////////////////////// @@ -1879,8 +1790,9 @@ impl Drop for PartialVecZeroSized { mod tests { use prelude::*; use core::mem::size_of; + use core::iter::repeat; use test::Bencher; - use super::{as_vec, unzip, raw}; + use super::as_vec; struct DropCounter<'a> { count: &'a mut int @@ -2069,13 +1981,6 @@ mod tests { assert_eq!(v, three) } - #[test] - fn test_grow_fn() { - let mut v = vec![0u, 1]; - v.grow_fn(3, |i| i); - assert!(v == vec![0u, 1, 0, 1, 2]); - } - #[test] fn test_retain() { let mut vec = vec![1u, 2, 3, 4]; @@ -2116,25 +2021,17 @@ mod tests { #[test] fn test_partition() { - assert_eq!(vec![].partition(|x: &int| *x < 3), (vec![], vec![])); - assert_eq!(vec![1i, 2, 3].partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![])); - assert_eq!(vec![1i, 2, 3].partition(|x: &int| *x < 2), (vec![1], vec![2, 3])); - assert_eq!(vec![1i, 2, 3].partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3])); - } - - #[test] - fn test_partitioned() { - assert_eq!(vec![].partitioned(|x: &int| *x < 3), (vec![], vec![])); - assert_eq!(vec![1i, 2, 3].partitioned(|x: &int| *x < 4), (vec![1, 2, 3], vec![])); - assert_eq!(vec![1i, 2, 3].partitioned(|x: &int| *x < 2), (vec![1], vec![2, 3])); - assert_eq!(vec![1i, 2, 3].partitioned(|x: &int| *x < 0), (vec![], vec![1, 2, 3])); + assert_eq!(vec![].into_iter().partition(|x: &int| *x < 3), (vec![], vec![])); + assert_eq!(vec![1i, 2, 3].into_iter().partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![])); + assert_eq!(vec![1i, 2, 3].into_iter().partition(|x: &int| *x < 2), (vec![1], vec![2, 3])); + assert_eq!(vec![1i, 2, 3].into_iter().partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3])); } #[test] fn test_zip_unzip() { let z1 = vec![(1i, 4i), (2, 5), (3, 6)]; - let (left, right) = unzip(z1.iter().map(|&x| x)); + let (left, right): (Vec<_>, Vec<_>) = z1.iter().map(|&x| x).unzip(); assert_eq!((1, 4), (left[0], right[0])); assert_eq!((2, 5), (left[1], right[1])); @@ -2147,13 +2044,13 @@ mod tests { // Test on-stack copy-from-buf. let a = [1i, 2, 3]; let ptr = a.as_ptr(); - let b = raw::from_buf(ptr, 3u); + let b = Vec::from_raw_buf(ptr, 3u); assert_eq!(b, vec![1, 2, 3]); // Test on-heap copy-from-buf. let c = vec![1i, 2, 3, 4, 5]; let ptr = c.as_ptr(); - let d = raw::from_buf(ptr, 5u); + let d = Vec::from_raw_buf(ptr, 5u); assert_eq!(d, vec![1, 2, 3, 4, 5]); } } @@ -2254,7 +2151,7 @@ mod tests { vec.push(1); vec.push(2); let ptr = vec.as_ptr(); - vec = vec.into_iter().unwrap(); + vec = vec.into_iter().into_inner(); assert_eq!(vec.as_ptr(), ptr); assert_eq!(vec.capacity(), 7); assert_eq!(vec.len(), 0); @@ -2283,8 +2180,7 @@ mod tests { #[test] fn test_map_in_place_zero_drop_count() { - use std::sync::atomic; - use std::sync::atomic::AtomicUint; + use std::sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT}; #[derive(Clone, PartialEq, Show)] struct Nothing; @@ -2294,20 +2190,20 @@ mod tests { struct ZeroSized; impl Drop for ZeroSized { fn drop(&mut self) { - DROP_COUNTER.fetch_add(1, atomic::Relaxed); + DROP_COUNTER.fetch_add(1, Ordering::Relaxed); } } const NUM_ELEMENTS: uint = 2; - static DROP_COUNTER: AtomicUint = atomic::ATOMIC_UINT_INIT; + static DROP_COUNTER: AtomicUint = ATOMIC_UINT_INIT; - let v = Vec::from_elem(NUM_ELEMENTS, Nothing); + let v = repeat(Nothing).take(NUM_ELEMENTS).collect::>(); - DROP_COUNTER.store(0, atomic::Relaxed); + DROP_COUNTER.store(0, Ordering::Relaxed); let v = v.map_in_place(|_| ZeroSized); - assert_eq!(DROP_COUNTER.load(atomic::Relaxed), 0); + assert_eq!(DROP_COUNTER.load(Ordering::Relaxed), 0); drop(v); - assert_eq!(DROP_COUNTER.load(atomic::Relaxed), NUM_ELEMENTS); + assert_eq!(DROP_COUNTER.load(Ordering::Relaxed), NUM_ELEMENTS); } #[test] @@ -2423,7 +2319,7 @@ mod tests { b.bytes = src_len as u64; b.iter(|| { - let dst = Vec::from_fn(src_len, |i| i); + let dst = range(0, src_len).collect::>(); assert_eq!(dst.len(), src_len); assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); }) @@ -2453,7 +2349,7 @@ mod tests { b.bytes = src_len as u64; b.iter(|| { - let dst: Vec = Vec::from_elem(src_len, 5); + let dst: Vec = repeat(5).take(src_len).collect(); assert_eq!(dst.len(), src_len); assert!(dst.iter().all(|x| *x == 5)); }) diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index b9c1a6a43f972..ab6c6b7ca55bf 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -343,12 +343,6 @@ impl VecMap { #[stable] pub fn clear(&mut self) { self.v.clear() } - /// Deprecated: Renamed to `get`. - #[deprecated = "Renamed to `get`"] - pub fn find(&self, key: &uint) -> Option<&V> { - self.get(key) - } - /// Returns a reference to the value corresponding to the key. /// /// # Examples @@ -391,12 +385,6 @@ impl VecMap { self.get(key).is_some() } - /// Deprecated: Renamed to `get_mut`. - #[deprecated = "Renamed to `get_mut`"] - pub fn find_mut(&mut self, key: &uint) -> Option<&mut V> { - self.get_mut(key) - } - /// Returns a mutable reference to the value corresponding to the key. /// /// # Examples @@ -424,12 +412,6 @@ impl VecMap { } } - /// Deprecated: Renamed to `insert`. - #[deprecated = "Renamed to `insert`"] - pub fn swap(&mut self, key: uint, value: V) -> Option { - self.insert(key, value) - } - /// Inserts a key-value pair from the map. If the key already had a value /// present in the map, that value is returned. Otherwise, `None` is returned. /// @@ -455,12 +437,6 @@ impl VecMap { replace(&mut self.v[key], Some(value)) } - /// Deprecated: Renamed to `remove`. - #[deprecated = "Renamed to `remove`"] - pub fn pop(&mut self, key: &uint) -> Option { - self.remove(key) - } - /// Removes a key from the map, returning the value at the key if the key /// was previously in the map. /// @@ -483,27 +459,6 @@ impl VecMap { } } -impl VecMap { - /// Deprecated: Use the entry API when available; shouldn't matter anyway, access is cheap. - #[deprecated = "Use the entry API when available; shouldn't matter anyway, access is cheap"] - #[allow(deprecated)] - pub fn update(&mut self, key: uint, newval: V, ff: F) -> bool where F: FnOnce(V, V) -> V { - self.update_with_key(key, newval, move |_k, v, v1| ff(v,v1)) - } - - /// Deprecated: Use the entry API when available; shouldn't matter anyway, access is cheap. - #[deprecated = "Use the entry API when available; shouldn't matter anyway, access is cheap"] - pub fn update_with_key(&mut self, key: uint, val: V, ff: F) -> bool where - F: FnOnce(uint, V, V) -> V - { - let new_val = match self.get(&key) { - None => val, - Some(orig) => ff(key, (*orig).clone(), val) - }; - self.insert(key, new_val).is_none() - } -} - #[stable] impl PartialEq for VecMap { fn eq(&self, other: &VecMap) -> bool { @@ -824,36 +779,6 @@ mod test_map { assert!(map.get(&14).is_none()); } - #[test] - fn test_insert_with_key() { - let mut map = VecMap::new(); - - // given a new key, initialize it with this new count, - // given an existing key, add more to its count - fn add_more_to_count(_k: uint, v0: uint, v1: uint) -> uint { - v0 + v1 - } - - fn add_more_to_count_simple(v0: uint, v1: uint) -> uint { - v0 + v1 - } - - // count integers - map.update(3, 1, add_more_to_count_simple); - map.update_with_key(9, 1, add_more_to_count); - map.update(3, 7, add_more_to_count_simple); - map.update_with_key(5, 3, add_more_to_count); - map.update_with_key(3, 2, add_more_to_count); - - // check the total counts - assert_eq!(map.get(&3).unwrap(), &10); - assert_eq!(map.get(&5).unwrap(), &3); - assert_eq!(map.get(&9).unwrap(), &1); - - // sadly, no sevens were counted - assert!(map.get(&7).is_none()); - } - #[test] fn test_insert() { let mut m = VecMap::new(); diff --git a/src/libcore/atomic.rs b/src/libcore/atomic.rs index 5d3bcb19ae867..0ac0dc396cc1a 100644 --- a/src/libcore/atomic.rs +++ b/src/libcore/atomic.rs @@ -8,7 +8,65 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! Core atomic primitives +//! Atomic types +//! +//! Atomic types provide primitive shared-memory communication between +//! threads, and are the building blocks of other concurrent +//! types. +//! +//! This module defines atomic versions of a select number of primitive +//! types, including `AtomicBool`, `AtomicInt`, `AtomicUint`, and `AtomicOption`. +//! Atomic types present operations that, when used correctly, synchronize +//! updates between threads. +//! +//! Each method takes an `Ordering` which represents the strength of +//! the memory barrier for that operation. These orderings are the +//! same as [C++11 atomic orderings][1]. +//! +//! [1]: http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync +//! +//! Atomic variables are safe to share between threads (they implement `Sync`) +//! but they do not themselves provide the mechanism for sharing. The most +//! common way to share an atomic variable is to put it into an `Arc` (an +//! atomically-reference-counted shared pointer). +//! +//! Most atomic types may be stored in static variables, initialized using +//! the provided static initializers like `INIT_ATOMIC_BOOL`. Atomic statics +//! are often used for lazy global initialization. +//! +//! +//! # Examples +//! +//! A simple spinlock: +//! +//! ``` +//! use std::sync::Arc; +//! use std::sync::atomic::{AtomicUint, Ordering}; +//! use std::thread::Thread; +//! +//! fn main() { +//! let spinlock = Arc::new(AtomicUint::new(1)); +//! +//! let spinlock_clone = spinlock.clone(); +//! Thread::spawn(move|| { +//! spinlock_clone.store(0, Ordering::SeqCst); +//! }).detach(); +//! +//! // Wait for the other task to release the lock +//! while spinlock.load(Ordering::SeqCst) != 0 {} +//! } +//! ``` +//! +//! Keep a global count of live tasks: +//! +//! ``` +//! use std::sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT}; +//! +//! static GLOBAL_TASK_COUNT: AtomicUint = ATOMIC_UINT_INIT; +//! +//! let old_task_count = GLOBAL_TASK_COUNT.fetch_add(1, Ordering::SeqCst); +//! println!("live tasks: {}", old_task_count + 1); +//! ``` #![stable] @@ -235,19 +293,19 @@ impl AtomicBool { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicBool, SeqCst}; + /// use std::sync::atomic::{AtomicBool, Ordering}; /// /// let foo = AtomicBool::new(true); - /// assert_eq!(true, foo.fetch_and(false, SeqCst)); - /// assert_eq!(false, foo.load(SeqCst)); + /// assert_eq!(true, foo.fetch_and(false, Ordering::SeqCst)); + /// assert_eq!(false, foo.load(Ordering::SeqCst)); /// /// let foo = AtomicBool::new(true); - /// assert_eq!(true, foo.fetch_and(true, SeqCst)); - /// assert_eq!(true, foo.load(SeqCst)); + /// assert_eq!(true, foo.fetch_and(true, Ordering::SeqCst)); + /// assert_eq!(true, foo.load(Ordering::SeqCst)); /// /// let foo = AtomicBool::new(false); - /// assert_eq!(false, foo.fetch_and(false, SeqCst)); - /// assert_eq!(false, foo.load(SeqCst)); + /// assert_eq!(false, foo.fetch_and(false, Ordering::SeqCst)); + /// assert_eq!(false, foo.load(Ordering::SeqCst)); /// ``` #[inline] #[stable] @@ -267,20 +325,20 @@ impl AtomicBool { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicBool, SeqCst}; + /// use std::sync::atomic::{AtomicBool, Ordering}; /// /// let foo = AtomicBool::new(true); - /// assert_eq!(true, foo.fetch_nand(false, SeqCst)); - /// assert_eq!(true, foo.load(SeqCst)); + /// assert_eq!(true, foo.fetch_nand(false, Ordering::SeqCst)); + /// assert_eq!(true, foo.load(Ordering::SeqCst)); /// /// let foo = AtomicBool::new(true); - /// assert_eq!(true, foo.fetch_nand(true, SeqCst)); - /// assert_eq!(0, foo.load(SeqCst) as int); - /// assert_eq!(false, foo.load(SeqCst)); + /// assert_eq!(true, foo.fetch_nand(true, Ordering::SeqCst)); + /// assert_eq!(0, foo.load(Ordering::SeqCst) as int); + /// assert_eq!(false, foo.load(Ordering::SeqCst)); /// /// let foo = AtomicBool::new(false); - /// assert_eq!(false, foo.fetch_nand(false, SeqCst)); - /// assert_eq!(true, foo.load(SeqCst)); + /// assert_eq!(false, foo.fetch_nand(false, Ordering::SeqCst)); + /// assert_eq!(true, foo.load(Ordering::SeqCst)); /// ``` #[inline] #[stable] @@ -300,19 +358,19 @@ impl AtomicBool { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicBool, SeqCst}; + /// use std::sync::atomic::{AtomicBool, Ordering}; /// /// let foo = AtomicBool::new(true); - /// assert_eq!(true, foo.fetch_or(false, SeqCst)); - /// assert_eq!(true, foo.load(SeqCst)); + /// assert_eq!(true, foo.fetch_or(false, Ordering::SeqCst)); + /// assert_eq!(true, foo.load(Ordering::SeqCst)); /// /// let foo = AtomicBool::new(true); - /// assert_eq!(true, foo.fetch_or(true, SeqCst)); - /// assert_eq!(true, foo.load(SeqCst)); + /// assert_eq!(true, foo.fetch_or(true, Ordering::SeqCst)); + /// assert_eq!(true, foo.load(Ordering::SeqCst)); /// /// let foo = AtomicBool::new(false); - /// assert_eq!(false, foo.fetch_or(false, SeqCst)); - /// assert_eq!(false, foo.load(SeqCst)); + /// assert_eq!(false, foo.fetch_or(false, Ordering::SeqCst)); + /// assert_eq!(false, foo.load(Ordering::SeqCst)); /// ``` #[inline] #[stable] @@ -332,19 +390,19 @@ impl AtomicBool { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicBool, SeqCst}; + /// use std::sync::atomic::{AtomicBool, Ordering}; /// /// let foo = AtomicBool::new(true); - /// assert_eq!(true, foo.fetch_xor(false, SeqCst)); - /// assert_eq!(true, foo.load(SeqCst)); + /// assert_eq!(true, foo.fetch_xor(false, Ordering::SeqCst)); + /// assert_eq!(true, foo.load(Ordering::SeqCst)); /// /// let foo = AtomicBool::new(true); - /// assert_eq!(true, foo.fetch_xor(true, SeqCst)); - /// assert_eq!(false, foo.load(SeqCst)); + /// assert_eq!(true, foo.fetch_xor(true, Ordering::SeqCst)); + /// assert_eq!(false, foo.load(Ordering::SeqCst)); /// /// let foo = AtomicBool::new(false); - /// assert_eq!(false, foo.fetch_xor(false, SeqCst)); - /// assert_eq!(false, foo.load(SeqCst)); + /// assert_eq!(false, foo.fetch_xor(false, Ordering::SeqCst)); + /// assert_eq!(false, foo.load(Ordering::SeqCst)); /// ``` #[inline] #[stable] @@ -463,11 +521,11 @@ impl AtomicInt { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicInt, SeqCst}; + /// use std::sync::atomic::{AtomicInt, Ordering}; /// /// let foo = AtomicInt::new(0); - /// assert_eq!(0, foo.fetch_add(10, SeqCst)); - /// assert_eq!(10, foo.load(SeqCst)); + /// assert_eq!(0, foo.fetch_add(10, Ordering::SeqCst)); + /// assert_eq!(10, foo.load(Ordering::SeqCst)); /// ``` #[inline] #[stable] @@ -480,11 +538,11 @@ impl AtomicInt { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicInt, SeqCst}; + /// use std::sync::atomic::{AtomicInt, Ordering}; /// /// let foo = AtomicInt::new(0); - /// assert_eq!(0, foo.fetch_sub(10, SeqCst)); - /// assert_eq!(-10, foo.load(SeqCst)); + /// assert_eq!(0, foo.fetch_sub(10, Ordering::SeqCst)); + /// assert_eq!(-10, foo.load(Ordering::SeqCst)); /// ``` #[inline] #[stable] @@ -497,11 +555,11 @@ impl AtomicInt { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicInt, SeqCst}; + /// use std::sync::atomic::{AtomicInt, Ordering}; /// /// let foo = AtomicInt::new(0b101101); - /// assert_eq!(0b101101, foo.fetch_and(0b110011, SeqCst)); - /// assert_eq!(0b100001, foo.load(SeqCst)); + /// assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst)); + /// assert_eq!(0b100001, foo.load(Ordering::SeqCst)); #[inline] #[stable] pub fn fetch_and(&self, val: int, order: Ordering) -> int { @@ -513,11 +571,11 @@ impl AtomicInt { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicInt, SeqCst}; + /// use std::sync::atomic::{AtomicInt, Ordering}; /// /// let foo = AtomicInt::new(0b101101); - /// assert_eq!(0b101101, foo.fetch_or(0b110011, SeqCst)); - /// assert_eq!(0b111111, foo.load(SeqCst)); + /// assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst)); + /// assert_eq!(0b111111, foo.load(Ordering::SeqCst)); #[inline] #[stable] pub fn fetch_or(&self, val: int, order: Ordering) -> int { @@ -529,11 +587,11 @@ impl AtomicInt { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicInt, SeqCst}; + /// use std::sync::atomic::{AtomicInt, Ordering}; /// /// let foo = AtomicInt::new(0b101101); - /// assert_eq!(0b101101, foo.fetch_xor(0b110011, SeqCst)); - /// assert_eq!(0b011110, foo.load(SeqCst)); + /// assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst)); + /// assert_eq!(0b011110, foo.load(Ordering::SeqCst)); #[inline] #[stable] pub fn fetch_xor(&self, val: int, order: Ordering) -> int { @@ -649,11 +707,11 @@ impl AtomicUint { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicUint, SeqCst}; + /// use std::sync::atomic::{AtomicUint, Ordering}; /// /// let foo = AtomicUint::new(0); - /// assert_eq!(0, foo.fetch_add(10, SeqCst)); - /// assert_eq!(10, foo.load(SeqCst)); + /// assert_eq!(0, foo.fetch_add(10, Ordering::SeqCst)); + /// assert_eq!(10, foo.load(Ordering::SeqCst)); /// ``` #[inline] #[stable] @@ -666,11 +724,11 @@ impl AtomicUint { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicUint, SeqCst}; + /// use std::sync::atomic::{AtomicUint, Ordering}; /// /// let foo = AtomicUint::new(10); - /// assert_eq!(10, foo.fetch_sub(10, SeqCst)); - /// assert_eq!(0, foo.load(SeqCst)); + /// assert_eq!(10, foo.fetch_sub(10, Ordering::SeqCst)); + /// assert_eq!(0, foo.load(Ordering::SeqCst)); /// ``` #[inline] #[stable] @@ -683,11 +741,11 @@ impl AtomicUint { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicUint, SeqCst}; + /// use std::sync::atomic::{AtomicUint, Ordering}; /// /// let foo = AtomicUint::new(0b101101); - /// assert_eq!(0b101101, foo.fetch_and(0b110011, SeqCst)); - /// assert_eq!(0b100001, foo.load(SeqCst)); + /// assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst)); + /// assert_eq!(0b100001, foo.load(Ordering::SeqCst)); #[inline] #[stable] pub fn fetch_and(&self, val: uint, order: Ordering) -> uint { @@ -699,11 +757,11 @@ impl AtomicUint { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicUint, SeqCst}; + /// use std::sync::atomic::{AtomicUint, Ordering}; /// /// let foo = AtomicUint::new(0b101101); - /// assert_eq!(0b101101, foo.fetch_or(0b110011, SeqCst)); - /// assert_eq!(0b111111, foo.load(SeqCst)); + /// assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst)); + /// assert_eq!(0b111111, foo.load(Ordering::SeqCst)); #[inline] #[stable] pub fn fetch_or(&self, val: uint, order: Ordering) -> uint { @@ -715,11 +773,11 @@ impl AtomicUint { /// # Examples /// /// ``` - /// use std::sync::atomic::{AtomicUint, SeqCst}; + /// use std::sync::atomic::{AtomicUint, Ordering}; /// /// let foo = AtomicUint::new(0b101101); - /// assert_eq!(0b101101, foo.fetch_xor(0b110011, SeqCst)); - /// assert_eq!(0b011110, foo.load(SeqCst)); + /// assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst)); + /// assert_eq!(0b011110, foo.load(Ordering::SeqCst)); #[inline] #[stable] pub fn fetch_xor(&self, val: uint, order: Ordering) -> uint { diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 47204dfc422f4..eb772388dce22 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -267,10 +267,6 @@ impl RefCell { unsafe { self.value.into_inner() } } - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub fn unwrap(self) -> T { self.into_inner() } - /// Attempts to immutably borrow the wrapped value. /// /// The borrow lasts until the returned `Ref` exits scope. Multiple @@ -569,8 +565,4 @@ impl UnsafeCell { #[inline] #[stable] pub unsafe fn into_inner(self) -> T { self.value } - - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub unsafe fn unwrap(self) -> T { self.into_inner() } } diff --git a/src/libcore/char.rs b/src/libcore/char.rs index 3bd200d38d715..3423e76ea6408 100644 --- a/src/libcore/char.rs +++ b/src/libcore/char.rs @@ -17,7 +17,6 @@ use iter::Iterator; use mem::transmute; -use ops::FnMut; use option::Option::{None, Some}; use option::Option; use slice::SliceExt; @@ -80,51 +79,6 @@ pub fn from_u32(i: u32) -> Option { } } -/// -/// Checks if a `char` parses as a numeric digit in the given radix -/// -/// Compared to `is_numeric()`, this function only recognizes the -/// characters `0-9`, `a-z` and `A-Z`. -/// -/// # Return value -/// -/// Returns `true` if `c` is a valid digit under `radix`, and `false` -/// otherwise. -/// -/// # Panics -/// -/// Panics if given a `radix` > 36. -/// -/// # Note -/// -/// This just wraps `to_digit()`. -/// -#[inline] -#[deprecated = "use the Char::is_digit method"] -pub fn is_digit_radix(c: char, radix: uint) -> bool { - c.is_digit(radix) -} - -/// -/// Converts a `char` to the corresponding digit -/// -/// # Return value -/// -/// If `c` is between '0' and '9', the corresponding value -/// between 0 and 9. If `c` is 'a' or 'A', 10. If `c` is -/// 'b' or 'B', 11, etc. Returns none if the `char` does not -/// refer to a digit in the given radix. -/// -/// # Panics -/// -/// Panics if given a `radix` outside the range `[0..36]`. -/// -#[inline] -#[deprecated = "use the Char::to_digit method"] -pub fn to_digit(c: char, radix: uint) -> Option { - c.to_digit(radix) -} - /// /// Converts a number to the character representing it /// @@ -156,48 +110,9 @@ pub fn from_digit(num: uint, radix: uint) -> Option { } } -/// Deprecated, call the escape_unicode method instead. -#[deprecated = "use the Char::escape_unicode method"] -pub fn escape_unicode(c: char, mut f: F) where F: FnMut(char) { - for char in c.escape_unicode() { - f(char); - } -} - -/// Deprecated, call the escape_default method instead. -#[deprecated = "use the Char::escape_default method"] -pub fn escape_default(c: char, mut f: F) where F: FnMut(char) { - for c in c.escape_default() { - f(c); - } -} - -/// Returns the amount of bytes this `char` would need if encoded in UTF-8 -#[inline] -#[deprecated = "use the Char::len_utf8 method"] -pub fn len_utf8_bytes(c: char) -> uint { - c.len_utf8() -} - /// Basic `char` manipulations. #[experimental = "trait organization may change"] pub trait Char { - /// Checks if a `char` parses as a numeric digit in the given radix. - /// - /// Compared to `is_numeric()`, this function only recognizes the characters - /// `0-9`, `a-z` and `A-Z`. - /// - /// # Return value - /// - /// Returns `true` if `c` is a valid digit under `radix`, and `false` - /// otherwise. - /// - /// # Panics - /// - /// Panics if given a radix > 36. - #[deprecated = "use is_digit"] - fn is_digit_radix(self, radix: uint) -> bool; - /// Checks if a `char` parses as a numeric digit in the given radix. /// /// Compared to `is_numeric()`, this function only recognizes the characters @@ -228,23 +143,6 @@ pub trait Char { #[unstable = "pending error conventions, trait organization"] fn to_digit(self, radix: uint) -> Option; - /// Converts a number to the character representing it. - /// - /// # Return value - /// - /// Returns `Some(char)` if `num` represents one digit under `radix`, - /// using one character of `0-9` or `a-z`, or `None` if it doesn't. - /// - /// # Panics - /// - /// Panics if given a radix > 36. - #[deprecated = "use the char::from_digit free function"] - fn from_digit(num: uint, radix: uint) -> Option; - - /// Converts from `u32` to a `char` - #[deprecated = "use the char::from_u32 free function"] - fn from_u32(i: u32) -> Option; - /// Returns an iterator that yields the hexadecimal Unicode escape /// of a character, as `char`s. /// @@ -269,11 +167,6 @@ pub trait Char { #[unstable = "pending error conventions, trait organization"] fn escape_default(self) -> EscapeDefault; - /// Returns the amount of bytes this character would need if encoded in - /// UTF-8. - #[deprecated = "use len_utf8"] - fn len_utf8_bytes(self) -> uint; - /// Returns the amount of bytes this character would need if encoded in /// UTF-8. #[unstable = "pending trait organization"] @@ -303,9 +196,6 @@ pub trait Char { #[experimental = "trait is experimental"] impl Char for char { - #[deprecated = "use is_digit"] - fn is_digit_radix(self, radix: uint) -> bool { self.is_digit(radix) } - #[unstable = "pending trait organization"] fn is_digit(self, radix: uint) -> bool { match self.to_digit(radix) { @@ -329,13 +219,6 @@ impl Char for char { else { None } } - #[deprecated = "use the char::from_digit free function"] - fn from_digit(num: uint, radix: uint) -> Option { from_digit(num, radix) } - - #[inline] - #[deprecated = "use the char::from_u32 free function"] - fn from_u32(i: u32) -> Option { from_u32(i) } - #[unstable = "pending error conventions, trait organization"] fn escape_unicode(self) -> EscapeUnicode { EscapeUnicode { c: self, state: EscapeUnicodeState::Backslash } @@ -356,10 +239,6 @@ impl Char for char { EscapeDefault { state: init_state } } - #[inline] - #[deprecated = "use len_utf8"] - fn len_utf8_bytes(self) -> uint { self.len_utf8() } - #[inline] #[unstable = "pending trait organization"] fn len_utf8(self) -> uint { diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 6b52d1817e9c4..13f9f5ccee916 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -271,16 +271,6 @@ pub trait PartialOrd for Sized?: PartialEq { } } -/// The equivalence relation. Two values may be equivalent even if they are -/// of different types. The most common use case for this relation is -/// container types; e.g. it is often desirable to be able to use `&str` -/// values to look up entries in a container with `String` keys. -#[deprecated = "Use overloaded core::cmp::PartialEq"] -pub trait Equiv for Sized? { - /// Implement this function to decide equivalent values. - fn equiv(&self, other: &T) -> bool; -} - /// Compare and return the minimum of two values. #[inline] #[stable] diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index b409b79cbf505..62bfa381c445e 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -68,8 +68,6 @@ use option::Option::{Some, None}; use std::kinds::Sized; use uint; -#[deprecated = "renamed to Extend"] pub use self::Extend as Extendable; - /// An interface for dealing with "external iterators". These types of iterators /// can be resumed at any time as all state is stored internally as opposed to /// being located on the call stack. @@ -2781,15 +2779,6 @@ pub struct Repeat { element: A } -impl Repeat { - /// Create a new `Repeat` that endlessly repeats the element `elt`. - #[inline] - #[deprecated = "use iter::repeat instead"] - pub fn new(elt: A) -> Repeat { - Repeat{element: elt} - } -} - #[unstable = "trait is unstable"] impl Iterator for Repeat { type Item = A; diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index d8b22a085aa94..aab28ae9c4738 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -20,7 +20,6 @@ use intrinsics; use mem; use num::Float; use num::FpCategory as Fp; -use num::from_str_radix; use option::Option; #[stable] @@ -314,14 +313,6 @@ impl Float for f32 { unsafe { intrinsics::powf32(self, n) } } - /// sqrt(2.0) - #[inline] - fn sqrt2() -> f32 { consts::SQRT2 } - - /// 1.0 / sqrt(2.0) - #[inline] - fn frac_1_sqrt2() -> f32 { consts::FRAC_1_SQRT2 } - #[inline] fn sqrt(self) -> f32 { if self < 0.0 { @@ -334,66 +325,6 @@ impl Float for f32 { #[inline] fn rsqrt(self) -> f32 { self.sqrt().recip() } - /// Archimedes' constant - #[inline] - fn pi() -> f32 { consts::PI } - - /// 2.0 * pi - #[inline] - fn two_pi() -> f32 { consts::PI_2 } - - /// pi / 2.0 - #[inline] - fn frac_pi_2() -> f32 { consts::FRAC_PI_2 } - - /// pi / 3.0 - #[inline] - fn frac_pi_3() -> f32 { consts::FRAC_PI_3 } - - /// pi / 4.0 - #[inline] - fn frac_pi_4() -> f32 { consts::FRAC_PI_4 } - - /// pi / 6.0 - #[inline] - fn frac_pi_6() -> f32 { consts::FRAC_PI_6 } - - /// pi / 8.0 - #[inline] - fn frac_pi_8() -> f32 { consts::FRAC_PI_8 } - - /// 1.0 / pi - #[inline] - fn frac_1_pi() -> f32 { consts::FRAC_1_PI } - - /// 2.0 / pi - #[inline] - fn frac_2_pi() -> f32 { consts::FRAC_2_PI } - - /// 2.0 / sqrt(pi) - #[inline] - fn frac_2_sqrtpi() -> f32 { consts::FRAC_2_SQRTPI } - - /// Euler's number - #[inline] - fn e() -> f32 { consts::E } - - /// log2(e) - #[inline] - fn log2_e() -> f32 { consts::LOG2_E } - - /// log10(e) - #[inline] - fn log10_e() -> f32 { consts::LOG10_E } - - /// ln(2.0) - #[inline] - fn ln_2() -> f32 { consts::LN_2 } - - /// ln(10.0) - #[inline] - fn ln_10() -> f32 { consts::LN_10 } - /// Returns the exponential of the number. #[inline] fn exp(self) -> f32 { @@ -439,10 +370,3 @@ impl Float for f32 { self * (value / 180.0f32) } } - -#[inline] -#[allow(missing_docs)] -#[deprecated="Use `FromStrRadix::from_str_radix(src, 16)`"] -pub fn from_str_hex(src: &str) -> Option { - from_str_radix(src, 16) -} diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index a3f5c2df91fac..d6d9c3446e98b 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -20,7 +20,6 @@ use intrinsics; use mem; use num::Float; use num::FpCategory as Fp; -use num::from_str_radix; use option::Option; // FIXME(#5527): These constants should be deprecated once associated @@ -322,14 +321,6 @@ impl Float for f64 { unsafe { intrinsics::powif64(self, n) } } - /// sqrt(2.0) - #[inline] - fn sqrt2() -> f64 { consts::SQRT2 } - - /// 1.0 / sqrt(2.0) - #[inline] - fn frac_1_sqrt2() -> f64 { consts::FRAC_1_SQRT2 } - #[inline] fn sqrt(self) -> f64 { if self < 0.0 { @@ -342,66 +333,6 @@ impl Float for f64 { #[inline] fn rsqrt(self) -> f64 { self.sqrt().recip() } - /// Archimedes' constant - #[inline] - fn pi() -> f64 { consts::PI } - - /// 2.0 * pi - #[inline] - fn two_pi() -> f64 { consts::PI_2 } - - /// pi / 2.0 - #[inline] - fn frac_pi_2() -> f64 { consts::FRAC_PI_2 } - - /// pi / 3.0 - #[inline] - fn frac_pi_3() -> f64 { consts::FRAC_PI_3 } - - /// pi / 4.0 - #[inline] - fn frac_pi_4() -> f64 { consts::FRAC_PI_4 } - - /// pi / 6.0 - #[inline] - fn frac_pi_6() -> f64 { consts::FRAC_PI_6 } - - /// pi / 8.0 - #[inline] - fn frac_pi_8() -> f64 { consts::FRAC_PI_8 } - - /// 1.0 / pi - #[inline] - fn frac_1_pi() -> f64 { consts::FRAC_1_PI } - - /// 2.0 / pi - #[inline] - fn frac_2_pi() -> f64 { consts::FRAC_2_PI } - - /// 2.0 / sqrt(pi) - #[inline] - fn frac_2_sqrtpi() -> f64 { consts::FRAC_2_SQRTPI } - - /// Euler's number - #[inline] - fn e() -> f64 { consts::E } - - /// log2(e) - #[inline] - fn log2_e() -> f64 { consts::LOG2_E } - - /// log10(e) - #[inline] - fn log10_e() -> f64 { consts::LOG10_E } - - /// ln(2.0) - #[inline] - fn ln_2() -> f64 { consts::LN_2 } - - /// ln(10.0) - #[inline] - fn ln_10() -> f64 { consts::LN_10 } - /// Returns the exponential of the number. #[inline] fn exp(self) -> f64 { @@ -447,10 +378,3 @@ impl Float for f64 { self * (value / 180.0) } } - -#[inline] -#[allow(missing_docs)] -#[deprecated="Use `FromStrRadix::from_str_radix(src, 16)`"] -pub fn from_str_hex(src: &str) -> Option { - from_str_radix(src, 16) -} diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 4793efbe02ac3..6c3b153c00057 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -15,9 +15,6 @@ #![stable] #![allow(missing_docs)] -use {int, i8, i16, i32, i64}; -use {uint, u8, u16, u32, u64}; -use {f32, f64}; use char::Char; use clone::Clone; use cmp::{PartialEq, Eq}; @@ -30,21 +27,7 @@ use ops::{Add, Sub, Mul, Div, Rem, Neg}; use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr}; use option::Option; use option::Option::{Some, None}; -use str::{FromStr, from_str, StrExt}; - -/// Simultaneous division and remainder -#[inline] -#[deprecated = "use division and remainder directly"] -pub fn div_rem + Rem>(x: T, y: T) -> (T, T) { - (x.clone() / y.clone(), x % y) -} - -/// Raises a `base` to the power of `exp`, using exponentiation by squaring. -#[inline] -#[deprecated = "Use Int::pow() instead, as in 2i.pow(4)"] -pub fn pow(base: T, exp: uint) -> T { - base.pow(exp) -} +use str::{FromStr, StrExt}; /// A built-in signed or unsigned integer. #[unstable = "recently settled as part of numerics reform"] @@ -1345,11 +1328,6 @@ pub trait Float /// Raise a number to a floating point power. fn powf(self, n: Self) -> Self; - /// sqrt(2.0). - fn sqrt2() -> Self; - /// 1.0 / sqrt(2.0). - fn frac_1_sqrt2() -> Self; - /// Take the square root of a number. /// /// Returns NaN if `self` is a negative number. @@ -1357,53 +1335,6 @@ pub trait Float /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`. fn rsqrt(self) -> Self; - /// Archimedes' constant. - #[deprecated = "use f32::consts or f64::consts instead"] - fn pi() -> Self; - /// 2.0 * pi. - #[deprecated = "use f32::consts or f64::consts instead"] - fn two_pi() -> Self; - /// pi / 2.0. - #[deprecated = "use f32::consts or f64::consts instead"] - fn frac_pi_2() -> Self; - /// pi / 3.0. - #[deprecated = "use f32::consts or f64::consts instead"] - fn frac_pi_3() -> Self; - /// pi / 4.0. - #[deprecated = "use f32::consts or f64::consts instead"] - fn frac_pi_4() -> Self; - /// pi / 6.0. - #[deprecated = "use f32::consts or f64::consts instead"] - fn frac_pi_6() -> Self; - /// pi / 8.0. - #[deprecated = "use f32::consts or f64::consts instead"] - fn frac_pi_8() -> Self; - /// 1.0 / pi. - #[deprecated = "use f32::consts or f64::consts instead"] - fn frac_1_pi() -> Self; - /// 2.0 / pi. - #[deprecated = "use f32::consts or f64::consts instead"] - fn frac_2_pi() -> Self; - /// 2.0 / sqrt(pi). - #[deprecated = "use f32::consts or f64::consts instead"] - fn frac_2_sqrtpi() -> Self; - - /// Euler's number. - #[deprecated = "use f32::consts or f64::consts instead"] - fn e() -> Self; - /// log2(e). - #[deprecated = "use f32::consts or f64::consts instead"] - fn log2_e() -> Self; - /// log10(e). - #[deprecated = "use f32::consts or f64::consts instead"] - fn log10_e() -> Self; - /// ln(2.0). - #[deprecated = "use f32::consts or f64::consts instead"] - fn ln_2() -> Self; - /// ln(10.0). - #[deprecated = "use f32::consts or f64::consts instead"] - fn ln_10() -> Self; - /// Returns `e^(self)`, (the exponential function). fn exp(self) -> Self; /// Returns 2 raised to the power of the number, `2^(self)`. @@ -1609,9 +1540,9 @@ macro_rules! from_str_radix_float_impl { // Parse the exponent as decimal integer let src = src[offset..]; let (is_positive, exp) = match src.slice_shift_char() { - Some(('-', src)) => (false, from_str::(src)), - Some(('+', src)) => (true, from_str::(src)), - Some((_, _)) => (true, from_str::(src)), + Some(('-', src)) => (false, src.parse::()), + Some(('+', src)) => (true, src.parse::()), + Some((_, _)) => (true, src.parse::()), None => return None, }; @@ -1706,135 +1637,3 @@ from_str_radix_int_impl! { u8 } from_str_radix_int_impl! { u16 } from_str_radix_int_impl! { u32 } from_str_radix_int_impl! { u64 } - -// DEPRECATED - -macro_rules! trait_impl { - ($name:ident for $($t:ty)*) => { - $(#[allow(deprecated)] impl $name for $t {})* - }; -} - -#[deprecated = "Generalised numbers are no longer supported"] -#[allow(deprecated)] -pub trait Num: PartialEq + Zero + One - + Neg - + Add - + Sub - + Mul - + Div - + Rem {} -trait_impl! { Num for uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 } - -#[deprecated = "Generalised unsigned numbers are no longer supported"] -#[allow(deprecated)] -pub trait Unsigned: Num {} -trait_impl! { Unsigned for uint u8 u16 u32 u64 } - -#[deprecated = "Use `Float` or `Int`"] -#[allow(deprecated)] -pub trait Primitive: Copy + Clone + Num + NumCast + PartialOrd {} -trait_impl! { Primitive for uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 } - -#[deprecated = "The generic `Zero` trait will be removed soon."] -pub trait Zero: Add { - #[deprecated = "Use `Int::zero()` or `Float::zero()`."] - fn zero() -> Self; - #[deprecated = "Use `x == Int::zero()` or `x == Float::zero()`."] - fn is_zero(&self) -> bool; -} -#[deprecated = "Use `Int::zero()` or `Float::zero()`."] -#[allow(deprecated)] -pub fn zero() -> T { Zero::zero() } -macro_rules! zero_impl { - ($t:ty, $v:expr) => { - impl Zero for $t { - fn zero() -> $t { $v } - fn is_zero(&self) -> bool { *self == $v } - } - } -} -zero_impl! { uint, 0u } -zero_impl! { u8, 0u8 } -zero_impl! { u16, 0u16 } -zero_impl! { u32, 0u32 } -zero_impl! { u64, 0u64 } -zero_impl! { int, 0i } -zero_impl! { i8, 0i8 } -zero_impl! { i16, 0i16 } -zero_impl! { i32, 0i32 } -zero_impl! { i64, 0i64 } -zero_impl! { f32, 0.0f32 } -zero_impl! { f64, 0.0f64 } - -#[deprecated = "The generic `One` trait will be removed soon."] -pub trait One: Mul { - #[deprecated = "Use `Int::one()` or `Float::one()`."] - fn one() -> Self; -} -#[deprecated = "Use `Int::one()` or `Float::one()`."] -#[allow(deprecated)] -pub fn one() -> T { One::one() } -macro_rules! one_impl { - ($t:ty, $v:expr) => { - impl One for $t { - fn one() -> $t { $v } - } - } -} -one_impl! { uint, 1u } -one_impl! { u8, 1u8 } -one_impl! { u16, 1u16 } -one_impl! { u32, 1u32 } -one_impl! { u64, 1u64 } -one_impl! { int, 1i } -one_impl! { i8, 1i8 } -one_impl! { i16, 1i16 } -one_impl! { i32, 1i32 } -one_impl! { i64, 1i64 } -one_impl! { f32, 1.0f32 } -one_impl! { f64, 1.0f64 } - -#[deprecated = "Use `UnsignedInt::next_power_of_two`"] -pub fn next_power_of_two(n: T) -> T { - n.next_power_of_two() -} -#[deprecated = "Use `UnsignedInt::is_power_of_two`"] -pub fn is_power_of_two(n: T) -> bool { - n.is_power_of_two() -} -#[deprecated = "Use `UnsignedInt::checked_next_power_of_two`"] -pub fn checked_next_power_of_two(n: T) -> Option { - n.checked_next_power_of_two() -} - -#[deprecated = "Generalised bounded values are no longer supported"] -pub trait Bounded { - #[deprecated = "Use `Int::min_value` or `Float::min_value`"] - fn min_value() -> Self; - #[deprecated = "Use `Int::max_value` or `Float::max_value`"] - fn max_value() -> Self; -} -macro_rules! bounded_impl { - ($T:ty, $min:expr, $max:expr) => { - impl Bounded for $T { - #[inline] - fn min_value() -> $T { $min } - - #[inline] - fn max_value() -> $T { $max } - } - }; -} -bounded_impl! { uint, uint::MIN, uint::MAX } -bounded_impl! { u8, u8::MIN, u8::MAX } -bounded_impl! { u16, u16::MIN, u16::MAX } -bounded_impl! { u32, u32::MIN, u32::MAX } -bounded_impl! { u64, u64::MIN, u64::MAX } -bounded_impl! { int, int::MIN, int::MAX } -bounded_impl! { i8, i8::MIN, i8::MAX } -bounded_impl! { i16, i16::MIN, i16::MAX } -bounded_impl! { i32, i32::MIN, i32::MAX } -bounded_impl! { i64, i64::MIN, i64::MAX } -bounded_impl! { f32, f32::MIN_VALUE, f32::MAX_VALUE } -bounded_impl! { f64, f64::MIN_VALUE, f64::MAX_VALUE } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 9aed78d0737cd..0b77f3456b2f5 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -94,7 +94,7 @@ use intrinsics; use option::Option::{self, Some, None}; use kinds::{Send, Sized, Sync}; -use cmp::{PartialEq, Eq, Ord, PartialOrd, Equiv}; +use cmp::{PartialEq, Eq, Ord, PartialOrd}; use cmp::Ordering::{self, Less, Equal, Greater}; // FIXME #19649: instrinsic docs don't render, so these have no docs :( @@ -246,22 +246,10 @@ pub unsafe fn write(dst: *mut T, src: T) { pub trait PtrExt: Sized { type Target; - /// Returns the null pointer. - #[deprecated = "call ptr::null instead"] - fn null() -> Self; - /// Returns true if the pointer is null. #[stable] fn is_null(self) -> bool; - /// Returns true if the pointer is not equal to the null pointer. - #[deprecated = "use !p.is_null() instead"] - fn is_not_null(self) -> bool { !self.is_null() } - - /// Returns true if the pointer is not null. - #[deprecated = "use `as uint` instead"] - fn to_uint(self) -> uint; - /// Returns `None` if the pointer is null, or else returns a reference to /// the value wrapped in `Some`. /// @@ -308,18 +296,10 @@ pub trait MutPtrExt { impl PtrExt for *const T { type Target = T; - #[inline] - #[deprecated = "call ptr::null instead"] - fn null() -> *const T { null() } - #[inline] #[stable] fn is_null(self) -> bool { self as uint == 0 } - #[inline] - #[deprecated = "use `as uint` instead"] - fn to_uint(self) -> uint { self as uint } - #[inline] #[stable] unsafe fn offset(self, count: int) -> *const T { @@ -342,18 +322,10 @@ impl PtrExt for *const T { impl PtrExt for *mut T { type Target = T; - #[inline] - #[deprecated = "call ptr::null instead"] - fn null() -> *mut T { null_mut() } - #[inline] #[stable] fn is_null(self) -> bool { self as uint == 0 } - #[inline] - #[deprecated = "use `as uint` instead"] - fn to_uint(self) -> uint { self as uint } - #[inline] #[stable] unsafe fn offset(self, count: int) -> *mut T { @@ -415,23 +387,6 @@ impl PartialEq for *mut T { #[stable] impl Eq for *mut T {} -// Equivalence for pointers -#[allow(deprecated)] -#[deprecated = "Use overloaded `core::cmp::PartialEq`"] -impl Equiv<*mut T> for *const T { - fn equiv(&self, other: &*mut T) -> bool { - self.to_uint() == other.to_uint() - } -} - -#[allow(deprecated)] -#[deprecated = "Use overloaded `core::cmp::PartialEq`"] -impl Equiv<*const T> for *mut T { - fn equiv(&self, other: &*const T) -> bool { - self.to_uint() == other.to_uint() - } -} - #[stable] impl Clone for *const T { #[inline] diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index fd4bc4a141357..f17a775cf4240 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -36,7 +36,7 @@ use mem::transmute; use clone::Clone; -use cmp::{Ordering, PartialEq, PartialOrd, Eq, Ord, Equiv}; +use cmp::{Ordering, PartialEq, PartialOrd, Eq, Ord}; use cmp::Ordering::{Less, Equal, Greater}; use cmp; use default::Default; @@ -1369,68 +1369,6 @@ pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] { // Submodules // -/// Unsafe operations -#[deprecated] -pub mod raw { - use mem::transmute; - use ptr::PtrExt; - use raw::Slice; - use ops::FnOnce; - use option::Option; - use option::Option::{None, Some}; - - /// Form a slice from a pointer and length (as a number of units, - /// not bytes). - #[inline] - #[deprecated = "renamed to slice::from_raw_buf"] - pub unsafe fn buf_as_slice(p: *const T, len: uint, f: F) -> U where - F: FnOnce(&[T]) -> U, - { - f(transmute(Slice { - data: p, - len: len - })) - } - - /// Form a slice from a pointer and length (as a number of units, - /// not bytes). - #[inline] - #[deprecated = "renamed to slice::from_raw_mut_buf"] - pub unsafe fn mut_buf_as_slice(p: *mut T, len: uint, f: F) -> U where - F: FnOnce(&mut [T]) -> U, - { - f(transmute(Slice { - data: p as *const T, - len: len - })) - } - - /// Returns a pointer to first element in slice and adjusts - /// slice so it no longer contains that element. Returns None - /// if the slice is empty. O(1). - #[inline] - #[deprecated = "inspect `Slice::{data, len}` manually (increment data by 1)"] - pub unsafe fn shift_ptr(slice: &mut Slice) -> Option<*const T> { - if slice.len == 0 { return None; } - let head: *const T = slice.data; - slice.data = slice.data.offset(1); - slice.len -= 1; - Some(head) - } - - /// Returns a pointer to last element in slice and adjusts - /// slice so it no longer contains that element. Returns None - /// if the slice is empty. O(1). - #[inline] - #[deprecated = "inspect `Slice::{data, len}` manually (decrement len by 1)"] - pub unsafe fn pop_ptr(slice: &mut Slice) -> Option<*const T> { - if slice.len == 0 { return None; } - let tail: *const T = slice.data.offset((slice.len - 1) as int); - slice.len -= 1; - Some(tail) - } -} - /// Operations on `[u8]`. #[experimental = "needs review"] pub mod bytes { @@ -1490,20 +1428,6 @@ impl PartialEq<[B]> for [A] where A: PartialEq { #[stable] impl Eq for [T] {} -#[allow(deprecated)] -#[deprecated = "Use overloaded `core::cmp::PartialEq`"] -impl> Equiv for [T] { - #[inline] - fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() } -} - -#[allow(deprecated)] -#[deprecated = "Use overloaded `core::cmp::PartialEq`"] -impl<'a,T:PartialEq, Sized? V: AsSlice> Equiv for &'a mut [T] { - #[inline] - fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() } -} - #[stable] impl Ord for [T] { fn cmp(&self, other: &[T]) -> Ordering { diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 07662c567e389..d069744f8da54 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -114,12 +114,6 @@ pub trait FromStr { fn from_str(s: &str) -> Option; } -/// A utility function that just calls FromStr::from_str -#[deprecated = "call the .parse() method on the string instead"] -pub fn from_str(s: &str) -> Option { - FromStr::from_str(s) -} - impl FromStr for bool { /// Parse a `bool` from a string. /// @@ -427,8 +421,7 @@ impl<'a> Fn(&'a u8) -> u8 for BytesDeref { /// An iterator over the substrings of a string, separated by `sep`. #[derive(Clone)] -#[deprecated = "Type is now named `Split` or `SplitTerminator`"] -pub struct CharSplits<'a, Sep> { +struct CharSplits<'a, Sep> { /// The slice remaining to be iterated string: &'a str, sep: Sep, @@ -441,8 +434,7 @@ pub struct CharSplits<'a, Sep> { /// An iterator over the substrings of a string, separated by `sep`, /// splitting at most `count` times. #[derive(Clone)] -#[deprecated = "Type is now named `SplitN` or `RSplitN`"] -pub struct CharSplitsN<'a, Sep> { +struct CharSplitsN<'a, Sep> { iter: CharSplits<'a, Sep>, /// The number of splits remaining count: uint, @@ -873,10 +865,6 @@ pub struct SplitStr<'a> { finished: bool } -/// Deprecated -#[deprecated = "Type is now named `SplitStr`"] -pub type StrSplits<'a> = SplitStr<'a>; - impl<'a> Iterator for MatchIndices<'a> { type Item = (uint, uint); @@ -1027,22 +1015,6 @@ fn run_utf8_validation_iterator(iter: &mut slice::Iter) } } -/// Determines if a vector of bytes contains valid UTF-8. -#[deprecated = "call from_utf8 instead"] -pub fn is_utf8(v: &[u8]) -> bool { - run_utf8_validation_iterator(&mut v.iter()).is_ok() -} - -/// Deprecated function -#[deprecated = "this function will be removed"] -pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] { - match v.iter().position(|c| *c == 0) { - // don't include the 0 - Some(i) => v[..i], - None => v - } -} - // https://tools.ietf.org/html/rfc3629 static UTF8_CHAR_WIDTH: [u8; 256] = [ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, @@ -1063,13 +1035,6 @@ static UTF8_CHAR_WIDTH: [u8; 256] = [ 4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0, // 0xFF ]; -/// Given a first byte, determine how many bytes are in this UTF-8 character -#[inline] -#[deprecated = "this function has moved to libunicode"] -pub fn utf8_char_width(b: u8) -> uint { - return UTF8_CHAR_WIDTH[b as uint] as uint; -} - /// Struct that contains a `char` and the index of the first byte of /// the next `char` in a string. This can be used as a data structure /// for iterating over the UTF-8 bytes of a string. @@ -1087,78 +1052,19 @@ const CONT_MASK: u8 = 0b0011_1111u8; /// Value of the tag bits (tag mask is !CONT_MASK) of a continuation byte const TAG_CONT_U8: u8 = 0b1000_0000u8; -/// Unsafe operations -#[deprecated] -pub mod raw { - use ptr::PtrExt; - use raw::Slice; - use slice::SliceExt; - use str::StrExt; - - /// Converts a slice of bytes to a string slice without checking - /// that the string contains valid UTF-8. - #[deprecated = "renamed to str::from_utf8_unchecked"] - pub unsafe fn from_utf8<'a>(v: &'a [u8]) -> &'a str { - super::from_utf8_unchecked(v) - } - - /// Form a slice from a C string. Unsafe because the caller must ensure the - /// C string has the static lifetime, or else the return value may be - /// invalidated later. - #[deprecated = "renamed to str::from_c_str"] - pub unsafe fn c_str_to_static_slice(s: *const i8) -> &'static str { - let s = s as *const u8; - let mut curr = s; - let mut len = 0u; - while *curr != 0u8 { - len += 1u; - curr = s.offset(len as int); - } - let v = Slice { data: s, len: len }; - super::from_utf8(::mem::transmute(v)).unwrap() - } - - /// Takes a bytewise (not UTF-8) slice from a string. - /// - /// Returns the substring from [`begin`..`end`). - /// - /// # Panics - /// - /// If begin is greater than end. - /// If end is greater than the length of the string. - #[inline] - #[deprecated = "call the slice_unchecked method instead"] - pub unsafe fn slice_bytes<'a>(s: &'a str, begin: uint, end: uint) -> &'a str { - assert!(begin <= end); - assert!(end <= s.len()); - s.slice_unchecked(begin, end) - } - - /// Takes a bytewise (not UTF-8) slice from a string. - /// - /// Returns the substring from [`begin`..`end`). - /// - /// Caller must check slice boundaries! - #[inline] - #[deprecated = "this has moved to a method on `str` directly"] - pub unsafe fn slice_unchecked<'a>(s: &'a str, begin: uint, end: uint) -> &'a str { - s.slice_unchecked(begin, end) - } -} - /* Section: Trait implementations */ #[allow(missing_docs)] pub mod traits { - use cmp::{Ordering, Ord, PartialEq, PartialOrd, Equiv, Eq}; + use cmp::{Ordering, Ord, PartialEq, PartialOrd, Eq}; use cmp::Ordering::{Less, Equal, Greater}; use iter::IteratorExt; use option::Option; use option::Option::Some; use ops; - use str::{Str, StrExt, eq_slice}; + use str::{StrExt, eq_slice}; #[stable] impl Ord for str { @@ -1197,13 +1103,6 @@ pub mod traits { } } - #[allow(deprecated)] - #[deprecated = "Use overloaded `core::cmp::PartialEq`"] - impl Equiv for str { - #[inline] - fn equiv(&self, other: &S) -> bool { eq_slice(self, other.as_slice()) } - } - impl ops::Slice for str { #[inline] fn as_slice_<'a>(&'a self) -> &'a str { @@ -1236,13 +1135,11 @@ pub trait Str for Sized? { fn as_slice<'a>(&'a self) -> &'a str; } -#[allow(deprecated)] impl Str for str { #[inline] fn as_slice<'a>(&'a self) -> &'a str { self } } -#[allow(deprecated)] impl<'a, Sized? S> Str for &'a S where S: Str { #[inline] fn as_slice(&self) -> &str { Str::as_slice(*self) } @@ -1316,6 +1213,7 @@ pub trait StrExt for Sized? { fn as_ptr(&self) -> *const u8; fn len(&self) -> uint; fn is_empty(&self) -> bool; + fn parse(&self) -> Option; } #[inline(never)] @@ -1352,7 +1250,6 @@ impl StrExt for str { } #[inline] - #[allow(deprecated)] // For using CharSplits fn split(&self, pat: P) -> Split

{ Split(CharSplits { string: self, @@ -1364,7 +1261,6 @@ impl StrExt for str { } #[inline] - #[allow(deprecated)] // For using CharSplitsN fn splitn(&self, count: uint, pat: P) -> SplitN

{ SplitN(CharSplitsN { iter: self.split(pat).0, @@ -1374,7 +1270,6 @@ impl StrExt for str { } #[inline] - #[allow(deprecated)] // For using CharSplits fn split_terminator(&self, pat: P) -> SplitTerminator

{ SplitTerminator(CharSplits { allow_trailing_empty: false, @@ -1383,7 +1278,6 @@ impl StrExt for str { } #[inline] - #[allow(deprecated)] // For using CharSplitsN fn rsplitn(&self, count: uint, pat: P) -> RSplitN

{ RSplitN(CharSplitsN { iter: self.split(pat).0, @@ -1681,6 +1575,9 @@ impl StrExt for str { #[inline] fn is_empty(&self) -> bool { self.len() == 0 } + + #[inline] + fn parse(&self) -> Option { FromStr::from_str(self) } } #[stable] diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index ad2323296d97f..4aca830cb9413 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -58,44 +58,6 @@ macro_rules! tuple_impls { } )+) => { $( - #[allow(missing_docs)] - #[deprecated] - pub trait $Tuple<$($T),+> { - $( - #[deprecated = "use tuple indexing: `tuple.N`"] - fn $valN(self) -> $T; - #[deprecated = "use tuple indexing: `&tuple.N`"] - fn $refN<'a>(&'a self) -> &'a $T; - #[deprecated = "use tuple indexing: `&mut tuple.N`"] - fn $mutN<'a>(&'a mut self) -> &'a mut $T; - )+ - } - - impl<$($T),+> $Tuple<$($T),+> for ($($T,)+) { - $( - #[inline] - #[allow(unused_variables)] - #[deprecated = "use tuple indexing: `tuple.N`"] - fn $valN(self) -> $T { - e!(self.$idx) - } - - #[inline] - #[allow(unused_variables)] - #[deprecated = "use tuple indexing: `&tuple.N`"] - fn $refN<'a>(&'a self) -> &'a $T { - e!(&self.$idx) - } - - #[inline] - #[allow(unused_variables)] - #[deprecated = "use tuple indexing: &mut tuple.N"] - fn $mutN<'a>(&'a mut self) -> &'a mut $T { - e!(&mut self.$idx) - } - )+ - } - #[stable] impl<$($T:Clone),+> Clone for ($($T,)+) { fn clone(&self) -> ($($T,)+) { diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs index b931809e6036e..b581cdbd71093 100644 --- a/src/libcoretest/char.rs +++ b/src/libcoretest/char.rs @@ -10,8 +10,6 @@ // // ignore-lexer-test FIXME #15679 -use core::char::{escape_unicode, escape_default}; - #[test] fn test_is_lowercase() { assert!('a'.is_lowercase()); @@ -33,12 +31,12 @@ fn test_is_uppercase() { #[test] fn test_is_whitespace() { assert!(' '.is_whitespace()); - assert!('\u2007'.is_whitespace()); + assert!('\u{2007}'.is_whitespace()); assert!('\t'.is_whitespace()); assert!('\n'.is_whitespace()); assert!(!'a'.is_whitespace()); assert!(!'_'.is_whitespace()); - assert!(!'\u0000'.is_whitespace()); + assert!(!'\u{0}'.is_whitespace()); } #[test] @@ -92,15 +90,15 @@ fn test_to_uppercase() { #[test] fn test_is_control() { - assert!('\u0000'.is_control()); - assert!('\u0003'.is_control()); - assert!('\u0006'.is_control()); - assert!('\u0009'.is_control()); - assert!('\u007f'.is_control()); - assert!('\u0092'.is_control()); - assert!(!'\u0020'.is_control()); - assert!(!'\u0055'.is_control()); - assert!(!'\u0068'.is_control()); + assert!('\u{0}'.is_control()); + assert!('\u{3}'.is_control()); + assert!('\u{6}'.is_control()); + assert!('\u{9}'.is_control()); + assert!('\u{7f}'.is_control()); + assert!('\u{92}'.is_control()); + assert!(!'\u{20}'.is_control()); + assert!(!'\u{55}'.is_control()); + assert!(!'\u{68}'.is_control()); } #[test] @@ -116,9 +114,7 @@ fn test_is_digit() { #[test] fn test_escape_default() { fn string(c: char) -> String { - let mut result = String::new(); - escape_default(c, |c| { result.push(c); }); - return result; + c.escape_default().collect() } let s = string('\n'); assert_eq!(s, "\\n"); @@ -175,9 +171,9 @@ fn test_encode_utf8() { } check('x', &[0x78]); - check('\u00e9', &[0xc3, 0xa9]); - check('\ua66e', &[0xea, 0x99, 0xae]); - check('\U0001f4a9', &[0xf0, 0x9f, 0x92, 0xa9]); + check('\u{e9}', &[0xc3, 0xa9]); + check('\u{a66e}', &[0xea, 0x99, 0xae]); + check('\u{1f4a9}', &[0xf0, 0x9f, 0x92, 0xa9]); } #[test] @@ -189,17 +185,17 @@ fn test_encode_utf16() { } check('x', &[0x0078]); - check('\u00e9', &[0x00e9]); - check('\ua66e', &[0xa66e]); - check('\U0001f4a9', &[0xd83d, 0xdca9]); + check('\u{e9}', &[0x00e9]); + check('\u{a66e}', &[0xa66e]); + check('\u{1f4a9}', &[0xd83d, 0xdca9]); } #[test] fn test_len_utf16() { assert!('x'.len_utf16() == 1); - assert!('\u00e9'.len_utf16() == 1); - assert!('\ua66e'.len_utf16() == 1); - assert!('\U0001f4a9'.len_utf16() == 2); + assert!('\u{e9}'.len_utf16() == 1); + assert!('\u{a66e}'.len_utf16() == 1); + assert!('\u{1f4a9}'.len_utf16() == 2); } #[test] @@ -216,15 +212,15 @@ fn test_width() { assert_eq!('ｈ'.width(false),Some(2)); assert_eq!('ｈ'.width(true),Some(2)); - assert_eq!('\u00AD'.width(false),Some(1)); - assert_eq!('\u00AD'.width(true),Some(1)); + assert_eq!('\u{AD}'.width(false),Some(1)); + assert_eq!('\u{AD}'.width(true),Some(1)); - assert_eq!('\u1160'.width(false),Some(0)); - assert_eq!('\u1160'.width(true),Some(0)); + assert_eq!('\u{1160}'.width(false),Some(0)); + assert_eq!('\u{1160}'.width(true),Some(0)); - assert_eq!('\u00a1'.width(false),Some(1)); - assert_eq!('\u00a1'.width(true),Some(2)); + assert_eq!('\u{a1}'.width(false),Some(1)); + assert_eq!('\u{a1}'.width(true),Some(2)); - assert_eq!('\u0300'.width(false),Some(0)); - assert_eq!('\u0300'.width(true),Some(0)); + assert_eq!('\u{300}'.width(false),Some(0)); + assert_eq!('\u{300}'.width(true),Some(0)); } diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs index b53791f694480..2aa2a229f90fa 100644 --- a/src/libcoretest/iter.rs +++ b/src/libcoretest/iter.rs @@ -103,7 +103,7 @@ fn test_iterator_chain() { #[test] fn test_filter_map() { - let mut it = count(0u, 1u).take(10) + let it = count(0u, 1u).take(10) .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None }); assert!(it.collect::>() == vec![0*0, 2*2, 4*4, 6*6, 8*8]); } diff --git a/src/libcoretest/nonzero.rs b/src/libcoretest/nonzero.rs index ed66be3d890dc..ab2f6da1cf7d9 100644 --- a/src/libcoretest/nonzero.rs +++ b/src/libcoretest/nonzero.rs @@ -92,7 +92,7 @@ fn test_match_option_empty_string() { #[test] fn test_match_option_string() { - let five = "Five".into_string(); + let five = "Five".to_string(); match Some(five) { Some(s) => assert_eq!(s, "Five"), None => panic!("unexpected None while matching on Some(String { ... })") diff --git a/src/libcoretest/num/int_macros.rs b/src/libcoretest/num/int_macros.rs index e409dc61510f6..8885d3a52082c 100644 --- a/src/libcoretest/num/int_macros.rs +++ b/src/libcoretest/num/int_macros.rs @@ -16,7 +16,6 @@ mod tests { use core::$T_i::*; 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; @@ -161,6 +160,9 @@ mod tests { #[test] fn test_from_str() { + fn from_str(t: &str) -> Option { + ::std::str::FromStr::from_str(t) + } assert_eq!(from_str::<$T>("0"), Some(0 as $T)); assert_eq!(from_str::<$T>("3"), Some(3 as $T)); assert_eq!(from_str::<$T>("10"), Some(10 as $T)); diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs index 274b4cee3ba12..651e8640e912a 100644 --- a/src/libcoretest/num/mod.rs +++ b/src/libcoretest/num/mod.rs @@ -13,7 +13,6 @@ 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; @@ -55,7 +54,6 @@ 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() { @@ -88,35 +86,35 @@ mod test { #[test] fn test_int_from_str_overflow() { let mut i8_val: i8 = 127_i8; - assert_eq!(from_str::("127"), Some(i8_val)); - assert_eq!(from_str::("128"), None); + assert_eq!("127".parse::(), Some(i8_val)); + assert_eq!("128".parse::(), None); i8_val += 1 as i8; - assert_eq!(from_str::("-128"), Some(i8_val)); - assert_eq!(from_str::("-129"), None); + assert_eq!("-128".parse::(), Some(i8_val)); + assert_eq!("-129".parse::(), None); let mut i16_val: i16 = 32_767_i16; - assert_eq!(from_str::("32767"), Some(i16_val)); - assert_eq!(from_str::("32768"), None); + assert_eq!("32767".parse::(), Some(i16_val)); + assert_eq!("32768".parse::(), None); i16_val += 1 as i16; - assert_eq!(from_str::("-32768"), Some(i16_val)); - assert_eq!(from_str::("-32769"), None); + assert_eq!("-32768".parse::(), Some(i16_val)); + assert_eq!("-32769".parse::(), None); let mut i32_val: i32 = 2_147_483_647_i32; - assert_eq!(from_str::("2147483647"), Some(i32_val)); - assert_eq!(from_str::("2147483648"), None); + assert_eq!("2147483647".parse::(), Some(i32_val)); + assert_eq!("2147483648".parse::(), None); i32_val += 1 as i32; - assert_eq!(from_str::("-2147483648"), Some(i32_val)); - assert_eq!(from_str::("-2147483649"), None); + assert_eq!("-2147483648".parse::(), Some(i32_val)); + assert_eq!("-2147483649".parse::(), None); let mut i64_val: i64 = 9_223_372_036_854_775_807_i64; - assert_eq!(from_str::("9223372036854775807"), Some(i64_val)); - assert_eq!(from_str::("9223372036854775808"), None); + assert_eq!("9223372036854775807".parse::(), Some(i64_val)); + assert_eq!("9223372036854775808".parse::(), None); i64_val += 1 as i64; - assert_eq!(from_str::("-9223372036854775808"), Some(i64_val)); - assert_eq!(from_str::("-9223372036854775809"), None); + assert_eq!("-9223372036854775808".parse::(), Some(i64_val)); + assert_eq!("-9223372036854775809".parse::(), None); } } diff --git a/src/libcoretest/ptr.rs b/src/libcoretest/ptr.rs index 162f75763de42..875affe0ac780 100644 --- a/src/libcoretest/ptr.rs +++ b/src/libcoretest/ptr.rs @@ -10,6 +10,7 @@ use core::ptr::*; use core::mem; +use std::iter::repeat; #[test] fn test() { @@ -56,19 +57,15 @@ fn test() { fn test_is_null() { let p: *const int = null(); assert!(p.is_null()); - assert!(!p.is_not_null()); let q = unsafe { p.offset(1) }; assert!(!q.is_null()); - assert!(q.is_not_null()); let mp: *mut int = null_mut(); assert!(mp.is_null()); - assert!(!mp.is_not_null()); let mq = unsafe { mp.offset(1) }; assert!(!mq.is_null()); - assert!(mq.is_not_null()); } #[test] @@ -116,7 +113,7 @@ fn test_as_mut() { #[test] fn test_ptr_addition() { unsafe { - let xs = Vec::from_elem(16, 5i); + let xs = repeat(5i).take(16).collect::>(); let mut ptr = xs.as_ptr(); let end = ptr.offset(16); @@ -134,7 +131,7 @@ fn test_ptr_addition() { m_ptr = m_ptr.offset(1); } - assert!(xs_mut == Vec::from_elem(16, 10i)); + assert!(xs_mut == repeat(10i).take(16).collect::>()); } } diff --git a/src/libcoretest/str.rs b/src/libcoretest/str.rs index fc02f46724fb8..1c0af55370d39 100644 --- a/src/libcoretest/str.rs +++ b/src/libcoretest/str.rs @@ -8,13 +8,11 @@ // 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)); - assert_eq!(from_str::("false"), Some(false)); - assert_eq!(from_str::("not even a boolean"), None); + assert_eq!("true".parse(), Some(true)); + assert_eq!("false".parse(), Some(false)); + assert_eq!("not even a boolean".parse::(), None); } fn check_contains_all_substrings(s: &str) { @@ -120,6 +118,6 @@ fn test_rev_split_char_iterator_no_trailing() { #[test] fn test_utf16_code_units() { use unicode::str::Utf16Encoder; - assert_eq!(Utf16Encoder::new(vec!['é', '\U0001F4A9'].into_iter()).collect::>(), + assert_eq!(Utf16Encoder::new(vec!['é', '\u{1F4A9}'].into_iter()).collect::>(), vec![0xE9, 0xD83D, 0xDCA9]) } diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index e5a8db54eab05..f151102f28629 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -278,7 +278,7 @@ pub use self::LabelText::*; use std::borrow::IntoCow; use std::io; -use std::str::CowString; +use std::string::CowString; use std::vec::CowVec; pub mod maybe_owned_vec; @@ -589,8 +589,8 @@ mod tests { use super::{Id, LabelText, LabelStr, EscStr, Labeller}; use super::{Nodes, Edges, GraphWalk, render}; use std::io::IoResult; - use std::str; use std::borrow::IntoCow; + use std::iter::repeat; /// each node is an index in a vector in the graph. type Node = uint; @@ -638,7 +638,7 @@ mod tests { fn to_opt_strs(self) -> Vec> { match self { UnlabelledNodes(len) - => Vec::from_elem(len, None).into_iter().collect(), + => repeat(None).take(len).collect(), AllNodesLabelled(lbls) => lbls.into_iter().map( |l|Some(l)).collect(), diff --git a/src/libgraphviz/maybe_owned_vec.rs b/src/libgraphviz/maybe_owned_vec.rs index 901dffc04c5e9..04aa6d1649538 100644 --- a/src/libgraphviz/maybe_owned_vec.rs +++ b/src/libgraphviz/maybe_owned_vec.rs @@ -12,7 +12,7 @@ pub use self::MaybeOwnedVector::*; -use std::cmp::{Equiv, Ordering}; +use std::cmp::Ordering; use std::default::Default; use std::fmt; use std::iter::FromIterator; @@ -97,13 +97,6 @@ impl<'a, T: Ord> Ord for MaybeOwnedVector<'a, T> { } } -#[allow(deprecated)] -impl<'a, T: PartialEq> Equiv<[T]> for MaybeOwnedVector<'a, T> { - fn equiv(&self, other: &[T]) -> bool { - self.as_slice() == other - } -} - // The `Vector` trait is provided in the prelude and is implemented on // both `&'a [T]` and `Vec`, so it makes sense to try to support it // seamlessly. The other vector related traits from the prelude do diff --git a/src/librand/chacha.rs b/src/librand/chacha.rs index 0b1dd2e13b471..71ce882e98ca9 100644 --- a/src/librand/chacha.rs +++ b/src/librand/chacha.rs @@ -249,14 +249,14 @@ mod test { let seed : &[_] = &[0u32; 8]; let mut ra: ChaChaRng = SeedableRng::from_seed(seed); - let v = Vec::from_fn(16, |_| ra.next_u32()); + let v = range(0, 16).map(|_| ra.next_u32()).collect::>(); assert_eq!(v, vec!(0xade0b876, 0x903df1a0, 0xe56a5d40, 0x28bd8653, 0xb819d2bd, 0x1aed8da0, 0xccef36a8, 0xc70d778b, 0x7c5941da, 0x8d485751, 0x3fe02477, 0x374ad8b8, 0xf4b8436a, 0x1ca11815, 0x69b687c3, 0x8665eeb2)); - let v = Vec::from_fn(16, |_| ra.next_u32()); + let v = range(0, 16).map(|_| ra.next_u32()).collect::>(); assert_eq!(v, vec!(0xbee7079f, 0x7a385155, 0x7c97ba98, 0x0d082d73, 0xa0290fcb, 0x6965e348, 0x3e53c612, 0xed7aee32, diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index af90a0a308dc9..53ae242c5e245 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -555,7 +555,7 @@ mod test { let seed: &[_] = &[1, 23, 456, 7890, 12345]; let mut ra: IsaacRng = SeedableRng::from_seed(seed); // Regression test that isaac is actually using the above vector - let v = Vec::from_fn(10, |_| ra.next_u32()); + let v = range(0, 10).map(|_| ra.next_u32()).collect::>(); assert_eq!(v, vec!(2558573138, 873787463, 263499565, 2103644246, 3595684709, 4203127393, 264982119, 2765226902, 2737944514, 3900253796)); @@ -565,7 +565,7 @@ mod test { // skip forward to the 10000th number for _ in range(0u, 10000) { rb.next_u32(); } - let v = Vec::from_fn(10, |_| rb.next_u32()); + let v = range(0, 10).map(|_| rb.next_u32()).collect::>(); assert_eq!(v, vec!(3676831399, 3183332890, 2834741178, 3854698763, 2717568474, 1576568959, 3507990155, 179069555, 141456972, 2478885421)); @@ -575,7 +575,7 @@ mod test { let seed: &[_] = &[1, 23, 456, 7890, 12345]; let mut ra: Isaac64Rng = SeedableRng::from_seed(seed); // Regression test that isaac is actually using the above vector - let v = Vec::from_fn(10, |_| ra.next_u64()); + let v = range(0, 10).map(|_| ra.next_u64()).collect::>(); assert_eq!(v, vec!(547121783600835980, 14377643087320773276, 17351601304698403469, 1238879483818134882, 11952566807690396487, 13970131091560099343, @@ -587,7 +587,7 @@ mod test { // skip forward to the 10000th number for _ in range(0u, 10000) { rb.next_u64(); } - let v = Vec::from_fn(10, |_| rb.next_u64()); + let v = range(0, 10).map(|_| rb.next_u64()).collect::>(); assert_eq!(v, vec!(18143823860592706164, 8491801882678285927, 2699425367717515619, 17196852593171130876, 2606123525235546165, 15790932315217671084, diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs index 795e8fab85692..63de49ac5cd81 100644 --- a/src/librand/reseeding.rs +++ b/src/librand/reseeding.rs @@ -151,7 +151,7 @@ impl Default for ReseedWithDefault { mod test { use std::prelude::v1::*; - use core::iter::order; + use core::iter::{order, repeat}; use super::{ReseedingRng, ReseedWithDefault}; use std::default::Default; use {SeedableRng, Rng}; @@ -215,7 +215,7 @@ mod test { static FILL_BYTES_V_LEN: uint = 13579; #[test] fn test_rng_fill_bytes() { - let mut v = Vec::from_elem(FILL_BYTES_V_LEN, 0u8); + let mut v = repeat(0u8).take(FILL_BYTES_V_LEN).collect::>(); ::test::rng().fill_bytes(v.as_mut_slice()); // Sanity test: if we've gotten here, `fill_bytes` has not infinitely diff --git a/src/librbml/io.rs b/src/librbml/io.rs index fd0c54e8ed3a8..de06471e65ed9 100644 --- a/src/librbml/io.rs +++ b/src/librbml/io.rs @@ -133,6 +133,7 @@ mod tests { extern crate test; use super::SeekableMemWriter; use std::io; + use std::iter::repeat; use test::Bencher; #[test] @@ -183,7 +184,7 @@ mod tests { } fn do_bench_seekable_mem_writer(b: &mut Bencher, times: uint, len: uint) { - let src: Vec = Vec::from_elem(len, 5); + let src: Vec = repeat(5).take(len).collect(); b.bytes = (times * len) as u64; b.iter(|| { diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index 31fb504ba3d01..f7d5bfcd117d6 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -1165,12 +1165,12 @@ mod bench { #[bench] pub fn vuint_at_A_aligned(b: &mut Bencher) { - let data = Vec::from_fn(4*100, |i| { + let data = range(0, 4*100).map(|i| { match i % 2 { 0 => 0x80u8, _ => i as u8, } - }); + }).collect::>(); let mut sum = 0u; b.iter(|| { let mut i = 0; @@ -1183,12 +1183,12 @@ mod bench { #[bench] pub fn vuint_at_A_unaligned(b: &mut Bencher) { - let data = Vec::from_fn(4*100+1, |i| { + let data = range(0, 4*100+1).map(|i| { match i % 2 { 1 => 0x80u8, _ => i as u8 } - }); + }).collect::>(); let mut sum = 0u; b.iter(|| { let mut i = 1; @@ -1201,13 +1201,13 @@ mod bench { #[bench] pub fn vuint_at_D_aligned(b: &mut Bencher) { - let data = Vec::from_fn(4*100, |i| { + let data = range(0, 4*100).map(|i| { match i % 4 { 0 => 0x10u8, 3 => i as u8, _ => 0u8 } - }); + }).collect::>(); let mut sum = 0u; b.iter(|| { let mut i = 0; @@ -1220,13 +1220,13 @@ mod bench { #[bench] pub fn vuint_at_D_unaligned(b: &mut Bencher) { - let data = Vec::from_fn(4*100+1, |i| { + let data = range(0, 4*100+1).map(|i| { match i % 4 { 1 => 0x10u8, 0 => i as u8, _ => 0u8 } - }); + }).collect::>(); let mut sum = 0u; b.iter(|| { let mut i = 1; diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs index c546477ee0152..b3807d313145d 100644 --- a/src/libregex/lib.rs +++ b/src/libregex/lib.rs @@ -10,356 +10,9 @@ // // ignore-lexer-test FIXME #15679 -//! This crate provides a native implementation of regular expressions that is -//! heavily based on RE2 both in syntax and in implementation. Notably, -//! backreferences and arbitrary lookahead/lookbehind assertions are not -//! provided. In return, regular expression searching provided by this package -//! has excellent worst case performance. The specific syntax supported is -//! documented further down. +//! Regular expressions implemented in Rust //! -//! This crate's documentation provides some simple examples, describes Unicode -//! support and exhaustively lists the supported syntax. For more specific -//! details on the API, please see the documentation for the `Regex` type. -//! -//! # First example: find a date -//! -//! General use of regular expressions in this package involves compiling an -//! expression and then using it to search, split or replace text. For example, -//! to confirm that some text resembles a date: -//! -//! ```rust -//! use regex::Regex; -//! let re = match Regex::new(r"^\d{4}-\d{2}-\d{2}$") { -//! Ok(re) => re, -//! Err(err) => panic!("{}", err), -//! }; -//! assert_eq!(re.is_match("2014-01-01"), true); -//! ``` -//! -//! Notice the use of the `^` and `$` anchors. In this crate, every expression -//! is executed with an implicit `.*?` at the beginning and end, which allows -//! it to match anywhere in the text. Anchors can be used to ensure that the -//! full text matches an expression. -//! -//! This example also demonstrates the utility of [raw -//! strings](../reference.html#character-and-string-literals) in Rust, which -//! are just like regular strings except they are prefixed with an `r` and do -//! not process any escape sequences. For example, `"\\d"` is the same -//! expression as `r"\d"`. -//! -//! # The `regex!` macro -//! -//! Rust's compile time meta-programming facilities provide a way to write a -//! `regex!` macro which compiles regular expressions *when your program -//! compiles*. Said differently, if you only use `regex!` to build regular -//! expressions in your program, then your program cannot compile with an -//! invalid regular expression. Moreover, the `regex!` macro compiles the -//! given expression to native Rust code, which makes it much faster for -//! searching text. -//! -//! Since `regex!` provides compiled regular expressions that are both safer -//! and faster to use, you should use them whenever possible. The only -//! requirement for using them is that you have a string literal corresponding -//! to your expression. Otherwise, it is indistinguishable from an expression -//! compiled at runtime with `Regex::new`. -//! -//! To use the `regex!` macro, you must enable the `phase` feature and import -//! the `regex_macros` crate as a syntax extension: -//! -//! ```rust -//! #![feature(phase)] -//! #[phase(plugin)] -//! extern crate regex_macros; -//! extern crate regex; -//! -//! fn main() { -//! let re = regex!(r"^\d{4}-\d{2}-\d{2}$"); -//! assert_eq!(re.is_match("2014-01-01"), true); -//! } -//! ``` -//! -//! There are a few things worth mentioning about using the `regex!` macro. -//! Firstly, the `regex!` macro *only* accepts string *literals*. -//! Secondly, the `regex` crate *must* be linked with the name `regex` since -//! the generated code depends on finding symbols in the `regex` crate. -//! -//! The only downside of using the `regex!` macro is that it can increase the -//! size of your program's binary since it generates specialized Rust code. -//! The extra size probably won't be significant for a small number of -//! expressions, but 100+ calls to `regex!` will probably result in a -//! noticeably bigger binary. -//! -//! # Example: iterating over capture groups -//! -//! This crate provides convenient iterators for matching an expression -//! repeatedly against a search string to find successive non-overlapping -//! matches. For example, to find all dates in a string and be able to access -//! them by their component pieces: -//! -//! ```rust -//! # #![feature(phase)] -//! # extern crate regex; #[phase(plugin)] extern crate regex_macros; -//! # fn main() { -//! let re = regex!(r"(\d{4})-(\d{2})-(\d{2})"); -//! let text = "2012-03-14, 2013-01-01 and 2014-07-05"; -//! for cap in re.captures_iter(text) { -//! println!("Month: {} Day: {} Year: {}", -//! cap.at(2).unwrap_or(""), cap.at(3).unwrap_or(""), -//! cap.at(1).unwrap_or("")); -//! } -//! // Output: -//! // Month: 03 Day: 14 Year: 2012 -//! // Month: 01 Day: 01 Year: 2013 -//! // Month: 07 Day: 05 Year: 2014 -//! # } -//! ``` -//! -//! Notice that the year is in the capture group indexed at `1`. This is -//! because the *entire match* is stored in the capture group at index `0`. -//! -//! # Example: replacement with named capture groups -//! -//! Building on the previous example, perhaps we'd like to rearrange the date -//! formats. This can be done with text replacement. But to make the code -//! clearer, we can *name* our capture groups and use those names as variables -//! in our replacement text: -//! -//! ```rust -//! # #![feature(phase)] -//! # extern crate regex; #[phase(plugin)] extern crate regex_macros; -//! # fn main() { -//! let re = regex!(r"(?P\d{4})-(?P\d{2})-(?P\d{2})"); -//! let before = "2012-03-14, 2013-01-01 and 2014-07-05"; -//! let after = re.replace_all(before, "$m/$d/$y"); -//! assert_eq!(after.as_slice(), "03/14/2012, 01/01/2013 and 07/05/2014"); -//! # } -//! ``` -//! -//! The `replace` methods are actually polymorphic in the replacement, which -//! provides more flexibility than is seen here. (See the documentation for -//! `Regex::replace` for more details.) -//! -//! # Pay for what you use -//! -//! With respect to searching text with a regular expression, there are three -//! questions that can be asked: -//! -//! 1. Does the text match this expression? -//! 2. If so, where does it match? -//! 3. Where are the submatches? -//! -//! Generally speaking, this crate could provide a function to answer only #3, -//! which would subsume #1 and #2 automatically. However, it can be -//! significantly more expensive to compute the location of submatches, so it's -//! best not to do it if you don't need to. -//! -//! Therefore, only use what you need. For example, don't use `find` if you -//! only need to test if an expression matches a string. (Use `is_match` -//! instead.) -//! -//! # Unicode -//! -//! This implementation executes regular expressions **only** on sequences of -//! Unicode code points while exposing match locations as byte indices into the -//! search string. -//! -//! Currently, only naive case folding is supported. Namely, when matching -//! case insensitively, the characters are first converted to their uppercase -//! forms and then compared. -//! -//! Regular expressions themselves are also **only** interpreted as a sequence -//! of Unicode code points. This means you can use Unicode characters -//! directly in your expression: -//! -//! ```rust -//! # #![feature(phase)] -//! # extern crate regex; #[phase(plugin)] extern crate regex_macros; -//! # fn main() { -//! let re = regex!(r"(?i)Δ+"); -//! assert_eq!(re.find("ΔδΔ"), Some((0, 6))); -//! # } -//! ``` -//! -//! Finally, Unicode general categories and scripts are available as character -//! classes. For example, you can match a sequence of numerals, Greek or -//! Cherokee letters: -//! -//! ```rust -//! # #![feature(phase)] -//! # extern crate regex; #[phase(plugin)] extern crate regex_macros; -//! # fn main() { -//! let re = regex!(r"[\pN\p{Greek}\p{Cherokee}]+"); -//! assert_eq!(re.find("abcΔᎠβⅠᏴγδⅡxyz"), Some((3, 23))); -//! # } -//! ``` -//! -//! # Syntax -//! -//! The syntax supported in this crate is almost in an exact correspondence -//! with the syntax supported by RE2. -//! -//! ## Matching one character -//! -//! 

-//! .           any character except new line (includes new line with s flag)
-//! [xyz]       A character class matching either x, y or z.
-//! [^xyz]      A character class matching any character except x, y and z.
-//! [a-z]       A character class matching any character in range a-z.
-//! \d          Perl character class ([0-9])
-//! \D          Negated Perl character class ([^0-9])
-//! [:alpha:]   ASCII character class ([A-Za-z])
-//! [:^alpha:]  Negated ASCII character class ([^A-Za-z])
-//! \pN         One letter name Unicode character class
-//! \p{Greek}   Unicode character class (general category or script)
-//! \PN         Negated one letter name Unicode character class
-//! \P{Greek}   negated Unicode character class (general category or script)
-//!
-//! -//! Any named character class may appear inside a bracketed `[...]` character -//! class. For example, `[\p{Greek}\pN]` matches any Greek or numeral -//! character. -//! -//! ## Composites -//! -//! 
-//! xy    concatenation (x followed by y)
-//! x|y   alternation (x or y, prefer x)
-//!
-//! -//! ## Repetitions -//! -//! 
-//! x*        zero or more of x (greedy)
-//! x+        one or more of x (greedy)
-//! x?        zero or one of x (greedy)
-//! x*?       zero or more of x (ungreedy)
-//! x+?       one or more of x (ungreedy)
-//! x??       zero or one of x (ungreedy)
-//! x{n,m}    at least n x and at most m x (greedy)
-//! x{n,}     at least n x (greedy)
-//! x{n}      exactly n x
-//! x{n,m}?   at least n x and at most m x (ungreedy)
-//! x{n,}?    at least n x (ungreedy)
-//! x{n}?     exactly n x
-//!
-//! -//! ## Empty matches -//! -//! 
-//! ^     the beginning of text (or start-of-line with multi-line mode)
-//! $     the end of text (or end-of-line with multi-line mode)
-//! \A    only the beginning of text (even with multi-line mode enabled)
-//! \z    only the end of text (even with multi-line mode enabled)
-//! \b    a Unicode word boundary (\w on one side and \W, \A, or \z on other)
-//! \B    not a Unicode word boundary
-//!
-//! -//! ## Grouping and flags -//! -//! 
-//! (exp)          numbered capture group (indexed by opening parenthesis)
-//! (?P<name>exp)  named (also numbered) capture group (allowed chars: [_0-9a-zA-Z])
-//! (?:exp)        non-capturing group
-//! (?flags)       set flags within current group
-//! (?flags:exp)   set flags for exp (non-capturing)
-//!
-//! -//! Flags are each a single character. For example, `(?x)` sets the flag `x` -//! and `(?-x)` clears the flag `x`. Multiple flags can be set or cleared at -//! the same time: `(?xy)` sets both the `x` and `y` flags and `(?x-y)` sets -//! the `x` flag and clears the `y` flag. -//! -//! All flags are by default disabled. They are: -//! -//! 
-//! i     case insensitive
-//! m     multi-line mode: ^ and $ match begin/end of line
-//! s     allow . to match \n
-//! U     swap the meaning of x* and x*?
-//!
-//! -//! Here's an example that matches case insensitively for only part of the -//! expression: -//! -//! ```rust -//! # #![feature(phase)] -//! # extern crate regex; #[phase(plugin)] extern crate regex_macros; -//! # fn main() { -//! let re = regex!(r"(?i)a+(?-i)b+"); -//! let cap = re.captures("AaAaAbbBBBb").unwrap(); -//! assert_eq!(cap.at(0), Some("AaAaAbb")); -//! # } -//! ``` -//! -//! Notice that the `a+` matches either `a` or `A`, but the `b+` only matches -//! `b`. -//! -//! ## Escape sequences -//! -//! 
-//! \*         literal *, works for any punctuation character: \.+*?()|[]{}^$
-//! \a         bell (\x07)
-//! \f         form feed (\x0C)
-//! \t         horizontal tab
-//! \n         new line
-//! \r         carriage return
-//! \v         vertical tab (\x0B)
-//! \123       octal character code (up to three digits)
-//! \x7F       hex character code (exactly two digits)
-//! \x{10FFFF} any hex character code corresponding to a Unicode code point
-//!
-//! -//! ## Perl character classes (Unicode friendly) -//! -//! These classes are based on the definitions provided in -//! [UTS#18](http://www.unicode.org/reports/tr18/#Compatibility_Properties): -//! -//! 
-//! \d     digit (\p{Nd})
-//! \D     not digit
-//! \s     whitespace (\p{White_Space})
-//! \S     not whitespace
-//! \w     word character (\p{Alphabetic} + \p{M} + \d + \p{Pc} + \p{Join_Control})
-//! \W     not word character
-//!
-//! -//! ## ASCII character classes -//! -//! 
-//! [:alnum:]    alphanumeric ([0-9A-Za-z])
-//! [:alpha:]    alphabetic ([A-Za-z])
-//! [:ascii:]    ASCII ([\x00-\x7F])
-//! [:blank:]    blank ([\t ])
-//! [:cntrl:]    control ([\x00-\x1F\x7F])
-//! [:digit:]    digits ([0-9])
-//! [:graph:]    graphical ([!-~])
-//! [:lower:]    lower case ([a-z])
-//! [:print:]    printable ([ -~])
-//! [:punct:]    punctuation ([!-/:-@[-`{-~])
-//! [:space:]    whitespace ([\t\n\v\f\r ])
-//! [:upper:]    upper case ([A-Z])
-//! [:word:]     word characters ([0-9A-Za-z_])
-//! [:xdigit:]   hex digit ([0-9A-Fa-f])
-//!
-//! -//! # Untrusted input -//! -//! There are two factors to consider here: untrusted regular expressions and -//! untrusted search text. -//! -//! Currently, there are no counter-measures in place to prevent a malicious -//! user from writing an expression that may use a lot of resources. One such -//! example is to repeat counted repetitions: `((a{100}){100}){100}` will try -//! to repeat the `a` instruction `100^3` times. Essentially, this means it's -//! very easy for an attacker to exhaust your system's memory if they are -//! allowed to execute arbitrary regular expressions. A possible solution to -//! this is to impose a hard limit on the size of a compiled expression, but it -//! does not yet exist. -//! -//! The story is a bit better with untrusted search text, since this crate's -//! implementation provides `O(nm)` search where `n` is the number of -//! characters in the search text and `m` is the number of instructions in a -//! compiled expression. +//! For official documentation, see the rust-lang/regex crate #![crate_name = "regex"] #![crate_type = "rlib"] diff --git a/src/libregex/re.rs b/src/libregex/re.rs index 8edbf263d7400..1840a3343e63c 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -14,7 +14,7 @@ pub use self::Regex::*; use std::borrow::IntoCow; use std::collections::HashMap; use std::fmt; -use std::str::CowString; +use std::string::CowString; use compile::Program; use parse; @@ -51,59 +51,6 @@ pub fn is_match(regex: &str, text: &str) -> Result { } /// A compiled regular expression -/// -/// It is represented as either a sequence of bytecode instructions (dynamic) -/// or as a specialized Rust function (native). It can be used to search, split -/// or replace text. All searching is done with an implicit `.*?` at the -/// beginning and end of an expression. To force an expression to match the -/// whole string (or a prefix or a suffix), you must use an anchor like `^` or -/// `$` (or `\A` and `\z`). -/// -/// While this crate will handle Unicode strings (whether in the regular -/// expression or in the search text), all positions returned are **byte -/// indices**. Every byte index is guaranteed to be at a Unicode code point -/// boundary. -/// -/// The lifetimes `'r` and `'t` in this crate correspond to the lifetime of a -/// compiled regular expression and text to search, respectively. -/// -/// The only methods that allocate new strings are the string replacement -/// methods. All other methods (searching and splitting) return borrowed -/// pointers into the string given. -/// -/// # Examples -/// -/// Find the location of a US phone number: -/// -/// ```rust -/// # use regex::Regex; -/// let re = match Regex::new("[0-9]{3}-[0-9]{3}-[0-9]{4}") { -/// Ok(re) => re, -/// Err(err) => panic!("{}", err), -/// }; -/// assert_eq!(re.find("phone: 111-222-3333"), Some((7, 19))); -/// ``` -/// -/// You can also use the `regex!` macro to compile a regular expression when -/// you compile your program: -/// -/// ```rust -/// #![feature(phase)] -/// extern crate regex; -/// #[phase(plugin)] extern crate regex_macros; -/// -/// fn main() { -/// let re = regex!(r"\d+"); -/// assert_eq!(re.find("123 abc"), Some((0, 3))); -/// } -/// ``` -/// -/// Given an incorrect regular expression, `regex!` will cause the Rust -/// compiler to produce a compile time error. -/// Note that `regex!` will compile the expression to native Rust code, which -/// makes it much faster when searching text. -/// More details about the `regex!` macro can be found in the `regex` crate -/// documentation. #[derive(Clone)] pub enum Regex { // The representation of `Regex` is exported to support the `regex!` @@ -169,46 +116,12 @@ impl Regex { } /// Returns true if and only if the regex matches the string given. - /// - /// # Example - /// - /// Test if some text contains at least one word with exactly 13 - /// characters: - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let text = "I categorically deny having triskaidekaphobia."; - /// let matched = regex!(r"\b\w{13}\b").is_match(text); - /// assert!(matched); - /// # } - /// ``` pub fn is_match(&self, text: &str) -> bool { has_match(&exec(self, Exists, text)) } /// Returns the start and end byte range of the leftmost-first match in /// `text`. If no match exists, then `None` is returned. - /// - /// Note that this should only be used if you want to discover the position - /// of the match. Testing the existence of a match is faster if you use - /// `is_match`. - /// - /// # Example - /// - /// Find the start and end location of the first word with exactly 13 - /// characters: - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let text = "I categorically deny having triskaidekaphobia."; - /// let pos = regex!(r"\b\w{13}\b").find(text); - /// assert_eq!(pos, Some((2, 15))); - /// # } - /// ``` pub fn find(&self, text: &str) -> Option<(uint, uint)> { let caps = exec(self, Location, text); if has_match(&caps) { @@ -221,27 +134,6 @@ impl Regex { /// Returns an iterator for each successive non-overlapping match in /// `text`, returning the start and end byte indices with respect to /// `text`. - /// - /// # Example - /// - /// Find the start and end location of every word with exactly 13 - /// characters: - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let text = "Retroactively relinquishing remunerations is reprehensible."; - /// for pos in regex!(r"\b\w{13}\b").find_iter(text) { - /// println!("{}", pos); - /// } - /// // Output: - /// // (0, 13) - /// // (14, 27) - /// // (28, 41) - /// // (45, 58) - /// # } - /// ``` pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> FindMatches<'r, 't> { FindMatches { re: self, @@ -258,51 +150,6 @@ impl Regex { /// You should only use `captures` if you need access to submatches. /// Otherwise, `find` is faster for discovering the location of the overall /// match. - /// - /// # Examples - /// - /// Say you have some text with movie names and their release years, - /// like "'Citizen Kane' (1941)". It'd be nice if we could search for text - /// looking like that, while also extracting the movie name and its release - /// year separately. - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let re = regex!(r"'([^']+)'\s+\((\d{4})\)"); - /// let text = "Not my favorite movie: 'Citizen Kane' (1941)."; - /// let caps = re.captures(text).unwrap(); - /// assert_eq!(caps.at(1), Some("Citizen Kane")); - /// assert_eq!(caps.at(2), Some("1941")); - /// assert_eq!(caps.at(0), Some("'Citizen Kane' (1941)")); - /// # } - /// ``` - /// - /// Note that the full match is at capture group `0`. Each subsequent - /// capture group is indexed by the order of its opening `(`. - /// - /// We can make this example a bit clearer by using *named* capture groups: - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let re = regex!(r"'(?P[^']+)'\s+\((?P<year>\d{4})\)"); - /// let text = "Not my favorite movie: 'Citizen Kane' (1941)."; - /// let caps = re.captures(text).unwrap(); - /// assert_eq!(caps.name("title"), Some("Citizen Kane")); - /// assert_eq!(caps.name("year"), Some("1941")); - /// assert_eq!(caps.at(0), Some("'Citizen Kane' (1941)")); - /// # } - /// ``` - /// - /// Here we name the capture groups, which we can access with the `name` - /// method. Note that the named capture groups are still accessible with - /// `at`. - /// - /// The `0`th capture group is always unnamed, so it must always be - /// accessed with `at(0)`. pub fn captures<'t>(&self, text: &'t str) -> Option<Captures<'t>> { let caps = exec(self, Submatches, text); Captures::new(self, text, caps) @@ -311,27 +158,6 @@ impl Regex { /// Returns an iterator over all the non-overlapping capture groups matched /// in `text`. This is operationally the same as `find_iter` (except it /// yields information about submatches). - /// - /// # Example - /// - /// We can use this to find all movie titles and their release years in - /// some text, where the movie is formatted like "'Title' (xxxx)": - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let re = regex!(r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"); - /// let text = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931)."; - /// for caps in re.captures_iter(text) { - /// println!("Movie: {}, Released: {}", caps.name("title"), caps.name("year")); - /// } - /// // Output: - /// // Movie: Citizen Kane, Released: 1941 - /// // Movie: The Wizard of Oz, Released: 1939 - /// // Movie: M, Released: 1931 - /// # } - /// ``` pub fn captures_iter<'r, 't>(&'r self, text: &'t str) -> FindCaptures<'r, 't> { FindCaptures { @@ -348,20 +174,6 @@ impl Regex { /// matched by the regular expression. /// /// This method will *not* copy the text given. - /// - /// # Example - /// - /// To split a string delimited by arbitrary amounts of spaces or tabs: - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let re = regex!(r"[ \t]+"); - /// let fields: Vec<&str> = re.split("a b \t c\td e").collect(); - /// assert_eq!(fields, vec!("a", "b", "c", "d", "e")); - /// # } - /// ``` pub fn split<'r, 't>(&'r self, text: &'t str) -> RegexSplits<'r, 't> { RegexSplits { finder: self.find_iter(text), @@ -378,20 +190,6 @@ impl Regex { /// in the iterator. /// /// This method will *not* copy the text given. - /// - /// # Example - /// - /// Get the first two words in some text: - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let re = regex!(r"\W+"); - /// let fields: Vec<&str> = re.splitn("Hey! How are you?", 3).collect(); - /// assert_eq!(fields, vec!("Hey", "How", "are you?")); - /// # } - /// ``` pub fn splitn<'r, 't>(&'r self, text: &'t str, limit: uint) -> RegexSplitsN<'r, 't> { RegexSplitsN { @@ -407,72 +205,6 @@ impl Regex { /// `Captures` and returns the replaced string. /// /// If no match is found, then a copy of the string is returned unchanged. - /// - /// # Examples - /// - /// Note that this function is polymorphic with respect to the replacement. - /// In typical usage, this can just be a normal string: - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let re = regex!("[^01]+"); - /// assert_eq!(re.replace("1078910", ""), "1010"); - /// # } - /// ``` - /// - /// But anything satisfying the `Replacer` trait will work. For example, - /// a closure of type `|&Captures| -> String` provides direct access to the - /// captures corresponding to a match. This allows one to access - /// submatches easily: - /// - /// ```rust - /// # #![feature(phase)] - /// # #![feature(unboxed_closures)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # use regex::Captures; fn main() { - /// let re = regex!(r"([^,\s]+),\s+(\S+)"); - /// let result = re.replace("Springsteen, Bruce", |&: caps: &Captures| { - /// format!("{} {}", caps.at(2).unwrap_or(""), caps.at(1).unwrap_or("")) - /// }); - /// assert_eq!(result, "Bruce Springsteen"); - /// # } - /// ``` - /// - /// But this is a bit cumbersome to use all the time. Instead, a simple - /// syntax is supported that expands `$name` into the corresponding capture - /// group. Here's the last example, but using this expansion technique - /// with named capture groups: - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// let re = regex!(r"(?P<last>[^,\s]+),\s+(?P<first>\S+)"); - /// let result = re.replace("Springsteen, Bruce", "$first $last"); - /// assert_eq!(result, "Bruce Springsteen"); - /// # } - /// ``` - /// - /// Note that using `$2` instead of `$first` or `$1` instead of `$last` - /// would produce the same result. To write a literal `$` use `$$`. - /// - /// Finally, sometimes you just want to replace a literal string with no - /// submatch expansion. This can be done by wrapping a string with - /// `NoExpand`: - /// - /// ```rust - /// # #![feature(phase)] - /// # extern crate regex; #[phase(plugin)] extern crate regex_macros; - /// # fn main() { - /// use regex::NoExpand; - /// - /// let re = regex!(r"(?P<last>[^,\s]+),\s+(\S+)"); - /// let result = re.replace("Springsteen, Bruce", NoExpand("$2 $last")); - /// assert_eq!(result, "$2 $last"); - /// # } - /// ``` pub fn replace<R: Replacer>(&self, text: &str, rep: R) -> String { self.replacen(text, 1, rep) } diff --git a/src/libregex/test/mod.rs b/src/libregex/test/mod.rs index 1415664719124..48cc35aa5d93c 100644 --- a/src/libregex/test/mod.rs +++ b/src/libregex/test/mod.rs @@ -8,24 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[cfg(not(stage1))] -#[phase(plugin)] -extern crate regex_macros; - -#[cfg(not(stage1))] -#[path = "bench.rs"] -mod native_bench; - -#[cfg(not(stage1))] -#[path = "tests.rs"] -mod native_tests; - -#[cfg(not(stage1))] -mod native_static; - -// Due to macro scoping rules, this definition only applies for the modules -// defined below. Effectively, it allows us to use the same tests for both -// native and dynamic regexes. macro_rules! regex { ($re:expr) => ( match ::regex::Regex::new($re) { diff --git a/src/libregex_macros/lib.rs b/src/libregex_macros/lib.rs deleted file mode 100644 index ebd1cc7e166d7..0000000000000 --- a/src/libregex_macros/lib.rs +++ /dev/null @@ -1,643 +0,0 @@ -// 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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! This crate provides the `regex!` macro. Its use is documented in the -//! `regex` crate. - -#![crate_name = "regex_macros"] -#![crate_type = "dylib"] -#![experimental = "use the crates.io `regex_macros` library instead"] -#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", - html_favicon_url = "http://www.rust-lang.org/favicon.ico", - html_root_url = "http://doc.rust-lang.org/nightly/")] - -#![feature(plugin_registrar, quote)] -#![feature(unboxed_closures)] - -extern crate regex; -extern crate syntax; -extern crate rustc; - -use std::rc::Rc; - -use syntax::ast; -use syntax::codemap; -use syntax::ext::build::AstBuilder; -use syntax::ext::base::{ExtCtxt, MacResult, MacExpr, DummyResult}; -use syntax::parse::token; -use syntax::print::pprust; -use syntax::fold::Folder; -use syntax::ptr::P; - -use rustc::plugin::Registry; - -use regex::Regex; -use regex::native::{ - OneChar, CharClass, Any, Save, Jump, Split, - Match, EmptyBegin, EmptyEnd, EmptyWordBoundary, - Program, Dynamic, ExDynamic, Native, - FLAG_NOCASE, FLAG_MULTI, FLAG_DOTNL, FLAG_NEGATED, -}; - -/// For the `regex!` syntax extension. Do not use. -#[plugin_registrar] -#[doc(hidden)] -pub fn plugin_registrar(reg: &mut Registry) { - reg.register_macro("regex", native); -} - -/// Generates specialized code for the Pike VM for a particular regular -/// expression. -/// -/// There are two primary differences between the code generated here and the -/// general code in vm.rs. -/// -/// 1. All heap allocation is removed. Sized vector types are used instead. -/// Care must be taken to make sure that these vectors are not copied -/// gratuitously. (If you're not sure, run the benchmarks. They will yell -/// at you if you do.) -/// 2. The main `match instruction { ... }` expressions are replaced with more -/// direct `match pc { ... }`. The generators can be found in -/// `step_insts` and `add_insts`. -/// -/// Other more minor changes include eliding code when possible (although this -/// isn't completely thorough at the moment), and translating character class -/// matching from using a binary search to a simple `match` expression (see -/// `match_class`). -/// -/// It is strongly recommended to read the dynamic implementation in vm.rs -/// first before trying to understand the code generator. The implementation -/// strategy is identical and vm.rs has comments and will be easier to follow. -#[allow(experimental)] -fn native(cx: &mut ExtCtxt, sp: codemap::Span, tts: &[ast::TokenTree]) - -> Box<MacResult+'static> { - let regex = match parse(cx, tts) { - Some(r) => r, - // error is logged in 'parse' with cx.span_err - None => return DummyResult::any(sp), - }; - let re = match Regex::new(regex.as_slice()) { - Ok(re) => re, - Err(err) => { - cx.span_err(sp, err.to_string().as_slice()); - return DummyResult::any(sp) - } - }; - let prog = match re { - Dynamic(ExDynamic { ref prog, .. }) => prog.clone(), - Native(_) => unreachable!(), - }; - - let mut gen = NfaGen { - cx: &*cx, sp: sp, prog: prog, - names: re.names_iter().collect(), original: re.as_str().to_string(), - }; - MacExpr::new(gen.code()) -} - -struct NfaGen<'a> { - cx: &'a ExtCtxt<'a>, - sp: codemap::Span, - prog: Program, - names: Vec<Option<String>>, - original: String, -} - -impl<'a> NfaGen<'a> { - fn code(&mut self) -> P<ast::Expr> { - // Most or all of the following things are used in the quasiquoted - // expression returned. - let num_cap_locs = 2 * self.prog.num_captures(); - let num_insts = self.prog.insts.len(); - let cap_names = self.vec_expr(self.names.iter(), - |cx, name| match *name { - Some(ref name) => { - let name = name.as_slice(); - quote_expr!(cx, Some($name)) - } - None => cx.expr_none(self.sp), - } - ); - let prefix_anchor = - match self.prog.insts[1] { - EmptyBegin(flags) if flags & FLAG_MULTI == 0 => true, - _ => false, - }; - let init_groups = self.vec_expr(range(0, num_cap_locs), - |cx, _| cx.expr_none(self.sp)); - - let prefix_lit = Rc::new(self.prog.prefix.as_bytes().to_vec()); - let prefix_bytes = self.cx.expr_lit(self.sp, ast::LitBinary(prefix_lit)); - - let check_prefix = self.check_prefix(); - let step_insts = self.step_insts(); - let add_insts = self.add_insts(); - let regex = self.original.as_slice(); - - quote_expr!(self.cx, { -// When `regex!` is bound to a name that is not used, we have to make sure -// that dead_code warnings don't bubble up to the user from the generated -// code. Therefore, we suppress them by allowing dead_code. The effect is that -// the user is only warned about *their* unused variable/code, and not the -// unused code generated by regex!. See #14185 for an example. -#[allow(dead_code)] -static CAP_NAMES: &'static [Option<&'static str>] = &$cap_names; - -#[allow(dead_code)] -fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str, - start: uint, end: uint) -> Vec<Option<uint>> { - #![allow(unused_imports)] - #![allow(unused_mut)] - - use regex::native::{ - MatchKind, Exists, Location, Submatches, - StepState, StepMatchEarlyReturn, StepMatch, StepContinue, - CharReader, find_prefix, - }; - - return Nfa { - which: which, - input: input, - ic: 0, - chars: CharReader::new(input), - }.run(start, end); - - type Captures = [Option<uint>; $num_cap_locs]; - - struct Nfa<'t> { - which: MatchKind, - input: &'t str, - ic: uint, - chars: CharReader<'t>, - } - - impl<'t> Nfa<'t> { - #[allow(unused_variables)] - fn run(&mut self, start: uint, end: uint) -> Vec<Option<uint>> { - let mut matched = false; - let prefix_bytes: &[u8] = $prefix_bytes; - let mut clist = &mut Threads::new(self.which); - let mut nlist = &mut Threads::new(self.which); - - let mut groups = $init_groups; - - self.ic = start; - let mut next_ic = self.chars.set(start); - while self.ic <= end { - if clist.size == 0 { - if matched { - break - } - $check_prefix - } - if clist.size == 0 || (!$prefix_anchor && !matched) { - self.add(clist, 0, &mut groups) - } - - self.ic = next_ic; - next_ic = self.chars.advance(); - - for i in range(0, clist.size) { - let pc = clist.pc(i); - let step_state = self.step(&mut groups, nlist, - clist.groups(i), pc); - match step_state { - StepMatchEarlyReturn => - return vec![Some(0u), Some(0u)], - StepMatch => { matched = true; break }, - StepContinue => {}, - } - } - ::std::mem::swap(&mut clist, &mut nlist); - nlist.empty(); - } - match self.which { - Exists if matched => vec![Some(0u), Some(0u)], - Exists => vec![None, None], - Location | Submatches => groups.iter().map(|x| *x).collect(), - } - } - - // Sometimes `nlist` is never used (for empty regexes). - #[allow(unused_variables)] - #[inline] - fn step(&self, groups: &mut Captures, nlist: &mut Threads, - caps: &mut Captures, pc: uint) -> StepState { - $step_insts - StepContinue - } - - fn add(&self, nlist: &mut Threads, pc: uint, - groups: &mut Captures) { - if nlist.contains(pc) { - return - } - $add_insts - } - } - - struct Thread { - pc: uint, - groups: Captures, - } - - struct Threads { - which: MatchKind, - queue: [Thread; $num_insts], - sparse: [uint; $num_insts], - size: uint, - } - - impl Threads { - fn new(which: MatchKind) -> Threads { - Threads { - which: which, - // These unsafe blocks are used for performance reasons, as it - // gives us a zero-cost initialization of a sparse set. The - // trick is described in more detail here: - // http://research.swtch.com/sparse - // The idea here is to avoid initializing threads that never - // need to be initialized, particularly for larger regexs with - // a lot of instructions. - queue: unsafe { ::std::mem::uninitialized() }, - sparse: unsafe { ::std::mem::uninitialized() }, - size: 0, - } - } - - #[inline] - fn add(&mut self, pc: uint, groups: &Captures) { - let t = &mut self.queue[self.size]; - t.pc = pc; - match self.which { - Exists => {}, - Location => { - t.groups[0] = groups[0]; - t.groups[1] = groups[1]; - } - Submatches => { - for (slot, val) in t.groups.iter_mut().zip(groups.iter()) { - *slot = *val; - } - } - } - self.sparse[pc] = self.size; - self.size += 1; - } - - #[inline] - fn add_empty(&mut self, pc: uint) { - self.queue[self.size].pc = pc; - self.sparse[pc] = self.size; - self.size += 1; - } - - #[inline] - fn contains(&self, pc: uint) -> bool { - let s = self.sparse[pc]; - s < self.size && self.queue[s].pc == pc - } - - #[inline] - fn empty(&mut self) { - self.size = 0; - } - - #[inline] - fn pc(&self, i: uint) -> uint { - self.queue[i].pc - } - - #[inline] - fn groups<'r>(&'r mut self, i: uint) -> &'r mut Captures { - &mut self.queue[i].groups - } - } -} - -::regex::native::Native(::regex::native::ExNative { - original: $regex, - names: &CAP_NAMES, - prog: exec, -}) - }) - } - - // Generates code for the `add` method, which is responsible for adding - // zero-width states to the next queue of states to visit. - fn add_insts(&self) -> P<ast::Expr> { - let arms = self.prog.insts.iter().enumerate().map(|(pc, inst)| { - let nextpc = pc + 1; - let body = match *inst { - EmptyBegin(flags) => { - let cond = - if flags & FLAG_MULTI > 0 { - quote_expr!(self.cx, - self.chars.is_begin() - || self.chars.prev == Some('\n') - ) - } else { - quote_expr!(self.cx, self.chars.is_begin()) - }; - quote_expr!(self.cx, { - nlist.add_empty($pc); - if $cond { self.add(nlist, $nextpc, &mut *groups) } - }) - } - EmptyEnd(flags) => { - let cond = - if flags & FLAG_MULTI > 0 { - quote_expr!(self.cx, - self.chars.is_end() - || self.chars.cur == Some('\n') - ) - } else { - quote_expr!(self.cx, self.chars.is_end()) - }; - quote_expr!(self.cx, { - nlist.add_empty($pc); - if $cond { self.add(nlist, $nextpc, &mut *groups) } - }) - } - EmptyWordBoundary(flags) => { - let cond = - if flags & FLAG_NEGATED > 0 { - quote_expr!(self.cx, !self.chars.is_word_boundary()) - } else { - quote_expr!(self.cx, self.chars.is_word_boundary()) - }; - quote_expr!(self.cx, { - nlist.add_empty($pc); - if $cond { self.add(nlist, $nextpc, &mut *groups) } - }) - } - Save(slot) => { - let save = quote_expr!(self.cx, { - let old = groups[$slot]; - groups[$slot] = Some(self.ic); - self.add(nlist, $nextpc, &mut *groups); - groups[$slot] = old; - }); - let add = quote_expr!(self.cx, { - self.add(nlist, $nextpc, &mut *groups); - }); - // If this is saving a submatch location but we request - // existence or only full match location, then we can skip - // right over it every time. - if slot > 1 { - quote_expr!(self.cx, { - nlist.add_empty($pc); - match self.which { - Submatches => $save, - Exists | Location => $add, - } - }) - } else { - quote_expr!(self.cx, { - nlist.add_empty($pc); - match self.which { - Submatches | Location => $save, - Exists => $add, - } - }) - } - } - Jump(to) => { - quote_expr!(self.cx, { - nlist.add_empty($pc); - self.add(nlist, $to, &mut *groups); - }) - } - Split(x, y) => { - quote_expr!(self.cx, { - nlist.add_empty($pc); - self.add(nlist, $x, &mut *groups); - self.add(nlist, $y, &mut *groups); - }) - } - // For Match, OneChar, CharClass, Any - _ => quote_expr!(self.cx, nlist.add($pc, &*groups)), - }; - self.arm_inst(pc, body) - }).collect::<Vec<ast::Arm>>(); - - self.match_insts(arms) - } - - // Generates the code for the `step` method, which processes all states - // in the current queue that consume a single character. - fn step_insts(&self) -> P<ast::Expr> { - let arms = self.prog.insts.iter().enumerate().map(|(pc, inst)| { - let nextpc = pc + 1; - let body = match *inst { - Match => { - quote_expr!(self.cx, { - match self.which { - Exists => { - return StepMatchEarlyReturn - } - Location => { - groups[0] = caps[0]; - groups[1] = caps[1]; - return StepMatch - } - Submatches => { - for (slot, val) in groups.iter_mut().zip(caps.iter()) { - *slot = *val; - } - return StepMatch - } - } - }) - } - OneChar(c, flags) => { - if flags & FLAG_NOCASE > 0 { - let upc = c.to_uppercase(); - quote_expr!(self.cx, { - let upc = self.chars.prev.map(|c| c.to_uppercase()); - if upc == Some($upc) { - self.add(nlist, $nextpc, caps); - } - }) - } else { - quote_expr!(self.cx, { - if self.chars.prev == Some($c) { - self.add(nlist, $nextpc, caps); - } - }) - } - } - CharClass(ref ranges, flags) => { - let negate = flags & FLAG_NEGATED > 0; - let casei = flags & FLAG_NOCASE > 0; - let get_char = - if casei { - quote_expr!(self.cx, self.chars.prev.unwrap().to_uppercase()) - } else { - quote_expr!(self.cx, self.chars.prev.unwrap()) - }; - let negcond = - if negate { - quote_expr!(self.cx, !found) - } else { - quote_expr!(self.cx, found) - }; - let mranges = self.match_class(casei, ranges.as_slice()); - quote_expr!(self.cx, { - if self.chars.prev.is_some() { - let c = $get_char; - let found = $mranges; - if $negcond { - self.add(nlist, $nextpc, caps); - } - } - }) - } - Any(flags) => { - if flags & FLAG_DOTNL > 0 { - quote_expr!(self.cx, self.add(nlist, $nextpc, caps)) - } else { - quote_expr!(self.cx, { - if self.chars.prev != Some('\n') { - self.add(nlist, $nextpc, caps) - } - () - }) - } - } - // EmptyBegin, EmptyEnd, EmptyWordBoundary, Save, Jump, Split - _ => self.empty_block(), - }; - self.arm_inst(pc, body) - }).collect::<Vec<ast::Arm>>(); - - self.match_insts(arms) - } - - // Translates a character class into a match expression. - // This avoids a binary search (and is hopefully replaced by a jump - // table). - fn match_class(&self, casei: bool, ranges: &[(char, char)]) -> P<ast::Expr> { - let mut arms = ranges.iter().map(|&(mut start, mut end)| { - if casei { - start = start.to_uppercase(); - end = end.to_uppercase(); - } - let pat = self.cx.pat(self.sp, ast::PatRange(quote_expr!(self.cx, $start), - quote_expr!(self.cx, $end))); - self.cx.arm(self.sp, vec!(pat), quote_expr!(self.cx, true)) - }).collect::<Vec<ast::Arm>>(); - - arms.push(self.wild_arm_expr(quote_expr!(self.cx, false))); - - let match_on = quote_expr!(self.cx, c); - self.cx.expr_match(self.sp, match_on, arms) - } - - // Generates code for checking a literal prefix of the search string. - // The code is only generated if the regex *has* a literal prefix. - // Otherwise, a no-op is returned. - fn check_prefix(&self) -> P<ast::Expr> { - if self.prog.prefix.len() == 0 { - self.empty_block() - } else { - quote_expr!(self.cx, - if clist.size == 0 { - let haystack = self.input.as_bytes()[self.ic..]; - match find_prefix(prefix_bytes, haystack) { - None => break, - Some(i) => { - self.ic += i; - next_ic = self.chars.set(self.ic); - } - } - } - ) - } - } - - // Builds a `match pc { ... }` expression from a list of arms, specifically - // for matching the current program counter with an instruction. - // A wild-card arm is automatically added that executes a no-op. It will - // never be used, but is added to satisfy the compiler complaining about - // non-exhaustive patterns. - fn match_insts(&self, mut arms: Vec<ast::Arm>) -> P<ast::Expr> { - arms.push(self.wild_arm_expr(self.empty_block())); - self.cx.expr_match(self.sp, quote_expr!(self.cx, pc), arms) - } - - fn empty_block(&self) -> P<ast::Expr> { - quote_expr!(self.cx, {}) - } - - // Creates a match arm for the instruction at `pc` with the expression - // `body`. - fn arm_inst(&self, pc: uint, body: P<ast::Expr>) -> ast::Arm { - let pc_pat = self.cx.pat_lit(self.sp, quote_expr!(self.cx, $pc)); - - self.cx.arm(self.sp, vec!(pc_pat), body) - } - - // Creates a wild-card match arm with the expression `body`. - fn wild_arm_expr(&self, body: P<ast::Expr>) -> ast::Arm { - ast::Arm { - attrs: vec!(), - pats: vec!(P(ast::Pat{ - id: ast::DUMMY_NODE_ID, - span: self.sp, - node: ast::PatWild(ast::PatWildSingle), - })), - guard: None, - body: body, - } - } - - - // Converts `xs` to a `[x1, x2, .., xN]` expression by calling `to_expr` - // on each element in `xs`. - fn vec_expr<T, It, F>(&self, xs: It, mut to_expr: F) -> P<ast::Expr> where - It: Iterator<Item=T>, - F: FnMut(&ExtCtxt, T) -> P<ast::Expr>, - { - let exprs = xs.map(|x| to_expr(self.cx, x)).collect(); - self.cx.expr_vec(self.sp, exprs) - } -} - -/// Looks for a single string literal and returns it. -/// Otherwise, logs an error with cx.span_err and returns None. -fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option<String> { - let mut parser = cx.new_parser_from_tts(tts); - let entry = cx.expander().fold_expr(parser.parse_expr()); - let regex = match entry.node { - ast::ExprLit(ref lit) => { - match lit.node { - ast::LitStr(ref s, _) => s.to_string(), - _ => { - cx.span_err(entry.span, format!( - "expected string literal but got `{}`", - pprust::lit_to_string(&**lit)).as_slice()); - return None - } - } - } - _ => { - cx.span_err(entry.span, format!( - "expected string literal but got `{}`", - pprust::expr_to_string(&*entry)).as_slice()); - return None - } - }; - if !parser.eat(&token::Eof) { - cx.span_err(parser.span, "only one string literal allowed"); - return None; - } - Some(regex) -} diff --git a/src/librustc/middle/infer/region_inference/graphviz.rs b/src/librustc/middle/infer/region_inference/graphviz.rs index 7bc4bf1f4fe28..2bf32e7bdaede 100644 --- a/src/librustc/middle/infer/region_inference/graphviz.rs +++ b/src/librustc/middle/infer/region_inference/graphviz.rs @@ -29,7 +29,7 @@ use util::ppaux::Repr; use std::collections::hash_map::Entry::Vacant; use std::io::{self, File}; use std::os; -use std::sync::atomic; +use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT}; use syntax::ast; fn print_help_message() { @@ -73,10 +73,10 @@ pub fn maybe_print_constraints_for<'a, 'tcx>(region_vars: &RegionVarBindings<'a, let output_path = { let output_template = match requested_output { Some(ref s) if s.as_slice() == "help" => { - static PRINTED_YET : atomic::AtomicBool = atomic::ATOMIC_BOOL_INIT; - if !PRINTED_YET.load(atomic::SeqCst) { + static PRINTED_YET: AtomicBool = ATOMIC_BOOL_INIT; + if !PRINTED_YET.load(Ordering::SeqCst) { print_help_message(); - PRINTED_YET.store(true, atomic::SeqCst); + PRINTED_YET.store(true, Ordering::SeqCst); } return; } diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 01bd114474c9e..1480ff016b53d 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -18,7 +18,7 @@ pub use self::OptLevel::*; pub use self::OutputType::*; pub use self::DebugInfoLevel::*; -use session::{early_error, Session}; +use session::{early_error, early_warn, Session}; use session::search_paths::SearchPaths; use rustc_back::target::Target; @@ -394,7 +394,6 @@ 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 { @@ -456,7 +455,7 @@ macro_rules! cgoptions { } fn parse_uint(slot: &mut uint, v: Option<&str>) -> bool { - match v.and_then(from_str) { + match v.and_then(|s| s.parse()) { Some(i) => { *slot = i; true }, None => false } @@ -464,7 +463,7 @@ macro_rules! cgoptions { fn parse_opt_uint(slot: &mut Option<uint>, v: Option<&str>) -> bool { match v { - Some(s) => { *slot = from_str(s); slot.is_some() } + Some(s) => { *slot = s.parse(); slot.is_some() } None => { *slot = None; true } } } @@ -879,22 +878,22 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { } let parse_only = if matches.opt_present("parse-only") { - // FIXME(acrichto) uncomment deprecation warning - // early_warn("--parse-only is deprecated in favor of -Z parse-only"); + // FIXME(acrichto) remove this eventually + early_warn("--parse-only is deprecated in favor of -Z parse-only"); true } else { debugging_opts & PARSE_ONLY != 0 }; let no_trans = if matches.opt_present("no-trans") { - // FIXME(acrichto) uncomment deprecation warning - // early_warn("--no-trans is deprecated in favor of -Z no-trans"); + // FIXME(acrichto) remove this eventually + early_warn("--no-trans is deprecated in favor of -Z no-trans"); true } else { debugging_opts & NO_TRANS != 0 }; let no_analysis = if matches.opt_present("no-analysis") { - // FIXME(acrichto) uncomment deprecation warning - // early_warn("--no-analysis is deprecated in favor of -Z no-analysis"); + // FIXME(acrichto) remove this eventually + early_warn("--no-analysis is deprecated in favor of -Z no-analysis"); true } else { debugging_opts & NO_ANALYSIS != 0 @@ -946,8 +945,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { } Default } else if matches.opt_present("opt-level") { - // FIXME(acrichto) uncomment deprecation warning - // early_warn("--opt-level=N is deprecated in favor of -C opt-level=N"); + // FIXME(acrichto) remove this eventually + early_warn("--opt-level=N is deprecated in favor of -C opt-level=N"); match matches.opt_str("opt-level").as_ref().map(|s| s.as_slice()) { None | Some("0") => No, @@ -985,8 +984,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { } FullDebugInfo } else if matches.opt_present("debuginfo") { - // FIXME(acrichto) uncomment deprecation warning - // early_warn("--debuginfo=N is deprecated in favor of -C debuginfo=N"); + // FIXME(acrichto) remove this eventually + early_warn("--debuginfo=N is deprecated in favor of -C debuginfo=N"); match matches.opt_str("debuginfo").as_ref().map(|s| s.as_slice()) { Some("0") => NoDebugInfo, Some("1") => LimitedDebugInfo, @@ -1054,8 +1053,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let cfg = parse_cfgspecs(matches.opt_strs("cfg")); let test = matches.opt_present("test"); let write_dependency_info = if matches.opt_present("dep-info") { - // FIXME(acrichto) uncomment deprecation warning - // early_warn("--dep-info has been deprecated in favor of --emit"); + // FIXME(acrichto) remove this eventually + early_warn("--dep-info has been deprecated in favor of --emit"); (true, matches.opt_str("dep-info").map(|p| Path::new(p))) } else { (output_types.contains(&OutputTypeDepInfo), None) @@ -1072,22 +1071,21 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { } }).collect::<Vec<_>>(); if matches.opt_present("print-crate-name") { - // FIXME(acrichto) uncomment deprecation warning - // early_warn("--print-crate-name has been deprecated in favor of \ - // --print crate-name"); + // FIXME(acrichto) remove this eventually + early_warn("--print-crate-name has been deprecated in favor of \ + --print crate-name"); prints.push(PrintRequest::CrateName); } if matches.opt_present("print-file-name") { - // FIXME(acrichto) uncomment deprecation warning - // early_warn("--print-file-name has been deprecated in favor of \ - // --print file-names"); + // FIXME(acrichto) remove this eventually + early_warn("--print-file-name has been deprecated in favor of \ + --print file-names"); prints.push(PrintRequest::FileNames); } if !cg.remark.is_empty() && debuginfo == NoDebugInfo { - // FIXME(acrichto) uncomment deprecation warning - // early_warn("-C remark will not show source locations without \ - // --debuginfo"); + early_warn("-C remark will not show source locations without \ + --debuginfo"); } let color = match matches.opt_str("color").as_ref().map(|s| s[]) { diff --git a/src/librustc/util/lev_distance.rs b/src/librustc/util/lev_distance.rs index e7c77b1249927..79bd0d4e306e4 100644 --- a/src/librustc/util/lev_distance.rs +++ b/src/librustc/util/lev_distance.rs @@ -47,7 +47,7 @@ fn test_lev_distance() { // Test bytelength agnosticity for c in range(0u32, MAX as u32) .filter_map(|i| from_u32(i)) - .map(|i| String::from_char(1, i)) { + .map(|i| i.to_string()) { assert_eq!(lev_distance(c[], c[]), 0); } diff --git a/src/librustdoc/stability_summary.rs b/src/librustdoc/stability_summary.rs index 690a5d19367ed..451dbce568ee0 100644 --- a/src/librustdoc/stability_summary.rs +++ b/src/librustdoc/stability_summary.rs @@ -14,7 +14,6 @@ //! module's count includes its children's. use std::cmp::Ordering; -use std::num::Zero; use std::ops::Add; use syntax::attr::{Deprecated, Experimental, Unstable, Stable, Frozen, Locked}; @@ -26,7 +25,7 @@ use clean::{TypeTraitItem, ViewItemItem, PrimitiveItem, Stability}; use html::render::cache; -#[derive(Zero, RustcEncodable, RustcDecodable, PartialEq, Eq)] +#[derive(RustcEncodable, RustcDecodable, PartialEq, Eq)] /// The counts for each stability level. #[derive(Copy)] pub struct Counts { diff --git a/src/libserialize/base64.rs b/src/libserialize/base64.rs index 52d5a1a3af52f..44bf5f8977870 100644 --- a/src/libserialize/base64.rs +++ b/src/libserialize/base64.rs @@ -396,7 +396,7 @@ mod tests { for _ in range(0u, 1000) { let times = thread_rng().gen_range(1u, 100); - let v = Vec::from_fn(times, |_| random::<u8>()); + let v = thread_rng().gen_iter::<u8>().take(times).collect::<Vec<_>>(); assert_eq!(v.to_base64(STANDARD) .from_base64() .unwrap(), diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 73f986a97ef49..e31d8157332c9 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -2052,7 +2052,7 @@ macro_rules! read_primitive { Json::F64(f) => Err(ExpectedError("Integer".to_string(), format!("{}", f))), // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc) // is going to have a string here, as per JSON spec. - Json::String(s) => match std::str::from_str(s.as_slice()) { + Json::String(s) => match s.parse() { Some(f) => Ok(f), None => Err(ExpectedError("Number".to_string(), s)), }, diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 857a7072009bd..bcd87f6786d35 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -13,7 +13,6 @@ //! Operations on ASCII strings and characters #![unstable = "unsure about placement and naming"] -#![allow(deprecated)] use core::kinds::Sized; use iter::IteratorExt; diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs index 4fb4f220c592a..9c96a9cac7831 100644 --- a/src/libstd/c_str.rs +++ b/src/libstd/c_str.rs @@ -266,10 +266,6 @@ impl CString { self.buf } - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub unsafe fn unwrap(self) -> *const libc::c_char { self.into_inner() } - /// Return the number of bytes in the CString (not including the NUL /// terminator). #[inline] diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 40942f1b98798..4a20208f31a6a 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -150,10 +150,6 @@ impl<T> CVec<T> { self.base } - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub unsafe fn unwrap(self) -> *mut T { self.into_inner() } - /// Returns the number of items in this vector. pub fn len(&self) -> uint { self.len } diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index c63484396d211..651f31b205da8 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -16,7 +16,7 @@ use self::VacantEntryState::*; use borrow::BorrowFrom; use clone::Clone; -use cmp::{max, Eq, Equiv, PartialEq}; +use cmp::{max, Eq, PartialEq}; use default::Default; use fmt::{self, Show}; use hash::{Hash, Hasher, RandomSipHasher}; @@ -444,20 +444,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { table::make_hash(&self.hasher, x) } - #[allow(deprecated)] - fn search_equiv<'a, Sized? Q: Hash<S> + Equiv<K>>(&'a self, q: &Q) - -> Option<FullBucketImm<'a, K, V>> { - let hash = self.make_hash(q); - search_hashed(&self.table, hash, |k| q.equiv(k)).into_option() - } - - #[allow(deprecated)] - fn search_equiv_mut<'a, Sized? Q: Hash<S> + Equiv<K>>(&'a mut self, q: &Q) - -> Option<FullBucketMut<'a, K, V>> { - let hash = self.make_hash(q); - search_hashed(&mut self.table, hash, |k| q.equiv(k)).into_option() - } - /// Search for a key, yielding the index if it's found in the hashtable. /// If you already have the hash for the key lying around, use /// search_hashed. @@ -807,30 +793,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { } } - /// Deprecated: use `contains_key` and `BorrowFrom` instead. - #[deprecated = "use contains_key and BorrowFrom instead"] - pub fn contains_key_equiv<Sized? Q: Hash<S> + Equiv<K>>(&self, key: &Q) -> bool { - self.search_equiv(key).is_some() - } - - /// Deprecated: use `get` and `BorrowFrom` instead. - #[deprecated = "use get and BorrowFrom instead"] - pub fn find_equiv<'a, Sized? Q: Hash<S> + Equiv<K>>(&'a self, k: &Q) -> Option<&'a V> { - self.search_equiv(k).map(|bucket| bucket.into_refs().1) - } - - /// Deprecated: use `remove` and `BorrowFrom` instead. - #[deprecated = "use remove and BorrowFrom instead"] - pub fn pop_equiv<Sized? Q:Hash<S> + Equiv<K>>(&mut self, k: &Q) -> Option<V> { - if self.table.size() == 0 { - return None - } - - self.reserve(1); - - self.search_equiv_mut(k).map(|bucket| pop_internal(bucket).1) - } - /// An iterator visiting all keys in arbitrary order. /// Iterator element type is `&'a K`. /// @@ -1047,12 +1009,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { self.drain(); } - /// Deprecated: Renamed to `get`. - #[deprecated = "Renamed to `get`"] - pub fn find(&self, k: &K) -> Option<&V> { - self.get(k) - } - /// Returns a reference to the value corresponding to the key. /// /// The key may be any borrowed form of the map's key type, but @@ -1099,12 +1055,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { self.search(k).is_some() } - /// Deprecated: Renamed to `get_mut`. - #[deprecated = "Renamed to `get_mut`"] - pub fn find_mut(&mut self, k: &K) -> Option<&mut V> { - self.get_mut(k) - } - /// Returns a mutable reference to the value corresponding to the key. /// /// The key may be any borrowed form of the map's key type, but @@ -1131,12 +1081,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { self.search_mut(k).map(|bucket| bucket.into_mut_refs().1) } - /// Deprecated: Renamed to `insert`. - #[deprecated = "Renamed to `insert`"] - pub fn swap(&mut self, k: K, v: V) -> Option<V> { - self.insert(k, v) - } - /// Inserts a key-value pair from the map. If the key already had a value /// present in the map, that value is returned. Otherwise, `None` is returned. /// @@ -1165,12 +1109,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { retval } - /// Deprecated: Renamed to `remove`. - #[deprecated = "Renamed to `remove`"] - pub fn pop(&mut self, k: &K) -> Option<V> { - self.remove(k) - } - /// Removes a key from the map, returning the value at the key if the key /// was previously in the map. /// @@ -1246,24 +1184,6 @@ fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable<K,V>, hash: SafeHas } } -impl<K: Eq + Hash<S>, V: Clone, S, H: Hasher<S>> HashMap<K, V, H> { - /// Deprecated: Use `map.get(k).cloned()`. - /// - /// Return a copy of the value corresponding to the key. - #[deprecated = "Use `map.get(k).cloned()`"] - pub fn find_copy(&self, k: &K) -> Option<V> { - self.get(k).cloned() - } - - /// Deprecated: Use `map[k].clone()`. - /// - /// Return a copy of the value corresponding to the key. - #[deprecated = "Use `map[k].clone()`"] - pub fn get_copy(&self, k: &K) -> V { - self[*k].clone() - } -} - #[stable] impl<K: Eq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V, H> { fn eq(&self, other: &HashMap<K, V, H>) -> bool { @@ -1574,30 +1494,12 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Extend<(K, V)> for HashMap<K mod test_map { use prelude::v1::*; - use cmp::Equiv; use super::HashMap; use super::Entry::{Occupied, Vacant}; - use hash; - use iter::{range_inclusive, range_step_inclusive}; + use iter::{range_inclusive, range_step_inclusive, repeat}; use cell::RefCell; use rand::{weak_rng, Rng}; - struct KindaIntLike(int); - - #[allow(deprecated)] - impl Equiv<int> for KindaIntLike { - fn equiv(&self, other: &int) -> bool { - let KindaIntLike(this) = *self; - this == *other - } - } - impl<S: hash::Writer> hash::Hash<S> for KindaIntLike { - fn hash(&self, state: &mut S) { - let KindaIntLike(this) = *self; - this.hash(state) - } - } - #[test] fn test_create_capacity_zero() { let mut m = HashMap::with_capacity(0); @@ -1654,7 +1556,7 @@ mod test_map { #[test] fn test_drops() { DROP_VECTOR.with(|slot| { - *slot.borrow_mut() = Vec::from_elem(200, 0i); + *slot.borrow_mut() = repeat(0i).take(200).collect(); }); { @@ -1713,7 +1615,7 @@ mod test_map { #[test] fn test_move_iter_drops() { DROP_VECTOR.with(|v| { - *v.borrow_mut() = Vec::from_elem(200, 0i); + *v.borrow_mut() = repeat(0).take(200).collect(); }); let hm = { @@ -1911,15 +1813,6 @@ mod test_map { assert_eq!(m.remove(&1), None); } - #[test] - #[allow(deprecated)] - fn test_pop_equiv() { - let mut m = HashMap::new(); - m.insert(1i, 2i); - assert_eq!(m.pop_equiv(&KindaIntLike(1)), Some(2)); - assert_eq!(m.pop_equiv(&KindaIntLike(1)), None); - } - #[test] fn test_iterate() { let mut m = HashMap::with_capacity(4); @@ -1970,27 +1863,6 @@ mod test_map { } } - #[test] - #[allow(deprecated)] - fn test_find_copy() { - let mut m = HashMap::new(); - assert!(m.get(&1i).is_none()); - - for i in range(1i, 10000) { - m.insert(i, i + 7); - match m.find_copy(&i) { - None => panic!(), - Some(v) => assert_eq!(v, i + 7) - } - for j in range(1i, i/100) { - match m.find_copy(&j) { - None => panic!(), - Some(v) => assert_eq!(v, j + 7) - } - } - } - } - #[test] fn test_eq() { let mut m1 = HashMap::new(); diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index 28c78ca3a9137..b1824db93aad1 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -12,7 +12,7 @@ use borrow::BorrowFrom; use clone::Clone; -use cmp::{Eq, Equiv, PartialEq}; +use cmp::{Eq, PartialEq}; use core::kinds::Sized; use default::Default; use fmt::Show; @@ -228,13 +228,6 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> { self.map.shrink_to_fit() } - /// Deprecated: use `contains` and `BorrowFrom`. - #[deprecated = "use contains and BorrowFrom"] - #[allow(deprecated)] - pub fn contains_equiv<Sized? Q: Hash<S> + Equiv<T>>(&self, value: &Q) -> bool { - self.map.contains_key_equiv(value) - } - /// An iterator visiting all elements in arbitrary order. /// Iterator element type is &'a T. /// diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index 0d44e6d869ab1..4be83bfc6646d 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -314,17 +314,9 @@ pub use core_collections::{BinaryHeap, Bitv, BitvSet, BTreeMap, BTreeSet}; pub use core_collections::{DList, RingBuf, VecMap}; -/// Deprecated: Moved to collect-rs: https://github.com/Gankro/collect-rs/ -#[deprecated = "Moved to collect-rs: https://github.com/Gankro/collect-rs/"] -pub use core_collections::EnumSet; - pub use core_collections::{binary_heap, bitv, bitv_set, btree_map, btree_set}; pub use core_collections::{dlist, ring_buf, vec_map}; -/// Deprecated: Moved to collect-rs: https://github.com/Gankro/collect-rs/ -#[deprecated = "Moved to collect-rs: https://github.com/Gankro/collect-rs/"] -pub use core_collections::enum_set; - pub use self::hash_map::HashMap; pub use self::hash_set::HashSet; diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index d97f4a7bc34b6..c56acd38e810f 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -89,10 +89,6 @@ impl<R: Reader> BufferedReader<R> { /// /// Note that any leftover data in the internal buffer is lost. pub fn into_inner(self) -> R { self.inner } - - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub fn unwrap(self) -> R { self.into_inner() } } impl<R: Reader> Buffer for BufferedReader<R> { @@ -198,10 +194,6 @@ impl<W: Writer> BufferedWriter<W> { self.flush_buf().unwrap(); self.inner.take().unwrap() } - - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub fn unwrap(self) -> W { self.into_inner() } } impl<W: Writer> Writer for BufferedWriter<W> { @@ -262,10 +254,6 @@ impl<W: Writer> LineBufferedWriter<W> { /// /// The internal buffer is flushed before returning the writer. pub fn into_inner(self) -> W { self.inner.into_inner() } - - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub fn unwrap(self) -> W { self.into_inner() } } impl<W: Writer> Writer for LineBufferedWriter<W> { @@ -374,10 +362,6 @@ impl<S: Stream> BufferedStream<S> { let InternalBufferedWriter(w) = self.inner.inner; w.into_inner() } - - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub fn unwrap(self) -> S { self.into_inner() } } impl<S: Stream> Buffer for BufferedStream<S> { diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index 8c097a65db7bd..af08eea210e7f 100644 --- a/src/libstd/io/extensions.rs +++ b/src/libstd/io/extensions.rs @@ -518,7 +518,7 @@ mod bench { ({ use super::u64_from_be_bytes; - let data = Vec::from_fn($stride*100+$start_index, |i| i as u8); + let data = range(0u8, $stride*100+$start_index).collect::<Vec<_>>(); let mut sum = 0u64; $b.iter(|| { let mut i = $start_index; diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index 1615541e37d41..5c17644a1ace7 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -12,8 +12,6 @@ //! Readers and Writers for in-memory buffers -#![allow(deprecated)] - use cmp::min; use option::Option::None; use result::Result::{Err, Ok}; @@ -70,6 +68,7 @@ pub struct MemWriter { buf: Vec<u8>, } +#[allow(deprecated)] impl MemWriter { /// Create a new `MemWriter`. #[inline] @@ -96,10 +95,6 @@ impl MemWriter { /// Unwraps this `MemWriter`, returning the underlying buffer #[inline] pub fn into_inner(self) -> Vec<u8> { self.buf } - - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub fn unwrap(self) -> Vec<u8> { self.into_inner() } } impl Writer for MemWriter { @@ -155,10 +150,6 @@ impl MemReader { /// Unwraps this `MemReader`, returning the underlying buffer #[inline] pub fn into_inner(self) -> Vec<u8> { self.buf } - - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub fn unwrap(self) -> Vec<u8> { self.into_inner() } } impl Reader for MemReader { @@ -401,10 +392,11 @@ mod test { extern crate "test" as test_crate; use prelude::v1::*; - use super::*; use io::{SeekSet, SeekCur, SeekEnd}; use io; + use iter::repeat; use self::test_crate::Bencher; + use super::*; #[test] fn test_vec_writer() { @@ -664,7 +656,7 @@ mod test { } fn do_bench_mem_writer(b: &mut Bencher, times: uint, len: uint) { - let src: Vec<u8> = Vec::from_elem(len, 5); + let src: Vec<u8> = repeat(5).take(len).collect(); b.bytes = (times * len) as u64; b.iter(|| { @@ -673,7 +665,7 @@ mod test { wr.write(src.as_slice()).unwrap(); } - let v = wr.unwrap(); + let v = wr.into_inner(); assert_eq!(v.len(), times * len); assert!(v.iter().all(|x| *x == 5)); }); diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 590231dcd827c..ae401a04a96f0 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -263,7 +263,6 @@ pub use self::timer::Timer; pub use self::net::ip::IpAddr; pub use self::net::tcp::TcpListener; pub use self::net::tcp::TcpStream; -pub use self::net::udp::UdpStream; pub use self::pipe::PipeStream; pub use self::process::{Process, Command}; pub use self::tempfile::TempDir; @@ -862,23 +861,6 @@ pub trait Reader { } } -/// A reader which can be converted to a RefReader. -#[deprecated = "use ByRefReader instead"] -pub trait AsRefReader { - /// Creates a wrapper around a mutable reference to the reader. - /// - /// This is useful to allow applying adaptors while still - /// retaining ownership of the original value. - fn by_ref<'a>(&'a mut self) -> RefReader<'a, Self>; -} - -#[allow(deprecated)] -impl<T: Reader> AsRefReader for T { - fn by_ref<'a>(&'a mut self) -> RefReader<'a, T> { - RefReader { inner: self } - } -} - /// A reader which can be converted to a RefReader. pub trait ByRefReader { /// Creates a wrapper around a mutable reference to the reader. @@ -1242,24 +1224,6 @@ pub trait Writer { } } -/// A writer which can be converted to a RefWriter. -#[deprecated = "use ByRefWriter instead"] -pub trait AsRefWriter { - /// Creates a wrapper around a mutable reference to the writer. - /// - /// This is useful to allow applying wrappers while still - /// retaining ownership of the original value. - #[inline] - fn by_ref<'a>(&'a mut self) -> RefWriter<'a, Self>; -} - -#[allow(deprecated)] -impl<T: Writer> AsRefWriter for T { - fn by_ref<'a>(&'a mut self) -> RefWriter<'a, T> { - RefWriter { inner: self } - } -} - /// A writer which can be converted to a RefWriter. pub trait ByRefWriter { /// Creates a wrapper around a mutable reference to the writer. @@ -1847,64 +1811,6 @@ bitflags! { #[doc = "All possible permissions enabled."] const ALL_PERMISSIONS = USER_RWX.bits | GROUP_RWX.bits | OTHER_RWX.bits, - - // Deprecated names - #[allow(non_upper_case_globals)] - #[deprecated = "use USER_READ instead"] - const UserRead = USER_READ.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use USER_WRITE instead"] - const UserWrite = USER_WRITE.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use USER_EXECUTE instead"] - const UserExecute = USER_EXECUTE.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use GROUP_READ instead"] - const GroupRead = GROUP_READ.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use GROUP_WRITE instead"] - const GroupWrite = GROUP_WRITE.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use GROUP_EXECUTE instead"] - const GroupExecute = GROUP_EXECUTE.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use OTHER_READ instead"] - const OtherRead = OTHER_READ.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use OTHER_WRITE instead"] - const OtherWrite = OTHER_WRITE.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use OTHER_EXECUTE instead"] - const OtherExecute = OTHER_EXECUTE.bits, - - #[allow(non_upper_case_globals)] - #[deprecated = "use USER_RWX instead"] - const UserRWX = USER_RWX.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use GROUP_RWX instead"] - const GroupRWX = GROUP_RWX.bits, - #[allow(non_upper_case_globals)] - #[deprecated = "use OTHER_RWX instead"] - const OtherRWX = OTHER_RWX.bits, - - #[doc = "Deprecated: use `USER_FILE` instead."] - #[allow(non_upper_case_globals)] - #[deprecated = "use USER_FILE instead"] - const UserFile = USER_FILE.bits, - - #[doc = "Deprecated: use `USER_DIR` instead."] - #[allow(non_upper_case_globals)] - #[deprecated = "use USER_DIR instead"] - const UserDir = USER_DIR.bits, - #[doc = "Deprecated: use `USER_EXEC` instead."] - #[allow(non_upper_case_globals)] - #[deprecated = "use USER_EXEC instead"] - const UserExec = USER_EXEC.bits, - - #[doc = "Deprecated: use `ALL_PERMISSIONS` instead"] - #[allow(non_upper_case_globals)] - #[deprecated = "use ALL_PERMISSIONS instead"] - const AllPermissions = ALL_PERMISSIONS.bits, } } diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs index 6c167359966a8..a4db0d4f5de77 100644 --- a/src/libstd/io/net/udp.rs +++ b/src/libstd/io/net/udp.rs @@ -17,10 +17,8 @@ use clone::Clone; use io::net::ip::{SocketAddr, IpAddr, ToSocketAddr}; -use io::{Reader, Writer, IoResult}; -use ops::FnOnce; +use io::IoResult; use option::Option; -use result::Result::{Ok, Err}; use sys::udp::UdpSocket as UdpSocketImp; use sys_common; @@ -88,21 +86,6 @@ impl UdpSocket { super::with_addresses(addr, |addr| self.inner.send_to(buf, addr)) } - /// Creates a `UdpStream`, which allows use of the `Reader` and `Writer` - /// traits to receive and send data from the same address. This transfers - /// ownership of the socket to the stream. - /// - /// Note that this call does not perform any actual network communication, - /// because UDP is a datagram protocol. - #[deprecated = "`UdpStream` has been deprecated"] - #[allow(deprecated)] - pub fn connect(self, other: SocketAddr) -> UdpStream { - UdpStream { - socket: self, - connected_to: other, - } - } - /// Returns the socket address that this socket was created from. pub fn socket_name(&mut self) -> IoResult<SocketAddr> { self.inner.socket_name() @@ -192,59 +175,6 @@ impl sys_common::AsInner<UdpSocketImp> for UdpSocket { } } -/// A type that allows convenient usage of a UDP stream connected to one -/// address via the `Reader` and `Writer` traits. -/// -/// # Note -/// -/// This structure has been deprecated because `Reader` is a stream-oriented API but UDP -/// is a packet-oriented protocol. Every `Reader` method will read a whole packet and -/// throw all superfluous bytes away so that they are no longer available for further -/// method calls. -#[deprecated] -pub struct UdpStream { - socket: UdpSocket, - connected_to: SocketAddr -} - -impl UdpStream { - /// Allows access to the underlying UDP socket owned by this stream. This - /// is useful to, for example, use the socket to send data to hosts other - /// than the one that this stream is connected to. - pub fn as_socket<T, F>(&mut self, f: F) -> T where - F: FnOnce(&mut UdpSocket) -> T, - { - f(&mut self.socket) - } - - /// Consumes this UDP stream and returns out the underlying socket. - pub fn disconnect(self) -> UdpSocket { - self.socket - } -} - -impl Reader for UdpStream { - /// Returns the next non-empty message from the specified address. - fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { - let peer = self.connected_to; - self.as_socket(|sock| { - loop { - let (nread, src) = try!(sock.recv_from(buf)); - if nread > 0 && src == peer { - return Ok(nread); - } - } - }) - } -} - -impl Writer for UdpStream { - fn write(&mut self, buf: &[u8]) -> IoResult<()> { - let connected_to = self.connected_to; - self.as_socket(|sock| sock.send_to(buf, connected_to)) - } -} - #[cfg(test)] #[allow(experimental)] mod test { @@ -337,91 +267,6 @@ mod test { } } - #[test] - #[allow(deprecated)] - fn stream_smoke_test_ip4() { - let server_ip = next_test_ip4(); - let client_ip = next_test_ip4(); - let dummy_ip = next_test_ip4(); - let (tx1, rx1) = channel(); - let (tx2, rx2) = channel(); - - let _t = Thread::spawn(move|| { - let send_as = |&:ip, val: &[u8]| { - match UdpSocket::bind(ip) { - Ok(client) => { - let client = box client; - let mut stream = client.connect(server_ip); - stream.write(val).unwrap(); - } - Err(..) => panic!() - } - }; - rx1.recv().unwrap(); - send_as(dummy_ip, &[98]); - send_as(client_ip, &[99]); - tx2.send(()).unwrap(); - }); - - match UdpSocket::bind(server_ip) { - Ok(server) => { - let server = box server; - let mut stream = server.connect(client_ip); - tx1.send(()).unwrap(); - let mut buf = [0]; - match stream.read(&mut buf) { - Ok(nread) => { - assert_eq!(nread, 1); - assert_eq!(buf[0], 99); - } - Err(..) => panic!(), - } - } - Err(..) => panic!() - } - rx2.recv().unwrap(); - } - - #[test] - #[allow(deprecated)] - fn stream_smoke_test_ip6() { - let server_ip = next_test_ip6(); - let client_ip = next_test_ip6(); - let (tx1, rx1) = channel(); - let (tx2, rx2) = channel(); - - let _t = Thread::spawn(move|| { - match UdpSocket::bind(client_ip) { - Ok(client) => { - let client = box client; - let mut stream = client.connect(server_ip); - rx1.recv().unwrap(); - stream.write(&[99]).unwrap(); - } - Err(..) => panic!() - } - tx2.send(()).unwrap(); - }); - - match UdpSocket::bind(server_ip) { - Ok(server) => { - let server = box server; - let mut stream = server.connect(client_ip); - tx1.send(()).unwrap(); - let mut buf = [0]; - match stream.read(&mut buf) { - Ok(nread) => { - assert_eq!(nread, 1); - assert_eq!(buf[0], 99); - } - Err(..) => panic!() - } - } - Err(..) => panic!() - } - rx2.recv().unwrap(); - } - pub fn socket_name(addr: SocketAddr) { let server = UdpSocket::bind(addr); diff --git a/src/libstd/io/tempfile.rs b/src/libstd/io/tempfile.rs index 5cf8667665162..45e0dd4e8e5df 100644 --- a/src/libstd/io/tempfile.rs +++ b/src/libstd/io/tempfile.rs @@ -19,7 +19,7 @@ use option::Option::{None, Some}; use os; use path::{Path, GenericPath}; use result::Result::{Ok, Err}; -use sync::atomic; +use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering}; /// A wrapper for a path to temporary directory implementing automatic /// scope-based deletion. @@ -90,14 +90,14 @@ impl TempDir { return TempDir::new_in(&abs_tmpdir, suffix); } - static CNT: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT; + static CNT: AtomicUint = ATOMIC_UINT_INIT; let mut attempts = 0u; loop { let filename = format!("rs-{}-{}-{}", unsafe { libc::getpid() }, - CNT.fetch_add(1, atomic::SeqCst), + CNT.fetch_add(1, Ordering::SeqCst), suffix); let p = tmpdir.join(filename); match fs::mkdir(&p, io::USER_RWX) { @@ -129,10 +129,6 @@ impl TempDir { tmpdir.path.take().unwrap() } - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub fn unwrap(self) -> Path { self.into_inner() } - /// Access the wrapped `std::path::Path` to the temporary directory. pub fn path<'a>(&'a self) -> &'a Path { self.path.as_ref().unwrap() diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs index 2f87abd0ee2fc..3ce56c907b33d 100644 --- a/src/libstd/io/test.rs +++ b/src/libstd/io/test.rs @@ -17,12 +17,12 @@ use prelude::v1::*; use libc; use os; use std::io::net::ip::*; -use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Relaxed}; +use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering}; /// Get a port number, starting at 9600, for use in tests pub fn next_test_port() -> u16 { static NEXT_OFFSET: AtomicUint = ATOMIC_UINT_INIT; - base_port() + NEXT_OFFSET.fetch_add(1, Relaxed) as u16 + base_port() + NEXT_OFFSET.fetch_add(1, Ordering::Relaxed) as u16 } /// Get a temporary path which could be the location of a unix socket @@ -34,7 +34,7 @@ pub fn next_test_unix() -> Path { let string = format!("rust-test-unix-path-{}-{}-{}", base_port(), unsafe {libc::getpid()}, - COUNT.fetch_add(1, Relaxed)); + COUNT.fetch_add(1, Ordering::Relaxed)); if cfg!(unix) { os::tmpdir().join(string) } else { diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index 1381ad17ea2aa..86fa68d63ac89 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -30,10 +30,6 @@ impl<R: Reader> LimitReader<R> { /// Consumes the `LimitReader`, returning the underlying `Reader`. pub fn into_inner(self) -> R { self.inner } - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner"] - pub fn unwrap(self) -> R { self.into_inner() } - /// Returns the number of bytes that can be read before the `LimitReader` /// will return EOF. /// @@ -219,10 +215,6 @@ impl<R: Reader, W: Writer> TeeReader<R, W> { let TeeReader { reader, writer } = self; (reader, writer) } - - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner"] - pub fn unwrap(self) -> (R, W) { self.into_inner() } } impl<R: Reader, W: Writer> Reader for TeeReader<R, W> { diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 7c8aab2b31dae..608ad9882b977 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -226,7 +226,6 @@ pub mod hash; /* Threads and communication */ -pub mod task; pub mod thread; pub mod sync; diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 8f21fb0b8b97d..c126eb1d6cf17 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -21,12 +21,8 @@ #[cfg(test)] use ops::{Add, Sub, Mul, Div, Rem}; #[cfg(test)] use kinds::Copy; -pub use core::num::{Num, div_rem, Zero, zero, One, one}; -pub use core::num::{Unsigned, pow, Bounded}; -pub use core::num::{Primitive, Int, SignedInt, UnsignedInt}; +pub use core::num::{Int, SignedInt, UnsignedInt}; pub use core::num::{cast, FromPrimitive, NumCast, ToPrimitive}; -pub use core::num::{next_power_of_two, is_power_of_two}; -pub use core::num::{checked_next_power_of_two}; pub use core::num::{from_int, from_i8, from_i16, from_i32, from_i64}; pub use core::num::{from_uint, from_u8, from_u16, from_u32, from_u64}; pub use core::num::{from_f32, from_f64}; @@ -118,11 +114,6 @@ pub trait FloatMath: Float { // DEPRECATED -#[deprecated = "Use `FloatMath::abs_sub`"] -pub fn abs_sub<T: FloatMath>(x: T, y: T) -> T { - x.abs_sub(y) -} - /// Helper function for testing numeric operations #[cfg(test)] pub fn test_num<T>(ten: T, two: T) where @@ -804,7 +795,7 @@ mod bench { #[bench] fn bench_pow_function(b: &mut Bencher) { - let v = Vec::from_fn(1024u, |n| n); + let v = range(0, 1024u).collect::<Vec<_>>(); b.iter(|| {v.iter().fold(0u, |old, new| old.pow(*new));}); } } diff --git a/src/libstd/num/u16.rs b/src/libstd/num/u16.rs index 46699b78599b7..7cb6a8ffe077c 100644 --- a/src/libstd/num/u16.rs +++ b/src/libstd/num/u16.rs @@ -15,6 +15,4 @@ pub use core::u16::{BITS, BYTES, MIN, MAX}; -use ops::FnOnce; - uint_module! { u16 } diff --git a/src/libstd/num/u32.rs b/src/libstd/num/u32.rs index 45ee9251d2f4f..43b01ddb16bd0 100644 --- a/src/libstd/num/u32.rs +++ b/src/libstd/num/u32.rs @@ -15,6 +15,4 @@ pub use core::u32::{BITS, BYTES, MIN, MAX}; -use ops::FnOnce; - uint_module! { u32 } diff --git a/src/libstd/num/u64.rs b/src/libstd/num/u64.rs index 1d8ff77dac8a2..79e7f23705174 100644 --- a/src/libstd/num/u64.rs +++ b/src/libstd/num/u64.rs @@ -15,6 +15,4 @@ pub use core::u64::{BITS, BYTES, MIN, MAX}; -use ops::FnOnce; - uint_module! { u64 } diff --git a/src/libstd/num/u8.rs b/src/libstd/num/u8.rs index 0663ace2e5ba6..3da2fabe3f252 100644 --- a/src/libstd/num/u8.rs +++ b/src/libstd/num/u8.rs @@ -15,6 +15,4 @@ pub use core::u8::{BITS, BYTES, MIN, MAX}; -use ops::FnOnce; - uint_module! { u8 } diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs index cd000b3098bff..0fbc0953b20a2 100644 --- a/src/libstd/num/uint.rs +++ b/src/libstd/num/uint.rs @@ -15,6 +15,4 @@ pub use core::uint::{BITS, BYTES, MIN, MAX}; -use ops::FnOnce; - uint_module! { uint } diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index b52e4fda7af2c..7818f4a053497 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -17,41 +17,14 @@ macro_rules! uint_module { ($T:ty) => ( // String conversion functions and impl num -> str -/// Convert to a string as a byte slice in a given base. -/// -/// Use in place of x.to_string() when you do not need to store the string permanently -/// -/// # Examples -/// -/// ``` -/// #![allow(deprecated)] -/// -/// std::uint::to_str_bytes(123, 10, |v| { -/// assert!(v == "123".as_bytes()); -/// }); -/// ``` -#[inline] -#[deprecated = "just use .to_string(), or a BufWriter with write! if you mustn't allocate"] -pub fn to_str_bytes<U, F>(n: $T, radix: uint, f: F) -> U where - F: FnOnce(&[u8]) -> U, -{ - use io::{Writer, Seek}; - // The radix can be as low as 2, so we need at least 64 characters for a - // base 2 number, and then we need another for a possible '-' character. - let mut buf = [0u8; 65]; - let amt = { - let mut wr = ::io::BufWriter::new(&mut buf); - (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap(); - wr.tell().unwrap() as uint - }; - f(buf[..amt]) -} - #[cfg(test)] mod tests { use prelude::v1::*; use num::FromStrRadix; - use str::from_str; + + fn from_str<T: ::str::FromStr>(t: &str) -> Option<T> { + ::str::FromStr::from_str(t) + } #[test] pub fn test_from_str() { diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 771c808ab8a7a..be8f82349c222 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -54,7 +54,7 @@ use result::Result::{Err, Ok}; use slice::{AsSlice, SliceExt}; use str::{Str, StrExt}; use string::{String, ToString}; -use sync::atomic::{AtomicInt, ATOMIC_INT_INIT, SeqCst}; +use sync::atomic::{AtomicInt, ATOMIC_INT_INIT, Ordering}; use vec::Vec; #[cfg(unix)] use c_str::ToCStr; @@ -606,13 +606,13 @@ static EXIT_STATUS: AtomicInt = ATOMIC_INT_INIT; /// /// Note that this is not synchronized against modifications of other threads. pub fn set_exit_status(code: int) { - EXIT_STATUS.store(code, SeqCst) + EXIT_STATUS.store(code, Ordering::SeqCst) } /// Fetches the process's current exit code. This defaults to 0 and can change /// by calling `set_exit_status`. pub fn get_exit_status() -> int { - EXIT_STATUS.load(SeqCst) + EXIT_STATUS.load(Ordering::SeqCst) } #[cfg(target_os = "macos")] diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 731c3bbe427d5..bf9ffbffe7d50 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -69,9 +69,9 @@ use iter::IteratorExt; use option::Option; use option::Option::{None, Some}; use str; -use str::{CowString, MaybeOwned, Str, StrExt}; -use string::String; -use slice::{AsSlice, SliceExt}; +use str::StrExt; +use string::{String, CowString}; +use slice::SliceExt; use vec::Vec; /// Typedef for POSIX file paths. @@ -896,20 +896,6 @@ impl BytesContainer for CString { } } -#[allow(deprecated)] -impl<'a> BytesContainer for str::MaybeOwned<'a> { - #[inline] - fn container_as_bytes<'b>(&'b self) -> &'b [u8] { - self.as_slice().as_bytes() - } - #[inline] - fn container_as_str<'b>(&'b self) -> Option<&'b str> { - Some(self.as_slice()) - } - #[inline] - fn is_str(_: Option<&str::MaybeOwned>) -> bool { true } -} - impl<'a, Sized? T: BytesContainer> BytesContainer for &'a T { #[inline] fn container_as_bytes(&self) -> &[u8] { diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 55063f1393f74..aa28c8266d193 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -421,7 +421,7 @@ pub fn sample<T, I: Iterator<Item=T>, R: Rng>(rng: &mut R, mod test { use prelude::v1::*; use super::{Rng, thread_rng, random, SeedableRng, StdRng, sample}; - use iter::order; + use iter::{order, repeat}; struct ConstRng { i: u64 } impl Rng for ConstRng { @@ -439,7 +439,7 @@ mod test { let lengths = [0, 1, 2, 3, 4, 5, 6, 7, 80, 81, 82, 83, 84, 85, 86, 87]; for &n in lengths.iter() { - let mut v = Vec::from_elem(n, 0u8); + let mut v = repeat(0u8).take(n).collect::<Vec<_>>(); r.fill_bytes(v.as_mut_slice()); // use this to get nicer error messages. diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index 5caa71b43475e..6ae6a238c952a 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -93,12 +93,12 @@ mod imp { target_arch = "arm", target_arch = "aarch64")))] fn is_getrandom_available() -> bool { - use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Relaxed}; + use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering}; static GETRANDOM_CHECKED: AtomicBool = ATOMIC_BOOL_INIT; static GETRANDOM_AVAILABLE: AtomicBool = ATOMIC_BOOL_INIT; - if !GETRANDOM_CHECKED.load(Relaxed) { + if !GETRANDOM_CHECKED.load(Ordering::Relaxed) { let mut buf: [u8; 0] = []; let result = getrandom(&mut buf); let available = if result == -1 { @@ -107,11 +107,11 @@ mod imp { } else { true }; - GETRANDOM_AVAILABLE.store(available, Relaxed); - GETRANDOM_CHECKED.store(true, Relaxed); + GETRANDOM_AVAILABLE.store(available, Ordering::Relaxed); + GETRANDOM_CHECKED.store(true, Ordering::Relaxed); available } else { - GETRANDOM_AVAILABLE.load(Relaxed) + GETRANDOM_AVAILABLE.load(Ordering::Relaxed) } } diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index ae405e9400b37..578239c9cc42e 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -15,7 +15,7 @@ use prelude::v1::*; use os; -use sync::atomic; +use sync::atomic::{mod, Ordering}; pub use sys::backtrace::write; @@ -23,7 +23,7 @@ pub use sys::backtrace::write; // whether the magical environment variable is present to see if it's turned on. pub fn log_enabled() -> bool { static ENABLED: atomic::AtomicInt = atomic::ATOMIC_INT_INIT; - match ENABLED.load(atomic::SeqCst) { + match ENABLED.load(Ordering::SeqCst) { 1 => return false, 2 => return true, _ => {} @@ -33,7 +33,7 @@ pub fn log_enabled() -> bool { Some(..) => 2, None => 1, }; - ENABLED.store(val, atomic::SeqCst); + ENABLED.store(val, Ordering::SeqCst); val == 2 } diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index 99f791df474f4..a48a8edd82f60 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -67,7 +67,7 @@ use fmt; use intrinsics; use libc::c_void; use mem; -use sync::atomic; +use sync::atomic::{mod, Ordering}; use sync::{Once, ONCE_INIT}; use rt::libunwind as uw; @@ -543,11 +543,11 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) -> // callback. Additionally, CALLBACK_CNT may briefly be higher than // MAX_CALLBACKS, so we're sure to clamp it as necessary. let callbacks = { - let amt = CALLBACK_CNT.load(atomic::SeqCst); + let amt = CALLBACK_CNT.load(Ordering::SeqCst); CALLBACKS[..cmp::min(amt, MAX_CALLBACKS)] }; for cb in callbacks.iter() { - match cb.load(atomic::SeqCst) { + match cb.load(Ordering::SeqCst) { 0 => {} n => { let f: Callback = unsafe { mem::transmute(n) }; @@ -584,18 +584,18 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) -> /// currently possible to unregister a callback once it has been registered. #[experimental] pub unsafe fn register(f: Callback) -> bool { - match CALLBACK_CNT.fetch_add(1, atomic::SeqCst) { + match CALLBACK_CNT.fetch_add(1, Ordering::SeqCst) { // The invocation code has knowledge of this window where the count has // been incremented, but the callback has not been stored. We're // guaranteed that the slot we're storing into is 0. n if n < MAX_CALLBACKS => { - let prev = CALLBACKS[n].swap(mem::transmute(f), atomic::SeqCst); + let prev = CALLBACKS[n].swap(mem::transmute(f), Ordering::SeqCst); rtassert!(prev == 0); true } // If we accidentally bumped the count too high, pull it back. _ => { - CALLBACK_CNT.store(MAX_CALLBACKS, atomic::SeqCst); + CALLBACK_CNT.store(MAX_CALLBACKS, Ordering::SeqCst); false } } diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index d6cf35ee3cd90..883a01fa31801 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -19,7 +19,7 @@ use libc::{self, uintptr_t}; use os; use slice; use str; -use sync::atomic; +use sync::atomic::{mod, Ordering}; /// Dynamically inquire about whether we're running under V. /// You should usually not use this unless your test definitely @@ -47,7 +47,7 @@ pub fn limit_thread_creation_due_to_osx_and_valgrind() -> bool { pub fn min_stack() -> uint { static MIN: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT; - match MIN.load(atomic::SeqCst) { + match MIN.load(Ordering::SeqCst) { 0 => {} n => return n - 1, } @@ -55,7 +55,7 @@ pub fn min_stack() -> uint { let amt = amt.unwrap_or(2 * 1024 * 1024); // 0 is our sentinel value, so ensure that we'll never see 0 after // initialization has run - MIN.store(amt + 1, atomic::SeqCst); + MIN.store(amt + 1, Ordering::SeqCst); return amt; } diff --git a/src/libstd/sync/atomic.rs b/src/libstd/sync/atomic.rs deleted file mode 100644 index 3652b45ce973b..0000000000000 --- a/src/libstd/sync/atomic.rs +++ /dev/null @@ -1,227 +0,0 @@ -// Copyright 2012-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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Atomic types -//! -//! Atomic types provide primitive shared-memory communication between -//! threads, and are the building blocks of other concurrent -//! types. -//! -//! This module defines atomic versions of a select number of primitive -//! types, including `AtomicBool`, `AtomicInt`, `AtomicUint`, and `AtomicOption`. -//! Atomic types present operations that, when used correctly, synchronize -//! updates between threads. -//! -//! Each method takes an `Ordering` which represents the strength of -//! the memory barrier for that operation. These orderings are the -//! same as [C++11 atomic orderings][1]. -//! -//! [1]: http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync -//! -//! Atomic variables are safe to share between threads (they implement `Sync`) -//! but they do not themselves provide the mechanism for sharing. The most -//! common way to share an atomic variable is to put it into an `Arc` (an -//! atomically-reference-counted shared pointer). -//! -//! Most atomic types may be stored in static variables, initialized using -//! the provided static initializers like `INIT_ATOMIC_BOOL`. Atomic statics -//! are often used for lazy global initialization. -//! -//! -//! # Examples -//! -//! A simple spinlock: -//! -//! ``` -//! use std::sync::Arc; -//! use std::sync::atomic::{AtomicUint, SeqCst}; -//! use std::thread::Thread; -//! -//! fn main() { -//! let spinlock = Arc::new(AtomicUint::new(1)); -//! -//! let spinlock_clone = spinlock.clone(); -//! Thread::spawn(move|| { -//! spinlock_clone.store(0, SeqCst); -//! }).detach(); -//! -//! // Wait for the other task to release the lock -//! while spinlock.load(SeqCst) != 0 {} -//! } -//! ``` -//! -//! Transferring a heap object with `AtomicOption`: -//! -//! ``` -//! use std::sync::Arc; -//! use std::sync::atomic::{AtomicOption, SeqCst}; -//! use std::thread::Thread; -//! -//! fn main() { -//! struct BigObject; -//! -//! let shared_big_object = Arc::new(AtomicOption::empty()); -//! -//! let shared_big_object_clone = shared_big_object.clone(); -//! Thread::spawn(move|| { -//! let unwrapped_big_object = shared_big_object_clone.take(SeqCst); -//! if unwrapped_big_object.is_some() { -//! println!("got a big object from another task"); -//! } else { -//! println!("other task hasn't sent big object yet"); -//! } -//! }).detach(); -//! -//! shared_big_object.swap(box BigObject, SeqCst); -//! } -//! ``` -//! -//! Keep a global count of live tasks: -//! -//! ``` -//! use std::sync::atomic::{AtomicUint, SeqCst, ATOMIC_UINT_INIT}; -//! -//! static GLOBAL_TASK_COUNT: AtomicUint = ATOMIC_UINT_INIT; -//! -//! let old_task_count = GLOBAL_TASK_COUNT.fetch_add(1, SeqCst); -//! println!("live tasks: {}", old_task_count + 1); -//! ``` - -#![stable] - -use alloc::boxed::Box; -use core::mem; -use core::prelude::{Send, Drop, None, Option, Some}; - -pub use core::atomic::{AtomicBool, AtomicInt, AtomicUint, AtomicPtr}; -pub use core::atomic::{INIT_ATOMIC_BOOL, INIT_ATOMIC_INT, INIT_ATOMIC_UINT}; -pub use core::atomic::{ATOMIC_BOOL_INIT, ATOMIC_INT_INIT, ATOMIC_UINT_INIT}; -pub use core::atomic::fence; -pub use core::atomic::Ordering::{self, Relaxed, Release, Acquire, AcqRel, SeqCst}; - -/// An atomic, nullable unique pointer -/// -/// This can be used as the concurrency primitive for operations that transfer -/// owned heap objects across tasks. -#[unsafe_no_drop_flag] -#[deprecated = "no longer used; will eventually be replaced by a higher-level\ - concept like MVar"] -pub struct AtomicOption<T> { - p: AtomicUint, -} - -#[allow(deprecated)] -impl<T: Send> AtomicOption<T> { - /// Create a new `AtomicOption` - pub fn new(p: Box<T>) -> AtomicOption<T> { - unsafe { AtomicOption { p: AtomicUint::new(mem::transmute(p)) } } - } - - /// Create a new `AtomicOption` that doesn't contain a value - pub fn empty() -> AtomicOption<T> { AtomicOption { p: AtomicUint::new(0) } } - - /// Store a value, returning the old value - #[inline] - pub fn swap(&self, val: Box<T>, order: Ordering) -> Option<Box<T>> { - let val = unsafe { mem::transmute(val) }; - - match self.p.swap(val, order) { - 0 => None, - n => Some(unsafe { mem::transmute(n) }), - } - } - - /// Remove the value, leaving the `AtomicOption` empty. - #[inline] - pub fn take(&self, order: Ordering) -> Option<Box<T>> { - unsafe { self.swap(mem::transmute(0u), order) } - } - - /// Replace an empty value with a non-empty value. - /// - /// Succeeds if the option is `None` and returns `None` if so. If - /// the option was already `Some`, returns `Some` of the rejected - /// value. - #[inline] - pub fn fill(&self, val: Box<T>, order: Ordering) -> Option<Box<T>> { - unsafe { - let val = mem::transmute(val); - let expected = mem::transmute(0u); - let oldval = self.p.compare_and_swap(expected, val, order); - if oldval == expected { - None - } else { - Some(mem::transmute(val)) - } - } - } - - /// Returns `true` if the `AtomicOption` is empty. - /// - /// Be careful: The caller must have some external method of ensuring the - /// result does not get invalidated by another task after this returns. - #[inline] - pub fn is_empty(&self, order: Ordering) -> bool { - self.p.load(order) as uint == 0 - } -} - -#[unsafe_destructor] -impl<T: Send> Drop for AtomicOption<T> { - fn drop(&mut self) { - let _ = self.take(SeqCst); - } -} - -#[cfg(test)] -mod test { - use prelude::v1::*; - use super::*; - - #[test] - fn option_empty() { - let option: AtomicOption<()> = AtomicOption::empty(); - assert!(option.is_empty(SeqCst)); - } - - #[test] - fn option_swap() { - let p = AtomicOption::new(box 1i); - let a = box 2i; - - let b = p.swap(a, SeqCst); - - assert!(b == Some(box 1)); - assert!(p.take(SeqCst) == Some(box 2)); - } - - #[test] - fn option_take() { - let p = AtomicOption::new(box 1i); - - assert!(p.take(SeqCst) == Some(box 1)); - assert!(p.take(SeqCst) == None); - - let p2 = box 2i; - p.swap(p2, SeqCst); - - assert!(p.take(SeqCst) == Some(box 2)); - } - - #[test] - fn option_fill() { - let p = AtomicOption::new(box 1i); - assert!(p.fill(box 2i, SeqCst).is_some()); // should fail; shouldn't leak! - assert!(p.take(SeqCst) == Some(box 1)); - - assert!(p.fill(box 2i, SeqCst).is_none()); // shouldn't fail - assert!(p.take(SeqCst) == Some(box 2)); - } -} diff --git a/src/libstd/sync/condvar.rs b/src/libstd/sync/condvar.rs index 28c36922ca6f8..7734f655ed293 100644 --- a/src/libstd/sync/condvar.rs +++ b/src/libstd/sync/condvar.rs @@ -10,7 +10,7 @@ use prelude::v1::*; -use sync::atomic::{self, AtomicUint}; +use sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT}; use sync::poison::{self, LockResult}; use sys_common::condvar as sys; use sys_common::mutex as sys_mutex; @@ -88,7 +88,7 @@ unsafe impl Sync for StaticCondvar {} #[unstable = "may be merged with Condvar in the future"] pub const CONDVAR_INIT: StaticCondvar = StaticCondvar { inner: sys::CONDVAR_INIT, - mutex: atomic::ATOMIC_UINT_INIT, + mutex: ATOMIC_UINT_INIT, }; impl Condvar { @@ -260,7 +260,7 @@ impl StaticCondvar { fn verify(&self, mutex: &sys_mutex::Mutex) { let addr = mutex as *const _ as uint; - match self.mutex.compare_and_swap(0, addr, atomic::SeqCst) { + match self.mutex.compare_and_swap(0, addr, Ordering::SeqCst) { // If we got out 0, then we have successfully bound the mutex to // this cvar. 0 => {} diff --git a/src/libstd/sync/future.rs b/src/libstd/sync/future.rs index e5245251ea817..4c6adcc04f67c 100644 --- a/src/libstd/sync/future.rs +++ b/src/libstd/sync/future.rs @@ -65,10 +65,6 @@ impl<A> Future<A> { } } - /// Deprecated, use into_inner() instead - #[deprecated = "renamed to into_inner()"] - pub fn unwrap(self) -> A { self.into_inner() } - pub fn get_ref<'a>(&'a mut self) -> &'a A { /*! * Executes the future's closure and then returns a reference diff --git a/src/libstd/sync/mod.rs b/src/libstd/sync/mod.rs index c09c3b45d3e26..6ce278726e9de 100644 --- a/src/libstd/sync/mod.rs +++ b/src/libstd/sync/mod.rs @@ -18,6 +18,7 @@ #![experimental] pub use alloc::arc::{Arc, Weak}; +pub use core::atomic; pub use self::mutex::{Mutex, MutexGuard, StaticMutex}; pub use self::mutex::MUTEX_INIT; @@ -32,7 +33,6 @@ pub use self::poison::{PoisonError, TryLockError, TryLockResult, LockResult}; pub use self::future::Future; pub use self::task_pool::TaskPool; -pub mod atomic; pub mod mpsc; mod barrier; diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs index 8945233dac9cd..8f85dc6e043e2 100644 --- a/src/libstd/sync/mpsc/mpsc_queue.rs +++ b/src/libstd/sync/mpsc/mpsc_queue.rs @@ -48,7 +48,7 @@ use alloc::boxed::Box; use core::mem; use core::cell::UnsafeCell; -use sync::atomic::{AtomicPtr, Release, Acquire, AcqRel, Relaxed}; +use sync::atomic::{AtomicPtr, Ordering}; /// A result of the `pop` function. pub enum PopResult<T> { @@ -103,8 +103,8 @@ impl<T: Send> Queue<T> { pub fn push(&self, t: T) { unsafe { let n = Node::new(Some(t)); - let prev = self.head.swap(n, AcqRel); - (*prev).next.store(n, Release); + let prev = self.head.swap(n, Ordering::AcqRel); + (*prev).next.store(n, Ordering::Release); } } @@ -121,7 +121,7 @@ impl<T: Send> Queue<T> { pub fn pop(&self) -> PopResult<T> { unsafe { let tail = *self.tail.get(); - let next = (*tail).next.load(Acquire); + let next = (*tail).next.load(Ordering::Acquire); if !next.is_null() { *self.tail.get() = next; @@ -132,7 +132,7 @@ impl<T: Send> Queue<T> { return Data(ret); } - if self.head.load(Acquire) == tail {Empty} else {Inconsistent} + if self.head.load(Ordering::Acquire) == tail {Empty} else {Inconsistent} } } } @@ -143,7 +143,7 @@ impl<T: Send> Drop for Queue<T> { unsafe { let mut cur = *self.tail.get(); while !cur.is_null() { - let next = (*cur).next.load(Relaxed); + let next = (*cur).next.load(Ordering::Relaxed); let _: Box<Node<T>> = mem::transmute(cur); cur = next; } diff --git a/src/libstd/sync/mpsc/oneshot.rs b/src/libstd/sync/mpsc/oneshot.rs index 2811f403c6c3d..5c2331d0f2e93 100644 --- a/src/libstd/sync/mpsc/oneshot.rs +++ b/src/libstd/sync/mpsc/oneshot.rs @@ -42,7 +42,7 @@ use core::prelude::*; use sync::mpsc::Receiver; use sync::mpsc::blocking::{self, SignalToken}; use core::mem; -use sync::atomic; +use sync::atomic::{AtomicUint, Ordering}; // Various states you can find a port in. const EMPTY: uint = 0; // initial state: no data, no blocked reciever @@ -56,7 +56,7 @@ const DISCONNECTED: uint = 2; // channel is disconnected OR upgraded pub struct Packet<T> { // Internal state of the chan/port pair (stores the blocked task as well) - state: atomic::AtomicUint, + state: AtomicUint, // One-shot data slot location data: Option<T>, // when used for the second time, a oneshot channel must be upgraded, and @@ -93,7 +93,7 @@ impl<T: Send> Packet<T> { Packet { data: None, upgrade: NothingSent, - state: atomic::AtomicUint::new(EMPTY), + state: AtomicUint::new(EMPTY), } } @@ -107,7 +107,7 @@ impl<T: Send> Packet<T> { self.data = Some(t); self.upgrade = SendUsed; - match self.state.swap(DATA, atomic::SeqCst) { + match self.state.swap(DATA, Ordering::SeqCst) { // Sent the data, no one was waiting EMPTY => Ok(()), @@ -141,14 +141,14 @@ impl<T: Send> Packet<T> { pub fn recv(&mut self) -> Result<T, Failure<T>> { // Attempt to not block the task (it's a little expensive). If it looks // like we're not empty, then immediately go through to `try_recv`. - if self.state.load(atomic::SeqCst) == EMPTY { + if self.state.load(Ordering::SeqCst) == EMPTY { let (wait_token, signal_token) = blocking::tokens(); let ptr = unsafe { signal_token.cast_to_uint() }; // race with senders to enter the blocking state - if self.state.compare_and_swap(EMPTY, ptr, atomic::SeqCst) == EMPTY { + if self.state.compare_and_swap(EMPTY, ptr, Ordering::SeqCst) == EMPTY { wait_token.wait(); - debug_assert!(self.state.load(atomic::SeqCst) != EMPTY); + debug_assert!(self.state.load(Ordering::SeqCst) != EMPTY); } else { // drop the signal token, since we never blocked drop(unsafe { SignalToken::cast_from_uint(ptr) }); @@ -159,7 +159,7 @@ impl<T: Send> Packet<T> { } pub fn try_recv(&mut self) -> Result<T, Failure<T>> { - match self.state.load(atomic::SeqCst) { + match self.state.load(Ordering::SeqCst) { EMPTY => Err(Empty), // We saw some data on the channel, but the channel can be used @@ -169,7 +169,7 @@ impl<T: Send> Packet<T> { // the state changes under our feet we'd rather just see that state // change. DATA => { - self.state.compare_and_swap(DATA, EMPTY, atomic::SeqCst); + self.state.compare_and_swap(DATA, EMPTY, Ordering::SeqCst); match self.data.take() { Some(data) => Ok(data), None => unreachable!(), @@ -209,7 +209,7 @@ impl<T: Send> Packet<T> { }; self.upgrade = GoUp(up); - match self.state.swap(DISCONNECTED, atomic::SeqCst) { + match self.state.swap(DISCONNECTED, Ordering::SeqCst) { // If the channel is empty or has data on it, then we're good to go. // Senders will check the data before the upgrade (in case we // plastered over the DATA state). @@ -225,7 +225,7 @@ impl<T: Send> Packet<T> { } pub fn drop_chan(&mut self) { - match self.state.swap(DISCONNECTED, atomic::SeqCst) { + match self.state.swap(DISCONNECTED, Ordering::SeqCst) { DATA | DISCONNECTED | EMPTY => {} // If someone's waiting, we gotta wake them up @@ -236,7 +236,7 @@ impl<T: Send> Packet<T> { } pub fn drop_port(&mut self) { - match self.state.swap(DISCONNECTED, atomic::SeqCst) { + match self.state.swap(DISCONNECTED, Ordering::SeqCst) { // An empty channel has nothing to do, and a remotely disconnected // channel also has nothing to do b/c we're about to run the drop // glue @@ -259,7 +259,7 @@ impl<T: Send> Packet<T> { // If Ok, the value is whether this port has data, if Err, then the upgraded // port needs to be checked instead of this one. pub fn can_recv(&mut self) -> Result<bool, Receiver<T>> { - match self.state.load(atomic::SeqCst) { + match self.state.load(Ordering::SeqCst) { EMPTY => Ok(false), // Welp, we tried DATA => Ok(true), // we have some un-acquired data DISCONNECTED if self.data.is_some() => Ok(true), // we have data @@ -284,7 +284,7 @@ impl<T: Send> Packet<T> { // because there is data, or fail because there is an upgrade pending. pub fn start_selection(&mut self, token: SignalToken) -> SelectionResult<T> { let ptr = unsafe { token.cast_to_uint() }; - match self.state.compare_and_swap(EMPTY, ptr, atomic::SeqCst) { + match self.state.compare_and_swap(EMPTY, ptr, Ordering::SeqCst) { EMPTY => SelSuccess, DATA => { drop(unsafe { SignalToken::cast_from_uint(ptr) }); @@ -322,7 +322,7 @@ impl<T: Send> Packet<T> { // // The return value indicates whether there's data on this port. pub fn abort_selection(&mut self) -> Result<bool, Receiver<T>> { - let state = match self.state.load(atomic::SeqCst) { + let state = match self.state.load(Ordering::SeqCst) { // Each of these states means that no further activity will happen // with regard to abortion selection s @ EMPTY | @@ -331,7 +331,7 @@ impl<T: Send> Packet<T> { // If we've got a blocked task, then use an atomic to gain ownership // of it (may fail) - ptr => self.state.compare_and_swap(ptr, EMPTY, atomic::SeqCst) + ptr => self.state.compare_and_swap(ptr, EMPTY, Ordering::SeqCst) }; // Now that we've got ownership of our state, figure out what to do @@ -370,6 +370,6 @@ impl<T: Send> Packet<T> { #[unsafe_destructor] impl<T: Send> Drop for Packet<T> { fn drop(&mut self) { - assert_eq!(self.state.load(atomic::SeqCst), DISCONNECTED); + assert_eq!(self.state.load(Ordering::SeqCst), DISCONNECTED); } } diff --git a/src/libstd/sync/mpsc/shared.rs b/src/libstd/sync/mpsc/shared.rs index cadac8e62724e..4295d116aed91 100644 --- a/src/libstd/sync/mpsc/shared.rs +++ b/src/libstd/sync/mpsc/shared.rs @@ -25,11 +25,12 @@ use core::prelude::*; use core::cmp; use core::int; -use sync::{atomic, Mutex, MutexGuard}; -use sync::mpsc::mpsc_queue as mpsc; +use sync::atomic::{AtomicUint, AtomicInt, AtomicBool, Ordering}; use sync::mpsc::blocking::{self, SignalToken}; -use sync::mpsc::select::StartResult; +use sync::mpsc::mpsc_queue as mpsc; use sync::mpsc::select::StartResult::*; +use sync::mpsc::select::StartResult; +use sync::{Mutex, MutexGuard}; use thread::Thread; const DISCONNECTED: int = int::MIN; @@ -41,17 +42,17 @@ const MAX_STEALS: int = 1 << 20; pub struct Packet<T> { queue: mpsc::Queue<T>, - cnt: atomic::AtomicInt, // How many items are on this channel + cnt: AtomicInt, // How many items are on this channel steals: int, // How many times has a port received without blocking? - to_wake: atomic::AtomicUint, // SignalToken for wake up + to_wake: AtomicUint, // SignalToken for wake up // The number of channels which are currently using this packet. - channels: atomic::AtomicInt, + channels: AtomicInt, // See the discussion in Port::drop and the channel send methods for what // these are used for - port_dropped: atomic::AtomicBool, - sender_drain: atomic::AtomicInt, + port_dropped: AtomicBool, + sender_drain: AtomicInt, // this lock protects various portions of this implementation during // select() @@ -69,12 +70,12 @@ impl<T: Send> Packet<T> { pub fn new() -> Packet<T> { let p = Packet { queue: mpsc::Queue::new(), - cnt: atomic::AtomicInt::new(0), + cnt: AtomicInt::new(0), steals: 0, - to_wake: atomic::AtomicUint::new(0), - channels: atomic::AtomicInt::new(2), - port_dropped: atomic::AtomicBool::new(false), - sender_drain: atomic::AtomicInt::new(0), + to_wake: AtomicUint::new(0), + channels: AtomicInt::new(2), + port_dropped: AtomicBool::new(false), + sender_drain: AtomicInt::new(0), select_lock: Mutex::new(()), }; return p; @@ -98,10 +99,10 @@ impl<T: Send> Packet<T> { token: Option<SignalToken>, guard: MutexGuard<()>) { token.map(|token| { - assert_eq!(self.cnt.load(atomic::SeqCst), 0); - assert_eq!(self.to_wake.load(atomic::SeqCst), 0); - self.to_wake.store(unsafe { token.cast_to_uint() }, atomic::SeqCst); - self.cnt.store(-1, atomic::SeqCst); + assert_eq!(self.cnt.load(Ordering::SeqCst), 0); + assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); + self.to_wake.store(unsafe { token.cast_to_uint() }, Ordering::SeqCst); + self.cnt.store(-1, Ordering::SeqCst); // This store is a little sketchy. What's happening here is that // we're transferring a blocker from a oneshot or stream channel to @@ -134,7 +135,7 @@ impl<T: Send> Packet<T> { pub fn send(&mut self, t: T) -> Result<(), T> { // See Port::drop for what's going on - if self.port_dropped.load(atomic::SeqCst) { return Err(t) } + if self.port_dropped.load(Ordering::SeqCst) { return Err(t) } // Note that the multiple sender case is a little trickier // semantically than the single sender case. The logic for @@ -161,12 +162,12 @@ impl<T: Send> Packet<T> { // preflight check serves as the definitive "this will never be // received". Once we get beyond this check, we have permanently // entered the realm of "this may be received" - if self.cnt.load(atomic::SeqCst) < DISCONNECTED + FUDGE { + if self.cnt.load(Ordering::SeqCst) < DISCONNECTED + FUDGE { return Err(t) } self.queue.push(t); - match self.cnt.fetch_add(1, atomic::SeqCst) { + match self.cnt.fetch_add(1, Ordering::SeqCst) { -1 => { self.take_to_wake().signal(); } @@ -183,9 +184,9 @@ impl<T: Send> Packet<T> { n if n < DISCONNECTED + FUDGE => { // see the comment in 'try' for a shared channel for why this // window of "not disconnected" is ok. - self.cnt.store(DISCONNECTED, atomic::SeqCst); + self.cnt.store(DISCONNECTED, Ordering::SeqCst); - if self.sender_drain.fetch_add(1, atomic::SeqCst) == 0 { + if self.sender_drain.fetch_add(1, Ordering::SeqCst) == 0 { loop { // drain the queue, for info on the thread yield see the // discussion in try_recv @@ -198,7 +199,7 @@ impl<T: Send> Packet<T> { } // maybe we're done, if we're not the last ones // here, then we need to go try again. - if self.sender_drain.fetch_sub(1, atomic::SeqCst) == 1 { + if self.sender_drain.fetch_sub(1, Ordering::SeqCst) == 1 { break } } @@ -239,15 +240,15 @@ impl<T: Send> Packet<T> { // Essentially the exact same thing as the stream decrement function. // Returns true if blocking should proceed. fn decrement(&mut self, token: SignalToken) -> StartResult { - assert_eq!(self.to_wake.load(atomic::SeqCst), 0); + assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); let ptr = unsafe { token.cast_to_uint() }; - self.to_wake.store(ptr, atomic::SeqCst); + self.to_wake.store(ptr, Ordering::SeqCst); let steals = self.steals; self.steals = 0; - match self.cnt.fetch_sub(1 + steals, atomic::SeqCst) { - DISCONNECTED => { self.cnt.store(DISCONNECTED, atomic::SeqCst); } + match self.cnt.fetch_sub(1 + steals, Ordering::SeqCst) { + DISCONNECTED => { self.cnt.store(DISCONNECTED, Ordering::SeqCst); } // If we factor in our steals and notice that the channel has no // data, we successfully sleep n => { @@ -256,7 +257,7 @@ impl<T: Send> Packet<T> { } } - self.to_wake.store(0, atomic::SeqCst); + self.to_wake.store(0, Ordering::SeqCst); drop(unsafe { SignalToken::cast_from_uint(ptr) }); Abort } @@ -297,9 +298,9 @@ impl<T: Send> Packet<T> { // might decrement steals. Some(data) => { if self.steals > MAX_STEALS { - match self.cnt.swap(0, atomic::SeqCst) { + match self.cnt.swap(0, Ordering::SeqCst) { DISCONNECTED => { - self.cnt.store(DISCONNECTED, atomic::SeqCst); + self.cnt.store(DISCONNECTED, Ordering::SeqCst); } n => { let m = cmp::min(n, self.steals); @@ -316,7 +317,7 @@ impl<T: Send> Packet<T> { // See the discussion in the stream implementation for why we try // again. None => { - match self.cnt.load(atomic::SeqCst) { + match self.cnt.load(Ordering::SeqCst) { n if n != DISCONNECTED => Err(Empty), _ => { match self.queue.pop() { @@ -334,20 +335,20 @@ impl<T: Send> Packet<T> { // Prepares this shared packet for a channel clone, essentially just bumping // a refcount. pub fn clone_chan(&mut self) { - self.channels.fetch_add(1, atomic::SeqCst); + self.channels.fetch_add(1, Ordering::SeqCst); } // Decrement the reference count on a channel. This is called whenever a // Chan is dropped and may end up waking up a receiver. It's the receiver's // responsibility on the other end to figure out that we've disconnected. pub fn drop_chan(&mut self) { - match self.channels.fetch_sub(1, atomic::SeqCst) { + match self.channels.fetch_sub(1, Ordering::SeqCst) { 1 => {} n if n > 1 => return, n => panic!("bad number of channels left {}", n), } - match self.cnt.swap(DISCONNECTED, atomic::SeqCst) { + match self.cnt.swap(DISCONNECTED, Ordering::SeqCst) { -1 => { self.take_to_wake().signal(); } DISCONNECTED => {} n => { assert!(n >= 0); } @@ -357,10 +358,10 @@ impl<T: Send> Packet<T> { // See the long discussion inside of stream.rs for why the queue is drained, // and why it is done in this fashion. pub fn drop_port(&mut self) { - self.port_dropped.store(true, atomic::SeqCst); + self.port_dropped.store(true, Ordering::SeqCst); let mut steals = self.steals; while { - let cnt = self.cnt.compare_and_swap(steals, DISCONNECTED, atomic::SeqCst); + let cnt = self.cnt.compare_and_swap(steals, DISCONNECTED, Ordering::SeqCst); cnt != DISCONNECTED && cnt != steals } { // See the discussion in 'try_recv' for why we yield @@ -376,8 +377,8 @@ impl<T: Send> Packet<T> { // Consumes ownership of the 'to_wake' field. fn take_to_wake(&mut self) -> SignalToken { - let ptr = self.to_wake.load(atomic::SeqCst); - self.to_wake.store(0, atomic::SeqCst); + let ptr = self.to_wake.load(Ordering::SeqCst); + self.to_wake.store(0, Ordering::SeqCst); assert!(ptr != 0); unsafe { SignalToken::cast_from_uint(ptr) } } @@ -392,15 +393,15 @@ impl<T: Send> Packet<T> { // This is different than the stream version because there's no need to peek // at the queue, we can just look at the local count. pub fn can_recv(&mut self) -> bool { - let cnt = self.cnt.load(atomic::SeqCst); + let cnt = self.cnt.load(Ordering::SeqCst); cnt == DISCONNECTED || cnt - self.steals > 0 } // increment the count on the channel (used for selection) fn bump(&mut self, amt: int) -> int { - match self.cnt.fetch_add(amt, atomic::SeqCst) { + match self.cnt.fetch_add(amt, Ordering::SeqCst) { DISCONNECTED => { - self.cnt.store(DISCONNECTED, atomic::SeqCst); + self.cnt.store(DISCONNECTED, Ordering::SeqCst); DISCONNECTED } n => n @@ -444,13 +445,13 @@ impl<T: Send> Packet<T> { // the channel count and figure out what we should do to make it // positive. let steals = { - let cnt = self.cnt.load(atomic::SeqCst); + let cnt = self.cnt.load(Ordering::SeqCst); if cnt < 0 && cnt != DISCONNECTED {-cnt} else {0} }; let prev = self.bump(steals + 1); if prev == DISCONNECTED { - assert_eq!(self.to_wake.load(atomic::SeqCst), 0); + assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); true } else { let cur = prev + steals + 1; @@ -458,7 +459,7 @@ impl<T: Send> Packet<T> { if prev < 0 { drop(self.take_to_wake()); } else { - while self.to_wake.load(atomic::SeqCst) != 0 { + while self.to_wake.load(Ordering::SeqCst) != 0 { Thread::yield_now(); } } @@ -479,8 +480,8 @@ impl<T: Send> Drop for Packet<T> { // disconnection, but also a proper fence before the read of // `to_wake`, so this assert cannot be removed with also removing // the `to_wake` assert. - assert_eq!(self.cnt.load(atomic::SeqCst), DISCONNECTED); - assert_eq!(self.to_wake.load(atomic::SeqCst), 0); - assert_eq!(self.channels.load(atomic::SeqCst), 0); + assert_eq!(self.cnt.load(Ordering::SeqCst), DISCONNECTED); + assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); + assert_eq!(self.channels.load(Ordering::SeqCst), 0); } } diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs index 15624601157fd..e8d6e380be5de 100644 --- a/src/libstd/sync/mpsc/spsc_queue.rs +++ b/src/libstd/sync/mpsc/spsc_queue.rs @@ -41,7 +41,7 @@ use alloc::boxed::Box; use core::mem; use core::cell::UnsafeCell; -use sync::atomic::{AtomicPtr, Relaxed, AtomicUint, Acquire, Release}; +use sync::atomic::{AtomicPtr, AtomicUint, Ordering}; // Node within the linked list queue of messages to send struct Node<T> { @@ -109,7 +109,7 @@ impl<T: Send> Queue<T> { pub unsafe fn new(bound: uint) -> Queue<T> { let n1 = Node::new(); let n2 = Node::new(); - (*n1).next.store(n2, Relaxed); + (*n1).next.store(n2, Ordering::Relaxed); Queue { tail: UnsafeCell::new(n2), tail_prev: AtomicPtr::new(n1), @@ -131,8 +131,8 @@ impl<T: Send> Queue<T> { let n = self.alloc(); assert!((*n).value.is_none()); (*n).value = Some(t); - (*n).next.store(0 as *mut Node<T>, Relaxed); - (**self.head.get()).next.store(n, Release); + (*n).next.store(0 as *mut Node<T>, Ordering::Relaxed); + (**self.head.get()).next.store(n, Ordering::Release); *self.head.get() = n; } } @@ -144,23 +144,23 @@ impl<T: Send> Queue<T> { // only one subtracting from the cache). if *self.first.get() != *self.tail_copy.get() { if self.cache_bound > 0 { - let b = self.cache_subtractions.load(Relaxed); - self.cache_subtractions.store(b + 1, Relaxed); + let b = self.cache_subtractions.load(Ordering::Relaxed); + self.cache_subtractions.store(b + 1, Ordering::Relaxed); } let ret = *self.first.get(); - *self.first.get() = (*ret).next.load(Relaxed); + *self.first.get() = (*ret).next.load(Ordering::Relaxed); return ret; } // If the above fails, then update our copy of the tail and try // again. - *self.tail_copy.get() = self.tail_prev.load(Acquire); + *self.tail_copy.get() = self.tail_prev.load(Ordering::Acquire); if *self.first.get() != *self.tail_copy.get() { if self.cache_bound > 0 { - let b = self.cache_subtractions.load(Relaxed); - self.cache_subtractions.store(b + 1, Relaxed); + let b = self.cache_subtractions.load(Ordering::Relaxed); + self.cache_subtractions.store(b + 1, Ordering::Relaxed); } let ret = *self.first.get(); - *self.first.get() = (*ret).next.load(Relaxed); + *self.first.get() = (*ret).next.load(Ordering::Relaxed); return ret; } // If all of that fails, then we have to allocate a new node @@ -177,25 +177,26 @@ impl<T: Send> Queue<T> { // tail's next field and see if we can use it. If we do a pop, then // the current tail node is a candidate for going into the cache. let tail = *self.tail.get(); - let next = (*tail).next.load(Acquire); + let next = (*tail).next.load(Ordering::Acquire); if next.is_null() { return None } assert!((*next).value.is_some()); let ret = (*next).value.take(); *self.tail.get() = next; if self.cache_bound == 0 { - self.tail_prev.store(tail, Release); + self.tail_prev.store(tail, Ordering::Release); } else { // FIXME: this is dubious with overflow. - let additions = self.cache_additions.load(Relaxed); - let subtractions = self.cache_subtractions.load(Relaxed); + let additions = self.cache_additions.load(Ordering::Relaxed); + let subtractions = self.cache_subtractions.load(Ordering::Relaxed); let size = additions - subtractions; if size < self.cache_bound { - self.tail_prev.store(tail, Release); - self.cache_additions.store(additions + 1, Relaxed); + self.tail_prev.store(tail, Ordering::Release); + self.cache_additions.store(additions + 1, Ordering::Relaxed); } else { - (*self.tail_prev.load(Relaxed)).next.store(next, Relaxed); + (*self.tail_prev.load(Ordering::Relaxed)) + .next.store(next, Ordering::Relaxed); // We have successfully erased all references to 'tail', so // now we can safely drop it. let _: Box<Node<T>> = mem::transmute(tail); @@ -217,7 +218,7 @@ impl<T: Send> Queue<T> { // stripped out. unsafe { let tail = *self.tail.get(); - let next = (*tail).next.load(Acquire); + let next = (*tail).next.load(Ordering::Acquire); if next.is_null() { return None } return (*next).value.as_mut(); } @@ -230,7 +231,7 @@ impl<T: Send> Drop for Queue<T> { unsafe { let mut cur = *self.first.get(); while !cur.is_null() { - let next = (*cur).next.load(Relaxed); + let next = (*cur).next.load(Ordering::Relaxed); let _n: Box<Node<T>> = mem::transmute(cur); cur = next; } diff --git a/src/libstd/sync/mpsc/stream.rs b/src/libstd/sync/mpsc/stream.rs index c526e6acb8f15..bd1e74a33902e 100644 --- a/src/libstd/sync/mpsc/stream.rs +++ b/src/libstd/sync/mpsc/stream.rs @@ -28,10 +28,10 @@ use core::cmp; use core::int; use thread::Thread; +use sync::atomic::{AtomicInt, AtomicUint, Ordering, AtomicBool}; +use sync::mpsc::Receiver; use sync::mpsc::blocking::{self, SignalToken}; use sync::mpsc::spsc_queue as spsc; -use sync::mpsc::Receiver; -use sync::atomic; const DISCONNECTED: int = int::MIN; #[cfg(test)] @@ -42,11 +42,11 @@ const MAX_STEALS: int = 1 << 20; pub struct Packet<T> { queue: spsc::Queue<Message<T>>, // internal queue for all message - cnt: atomic::AtomicInt, // How many items are on this channel + cnt: AtomicInt, // How many items are on this channel steals: int, // How many times has a port received without blocking? - to_wake: atomic::AtomicUint, // SignalToken for the blocked thread to wake up + to_wake: AtomicUint, // SignalToken for the blocked thread to wake up - port_dropped: atomic::AtomicBool, // flag if the channel has been destroyed. + port_dropped: AtomicBool, // flag if the channel has been destroyed. } pub enum Failure<T> { @@ -79,11 +79,11 @@ impl<T: Send> Packet<T> { Packet { queue: unsafe { spsc::Queue::new(128) }, - cnt: atomic::AtomicInt::new(0), + cnt: AtomicInt::new(0), steals: 0, - to_wake: atomic::AtomicUint::new(0), + to_wake: AtomicUint::new(0), - port_dropped: atomic::AtomicBool::new(false), + port_dropped: AtomicBool::new(false), } } @@ -91,7 +91,7 @@ impl<T: Send> Packet<T> { // If the other port has deterministically gone away, then definitely // must return the data back up the stack. Otherwise, the data is // considered as being sent. - if self.port_dropped.load(atomic::SeqCst) { return Err(t) } + if self.port_dropped.load(Ordering::SeqCst) { return Err(t) } match self.do_send(Data(t)) { UpSuccess | UpDisconnected => {}, @@ -103,14 +103,14 @@ impl<T: Send> Packet<T> { pub fn upgrade(&mut self, up: Receiver<T>) -> UpgradeResult { // If the port has gone away, then there's no need to proceed any // further. - if self.port_dropped.load(atomic::SeqCst) { return UpDisconnected } + if self.port_dropped.load(Ordering::SeqCst) { return UpDisconnected } self.do_send(GoUp(up)) } fn do_send(&mut self, t: Message<T>) -> UpgradeResult { self.queue.push(t); - match self.cnt.fetch_add(1, atomic::SeqCst) { + match self.cnt.fetch_add(1, Ordering::SeqCst) { // As described in the mod's doc comment, -1 == wakeup -1 => UpWoke(self.take_to_wake()), // As as described before, SPSC queues must be >= -2 @@ -124,7 +124,7 @@ impl<T: Send> Packet<T> { // will never remove this data. We can only have at most one item to // drain (the port drains the rest). DISCONNECTED => { - self.cnt.store(DISCONNECTED, atomic::SeqCst); + self.cnt.store(DISCONNECTED, Ordering::SeqCst); let first = self.queue.pop(); let second = self.queue.pop(); assert!(second.is_none()); @@ -143,8 +143,8 @@ impl<T: Send> Packet<T> { // Consumes ownership of the 'to_wake' field. fn take_to_wake(&mut self) -> SignalToken { - let ptr = self.to_wake.load(atomic::SeqCst); - self.to_wake.store(0, atomic::SeqCst); + let ptr = self.to_wake.load(Ordering::SeqCst); + self.to_wake.store(0, Ordering::SeqCst); assert!(ptr != 0); unsafe { SignalToken::cast_from_uint(ptr) } } @@ -153,15 +153,15 @@ impl<T: Send> Packet<T> { // back if it shouldn't sleep. Note that this is the location where we take // steals into account. fn decrement(&mut self, token: SignalToken) -> Result<(), SignalToken> { - assert_eq!(self.to_wake.load(atomic::SeqCst), 0); + assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); let ptr = unsafe { token.cast_to_uint() }; - self.to_wake.store(ptr, atomic::SeqCst); + self.to_wake.store(ptr, Ordering::SeqCst); let steals = self.steals; self.steals = 0; - match self.cnt.fetch_sub(1 + steals, atomic::SeqCst) { - DISCONNECTED => { self.cnt.store(DISCONNECTED, atomic::SeqCst); } + match self.cnt.fetch_sub(1 + steals, Ordering::SeqCst) { + DISCONNECTED => { self.cnt.store(DISCONNECTED, Ordering::SeqCst); } // If we factor in our steals and notice that the channel has no // data, we successfully sleep n => { @@ -170,7 +170,7 @@ impl<T: Send> Packet<T> { } } - self.to_wake.store(0, atomic::SeqCst); + self.to_wake.store(0, Ordering::SeqCst); Err(unsafe { SignalToken::cast_from_uint(ptr) }) } @@ -217,9 +217,9 @@ impl<T: Send> Packet<T> { // adding back in whatever we couldn't factor into steals. Some(data) => { if self.steals > MAX_STEALS { - match self.cnt.swap(0, atomic::SeqCst) { + match self.cnt.swap(0, Ordering::SeqCst) { DISCONNECTED => { - self.cnt.store(DISCONNECTED, atomic::SeqCst); + self.cnt.store(DISCONNECTED, Ordering::SeqCst); } n => { let m = cmp::min(n, self.steals); @@ -237,7 +237,7 @@ impl<T: Send> Packet<T> { } None => { - match self.cnt.load(atomic::SeqCst) { + match self.cnt.load(Ordering::SeqCst) { n if n != DISCONNECTED => Err(Empty), // This is a little bit of a tricky case. We failed to pop @@ -266,7 +266,7 @@ impl<T: Send> Packet<T> { pub fn drop_chan(&mut self) { // Dropping a channel is pretty simple, we just flag it as disconnected // and then wakeup a blocker if there is one. - match self.cnt.swap(DISCONNECTED, atomic::SeqCst) { + match self.cnt.swap(DISCONNECTED, Ordering::SeqCst) { -1 => { self.take_to_wake().signal(); } DISCONNECTED => {} n => { assert!(n >= 0); } @@ -293,7 +293,7 @@ impl<T: Send> Packet<T> { // sends are gated on this flag, so we're immediately guaranteed that // there are a bounded number of active sends that we'll have to deal // with. - self.port_dropped.store(true, atomic::SeqCst); + self.port_dropped.store(true, Ordering::SeqCst); // Now that we're guaranteed to deal with a bounded number of senders, // we need to drain the queue. This draining process happens atomically @@ -306,7 +306,7 @@ impl<T: Send> Packet<T> { let mut steals = self.steals; while { let cnt = self.cnt.compare_and_swap( - steals, DISCONNECTED, atomic::SeqCst); + steals, DISCONNECTED, Ordering::SeqCst); cnt != DISCONNECTED && cnt != steals } { loop { @@ -351,9 +351,9 @@ impl<T: Send> Packet<T> { // increment the count on the channel (used for selection) fn bump(&mut self, amt: int) -> int { - match self.cnt.fetch_add(amt, atomic::SeqCst) { + match self.cnt.fetch_add(amt, Ordering::SeqCst) { DISCONNECTED => { - self.cnt.store(DISCONNECTED, atomic::SeqCst); + self.cnt.store(DISCONNECTED, Ordering::SeqCst); DISCONNECTED } n => n @@ -403,7 +403,7 @@ impl<T: Send> Packet<T> { // of time until the data is actually sent. if was_upgrade { assert_eq!(self.steals, 0); - assert_eq!(self.to_wake.load(atomic::SeqCst), 0); + assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); return Ok(true) } @@ -416,7 +416,7 @@ impl<T: Send> Packet<T> { // If we were previously disconnected, then we know for sure that there // is no task in to_wake, so just keep going let has_data = if prev == DISCONNECTED { - assert_eq!(self.to_wake.load(atomic::SeqCst), 0); + assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); true // there is data, that data is that we're disconnected } else { let cur = prev + steals + 1; @@ -439,7 +439,7 @@ impl<T: Send> Packet<T> { if prev < 0 { drop(self.take_to_wake()); } else { - while self.to_wake.load(atomic::SeqCst) != 0 { + while self.to_wake.load(Ordering::SeqCst) != 0 { Thread::yield_now(); } } @@ -478,7 +478,7 @@ impl<T: Send> Drop for Packet<T> { // disconnection, but also a proper fence before the read of // `to_wake`, so this assert cannot be removed with also removing // the `to_wake` assert. - assert_eq!(self.cnt.load(atomic::SeqCst), DISCONNECTED); - assert_eq!(self.to_wake.load(atomic::SeqCst), 0); + assert_eq!(self.cnt.load(Ordering::SeqCst), DISCONNECTED); + assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); } } diff --git a/src/libstd/sync/mpsc/sync.rs b/src/libstd/sync/mpsc/sync.rs index 0eee10898bcbb..6836888e67e55 100644 --- a/src/libstd/sync/mpsc/sync.rs +++ b/src/libstd/sync/mpsc/sync.rs @@ -41,14 +41,15 @@ use self::Blocker::*; use vec::Vec; use core::mem; -use sync::{atomic, Mutex, MutexGuard}; +use sync::atomic::{Ordering, AtomicUint}; use sync::mpsc::blocking::{self, WaitToken, SignalToken}; use sync::mpsc::select::StartResult::{self, Installed, Abort}; +use sync::{Mutex, MutexGuard}; pub struct Packet<T> { /// Only field outside of the mutex. Just done for kicks, but mainly because /// the other shared channel already had the code implemented - channels: atomic::AtomicUint, + channels: AtomicUint, lock: Mutex<State<T>>, } @@ -137,7 +138,7 @@ fn wakeup<T>(token: SignalToken, guard: MutexGuard<State<T>>) { impl<T: Send> Packet<T> { pub fn new(cap: uint) -> Packet<T> { Packet { - channels: atomic::AtomicUint::new(1), + channels: AtomicUint::new(1), lock: Mutex::new(State { disconnected: false, blocker: NoneBlocked, @@ -304,12 +305,12 @@ impl<T: Send> Packet<T> { // Prepares this shared packet for a channel clone, essentially just bumping // a refcount. pub fn clone_chan(&self) { - self.channels.fetch_add(1, atomic::SeqCst); + self.channels.fetch_add(1, Ordering::SeqCst); } pub fn drop_chan(&self) { // Only flag the channel as disconnected if we're the last channel - match self.channels.fetch_sub(1, atomic::SeqCst) { + match self.channels.fetch_sub(1, Ordering::SeqCst) { 1 => {} _ => return } @@ -412,7 +413,7 @@ impl<T: Send> Packet<T> { #[unsafe_destructor] impl<T: Send> Drop for Packet<T> { fn drop(&mut self) { - assert_eq!(self.channels.load(atomic::SeqCst), 0); + assert_eq!(self.channels.load(Ordering::SeqCst), 0); let mut guard = self.lock.lock().unwrap(); assert!(guard.queue.dequeue().is_none()); assert!(guard.canceled.is_none()); diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs index 9e9a17e482fbf..08e323c9cb4c3 100644 --- a/src/libstd/sync/once.rs +++ b/src/libstd/sync/once.rs @@ -17,7 +17,7 @@ use int; use kinds::Sync; use mem::drop; use ops::FnOnce; -use sync::atomic; +use sync::atomic::{AtomicInt, Ordering, ATOMIC_INT_INIT}; use sync::{StaticMutex, MUTEX_INIT}; /// A synchronization primitive which can be used to run a one-time global @@ -39,8 +39,8 @@ use sync::{StaticMutex, MUTEX_INIT}; #[stable] pub struct Once { mutex: StaticMutex, - cnt: atomic::AtomicInt, - lock_cnt: atomic::AtomicInt, + cnt: AtomicInt, + lock_cnt: AtomicInt, } unsafe impl Sync for Once {} @@ -49,8 +49,8 @@ unsafe impl Sync for Once {} #[stable] pub const ONCE_INIT: Once = Once { mutex: MUTEX_INIT, - cnt: atomic::ATOMIC_INT_INIT, - lock_cnt: atomic::ATOMIC_INT_INIT, + cnt: ATOMIC_INT_INIT, + lock_cnt: ATOMIC_INT_INIT, }; impl Once { @@ -66,7 +66,7 @@ impl Once { #[stable] pub fn call_once<F>(&'static self, f: F) where F: FnOnce() { // Optimize common path: load is much cheaper than fetch_add. - if self.cnt.load(atomic::SeqCst) < 0 { + if self.cnt.load(Ordering::SeqCst) < 0 { return } @@ -97,11 +97,11 @@ impl Once { // calling `call_once` will return immediately before the initialization // has completed. - let prev = self.cnt.fetch_add(1, atomic::SeqCst); + let prev = self.cnt.fetch_add(1, Ordering::SeqCst); if prev < 0 { // Make sure we never overflow, we'll never have int::MIN // simultaneous calls to `call_once` to make this value go back to 0 - self.cnt.store(int::MIN, atomic::SeqCst); + self.cnt.store(int::MIN, Ordering::SeqCst); return } @@ -109,15 +109,15 @@ impl Once { // otherwise we run the job and record how many people will try to grab // this lock let guard = self.mutex.lock(); - if self.cnt.load(atomic::SeqCst) > 0 { + if self.cnt.load(Ordering::SeqCst) > 0 { f(); - let prev = self.cnt.swap(int::MIN, atomic::SeqCst); - self.lock_cnt.store(prev, atomic::SeqCst); + let prev = self.cnt.swap(int::MIN, Ordering::SeqCst); + self.lock_cnt.store(prev, Ordering::SeqCst); } drop(guard); // Last one out cleans up after everyone else, no leaks! - if self.lock_cnt.fetch_add(-1, atomic::SeqCst) == 1 { + if self.lock_cnt.fetch_add(-1, Ordering::SeqCst) == 1 { unsafe { self.mutex.destroy() } } } diff --git a/src/libstd/sys/common/thread_local.rs b/src/libstd/sys/common/thread_local.rs index 158fd3a8382a2..e9af796c6745c 100644 --- a/src/libstd/sys/common/thread_local.rs +++ b/src/libstd/sys/common/thread_local.rs @@ -58,7 +58,7 @@ use prelude::v1::*; -use sync::atomic::{self, AtomicUint}; +use sync::atomic::{self, AtomicUint, Ordering}; use sync::{Mutex, Once, ONCE_INIT}; use sys::thread_local as imp; @@ -166,7 +166,7 @@ impl StaticKey { /// Note that this does *not* run the user-provided destructor if one was /// specified at definition time. Doing so must be done manually. pub unsafe fn destroy(&self) { - match self.inner.key.swap(0, atomic::SeqCst) { + match self.inner.key.swap(0, Ordering::SeqCst) { 0 => {} n => { imp::destroy(n as imp::Key) } } @@ -174,7 +174,7 @@ impl StaticKey { #[inline] unsafe fn key(&self) -> imp::Key { - match self.inner.key.load(atomic::Relaxed) { + match self.inner.key.load(Ordering::Relaxed) { 0 => self.lazy_init() as imp::Key, n => n as imp::Key } @@ -199,7 +199,7 @@ impl StaticKey { key2 }; assert!(key != 0); - match self.inner.key.compare_and_swap(0, key as uint, atomic::SeqCst) { + match self.inner.key.compare_and_swap(0, key as uint, Ordering::SeqCst) { // The CAS succeeded, so we've created the actual key 0 => key as uint, // If someone beat us to the punch, use their key instead diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index 690574301d7dc..181b8fdd0f8a1 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -20,7 +20,6 @@ use libc::{self, c_int, c_char, c_void}; use os; use path::{BytesContainer}; use ptr; -use sync::atomic::{AtomicInt, SeqCst}; use sys::fs::FileDesc; use os::TMPBUF_SZ; diff --git a/src/libstd/sys/unix/pipe.rs b/src/libstd/sys/unix/pipe.rs index fcbfb383d3cc8..9063fbc2ba955 100644 --- a/src/libstd/sys/unix/pipe.rs +++ b/src/libstd/sys/unix/pipe.rs @@ -13,7 +13,8 @@ use prelude::v1::*; use libc; use c_str::CString; use mem; -use sync::{atomic, Arc, Mutex}; +use sync::{Arc, Mutex}; +use sync::atomic::{AtomicBool, Ordering}; use io::{self, IoResult, IoError}; use sys::{self, timer, retry, c, set_nonblocking, wouldblock}; @@ -242,7 +243,7 @@ impl UnixListener { listener: self, reader: reader, writer: writer, - closed: atomic::AtomicBool::new(false), + closed: AtomicBool::new(false), }), deadline: 0, }) @@ -260,7 +261,7 @@ struct AcceptorInner { listener: UnixListener, reader: FileDesc, writer: FileDesc, - closed: atomic::AtomicBool, + closed: AtomicBool, } impl UnixAcceptor { @@ -269,7 +270,7 @@ impl UnixAcceptor { pub fn accept(&mut self) -> IoResult<UnixStream> { let deadline = if self.deadline == 0 {None} else {Some(self.deadline)}; - while !self.inner.closed.load(atomic::SeqCst) { + while !self.inner.closed.load(Ordering::SeqCst) { unsafe { let mut storage: libc::sockaddr_storage = mem::zeroed(); let storagep = &mut storage as *mut libc::sockaddr_storage; @@ -297,7 +298,7 @@ impl UnixAcceptor { } pub fn close_accept(&mut self) -> IoResult<()> { - self.inner.closed.store(true, atomic::SeqCst); + self.inner.closed.store(true, Ordering::SeqCst); let fd = FileDesc::new(self.inner.writer.fd(), false); match fd.write(&[0]) { Ok(..) => Ok(()), diff --git a/src/libstd/sys/unix/tcp.rs b/src/libstd/sys/unix/tcp.rs index 13ccf685fd7fc..59eebd3f28eca 100644 --- a/src/libstd/sys/unix/tcp.rs +++ b/src/libstd/sys/unix/tcp.rs @@ -16,7 +16,8 @@ use libc; use mem; use ptr; use super::{last_error, last_net_error, retry, sock_t}; -use sync::{Arc, atomic}; +use sync::Arc; +use sync::atomic::{AtomicBool, Ordering}; use sys::fs::FileDesc; use sys::{set_nonblocking, wouldblock}; use sys; @@ -74,7 +75,7 @@ impl TcpListener { listener: self, reader: reader, writer: writer, - closed: atomic::AtomicBool::new(false), + closed: AtomicBool::new(false), }), deadline: 0, }) @@ -96,7 +97,7 @@ struct AcceptorInner { listener: TcpListener, reader: FileDesc, writer: FileDesc, - closed: atomic::AtomicBool, + closed: AtomicBool, } unsafe impl Sync for AcceptorInner {} @@ -121,7 +122,7 @@ impl TcpAcceptor { // self-pipe is never written to unless close_accept() is called. let deadline = if self.deadline == 0 {None} else {Some(self.deadline)}; - while !self.inner.closed.load(atomic::SeqCst) { + while !self.inner.closed.load(Ordering::SeqCst) { match retry(|| unsafe { libc::accept(self.fd(), ptr::null_mut(), ptr::null_mut()) }) { @@ -145,7 +146,7 @@ impl TcpAcceptor { } pub fn close_accept(&mut self) -> IoResult<()> { - self.inner.closed.store(true, atomic::SeqCst); + self.inner.closed.store(true, Ordering::SeqCst); let fd = FileDesc::new(self.inner.writer.fd(), false); match fd.write(&[0]) { Ok(..) => Ok(()), diff --git a/src/libstd/sys/unix/timer.rs b/src/libstd/sys/unix/timer.rs index 80f93dd2f618c..11f29232a925d 100644 --- a/src/libstd/sys/unix/timer.rs +++ b/src/libstd/sys/unix/timer.rs @@ -54,7 +54,7 @@ use libc; use mem; use os; use ptr; -use sync::atomic; +use sync::atomic::{mod, Ordering}; use sync::mpsc::{channel, Sender, Receiver, TryRecvError}; use sys::c; use sys::fs::FileDesc; @@ -212,7 +212,7 @@ impl Timer { HELPER.boot(|| {}, helper); static ID: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT; - let id = ID.fetch_add(1, atomic::Relaxed); + let id = ID.fetch_add(1, Ordering::Relaxed); Ok(Timer { id: id, inner: Some(box Inner { diff --git a/src/libstd/sys/windows/mutex.rs b/src/libstd/sys/windows/mutex.rs index f561e0121b3e6..1def99a374198 100644 --- a/src/libstd/sys/windows/mutex.rs +++ b/src/libstd/sys/windows/mutex.rs @@ -10,7 +10,7 @@ use prelude::v1::*; -use sync::atomic; +use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering}; use alloc::{self, heap}; use libc::DWORD; @@ -18,9 +18,9 @@ use sys::sync as ffi; const SPIN_COUNT: DWORD = 4000; -pub struct Mutex { inner: atomic::AtomicUint } +pub struct Mutex { inner: AtomicUint } -pub const MUTEX_INIT: Mutex = Mutex { inner: atomic::ATOMIC_UINT_INIT }; +pub const MUTEX_INIT: Mutex = Mutex { inner: ATOMIC_UINT_INIT }; unsafe impl Sync for Mutex {} @@ -32,7 +32,7 @@ pub unsafe fn raw(m: &Mutex) -> ffi::LPCRITICAL_SECTION { impl Mutex { #[inline] pub unsafe fn new() -> Mutex { - Mutex { inner: atomic::AtomicUint::new(init_lock() as uint) } + Mutex { inner: AtomicUint::new(init_lock() as uint) } } #[inline] pub unsafe fn lock(&self) { @@ -47,22 +47,22 @@ impl Mutex { ffi::LeaveCriticalSection(self.get()) } pub unsafe fn destroy(&self) { - let lock = self.inner.swap(0, atomic::SeqCst); + let lock = self.inner.swap(0, Ordering::SeqCst); if lock != 0 { free_lock(lock as ffi::LPCRITICAL_SECTION) } } unsafe fn get(&self) -> ffi::LPCRITICAL_SECTION { - match self.inner.load(atomic::SeqCst) { + match self.inner.load(Ordering::SeqCst) { 0 => {} n => return n as ffi::LPCRITICAL_SECTION } let lock = init_lock(); - match self.inner.compare_and_swap(0, lock as uint, atomic::SeqCst) { + match self.inner.compare_and_swap(0, lock as uint, Ordering::SeqCst) { 0 => return lock as ffi::LPCRITICAL_SECTION, _ => {} } free_lock(lock); - return self.inner.load(atomic::SeqCst) as ffi::LPCRITICAL_SECTION; + return self.inner.load(Ordering::SeqCst) as ffi::LPCRITICAL_SECTION; } } diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs index 0edae75a9ce64..9057515cad294 100644 --- a/src/libstd/sys/windows/pipe.rs +++ b/src/libstd/sys/windows/pipe.rs @@ -90,7 +90,8 @@ use libc; use c_str::CString; use mem; use ptr; -use sync::{atomic, Arc, Mutex}; +use sync::{Arc, Mutex}; +use sync::atomic::{AtomicBool, Ordering}; use io::{self, IoError, IoResult}; use sys_common::{self, eof}; @@ -126,8 +127,8 @@ impl Drop for Event { struct Inner { handle: libc::HANDLE, lock: Mutex<()>, - read_closed: atomic::AtomicBool, - write_closed: atomic::AtomicBool, + read_closed: AtomicBool, + write_closed: AtomicBool, } impl Inner { @@ -135,8 +136,8 @@ impl Inner { Inner { handle: handle, lock: Mutex::new(()), - read_closed: atomic::AtomicBool::new(false), - write_closed: atomic::AtomicBool::new(false), + read_closed: AtomicBool::new(false), + write_closed: AtomicBool::new(false), } } } @@ -334,11 +335,11 @@ impl UnixStream { pub fn handle(&self) -> libc::HANDLE { self.inner.handle } fn read_closed(&self) -> bool { - self.inner.read_closed.load(atomic::SeqCst) + self.inner.read_closed.load(Ordering::SeqCst) } fn write_closed(&self) -> bool { - self.inner.write_closed.load(atomic::SeqCst) + self.inner.write_closed.load(Ordering::SeqCst) } fn cancel_io(&self) -> IoResult<()> { @@ -517,14 +518,14 @@ impl UnixStream { // and 2 with a lock with respect to close_read(), we're guaranteed that // no thread will erroneously sit in a read forever. let _guard = unsafe { self.inner.lock.lock() }; - self.inner.read_closed.store(true, atomic::SeqCst); + self.inner.read_closed.store(true, Ordering::SeqCst); self.cancel_io() } pub fn close_write(&mut self) -> IoResult<()> { // see comments in close_read() for why this lock is necessary let _guard = unsafe { self.inner.lock.lock() }; - self.inner.write_closed.store(true, atomic::SeqCst); + self.inner.write_closed.store(true, Ordering::SeqCst); self.cancel_io() } @@ -586,7 +587,7 @@ impl UnixListener { deadline: 0, inner: Arc::new(AcceptorState { abort: try!(Event::new(true, false)), - closed: atomic::AtomicBool::new(false), + closed: AtomicBool::new(false), }), }) } @@ -614,7 +615,7 @@ unsafe impl Sync for UnixAcceptor {} struct AcceptorState { abort: Event, - closed: atomic::AtomicBool, + closed: AtomicBool, } unsafe impl Send for AcceptorState {} @@ -658,7 +659,7 @@ impl UnixAcceptor { // If we've had an artificial call to close_accept, be sure to never // proceed in accepting new clients in the future - if self.inner.closed.load(atomic::SeqCst) { return Err(eof()) } + if self.inner.closed.load(Ordering::SeqCst) { return Err(eof()) } let name = try!(to_utf16(self.listener.name.as_str())); @@ -734,7 +735,7 @@ impl UnixAcceptor { } pub fn close_accept(&mut self) -> IoResult<()> { - self.inner.closed.store(true, atomic::SeqCst); + self.inner.closed.store(true, Ordering::SeqCst); let ret = unsafe { c::SetEvent(self.inner.abort.handle()) }; diff --git a/src/libstd/sys/windows/tcp.rs b/src/libstd/sys/windows/tcp.rs index 1c8ec2a80a7e4..77139b52efa14 100644 --- a/src/libstd/sys/windows/tcp.rs +++ b/src/libstd/sys/windows/tcp.rs @@ -15,7 +15,8 @@ use mem; use ptr; use prelude::v1::*; use super::{last_error, last_net_error, retry, sock_t}; -use sync::{Arc, atomic}; +use sync::Arc; +use sync::atomic::{AtomicBool, Ordering}; use sys::fs::FileDesc; use sys::{self, c, set_nonblocking, wouldblock, timer}; use sys_common::{self, timeout, eof, net}; @@ -91,7 +92,7 @@ impl TcpListener { listener: self, abort: try!(Event::new()), accept: accept, - closed: atomic::AtomicBool::new(false), + closed: AtomicBool::new(false), }), deadline: 0, }) @@ -122,7 +123,7 @@ struct AcceptorInner { listener: TcpListener, abort: Event, accept: Event, - closed: atomic::AtomicBool, + closed: AtomicBool, } unsafe impl Send for AcceptorInner {} @@ -154,7 +155,7 @@ impl TcpAcceptor { // stolen, so we do all of this in a loop as well. let events = [self.inner.abort.handle(), self.inner.accept.handle()]; - while !self.inner.closed.load(atomic::SeqCst) { + while !self.inner.closed.load(Ordering::SeqCst) { let ms = if self.deadline == 0 { c::WSA_INFINITE as u64 } else { @@ -214,7 +215,7 @@ impl TcpAcceptor { } pub fn close_accept(&mut self) -> IoResult<()> { - self.inner.closed.store(true, atomic::SeqCst); + self.inner.closed.store(true, Ordering::SeqCst); let ret = unsafe { c::WSASetEvent(self.inner.abort.handle()) }; if ret == libc::TRUE { Ok(()) diff --git a/src/libstd/task.rs b/src/libstd/task.rs deleted file mode 100644 index 0f08108fee547..0000000000000 --- a/src/libstd/task.rs +++ /dev/null @@ -1,44 +0,0 @@ -// Copyright 2012-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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Deprecated in favor of `thread`. - -#![deprecated = "use std::thread instead"] - -use any::Any; -use boxed::Box; -use thread; -use kinds::Send; -use result::Result; -use ops::FnOnce; - -/// Deprecate: use `std::thread::Builder` instead. -#[deprecated = "use std::thread::Builder instead"] -pub type TaskBuilder = thread::Builder; - -/// Deprecated: use `std::thread::Thread::spawn` and `detach` instead. -#[deprecated = "use std::thread::Thread::spawn and detach instead"] -pub fn spawn<F>(f: F) where F: FnOnce(), F: Send { - thread::Thread::spawn(f).detach(); -} - -/// Deprecated: use `std::thread::Thread::spawn` and `join` instead. -#[deprecated = "use std::thread::Thread::spawn and join instead"] -pub fn try<T, F>(f: F) -> Result<T, Box<Any + Send>> where - T: Send, F: FnOnce() -> T, F: Send -{ - thread::Thread::spawn(f).join() -} - -/// Deprecated: use `std::thread::Thread::yield_now instead`. -#[deprecated = "use std::thread::Thread::yield_now instead"] -pub fn deschedule() { - thread::Thread::yield_now() -} diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index 9c8a5fc239ce3..1d6f49b04a3f5 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -125,7 +125,6 @@ //! * It can be implemented highly efficiently on many platforms. use any::Any; -use borrow::IntoCow; use boxed::Box; use cell::UnsafeCell; use clone::Clone; @@ -175,12 +174,6 @@ impl Builder { self } - /// Deprecated: use `name` instead - #[deprecated = "use name instead"] - pub fn named<T: IntoCow<'static, String, str>>(self, name: T) -> Builder { - self.name(name.into_cow().into_owned()) - } - /// Set the size of the stack for the new thread. pub fn stack_size(mut self, size: uint) -> Builder { self.stack_size = Some(size); diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs index fc90bffa03c2f..f40b62182d42c 100644 --- a/src/libstd/tuple.rs +++ b/src/libstd/tuple.rs @@ -35,17 +35,6 @@ //! //! # Examples //! -//! Using fields: -//! -//! ``` -//! #[allow(deprecated)] -//! # fn main() { -//! let pair = ("pi", 3.14f64); -//! assert_eq!(pair.0, "pi"); -//! assert_eq!(pair.1, 3.14f64); -//! # } -//! ``` -//! //! Using traits implemented for tuples: //! //! ``` diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index 57d66f0e35524..14b19fee3df5e 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -25,7 +25,6 @@ pub mod decodable; pub mod hash; pub mod rand; pub mod show; -pub mod zero; pub mod default; pub mod primitive; @@ -110,7 +109,6 @@ pub fn expand_meta_derive(cx: &mut ExtCtxt, "Show" => expand!(show::expand_deriving_show), - "Zero" => expand!(zero::expand_deriving_zero), "Default" => expand!(default::expand_deriving_default), "FromPrimitive" => expand!(primitive::expand_deriving_from_primitive), diff --git a/src/libsyntax/ext/deriving/zero.rs b/src/libsyntax/ext/deriving/zero.rs deleted file mode 100644 index 73331f06aa4ee..0000000000000 --- a/src/libsyntax/ext/deriving/zero.rs +++ /dev/null @@ -1,102 +0,0 @@ -// Copyright 2012-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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use ast::{MetaItem, Item, Expr}; -use codemap::Span; -use ext::base::ExtCtxt; -use ext::build::AstBuilder; -use ext::deriving::generic::*; -use ext::deriving::generic::ty::*; -use parse::token::InternedString; -use ptr::P; - -pub fn expand_deriving_zero<F>(cx: &mut ExtCtxt, - span: Span, - mitem: &MetaItem, - item: &Item, - push: F) where - F: FnOnce(P<Item>), -{ - let inline = cx.meta_word(span, InternedString::new("inline")); - let attrs = vec!(cx.attribute(span, inline)); - let trait_def = TraitDef { - span: span, - attributes: Vec::new(), - path: Path::new(vec!("std", "num", "Zero")), - additional_bounds: Vec::new(), - generics: LifetimeBounds::empty(), - methods: vec!( - MethodDef { - name: "zero", - generics: LifetimeBounds::empty(), - explicit_self: None, - args: Vec::new(), - ret_ty: Self, - attributes: attrs.clone(), - combine_substructure: combine_substructure(|a, b, c| { - zero_substructure(a, b, c) - }) - }, - MethodDef { - name: "is_zero", - generics: LifetimeBounds::empty(), - explicit_self: borrowed_explicit_self(), - args: Vec::new(), - ret_ty: Literal(Path::new(vec!("bool"))), - attributes: attrs, - combine_substructure: combine_substructure(|cx, span, substr| { - cs_and(|cx, span, _, _| cx.span_bug(span, - "Non-matching enum \ - variant in \ - deriving(Zero)"), - cx, span, substr) - }) - } - ) - }; - trait_def.expand(cx, mitem, item, push) -} - -fn zero_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> { - let zero_ident = vec!( - cx.ident_of("std"), - cx.ident_of("num"), - cx.ident_of("Zero"), - cx.ident_of("zero") - ); - let zero_call = |&: span| cx.expr_call_global(span, zero_ident.clone(), Vec::new()); - - return match *substr.fields { - StaticStruct(_, ref summary) => { - match *summary { - Unnamed(ref fields) => { - if fields.is_empty() { - cx.expr_ident(trait_span, substr.type_ident) - } else { - let exprs = fields.iter().map(|sp| zero_call(*sp)).collect(); - cx.expr_call_ident(trait_span, substr.type_ident, exprs) - } - } - Named(ref fields) => { - let zero_fields = fields.iter().map(|&(ident, span)| { - cx.field_imm(span, ident, zero_call(span)) - }).collect(); - cx.expr_struct_ident(trait_span, substr.type_ident, zero_fields) - } - } - } - StaticEnum(..) => { - cx.span_err(trait_span, "`Zero` cannot be derived for enums, only structs"); - // let compilation continue - cx.expr_uint(trait_span, 0) - } - _ => cx.bug("Non-static method in `deriving(Zero)`") - }; -} diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 46a124074c7a3..a50b97142c2ef 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -23,6 +23,7 @@ use std::mem::replace; use std::num; use std::rc::Rc; use std::str; +use std::string::CowString; pub use ext::tt::transcribe::{TtReader, new_tt_reader}; @@ -277,7 +278,7 @@ impl<'a> StringReader<'a> { /// Converts CRLF to LF in the given string, raising an error on bare CR. fn translate_crlf<'b>(&self, start: BytePos, - s: &'b str, errmsg: &'b str) -> str::CowString<'b> { + s: &'b str, errmsg: &'b str) -> CowString<'b> { let mut i = 0u; while i < s.len() { let str::CharRange { ch, next } = s.char_range_at(i); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index c0444363d4ec4..37ac86a33242e 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -89,7 +89,6 @@ use std::mem; use std::num::Float; use std::rc::Rc; 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 1df7e2893f68a..4bfcc94a083d4 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -22,7 +22,6 @@ 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; @@ -632,13 +631,6 @@ impl fmt::Show for InternedString { } } -#[allow(deprecated)] -impl<'a> Equiv<&'a str> for InternedString { - fn equiv(&self, other: & &'a str) -> bool { - (*other) == self.string[] - } -} - impl<'a> PartialEq<&'a str> for InternedString { #[inline(always)] fn eq(&self, other: & &'a str) -> bool { diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index d54930998f153..4bac20dd67c06 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -71,7 +71,7 @@ use std::io; use std::iter::repeat; use std::num::{Float, FloatMath, Int}; use std::os; -use std::str::{FromStr, from_str}; +use std::str::FromStr; use std::sync::mpsc::{channel, Sender}; use std::thread::{self, Thread}; use std::thunk::{Thunk, Invoke}; diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index 7459d30b663fb..35af0e763d7dd 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -1066,7 +1066,7 @@ mod bench { #[bench] pub fn sum_many_f64(b: &mut Bencher) { let nums = [-1e30f64, 1e60, 1e30, 1.0, -1e60]; - let v = Vec::from_fn(500, |i| nums[i%5]); + let v = range(0, 500).map(|i| nums[i%5]).collect::<Vec<_>>(); b.iter(|| { v.as_slice().sum(); diff --git a/src/libtime/lib.rs b/src/libtime/lib.rs deleted file mode 100644 index 0dc1524a7cb6b..0000000000000 --- a/src/libtime/lib.rs +++ /dev/null @@ -1,1773 +0,0 @@ -// Copyright 2012-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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Simple time handling. - -#![crate_name = "time"] -#![deprecated = "use the http://github.com/rust-lang/time crate instead"] -#![allow(deprecated)] - -#![crate_type = "rlib"] -#![crate_type = "dylib"] -#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", - html_favicon_url = "http://www.rust-lang.org/favicon.ico", - html_root_url = "http://doc.rust-lang.org/nightly/", - html_playground_url = "http://play.rust-lang.org/")] - -#![allow(unknown_features)] -#![feature(phase, globs)] -#![feature(old_orphan_check)] -#![feature(associated_types)] -#![feature(default_type_params)] - -#[cfg(test)] #[phase(plugin, link)] extern crate log; - -extern crate "serialize" as rustc_serialize; -extern crate libc; - -pub use self::ParseError::*; -use self::Fmt::*; - -use std::fmt::{self, Show}; -use std::num::SignedInt; -use std::ops::{Add, Sub}; -use std::time::Duration; - -static NSEC_PER_SEC: i32 = 1_000_000_000_i32; - -mod rustrt { - use super::Tm; - - extern { - pub fn rust_tzset(); - pub fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm); - pub fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm); - pub fn rust_timegm(tm: &Tm) -> i64; - pub fn rust_mktime(tm: &Tm) -> i64; - } -} - -#[cfg(all(unix, not(target_os = "macos"), not(target_os = "ios")))] -mod imp { - use libc::{c_int, timespec}; - - // Apparently android provides this in some other library? - #[cfg(not(target_os = "android"))] - #[link(name = "rt")] - extern {} - - extern { - pub fn clock_gettime(clk_id: c_int, tp: *mut timespec) -> c_int; - } - -} -#[cfg(any(target_os = "macos", target_os = "ios"))] -mod imp { - use libc::{timeval, timezone, c_int, mach_timebase_info}; - - extern { - pub fn gettimeofday(tp: *mut timeval, tzp: *mut timezone) -> c_int; - pub fn mach_absolute_time() -> u64; - pub fn mach_timebase_info(info: *mut mach_timebase_info) -> c_int; - } -} - -/// A record specifying a time value in seconds and nanoseconds. -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, - RustcDecodable, Show, Copy)] -pub struct Timespec { - pub sec: i64, - pub nsec: i32, -} - -/* - * Timespec assumes that pre-epoch Timespecs have negative sec and positive - * nsec fields. Darwin's and Linux's struct timespec functions handle pre- - * epoch timestamps using a "two steps back, one step forward" representation, - * though the man pages do not actually document this. For example, the time - * -1.2 seconds before the epoch is represented by `Timespec { sec: -2_i64, - * nsec: 800_000_000_i32 }`. - */ -impl Timespec { - pub fn new(sec: i64, nsec: i32) -> Timespec { - assert!(nsec >= 0 && nsec < NSEC_PER_SEC); - Timespec { sec: sec, nsec: nsec } - } -} - -impl Add<Duration> for Timespec { - type Output = Timespec; - - fn add(self, other: Duration) -> Timespec { - let d_sec = other.num_seconds(); - // It is safe to unwrap the nanoseconds, because there cannot be - // more than one second left, which fits in i64 and in i32. - let d_nsec = (other - Duration::seconds(d_sec)) - .num_nanoseconds().unwrap() as i32; - let mut sec = self.sec + d_sec; - let mut nsec = self.nsec + d_nsec; - if nsec >= NSEC_PER_SEC { - nsec -= NSEC_PER_SEC; - sec += 1; - } else if nsec < 0 { - nsec += NSEC_PER_SEC; - sec -= 1; - } - Timespec::new(sec, nsec) - } -} - -impl Sub for Timespec { - type Output = Duration; - - fn sub(self, other: Timespec) -> Duration { - let sec = self.sec - other.sec; - let nsec = self.nsec - other.nsec; - Duration::seconds(sec) + Duration::nanoseconds(nsec as i64) - } -} - -/// Returns the current time as a `timespec` containing the seconds and -/// nanoseconds since 1970-01-01T00:00:00Z. -pub fn get_time() -> Timespec { - unsafe { - let (sec, nsec) = os_get_time(); - return Timespec::new(sec, nsec); - } - - #[cfg(windows)] - unsafe fn os_get_time() -> (i64, i32) { - static NANOSECONDS_FROM_1601_TO_1970: u64 = 11644473600000000; - - let mut time = libc::FILETIME { - dwLowDateTime: 0, - dwHighDateTime: 0, - }; - libc::GetSystemTimeAsFileTime(&mut time); - - // A FILETIME contains a 64-bit value representing the number of - // hectonanosecond (100-nanosecond) intervals since 1601-01-01T00:00:00Z. - // http://support.microsoft.com/kb/167296/en-us - let ns_since_1601 = (((time.dwHighDateTime as u64) << 32) | - ((time.dwLowDateTime as u64) << 0)) / 10; - let ns_since_1970 = ns_since_1601 - NANOSECONDS_FROM_1601_TO_1970; - - ((ns_since_1970 / 1000000) as i64, - ((ns_since_1970 % 1000000) * 1000) as i32) - } - - #[cfg(any(target_os = "macos", target_os = "ios"))] - unsafe fn os_get_time() -> (i64, i32) { - use std::ptr; - let mut tv = libc::timeval { tv_sec: 0, tv_usec: 0 }; - imp::gettimeofday(&mut tv, ptr::null_mut()); - (tv.tv_sec as i64, tv.tv_usec * 1000) - } - - #[cfg(not(any(target_os = "macos", target_os = "ios", windows)))] - unsafe fn os_get_time() -> (i64, i32) { - let mut tv = libc::timespec { tv_sec: 0, tv_nsec: 0 }; - imp::clock_gettime(libc::CLOCK_REALTIME, &mut tv); - (tv.tv_sec as i64, tv.tv_nsec as i32) - } -} - - -/// Returns the current value of a high-resolution performance counter -/// in nanoseconds since an unspecified epoch. -pub fn precise_time_ns() -> u64 { - return os_precise_time_ns(); - - #[cfg(windows)] - fn os_precise_time_ns() -> u64 { - let mut ticks_per_s = 0; - assert_eq!(unsafe { - libc::QueryPerformanceFrequency(&mut ticks_per_s) - }, 1); - let ticks_per_s = if ticks_per_s == 0 {1} else {ticks_per_s}; - let mut ticks = 0; - assert_eq!(unsafe { - libc::QueryPerformanceCounter(&mut ticks) - }, 1); - - return (ticks as u64 * 1000000000) / (ticks_per_s as u64); - } - - #[cfg(any(target_os = "macos", target_os = "ios"))] - fn os_precise_time_ns() -> u64 { - static mut TIMEBASE: libc::mach_timebase_info = libc::mach_timebase_info { numer: 0, - denom: 0 }; - static ONCE: std::sync::Once = std::sync::ONCE_INIT; - unsafe { - ONCE.call_once(|| { - imp::mach_timebase_info(&mut TIMEBASE); - }); - let time = imp::mach_absolute_time(); - time * TIMEBASE.numer as u64 / TIMEBASE.denom as u64 - } - } - - #[cfg(not(any(windows, target_os = "macos", target_os = "ios")))] - fn os_precise_time_ns() -> u64 { - let mut ts = libc::timespec { tv_sec: 0, tv_nsec: 0 }; - unsafe { - imp::clock_gettime(libc::CLOCK_MONOTONIC, &mut ts); - } - return (ts.tv_sec as u64) * 1000000000 + (ts.tv_nsec as u64) - } -} - - -/// Returns the current value of a high-resolution performance counter -/// in seconds since an unspecified epoch. -pub fn precise_time_s() -> f64 { - return (precise_time_ns() as f64) / 1000000000.; -} - -pub fn tzset() { - unsafe { - rustrt::rust_tzset(); - } -} - -/// Holds a calendar date and time broken down into its components (year, month, day, and so on), -/// also called a broken-down time value. -// FIXME: use c_int instead of i32? -#[repr(C)] -#[derive(Clone, Copy, PartialEq, Eq, Show)] -pub struct Tm { - /// Seconds after the minute - [0, 60] - pub tm_sec: i32, - - /// Minutes after the hour - [0, 59] - pub tm_min: i32, - - /// Hours after midnight - [0, 23] - pub tm_hour: i32, - - /// Day of the month - [1, 31] - pub tm_mday: i32, - - /// Months since January - [0, 11] - pub tm_mon: i32, - - /// Years since 1900 - pub tm_year: i32, - - /// Days since Sunday - [0, 6]. 0 = Sunday, 1 = Monday, ..., 6 = Saturday. - pub tm_wday: i32, - - /// Days since January 1 - [0, 365] - pub tm_yday: i32, - - /// Daylight Saving Time flag. - /// - /// This value is positive if Daylight Saving Time is in effect, zero if Daylight Saving Time - /// is not in effect, and negative if this information is not available. - pub tm_isdst: i32, - - /// Identifies the time zone that was used to compute this broken-down time value, including any - /// adjustment for Daylight Saving Time. This is the number of seconds east of UTC. For example, - /// for U.S. Pacific Daylight Time, the value is -7*60*60 = -25200. - pub tm_gmtoff: i32, - - /// Nanoseconds after the second - [0, 10<sup>9</sup> - 1] - pub tm_nsec: i32, -} - -pub fn empty_tm() -> Tm { - Tm { - tm_sec: 0_i32, - tm_min: 0_i32, - tm_hour: 0_i32, - tm_mday: 0_i32, - tm_mon: 0_i32, - tm_year: 0_i32, - tm_wday: 0_i32, - tm_yday: 0_i32, - tm_isdst: 0_i32, - tm_gmtoff: 0_i32, - tm_nsec: 0_i32, - } -} - -/// Returns the specified time in UTC -pub fn at_utc(clock: Timespec) -> Tm { - unsafe { - let Timespec { sec, nsec } = clock; - let mut tm = empty_tm(); - rustrt::rust_gmtime(sec, nsec, &mut tm); - tm - } -} - -/// Returns the current time in UTC -pub fn now_utc() -> Tm { - at_utc(get_time()) -} - -/// Returns the specified time in the local timezone -pub fn at(clock: Timespec) -> Tm { - unsafe { - let Timespec { sec, nsec } = clock; - let mut tm = empty_tm(); - rustrt::rust_localtime(sec, nsec, &mut tm); - tm - } -} - -/// Returns the current time in the local timezone -pub fn now() -> Tm { - at(get_time()) -} - -impl Tm { - /// Convert time to the seconds from January 1, 1970 - pub fn to_timespec(&self) -> Timespec { - unsafe { - let sec = match self.tm_gmtoff { - 0_i32 => rustrt::rust_timegm(self), - _ => rustrt::rust_mktime(self) - }; - - Timespec::new(sec, self.tm_nsec) - } - } - - /// Convert time to the local timezone - pub fn to_local(&self) -> Tm { - at(self.to_timespec()) - } - - /// Convert time to the UTC - pub fn to_utc(&self) -> Tm { - at_utc(self.to_timespec()) - } - - /// Returns a TmFmt that outputs according to the `asctime` format in ISO - /// C, in the local timezone. - /// - /// Example: "Thu Jan 1 00:00:00 1970" - pub fn ctime(&self) -> TmFmt { - TmFmt { - tm: self, - format: FmtCtime, - } - } - - /// Returns a TmFmt that outputs according to the `asctime` format in ISO - /// C. - /// - /// Example: "Thu Jan 1 00:00:00 1970" - pub fn asctime(&self) -> TmFmt { - TmFmt { - tm: self, - format: FmtStr("%c"), - } - } - - /// Formats the time according to the format string. - pub fn strftime<'a>(&'a self, format: &'a str) -> Result<TmFmt<'a>, ParseError> { - validate_format(TmFmt { - tm: self, - format: FmtStr(format), - }) - } - - /// Returns a TmFmt that outputs according to RFC 822. - /// - /// local: "Thu, 22 Mar 2012 07:53:18 PST" - /// utc: "Thu, 22 Mar 2012 14:53:18 GMT" - pub fn rfc822(&self) -> TmFmt { - if self.tm_gmtoff == 0_i32 { - TmFmt { - tm: self, - format: FmtStr("%a, %d %b %Y %T GMT"), - } - } else { - TmFmt { - tm: self, - format: FmtStr("%a, %d %b %Y %T %Z"), - } - } - } - - /// Returns a TmFmt that outputs according to RFC 822 with Zulu time. - /// - /// local: "Thu, 22 Mar 2012 07:53:18 -0700" - /// utc: "Thu, 22 Mar 2012 14:53:18 -0000" - pub fn rfc822z(&self) -> TmFmt { - TmFmt { - tm: self, - format: FmtStr("%a, %d %b %Y %T %z"), - } - } - - /// Returns a TmFmt that outputs according to RFC 3339. RFC 3339 is - /// compatible with ISO 8601. - /// - /// local: "2012-02-22T07:53:18-07:00" - /// utc: "2012-02-22T14:53:18Z" - pub fn rfc3339<'a>(&'a self) -> TmFmt { - TmFmt { - tm: self, - format: FmtRfc3339, - } - } -} - -#[derive(Copy, PartialEq)] -pub enum ParseError { - InvalidSecond, - InvalidMinute, - InvalidHour, - InvalidDay, - InvalidMonth, - InvalidYear, - InvalidDayOfWeek, - InvalidDayOfMonth, - InvalidDayOfYear, - InvalidZoneOffset, - InvalidTime, - MissingFormatConverter, - InvalidFormatSpecifier(char), - UnexpectedCharacter(char, char), -} - -impl Show for ParseError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - InvalidSecond => write!(f, "Invalid second."), - InvalidMinute => write!(f, "Invalid minute."), - InvalidHour => write!(f, "Invalid hour."), - InvalidDay => write!(f, "Invalid day."), - InvalidMonth => write!(f, "Invalid month."), - InvalidYear => write!(f, "Invalid year."), - InvalidDayOfWeek => write!(f, "Invalid day of the week."), - InvalidDayOfMonth => write!(f, "Invalid day of the month."), - InvalidDayOfYear => write!(f, "Invalid day of the year."), - InvalidZoneOffset => write!(f, "Invalid zone offset."), - InvalidTime => write!(f, "Invalid time."), - MissingFormatConverter => write!(f, "Missing format converter after `%`"), - InvalidFormatSpecifier(ch) => write!(f, "Invalid format specifier: %{}", ch), - UnexpectedCharacter(a, b) => write!(f, "Expected: {}, found: {}.", a, b), - } - } -} - -/// A wrapper around a `Tm` and format string that implements Show. -pub struct TmFmt<'a> { - tm: &'a Tm, - format: Fmt<'a> -} - -enum Fmt<'a> { - FmtStr(&'a str), - FmtRfc3339, - FmtCtime, -} - -fn validate_format<'a>(fmt: TmFmt<'a>) -> Result<TmFmt<'a>, ParseError> { - - match (fmt.tm.tm_wday, fmt.tm.tm_mon) { - (0...6, 0...11) => (), - (_wday, 0...11) => return Err(InvalidDayOfWeek), - (0...6, _mon) => return Err(InvalidMonth), - _ => return Err(InvalidDay) - } - match fmt.format { - FmtStr(ref s) => { - let mut chars = s.chars(); - loop { - match chars.next() { - Some('%') => { - match chars.next() { - Some('A') | - Some('a') | - Some('B') | - Some('b') | - Some('C') | - Some('c') | - Some('D') | - Some('d') | - Some('e') | - Some('F') | - Some('f') | - Some('G') | - Some('g') | - Some('H') | - Some('h') | - Some('I') | - Some('j') | - Some('k') | - Some('l') | - Some('M') | - Some('m') | - Some('n') | - Some('P') | - Some('p') | - Some('R') | - Some('r') | - Some('S') | - Some('s') | - Some('T') | - Some('t') | - Some('U') | - Some('u') | - Some('V') | - Some('v') | - Some('W') | - Some('w') | - Some('X') | - Some('x') | - Some('Y') | - Some('y') | - Some('Z') | - Some('z') | - Some('+') | - Some('%') - => (), - Some(c) => return Err(InvalidFormatSpecifier(c)), - None => return Err(MissingFormatConverter), - } - }, - None => break, - _ => () - } - } - }, - _ => () - } - Ok(fmt) -} - -impl<'a> fmt::Show for TmFmt<'a> { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fn days_in_year(year: int) -> i32 { - if (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)) { - 366 /* Days in a leap year */ - } else { - 365 /* Days in a non-leap year */ - } - } - - fn iso_week_days(yday: i32, wday: i32) -> int { - /* The number of days from the first day of the first ISO week of this - * year to the year day YDAY with week day WDAY. - * ISO weeks start on Monday. The first ISO week has the year's first - * Thursday. - * YDAY may be as small as yday_minimum. - */ - let yday: int = yday as int; - let wday: int = wday as int; - let iso_week_start_wday: int = 1; /* Monday */ - let iso_week1_wday: int = 4; /* Thursday */ - let yday_minimum: int = 366; - /* Add enough to the first operand of % to make it nonnegative. */ - let big_enough_multiple_of_7: int = (yday_minimum / 7 + 2) * 7; - - yday - (yday - wday + iso_week1_wday + big_enough_multiple_of_7) % 7 - + iso_week1_wday - iso_week_start_wday - } - - fn iso_week(fmt: &mut fmt::Formatter, ch:char, tm: &Tm) -> fmt::Result { - let mut year: int = tm.tm_year as int + 1900; - let mut days: int = iso_week_days (tm.tm_yday, tm.tm_wday); - - if days < 0 { - /* This ISO week belongs to the previous year. */ - year -= 1; - days = iso_week_days (tm.tm_yday + (days_in_year(year)), tm.tm_wday); - } else { - let d: int = iso_week_days (tm.tm_yday - (days_in_year(year)), - tm.tm_wday); - if 0 <= d { - /* This ISO week belongs to the next year. */ - year += 1; - days = d; - } - } - - match ch { - 'G' => write!(fmt, "{}", year), - 'g' => write!(fmt, "{:02}", (year % 100 + 100) % 100), - 'V' => write!(fmt, "{:02}", days / 7 + 1), - _ => Ok(()) - } - } - - fn parse_type(fmt: &mut fmt::Formatter, ch: char, tm: &Tm) -> fmt::Result { - let die = |&:| { - unreachable!() - }; - match ch { - 'A' => match tm.tm_wday as int { - 0 => "Sunday", - 1 => "Monday", - 2 => "Tuesday", - 3 => "Wednesday", - 4 => "Thursday", - 5 => "Friday", - 6 => "Saturday", - _ => return die() - }, - 'a' => match tm.tm_wday as int { - 0 => "Sun", - 1 => "Mon", - 2 => "Tue", - 3 => "Wed", - 4 => "Thu", - 5 => "Fri", - 6 => "Sat", - _ => return die() - }, - 'B' => match tm.tm_mon as int { - 0 => "January", - 1 => "February", - 2 => "March", - 3 => "April", - 4 => "May", - 5 => "June", - 6 => "July", - 7 => "August", - 8 => "September", - 9 => "October", - 10 => "November", - 11 => "December", - _ => return die() - }, - 'b' | 'h' => match tm.tm_mon as int { - 0 => "Jan", - 1 => "Feb", - 2 => "Mar", - 3 => "Apr", - 4 => "May", - 5 => "Jun", - 6 => "Jul", - 7 => "Aug", - 8 => "Sep", - 9 => "Oct", - 10 => "Nov", - 11 => "Dec", - _ => return die() - }, - 'C' => return write!(fmt, "{:02}", (tm.tm_year as int + 1900) / 100), - 'c' => { - try!(parse_type(fmt, 'a', tm)); - try!(' '.fmt(fmt)); - try!(parse_type(fmt, 'b', tm)); - try!(' '.fmt(fmt)); - try!(parse_type(fmt, 'e', tm)); - try!(' '.fmt(fmt)); - try!(parse_type(fmt, 'T', tm)); - try!(' '.fmt(fmt)); - return parse_type(fmt, 'Y', tm); - } - 'D' | 'x' => { - try!(parse_type(fmt, 'm', tm)); - try!('/'.fmt(fmt)); - try!(parse_type(fmt, 'd', tm)); - try!('/'.fmt(fmt)); - return parse_type(fmt, 'y', tm); - } - 'd' => return write!(fmt, "{:02}", tm.tm_mday), - 'e' => return write!(fmt, "{:2}", tm.tm_mday), - 'f' => return write!(fmt, "{:09}", tm.tm_nsec), - 'F' => { - try!(parse_type(fmt, 'Y', tm)); - try!('-'.fmt(fmt)); - try!(parse_type(fmt, 'm', tm)); - try!('-'.fmt(fmt)); - return parse_type(fmt, 'd', tm); - } - 'G' => return iso_week(fmt, 'G', tm), - 'g' => return iso_week(fmt, 'g', tm), - 'H' => return write!(fmt, "{:02}", tm.tm_hour), - 'I' => { - let mut h = tm.tm_hour; - if h == 0 { h = 12 } - if h > 12 { h -= 12 } - return write!(fmt, "{:02}", h) - } - 'j' => return write!(fmt, "{:03}", tm.tm_yday + 1), - 'k' => return write!(fmt, "{:2}", tm.tm_hour), - 'l' => { - let mut h = tm.tm_hour; - if h == 0 { h = 12 } - if h > 12 { h -= 12 } - return write!(fmt, "{:2}", h) - } - 'M' => return write!(fmt, "{:02}", tm.tm_min), - 'm' => return write!(fmt, "{:02}", tm.tm_mon + 1), - 'n' => "\n", - 'P' => if (tm.tm_hour as int) < 12 { "am" } else { "pm" }, - 'p' => if (tm.tm_hour as int) < 12 { "AM" } else { "PM" }, - 'R' => { - try!(parse_type(fmt, 'H', tm)); - try!(':'.fmt(fmt)); - return parse_type(fmt, 'M', tm); - } - 'r' => { - try!(parse_type(fmt, 'I', tm)); - try!(':'.fmt(fmt)); - try!(parse_type(fmt, 'M', tm)); - try!(':'.fmt(fmt)); - try!(parse_type(fmt, 'S', tm)); - try!(' '.fmt(fmt)); - return parse_type(fmt, 'p', tm); - } - 'S' => return write!(fmt, "{:02}", tm.tm_sec), - 's' => return write!(fmt, "{}", tm.to_timespec().sec), - 'T' | 'X' => { - try!(parse_type(fmt, 'H', tm)); - try!(':'.fmt(fmt)); - try!(parse_type(fmt, 'M', tm)); - try!(':'.fmt(fmt)); - return parse_type(fmt, 'S', tm); - } - 't' => "\t", - 'U' => return write!(fmt, "{:02}", (tm.tm_yday - tm.tm_wday + 7) / 7), - 'u' => { - let i = tm.tm_wday as int; - return (if i == 0 { 7 } else { i }).fmt(fmt); - } - 'V' => return iso_week(fmt, 'V', tm), - 'v' => { - try!(parse_type(fmt, 'e', tm)); - try!('-'.fmt(fmt)); - try!(parse_type(fmt, 'b', tm)); - try!('-'.fmt(fmt)); - return parse_type(fmt, 'Y', tm); - } - 'W' => { - return write!(fmt, "{:02}", - (tm.tm_yday - (tm.tm_wday - 1 + 7) % 7 + 7) / 7) - } - 'w' => return (tm.tm_wday as int).fmt(fmt), - 'Y' => return (tm.tm_year as int + 1900).fmt(fmt), - 'y' => return write!(fmt, "{:02}", (tm.tm_year as int + 1900) % 100), - 'Z' => if tm.tm_gmtoff == 0_i32 { "GMT"} else { "" }, // FIXME (#2350): support locale - 'z' => { - let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' }; - let mut m = tm.tm_gmtoff.abs() / 60_i32; - let h = m / 60_i32; - m -= h * 60_i32; - return write!(fmt, "{}{:02}{:02}", sign, h, m); - } - '+' => return tm.rfc3339().fmt(fmt), - '%' => "%", - _ => return die() - }.fmt(fmt) - } - - match self.format { - FmtStr(ref s) => { - let mut chars = s.chars(); - loop { - match chars.next() { - Some('%') => { - // we've already validated that % always precedes another char - try!(parse_type(fmt, chars.next().unwrap(), self.tm)); - } - Some(ch) => try!(ch.fmt(fmt)), - None => break, - } - } - - Ok(()) - } - FmtCtime => { - self.tm.to_local().asctime().fmt(fmt) - } - FmtRfc3339 => { - if self.tm.tm_gmtoff == 0_i32 { - TmFmt { - tm: self.tm, - format: FmtStr("%Y-%m-%dT%H:%M:%SZ"), - }.fmt(fmt) - } else { - let s = TmFmt { - tm: self.tm, - format: FmtStr("%Y-%m-%dT%H:%M:%S"), - }; - let sign = if self.tm.tm_gmtoff > 0_i32 { '+' } else { '-' }; - let mut m = self.tm.tm_gmtoff.abs() / 60_i32; - let h = m / 60_i32; - m -= h * 60_i32; - write!(fmt, "{}{}{:02}:{:02}", s, sign, h as int, m as int) - } - } - } - } -} - -/// Parses the time from the string according to the format string. -pub fn strptime(s: &str, format: &str) -> Result<Tm, ParseError> { - fn match_str(s: &str, pos: uint, needle: &str) -> bool { - s.slice_from(pos).starts_with(needle) - } - - fn match_strs(ss: &str, pos: uint, strs: &[(&str, i32)]) - -> Option<(i32, uint)> { - for &(needle, value) in strs.iter() { - if match_str(ss, pos, needle) { - return Some((value, pos + needle.len())); - } - } - - None - } - - fn match_digits(ss: &str, pos: uint, digits: uint, ws: bool) - -> Option<(i32, uint)> { - let mut pos = pos; - let len = ss.len(); - let mut value = 0_i32; - - let mut i = 0u; - while i < digits { - if pos >= len { - return None; - } - let range = ss.char_range_at(pos); - pos = range.next; - - match range.ch { - '0' ... '9' => { - value = value * 10_i32 + (range.ch as i32 - '0' as i32); - } - ' ' if ws => (), - _ => return None - } - i += 1u; - } - - Some((value, pos)) - } - - fn match_fractional_seconds(ss: &str, pos: uint) -> (i32, uint) { - let len = ss.len(); - let mut value = 0_i32; - let mut multiplier = NSEC_PER_SEC / 10; - let mut pos = pos; - - loop { - if pos >= len { - break; - } - let range = ss.char_range_at(pos); - - match range.ch { - '0' ... '9' => { - pos = range.next; - // This will drop digits after the nanoseconds place - let digit = range.ch as i32 - '0' as i32; - value += digit * multiplier; - multiplier /= 10; - } - _ => break - } - } - - (value, pos) - } - - fn match_digits_in_range(ss: &str, pos: uint, digits: uint, ws: bool, - min: i32, max: i32) -> Option<(i32, uint)> { - match match_digits(ss, pos, digits, ws) { - Some((val, pos)) if val >= min && val <= max => { - Some((val, pos)) - } - _ => None - } - } - - fn parse_char(s: &str, pos: uint, c: char) -> Result<uint, ParseError> { - let range = s.char_range_at(pos); - - if c == range.ch { - Ok(range.next) - } else { - Err(UnexpectedCharacter(c, range.ch)) - } - } - - fn parse_type(s: &str, pos: uint, ch: char, tm: &mut Tm) - -> Result<uint, ParseError> { - match ch { - 'A' => match match_strs(s, pos, &[ - ("Sunday", 0_i32), - ("Monday", 1_i32), - ("Tuesday", 2_i32), - ("Wednesday", 3_i32), - ("Thursday", 4_i32), - ("Friday", 5_i32), - ("Saturday", 6_i32) - ]) { - Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) } - None => Err(InvalidDay) - }, - 'a' => match match_strs(s, pos, &[ - ("Sun", 0_i32), - ("Mon", 1_i32), - ("Tue", 2_i32), - ("Wed", 3_i32), - ("Thu", 4_i32), - ("Fri", 5_i32), - ("Sat", 6_i32) - ]) { - Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) } - None => Err(InvalidDay) - }, - 'B' => match match_strs(s, pos, &[ - ("January", 0_i32), - ("February", 1_i32), - ("March", 2_i32), - ("April", 3_i32), - ("May", 4_i32), - ("June", 5_i32), - ("July", 6_i32), - ("August", 7_i32), - ("September", 8_i32), - ("October", 9_i32), - ("November", 10_i32), - ("December", 11_i32) - ]) { - Some(item) => { let (v, pos) = item; tm.tm_mon = v; Ok(pos) } - None => Err(InvalidMonth) - }, - 'b' | 'h' => match match_strs(s, pos, &[ - ("Jan", 0_i32), - ("Feb", 1_i32), - ("Mar", 2_i32), - ("Apr", 3_i32), - ("May", 4_i32), - ("Jun", 5_i32), - ("Jul", 6_i32), - ("Aug", 7_i32), - ("Sep", 8_i32), - ("Oct", 9_i32), - ("Nov", 10_i32), - ("Dec", 11_i32) - ]) { - Some(item) => { let (v, pos) = item; tm.tm_mon = v; Ok(pos) } - None => Err(InvalidMonth) - }, - 'C' => match match_digits_in_range(s, pos, 2u, false, 0_i32, - 99_i32) { - Some(item) => { - let (v, pos) = item; - tm.tm_year += (v * 100_i32) - 1900_i32; - Ok(pos) - } - None => Err(InvalidYear) - }, - 'c' => { - parse_type(s, pos, 'a', &mut *tm) - .and_then(|pos| parse_char(s, pos, ' ')) - .and_then(|pos| parse_type(s, pos, 'b', &mut *tm)) - .and_then(|pos| parse_char(s, pos, ' ')) - .and_then(|pos| parse_type(s, pos, 'e', &mut *tm)) - .and_then(|pos| parse_char(s, pos, ' ')) - .and_then(|pos| parse_type(s, pos, 'T', &mut *tm)) - .and_then(|pos| parse_char(s, pos, ' ')) - .and_then(|pos| parse_type(s, pos, 'Y', &mut *tm)) - } - 'D' | 'x' => { - parse_type(s, pos, 'm', &mut *tm) - .and_then(|pos| parse_char(s, pos, '/')) - .and_then(|pos| parse_type(s, pos, 'd', &mut *tm)) - .and_then(|pos| parse_char(s, pos, '/')) - .and_then(|pos| parse_type(s, pos, 'y', &mut *tm)) - } - 'd' => match match_digits_in_range(s, pos, 2u, false, 1_i32, - 31_i32) { - Some(item) => { let (v, pos) = item; tm.tm_mday = v; Ok(pos) } - None => Err(InvalidDayOfMonth) - }, - 'e' => match match_digits_in_range(s, pos, 2u, true, 1_i32, - 31_i32) { - Some(item) => { let (v, pos) = item; tm.tm_mday = v; Ok(pos) } - None => Err(InvalidDayOfMonth) - }, - 'f' => { - let (val, pos) = match_fractional_seconds(s, pos); - tm.tm_nsec = val; - Ok(pos) - } - 'F' => { - parse_type(s, pos, 'Y', &mut *tm) - .and_then(|pos| parse_char(s, pos, '-')) - .and_then(|pos| parse_type(s, pos, 'm', &mut *tm)) - .and_then(|pos| parse_char(s, pos, '-')) - .and_then(|pos| parse_type(s, pos, 'd', &mut *tm)) - } - 'H' => { - match match_digits_in_range(s, pos, 2u, false, 0_i32, 23_i32) { - Some(item) => { let (v, pos) = item; tm.tm_hour = v; Ok(pos) } - None => Err(InvalidHour) - } - } - 'I' => { - match match_digits_in_range(s, pos, 2u, false, 1_i32, 12_i32) { - Some(item) => { - let (v, pos) = item; - tm.tm_hour = if v == 12_i32 { 0_i32 } else { v }; - Ok(pos) - } - None => Err(InvalidHour) - } - } - 'j' => { - match match_digits_in_range(s, pos, 3u, false, 1_i32, 366_i32) { - Some(item) => { - let (v, pos) = item; - tm.tm_yday = v - 1_i32; - Ok(pos) - } - None => Err(InvalidDayOfYear) - } - } - 'k' => { - match match_digits_in_range(s, pos, 2u, true, 0_i32, 23_i32) { - Some(item) => { let (v, pos) = item; tm.tm_hour = v; Ok(pos) } - None => Err(InvalidHour) - } - } - 'l' => { - match match_digits_in_range(s, pos, 2u, true, 1_i32, 12_i32) { - Some(item) => { - let (v, pos) = item; - tm.tm_hour = if v == 12_i32 { 0_i32 } else { v }; - Ok(pos) - } - None => Err(InvalidHour) - } - } - 'M' => { - match match_digits_in_range(s, pos, 2u, false, 0_i32, 59_i32) { - Some(item) => { let (v, pos) = item; tm.tm_min = v; Ok(pos) } - None => Err(InvalidMinute) - } - } - 'm' => { - match match_digits_in_range(s, pos, 2u, false, 1_i32, 12_i32) { - Some(item) => { - let (v, pos) = item; - tm.tm_mon = v - 1_i32; - Ok(pos) - } - None => Err(InvalidMonth) - } - } - 'n' => parse_char(s, pos, '\n'), - 'P' => match match_strs(s, pos, - &[("am", 0_i32), ("pm", 12_i32)]) { - - Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) } - None => Err(InvalidHour) - }, - 'p' => match match_strs(s, pos, - &[("AM", 0_i32), ("PM", 12_i32)]) { - - Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) } - None => Err(InvalidHour) - }, - 'R' => { - parse_type(s, pos, 'H', &mut *tm) - .and_then(|pos| parse_char(s, pos, ':')) - .and_then(|pos| parse_type(s, pos, 'M', &mut *tm)) - } - 'r' => { - parse_type(s, pos, 'I', &mut *tm) - .and_then(|pos| parse_char(s, pos, ':')) - .and_then(|pos| parse_type(s, pos, 'M', &mut *tm)) - .and_then(|pos| parse_char(s, pos, ':')) - .and_then(|pos| parse_type(s, pos, 'S', &mut *tm)) - .and_then(|pos| parse_char(s, pos, ' ')) - .and_then(|pos| parse_type(s, pos, 'p', &mut *tm)) - } - 'S' => { - match match_digits_in_range(s, pos, 2u, false, 0_i32, 60_i32) { - Some(item) => { - let (v, pos) = item; - tm.tm_sec = v; - Ok(pos) - } - None => Err(InvalidSecond) - } - } - //'s' {} - 'T' | 'X' => { - parse_type(s, pos, 'H', &mut *tm) - .and_then(|pos| parse_char(s, pos, ':')) - .and_then(|pos| parse_type(s, pos, 'M', &mut *tm)) - .and_then(|pos| parse_char(s, pos, ':')) - .and_then(|pos| parse_type(s, pos, 'S', &mut *tm)) - } - 't' => parse_char(s, pos, '\t'), - 'u' => { - match match_digits_in_range(s, pos, 1u, false, 1_i32, 7_i32) { - Some(item) => { - let (v, pos) = item; - tm.tm_wday = if v == 7 { 0 } else { v }; - Ok(pos) - } - None => Err(InvalidDayOfWeek) - } - } - 'v' => { - parse_type(s, pos, 'e', &mut *tm) - .and_then(|pos| parse_char(s, pos, '-')) - .and_then(|pos| parse_type(s, pos, 'b', &mut *tm)) - .and_then(|pos| parse_char(s, pos, '-')) - .and_then(|pos| parse_type(s, pos, 'Y', &mut *tm)) - } - //'W' {} - 'w' => { - match match_digits_in_range(s, pos, 1u, false, 0_i32, 6_i32) { - Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) } - None => Err(InvalidDayOfWeek) - } - } - 'Y' => { - match match_digits(s, pos, 4u, false) { - Some(item) => { - let (v, pos) = item; - tm.tm_year = v - 1900_i32; - Ok(pos) - } - None => Err(InvalidYear) - } - } - 'y' => { - match match_digits_in_range(s, pos, 2u, false, 0_i32, 99_i32) { - Some(item) => { - let (v, pos) = item; - tm.tm_year = v; - Ok(pos) - } - None => Err(InvalidYear) - } - } - 'Z' => { - if match_str(s, pos, "UTC") || match_str(s, pos, "GMT") { - tm.tm_gmtoff = 0_i32; - Ok(pos + 3u) - } else { - // It's odd, but to maintain compatibility with c's - // strptime we ignore the timezone. - let mut pos = pos; - let len = s.len(); - while pos < len { - let range = s.char_range_at(pos); - pos = range.next; - if range.ch == ' ' { break; } - } - - Ok(pos) - } - } - 'z' => { - let range = s.char_range_at(pos); - - if range.ch == '+' || range.ch == '-' { - match match_digits(s, range.next, 4u, false) { - Some(item) => { - let (v, pos) = item; - if v == 0_i32 { - tm.tm_gmtoff = 0_i32; - } - - Ok(pos) - } - None => Err(InvalidZoneOffset) - } - } else { - Err(InvalidZoneOffset) - } - } - '%' => parse_char(s, pos, '%'), - ch => Err(InvalidFormatSpecifier(ch)) - } - } - - let mut rdr: &[u8] = format.as_bytes(); - let mut tm = Tm { - tm_sec: 0_i32, - tm_min: 0_i32, - tm_hour: 0_i32, - tm_mday: 0_i32, - tm_mon: 0_i32, - tm_year: 0_i32, - tm_wday: 0_i32, - tm_yday: 0_i32, - tm_isdst: 0_i32, - tm_gmtoff: 0_i32, - tm_nsec: 0_i32, - }; - let mut pos = 0u; - let len = s.len(); - let mut result = Err(InvalidTime); - - while pos < len { - let range = s.char_range_at(pos); - let ch = range.ch; - let next = range.next; - - let mut buf = [0]; - let c = match (&mut rdr).read(&mut buf) { - Ok(..) => buf[0] as char, - Err(..) => break - }; - match c { - '%' => { - let ch = match (&mut rdr).read(&mut buf) { - Ok(..) => buf[0] as char, - Err(..) => break - }; - match parse_type(s, pos, ch, &mut tm) { - Ok(next) => pos = next, - Err(e) => { result = Err(e); break; } - } - }, - c => { - if c != ch { break } - pos = next; - } - } - } - - if pos == len && (&mut rdr).is_empty() { - Ok(Tm { - tm_sec: tm.tm_sec, - tm_min: tm.tm_min, - tm_hour: tm.tm_hour, - tm_mday: tm.tm_mday, - tm_mon: tm.tm_mon, - tm_year: tm.tm_year, - tm_wday: tm.tm_wday, - tm_yday: tm.tm_yday, - tm_isdst: tm.tm_isdst, - tm_gmtoff: tm.tm_gmtoff, - tm_nsec: tm.tm_nsec, - }) - } else { result } -} - -/// Formats the time according to the format string. -pub fn strftime(format: &str, tm: &Tm) -> Result<String, ParseError> { - tm.strftime(format).map(|fmt| fmt.to_string()) -} - -#[cfg(test)] -mod tests { - extern crate test; - use super::{Timespec, InvalidTime, InvalidYear, get_time, precise_time_ns, - precise_time_s, tzset, at_utc, at, strptime, MissingFormatConverter, - InvalidFormatSpecifier}; - - use std::f64; - use std::result::Result::{Err, Ok}; - use std::time::Duration; - use self::test::Bencher; - - #[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. - extern { - fn _putenv(envstring: *const libc::c_char) -> libc::c_int; - } - - unsafe { - // Windows does not understand "America/Los_Angeles". - // PST+08 may look wrong, but not! "PST" indicates - // the name of timezone. "+08" means UTC = local + 08. - "TZ=PST+08".with_c_str(|env| { - _putenv(env); - }) - } - tzset(); - } - #[cfg(not(windows))] - fn set_time_zone() { - use std::os; - os::setenv("TZ", "America/Los_Angeles"); - tzset(); - } - - fn test_get_time() { - static SOME_RECENT_DATE: i64 = 1325376000i64; // 2012-01-01T00:00:00Z - static SOME_FUTURE_DATE: i64 = 1577836800i64; // 2020-01-01T00:00:00Z - - let tv1 = get_time(); - debug!("tv1={} sec + {} nsec", tv1.sec as uint, tv1.nsec as uint); - - assert!(tv1.sec > SOME_RECENT_DATE); - assert!(tv1.nsec < 1000000000i32); - - let tv2 = get_time(); - debug!("tv2={} sec + {} nsec", tv2.sec as uint, tv2.nsec as uint); - - assert!(tv2.sec >= tv1.sec); - assert!(tv2.sec < SOME_FUTURE_DATE); - assert!(tv2.nsec < 1000000000i32); - if tv2.sec == tv1.sec { - assert!(tv2.nsec >= tv1.nsec); - } - } - - fn test_precise_time() { - let s0 = precise_time_s(); - debug!("s0={} sec", f64::to_str_digits(s0, 9u)); - assert!(s0 > 0.); - - let ns0 = precise_time_ns(); - let ns1 = precise_time_ns(); - debug!("ns0={} ns", ns0); - debug!("ns1={} ns", ns1); - assert!(ns1 >= ns0); - - let ns2 = precise_time_ns(); - debug!("ns2={} ns", ns2); - assert!(ns2 >= ns1); - } - - fn test_at_utc() { - set_time_zone(); - - let time = Timespec::new(1234567890, 54321); - let utc = at_utc(time); - - assert_eq!(utc.tm_sec, 30_i32); - assert_eq!(utc.tm_min, 31_i32); - assert_eq!(utc.tm_hour, 23_i32); - assert_eq!(utc.tm_mday, 13_i32); - assert_eq!(utc.tm_mon, 1_i32); - assert_eq!(utc.tm_year, 109_i32); - assert_eq!(utc.tm_wday, 5_i32); - assert_eq!(utc.tm_yday, 43_i32); - assert_eq!(utc.tm_isdst, 0_i32); - assert_eq!(utc.tm_gmtoff, 0_i32); - assert_eq!(utc.tm_nsec, 54321_i32); - } - - fn test_at() { - set_time_zone(); - - let time = Timespec::new(1234567890, 54321); - let local = at(time); - - debug!("time_at: {}", local); - - assert_eq!(local.tm_sec, 30_i32); - assert_eq!(local.tm_min, 31_i32); - assert_eq!(local.tm_hour, 15_i32); - assert_eq!(local.tm_mday, 13_i32); - assert_eq!(local.tm_mon, 1_i32); - assert_eq!(local.tm_year, 109_i32); - assert_eq!(local.tm_wday, 5_i32); - assert_eq!(local.tm_yday, 43_i32); - assert_eq!(local.tm_isdst, 0_i32); - assert_eq!(local.tm_gmtoff, -28800_i32); - assert_eq!(local.tm_nsec, 54321_i32); - } - - fn test_to_timespec() { - set_time_zone(); - - let time = Timespec::new(1234567890, 54321); - let utc = at_utc(time); - - assert_eq!(utc.to_timespec(), time); - assert_eq!(utc.to_local().to_timespec(), time); - } - - fn test_conversions() { - set_time_zone(); - - let time = Timespec::new(1234567890, 54321); - let utc = at_utc(time); - let local = at(time); - - assert!(local.to_local() == local); - assert!(local.to_utc() == utc); - assert!(local.to_utc().to_local() == local); - assert!(utc.to_utc() == utc); - assert!(utc.to_local() == local); - assert!(utc.to_local().to_utc() == utc); - } - - fn test_strptime() { - set_time_zone(); - - match strptime("", "") { - Ok(ref tm) => { - assert!(tm.tm_sec == 0_i32); - assert!(tm.tm_min == 0_i32); - assert!(tm.tm_hour == 0_i32); - assert!(tm.tm_mday == 0_i32); - assert!(tm.tm_mon == 0_i32); - assert!(tm.tm_year == 0_i32); - assert!(tm.tm_wday == 0_i32); - assert!(tm.tm_isdst == 0_i32); - assert!(tm.tm_gmtoff == 0_i32); - assert!(tm.tm_nsec == 0_i32); - } - Err(_) => () - } - - let format = "%a %b %e %T.%f %Y"; - assert_eq!(strptime("", format), Err(InvalidTime)); - assert!(strptime("Fri Feb 13 15:31:30", format) - == Err(InvalidTime)); - - match strptime("Fri Feb 13 15:31:30.01234 2009", format) { - Err(e) => panic!(e), - Ok(ref tm) => { - assert!(tm.tm_sec == 30_i32); - assert!(tm.tm_min == 31_i32); - assert!(tm.tm_hour == 15_i32); - assert!(tm.tm_mday == 13_i32); - assert!(tm.tm_mon == 1_i32); - assert!(tm.tm_year == 109_i32); - assert!(tm.tm_wday == 5_i32); - assert!(tm.tm_yday == 0_i32); - assert!(tm.tm_isdst == 0_i32); - assert!(tm.tm_gmtoff == 0_i32); - assert!(tm.tm_nsec == 12340000_i32); - } - } - - fn test(s: &str, format: &str) -> bool { - match strptime(s, format) { - Ok(ref tm) => { - tm.strftime(format).unwrap().to_string() == s.to_string() - }, - Err(e) => panic!(e) - } - } - - let days = [ - "Sunday".to_string(), - "Monday".to_string(), - "Tuesday".to_string(), - "Wednesday".to_string(), - "Thursday".to_string(), - "Friday".to_string(), - "Saturday".to_string() - ]; - for day in days.iter() { - assert!(test(day.as_slice(), "%A")); - } - - let days = [ - "Sun".to_string(), - "Mon".to_string(), - "Tue".to_string(), - "Wed".to_string(), - "Thu".to_string(), - "Fri".to_string(), - "Sat".to_string() - ]; - for day in days.iter() { - assert!(test(day.as_slice(), "%a")); - } - - let months = [ - "January".to_string(), - "February".to_string(), - "March".to_string(), - "April".to_string(), - "May".to_string(), - "June".to_string(), - "July".to_string(), - "August".to_string(), - "September".to_string(), - "October".to_string(), - "November".to_string(), - "December".to_string() - ]; - for day in months.iter() { - assert!(test(day.as_slice(), "%B")); - } - - let months = [ - "Jan".to_string(), - "Feb".to_string(), - "Mar".to_string(), - "Apr".to_string(), - "May".to_string(), - "Jun".to_string(), - "Jul".to_string(), - "Aug".to_string(), - "Sep".to_string(), - "Oct".to_string(), - "Nov".to_string(), - "Dec".to_string() - ]; - for day in months.iter() { - assert!(test(day.as_slice(), "%b")); - } - - assert!(test("19", "%C")); - assert!(test("Fri Feb 13 23:31:30 2009", "%c")); - assert!(test("02/13/09", "%D")); - assert!(test("03", "%d")); - assert!(test("13", "%d")); - assert!(test(" 3", "%e")); - assert!(test("13", "%e")); - assert!(test("2009-02-13", "%F")); - assert!(test("03", "%H")); - assert!(test("13", "%H")); - assert!(test("03", "%I")); // FIXME (#2350): flesh out - assert!(test("11", "%I")); // FIXME (#2350): flesh out - assert!(test("044", "%j")); - assert!(test(" 3", "%k")); - assert!(test("13", "%k")); - assert!(test(" 1", "%l")); - assert!(test("11", "%l")); - assert!(test("03", "%M")); - assert!(test("13", "%M")); - assert!(test("\n", "%n")); - assert!(test("am", "%P")); - assert!(test("pm", "%P")); - assert!(test("AM", "%p")); - assert!(test("PM", "%p")); - assert!(test("23:31", "%R")); - assert!(test("11:31:30 AM", "%r")); - assert!(test("11:31:30 PM", "%r")); - assert!(test("03", "%S")); - assert!(test("13", "%S")); - assert!(test("15:31:30", "%T")); - assert!(test("\t", "%t")); - assert!(test("1", "%u")); - assert!(test("7", "%u")); - assert!(test("13-Feb-2009", "%v")); - assert!(test("0", "%w")); - assert!(test("6", "%w")); - assert!(test("2009", "%Y")); - assert!(test("09", "%y")); - assert!(strptime("-0000", "%z").unwrap().tm_gmtoff == - 0); - assert!(strptime("-0800", "%z").unwrap().tm_gmtoff == - 0); - assert!(test("%", "%%")); - - // Test for #7256 - assert_eq!(strptime("360", "%Y-%m-%d"), Err(InvalidYear)); - } - - fn test_asctime() { - set_time_zone(); - - let time = Timespec::new(1234567890, 54321); - let utc = at_utc(time); - let local = at(time); - - debug!("test_ctime: {} {}", utc.asctime(), local.asctime()); - - assert_eq!(utc.asctime().to_string(), "Fri Feb 13 23:31:30 2009"); - assert_eq!(local.asctime().to_string(), "Fri Feb 13 15:31:30 2009"); - } - - fn test_ctime() { - set_time_zone(); - - let time = Timespec::new(1234567890, 54321); - let utc = at_utc(time); - let local = at(time); - - debug!("test_ctime: {} {}", utc.ctime(), local.ctime()); - - assert_eq!(utc.ctime().to_string(), "Fri Feb 13 15:31:30 2009"); - assert_eq!(local.ctime().to_string(), "Fri Feb 13 15:31:30 2009"); - } - - fn test_strftime() { - set_time_zone(); - - let time = Timespec::new(1234567890, 54321); - let utc = at_utc(time); - let local = at(time); - - assert_eq!(local.strftime("").unwrap().to_string(), ""); - assert_eq!(local.strftime("%A").unwrap().to_string(), "Friday"); - assert_eq!(local.strftime("%a").unwrap().to_string(), "Fri"); - assert_eq!(local.strftime("%B").unwrap().to_string(), "February"); - assert_eq!(local.strftime("%b").unwrap().to_string(), "Feb"); - assert_eq!(local.strftime("%C").unwrap().to_string(), "20"); - assert_eq!(local.strftime("%c").unwrap().to_string(), - "Fri Feb 13 15:31:30 2009"); - assert_eq!(local.strftime("%D").unwrap().to_string(), "02/13/09"); - assert_eq!(local.strftime("%d").unwrap().to_string(), "13"); - assert_eq!(local.strftime("%e").unwrap().to_string(), "13"); - assert_eq!(local.strftime("%F").unwrap().to_string(), "2009-02-13"); - assert_eq!(local.strftime("%f").unwrap().to_string(), "000054321"); - assert_eq!(local.strftime("%G").unwrap().to_string(), "2009"); - assert_eq!(local.strftime("%g").unwrap().to_string(), "09"); - assert_eq!(local.strftime("%H").unwrap().to_string(), "15"); - assert_eq!(local.strftime("%h").unwrap().to_string(), "Feb"); - assert_eq!(local.strftime("%I").unwrap().to_string(), "03"); - assert_eq!(local.strftime("%j").unwrap().to_string(), "044"); - assert_eq!(local.strftime("%k").unwrap().to_string(), "15"); - assert_eq!(local.strftime("%l").unwrap().to_string(), " 3"); - assert_eq!(local.strftime("%M").unwrap().to_string(), "31"); - assert_eq!(local.strftime("%m").unwrap().to_string(), "02"); - assert_eq!(local.strftime("%n").unwrap().to_string(), "\n"); - assert_eq!(local.strftime("%P").unwrap().to_string(), "pm"); - assert_eq!(local.strftime("%p").unwrap().to_string(), "PM"); - assert_eq!(local.strftime("%R").unwrap().to_string(), "15:31"); - assert_eq!(local.strftime("%r").unwrap().to_string(), "03:31:30 PM"); - assert_eq!(local.strftime("%S").unwrap().to_string(), "30"); - assert_eq!(local.strftime("%s").unwrap().to_string(), "1234567890"); - assert_eq!(local.strftime("%T").unwrap().to_string(), "15:31:30"); - assert_eq!(local.strftime("%t").unwrap().to_string(), "\t"); - assert_eq!(local.strftime("%U").unwrap().to_string(), "06"); - assert_eq!(local.strftime("%u").unwrap().to_string(), "5"); - assert_eq!(local.strftime("%V").unwrap().to_string(), "07"); - assert_eq!(local.strftime("%v").unwrap().to_string(), "13-Feb-2009"); - assert_eq!(local.strftime("%W").unwrap().to_string(), "06"); - assert_eq!(local.strftime("%w").unwrap().to_string(), "5"); - // FIXME (#2350): support locale - assert_eq!(local.strftime("%X").unwrap().to_string(), "15:31:30"); - // FIXME (#2350): support locale - assert_eq!(local.strftime("%x").unwrap().to_string(), "02/13/09"); - assert_eq!(local.strftime("%Y").unwrap().to_string(), "2009"); - assert_eq!(local.strftime("%y").unwrap().to_string(), "09"); - // FIXME (#2350): support locale - assert_eq!(local.strftime("%Z").unwrap().to_string(), ""); - assert_eq!(local.strftime("%z").unwrap().to_string(), "-0800"); - assert_eq!(local.strftime("%+").unwrap().to_string(), - "2009-02-13T15:31:30-08:00"); - assert_eq!(local.strftime("%%").unwrap().to_string(), "%"); - - let invalid_specifiers = ["%E", "%J", "%K", "%L", "%N", "%O", "%o", "%Q", "%q"]; - for &sp in invalid_specifiers.iter() { - assert_eq!(local.strftime(sp).unwrap_err(), InvalidFormatSpecifier(sp.char_at(1))); - } - assert_eq!(local.strftime("%").unwrap_err(), MissingFormatConverter); - assert_eq!(local.strftime("%A %").unwrap_err(), MissingFormatConverter); - - assert_eq!(local.asctime().to_string(), "Fri Feb 13 15:31:30 2009"); - assert_eq!(local.ctime().to_string(), "Fri Feb 13 15:31:30 2009"); - assert_eq!(local.rfc822z().to_string(), "Fri, 13 Feb 2009 15:31:30 -0800"); - assert_eq!(local.rfc3339().to_string(), "2009-02-13T15:31:30-08:00"); - - assert_eq!(utc.asctime().to_string(), "Fri Feb 13 23:31:30 2009"); - assert_eq!(utc.ctime().to_string(), "Fri Feb 13 15:31:30 2009"); - assert_eq!(utc.rfc822().to_string(), "Fri, 13 Feb 2009 23:31:30 GMT"); - assert_eq!(utc.rfc822z().to_string(), "Fri, 13 Feb 2009 23:31:30 -0000"); - assert_eq!(utc.rfc3339().to_string(), "2009-02-13T23:31:30Z"); - } - - fn test_timespec_eq_ord() { - let a = &Timespec::new(-2, 1); - let b = &Timespec::new(-1, 2); - let c = &Timespec::new(1, 2); - let d = &Timespec::new(2, 1); - let e = &Timespec::new(2, 1); - - assert!(d.eq(e)); - assert!(c.ne(e)); - - assert!(a.lt(b)); - assert!(b.lt(c)); - assert!(c.lt(d)); - - assert!(a.le(b)); - assert!(b.le(c)); - assert!(c.le(d)); - assert!(d.le(e)); - assert!(e.le(d)); - - assert!(b.ge(a)); - assert!(c.ge(b)); - assert!(d.ge(c)); - assert!(e.ge(d)); - assert!(d.ge(e)); - - assert!(b.gt(a)); - assert!(c.gt(b)); - assert!(d.gt(c)); - } - - fn test_timespec_add() { - let a = Timespec::new(1, 2); - let b = Duration::seconds(2) + Duration::nanoseconds(3); - let c = a + b; - assert_eq!(c.sec, 3); - assert_eq!(c.nsec, 5); - - let p = Timespec::new(1, super::NSEC_PER_SEC - 2); - let q = Duration::seconds(2) + Duration::nanoseconds(2); - let r = p + q; - assert_eq!(r.sec, 4); - assert_eq!(r.nsec, 0); - - let u = Timespec::new(1, super::NSEC_PER_SEC - 2); - let v = Duration::seconds(2) + Duration::nanoseconds(3); - let w = u + v; - assert_eq!(w.sec, 4); - assert_eq!(w.nsec, 1); - - let k = Timespec::new(1, 0); - let l = Duration::nanoseconds(-1); - let m = k + l; - assert_eq!(m.sec, 0); - assert_eq!(m.nsec, 999_999_999); - } - - fn test_timespec_sub() { - let a = Timespec::new(2, 3); - let b = Timespec::new(1, 2); - let c = a - b; - assert_eq!(c.num_nanoseconds(), Some(super::NSEC_PER_SEC as i64 + 1)); - - let p = Timespec::new(2, 0); - let q = Timespec::new(1, 2); - let r = p - q; - assert_eq!(r.num_nanoseconds(), Some(super::NSEC_PER_SEC as i64 - 2)); - - let u = Timespec::new(1, 2); - let v = Timespec::new(2, 3); - let w = u - v; - assert_eq!(w.num_nanoseconds(), Some(-super::NSEC_PER_SEC as i64 - 1)); - } - - #[test] - #[cfg_attr(target_os = "android", ignore)] // FIXME #10958 - fn run_tests() { - // The tests race on tzset. So instead of having many independent - // tests, we will just call the functions now. - test_get_time(); - test_precise_time(); - test_at_utc(); - test_at(); - test_to_timespec(); - test_conversions(); - test_strptime(); - test_asctime(); - test_ctime(); - test_strftime(); - test_timespec_eq_ord(); - test_timespec_add(); - test_timespec_sub(); - } - - #[bench] - fn bench_precise_time_ns(b: &mut Bencher) { - b.iter(|| precise_time_ns()) - } -} diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs index c530c950b1f6a..72e9ce2bcafe6 100644 --- a/src/libunicode/lib.rs +++ b/src/libunicode/lib.rs @@ -58,19 +58,16 @@ mod u_str; /// however the converse is not always true due to the above range limits /// and, as such, should be performed via the `from_u32` function.. pub mod char { - pub use core::char::{MAX, from_u32, is_digit_radix, to_digit}; - pub use core::char::{from_digit, escape_unicode, escape_default}; - pub use core::char::{len_utf8_bytes, Char}; + pub use core::char::{MAX, from_u32}; + pub use core::char::{from_digit}; + pub use core::char::Char; pub use normalize::{decompose_canonical, decompose_compatible, compose}; pub use tables::normalization::canonical_combining_class; pub use tables::UNICODE_VERSION; - pub use u_char::{is_alphabetic, is_XID_start, is_XID_continue}; - pub use u_char::{is_lowercase, is_uppercase, is_whitespace}; - pub use u_char::{is_alphanumeric, is_control, is_digit}; - pub use u_char::{to_uppercase, to_lowercase, width, UnicodeChar}; + pub use u_char::UnicodeChar; } pub mod str { diff --git a/src/libunicode/u_char.rs b/src/libunicode/u_char.rs index a73dac1a61866..9c356801604dd 100644 --- a/src/libunicode/u_char.rs +++ b/src/libunicode/u_char.rs @@ -16,141 +16,6 @@ use core::option::Option; use tables::{derived_property, property, general_category, conversions, charwidth}; -/// Returns whether the specified `char` is considered a Unicode alphabetic -/// code point -#[deprecated = "use UnicodeChar::is_alphabetic"] -pub fn is_alphabetic(c: char) -> bool { - c.is_alphabetic() -} - -/// Returns whether the specified `char` satisfies the 'XID_Start' Unicode property -/// -/// 'XID_Start' is a Unicode Derived Property specified in -/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), -/// mostly similar to ID_Start but modified for closure under NFKx. -#[allow(non_snake_case)] -#[deprecated = "use UnicodeChar::is_XID_start"] -pub fn is_XID_start(c: char) -> bool { derived_property::XID_Start(c) } - -/// Returns whether the specified `char` satisfies the 'XID_Continue' Unicode property -/// -/// 'XID_Continue' is a Unicode Derived Property specified in -/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), -/// mostly similar to 'ID_Continue' but modified for closure under NFKx. -#[allow(non_snake_case)] -#[deprecated = "use UnicodeChar::is_XID_continue"] -pub fn is_XID_continue(c: char) -> bool { derived_property::XID_Continue(c) } - -/// -/// Indicates whether a `char` is in lower case -/// -/// This is defined according to the terms of the Unicode Derived Core Property 'Lowercase'. -/// -#[inline] -#[deprecated = "use UnicodeChar::is_lowercase"] -pub fn is_lowercase(c: char) -> bool { - c.is_lowercase() -} - -/// -/// Indicates whether a `char` is in upper case -/// -/// This is defined according to the terms of the Unicode Derived Core Property 'Uppercase'. -/// -#[inline] -#[deprecated = "use UnicodeChar::is_uppercase"] -pub fn is_uppercase(c: char) -> bool { - c.is_uppercase() -} - -/// -/// Indicates whether a `char` is whitespace -/// -/// Whitespace is defined in terms of the Unicode Property 'White_Space'. -/// -#[inline] -#[deprecated = "use UnicodeChar::is_whitespace"] -pub fn is_whitespace(c: char) -> bool { - c.is_whitespace() -} - -/// -/// Indicates whether a `char` is alphanumeric -/// -/// Alphanumericness is defined in terms of the Unicode General Categories -/// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'. -/// -#[inline] -#[deprecated = "use UnicodeChar::is_alphanumeric"] -pub fn is_alphanumeric(c: char) -> bool { - c.is_alphanumeric() -} - -/// -/// Indicates whether a `char` is a control code point -/// -/// Control code points are defined in terms of the Unicode General Category -/// 'Cc'. -/// -#[inline] -#[deprecated = "use UnicodeChar::is_control"] -pub fn is_control(c: char) -> bool { general_category::Cc(c) } - -/// Indicates whether the `char` is numeric (Nd, Nl, or No) -#[inline] -#[deprecated = "use UnicodeChar::is_numeric"] -pub fn is_digit(c: char) -> bool { - c.is_numeric() -} - -/// Convert a char to its uppercase equivalent -/// -/// The case-folding performed is the common or simple mapping: -/// it maps one Unicode codepoint (one char in Rust) to its uppercase equivalent according -/// to the Unicode database at ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt -/// The additional SpecialCasing.txt is not considered here, as it expands to multiple -/// codepoints in some cases. -/// -/// A full reference can be found here -/// http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992 -/// -/// # Return value -/// -/// Returns the char itself if no conversion was made -#[inline] -#[deprecated = "use UnicodeChar::to_uppercase"] -pub fn to_uppercase(c: char) -> char { - conversions::to_upper(c) -} - -/// Convert a char to its lowercase equivalent -/// -/// The case-folding performed is the common or simple mapping -/// see `to_uppercase` for references and more information -/// -/// # Return value -/// -/// Returns the char itself if no conversion if possible -#[inline] -#[deprecated = "use UnicodeChar::to_lowercase"] -pub fn to_lowercase(c: char) -> char { - conversions::to_lower(c) -} - -/// Returns this character's displayed width in columns, or `None` if it is a -/// control character other than `'\x00'`. -/// -/// `is_cjk` determines behavior for characters in the Ambiguous category: -/// if `is_cjk` is `true`, these are 2 columns wide; otherwise, they are 1. -/// In CJK contexts, `is_cjk` should be `true`, else it should be `false`. -/// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) -/// recommends that these characters be treated as 1 column (i.e., -/// `is_cjk` = `false`) if the context cannot be reliably determined. -#[deprecated = "use UnicodeChar::width"] -pub fn width(c: char, is_cjk: bool) -> Option<uint> { - charwidth::width(c, is_cjk) -} - /// Useful functions for Unicode characters. #[experimental = "pending prelude organization"] pub trait UnicodeChar { @@ -158,16 +23,6 @@ pub trait UnicodeChar { /// alphabetic code point. fn is_alphabetic(self) -> bool; - /// Returns whether the specified character satisfies the 'XID_Start' - /// Unicode property. - /// - /// 'XID_Start' is a Unicode Derived Property specified in - /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), - /// mostly similar to ID_Start but modified for closure under NFKx. - #[allow(non_snake_case)] - #[deprecated = "use is_xid_start"] - fn is_XID_start(self) -> bool; - /// Returns whether the specified character satisfies the 'XID_Start' /// Unicode property. /// @@ -176,16 +31,6 @@ pub trait UnicodeChar { /// mostly similar to ID_Start but modified for closure under NFKx. fn is_xid_start(self) -> bool; - /// Returns whether the specified `char` satisfies the 'XID_Continue' - /// Unicode property. - /// - /// 'XID_Continue' is a Unicode Derived Property specified in - /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), - /// mostly similar to 'ID_Continue' but modified for closure under NFKx. - #[allow(non_snake_case)] - #[deprecated = "use is_xid_continue"] - fn is_XID_continue(self) -> bool; - /// Returns whether the specified `char` satisfies the 'XID_Continue' /// Unicode property. /// @@ -282,12 +127,6 @@ impl UnicodeChar for char { } } - #[deprecated = "use is_xid_start"] - fn is_XID_start(self) -> bool { derived_property::XID_Start(self) } - - #[deprecated = "use is_xid_continue"] - fn is_XID_continue(self) -> bool { derived_property::XID_Continue(self) } - fn is_xid_start(self) -> bool { derived_property::XID_Start(self) } fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) } diff --git a/src/test/auxiliary/cci_capture_clause.rs b/src/test/auxiliary/cci_capture_clause.rs index ec470ddc21343..ec4c0281d5597 100644 --- a/src/test/auxiliary/cci_capture_clause.rs +++ b/src/test/auxiliary/cci_capture_clause.rs @@ -8,13 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; use std::sync::mpsc::{Receiver, channel}; pub fn foo<T:Send + Clone>(x: T) -> Receiver<T> { let (tx, rx) = channel(); - task::spawn(move|| { + Thread::spawn(move|| { tx.send(x.clone()); - }); + }).detach(); rx } diff --git a/src/test/auxiliary/static-methods-crate.rs b/src/test/auxiliary/static-methods-crate.rs index ea4751bf4ed20..1b18571cf8c25 100644 --- a/src/test/auxiliary/static-methods-crate.rs +++ b/src/test/auxiliary/static-methods-crate.rs @@ -12,7 +12,6 @@ #![crate_type = "lib"] use std::int; -use std::str::from_str; pub trait read { fn readMaybe(s: String) -> Option<Self>; @@ -20,7 +19,7 @@ pub trait read { impl read for int { fn readMaybe(s: String) -> Option<int> { - from_str::<int>(s.as_slice()) + s.parse() } } diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index 0ada1cb991c6b..c978046e3910f 100644 --- a/src/test/bench/core-map.rs +++ b/src/test/bench/core-map.rs @@ -13,7 +13,6 @@ 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; @@ -107,7 +106,7 @@ fn main() { let args = args.as_slice(); let n_keys = { if args.len() == 2 { - from_str::<uint>(args[1].as_slice()).unwrap() + args[1].parse::<uint>().unwrap() } else { 1000000 } diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs index 52380001c6c0d..491d910f3517d 100644 --- a/src/test/bench/core-set.rs +++ b/src/test/bench/core-set.rs @@ -20,7 +20,6 @@ use std::collections::BitvSet; use std::collections::HashSet; use std::hash::Hash; use std::os; -use std::str::from_str; use std::time::Duration; use std::uint; @@ -181,7 +180,7 @@ fn main() { let args = args.as_slice(); let num_keys = { if args.len() == 2 { - from_str::<uint>(args[1].as_slice()).unwrap() + args[1].parse::<uint>().unwrap() } else { 100 // woefully inadequate for any real measurement } diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 26d4ec25c6439..ee7c442da195c 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -15,6 +15,7 @@ #![feature(unboxed_closures)] use std::io::File; +use std::iter::repeat; use std::mem::swap; use std::os; use std::rand::Rng; @@ -61,7 +62,7 @@ fn maybe_run_test<F>(argv: &[String], name: String, test: F) where F: FnOnce() { } fn shift_push() { - let mut v1 = Vec::from_elem(30000, 1i); + let mut v1 = repeat(1i).take(30000).collect::<Vec<_>>(); let mut v2 = Vec::new(); while v1.len() > 0 { @@ -88,7 +89,7 @@ fn vec_plus() { let mut v = Vec::new(); let mut i = 0; while i < 1500 { - let rv = Vec::from_elem(r.gen_range(0u, i + 1), i); + let rv = repeat(i).take(r.gen_range(0u, i + 1)).collect::<Vec<_>>(); if r.gen() { v.extend(rv.into_iter()); } else { @@ -106,7 +107,7 @@ fn vec_append() { let mut v = Vec::new(); let mut i = 0; while i < 1500 { - let rv = Vec::from_elem(r.gen_range(0u, i + 1), i); + let rv = repeat(i).take(r.gen_range(0u, i + 1)).collect::<Vec<_>>(); if r.gen() { let mut t = v.clone(); t.push_all(rv.as_slice()); @@ -126,7 +127,7 @@ fn vec_push_all() { let mut v = Vec::new(); for i in range(0u, 1500) { - let mut rv = Vec::from_elem(r.gen_range(0u, i + 1), i); + let mut rv = repeat(i).take(r.gen_range(0u, i + 1)).collect::<Vec<_>>(); if r.gen() { v.push_all(rv.as_slice()); } @@ -141,8 +142,8 @@ fn is_utf8_ascii() { let mut v : Vec<u8> = Vec::new(); for _ in range(0u, 20000) { v.push('b' as u8); - if !str::is_utf8(v.as_slice()) { - panic!("is_utf8 panicked"); + if str::from_utf8(v.as_slice()).is_err() { + panic!("from_utf8 panicked"); } } } @@ -152,8 +153,8 @@ fn is_utf8_multibyte() { let mut v : Vec<u8> = Vec::new(); for _ in range(0u, 5000) { v.push_all(s.as_bytes()); - if !str::is_utf8(v.as_slice()) { - panic!("is_utf8 panicked"); + if str::from_utf8(v.as_slice()).is_err() { + panic!("from_utf8 panicked"); } } } diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs index 08637b4bf1c1c..0235482ca2c48 100644 --- a/src/test/bench/core-uint-to-str.rs +++ b/src/test/bench/core-uint-to-str.rs @@ -9,7 +9,6 @@ // except according to those terms. use std::os; -use std::str::from_str; use std::uint; fn main() { @@ -22,7 +21,7 @@ fn main() { args.into_iter().collect() }; - let n = from_str::<uint>(args[1].as_slice()).unwrap(); + let n = args[1].parse().unwrap(); for i in range(0u, n) { let x = i.to_string(); diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index 285d193e7da8b..d1126e7425273 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -20,7 +20,6 @@ use std::sync::mpsc::{channel, Sender, Receiver}; use std::os; -use std::str::from_str; use std::thread::Thread; use std::time::Duration; use std::uint; @@ -55,8 +54,8 @@ fn run(args: &[String]) { let (to_parent, from_child) = channel(); let (to_child, from_parent) = channel(); - let size = from_str::<uint>(args[1].as_slice()).unwrap(); - let workers = from_str::<uint>(args[2].as_slice()).unwrap(); + let size = args[1].parse::<uint>().unwrap(); + let workers = args[2].parse::<uint>().unwrap(); let num_bytes = 100; let mut result = None; let mut p = Some((to_child, to_parent, from_parent)); diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs index 3ead5ef64fd99..ef5e8f3f4bbf4 100644 --- a/src/test/bench/msgsend-ring-mutex-arcs.rs +++ b/src/test/bench/msgsend-ring-mutex-arcs.rs @@ -19,7 +19,6 @@ // 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; @@ -74,8 +73,8 @@ fn main() { args.clone().into_iter().collect() }; - let num_tasks = from_str::<uint>(args[1].as_slice()).unwrap(); - let msg_per_task = from_str::<uint>(args[2].as_slice()).unwrap(); + let num_tasks = args[1].parse::<uint>().unwrap(); + let msg_per_task = args[2].parse::<uint>().unwrap(); let (mut num_chan, num_port) = init(); diff --git a/src/test/bench/rt-messaging-ping-pong.rs b/src/test/bench/rt-messaging-ping-pong.rs index de9e6629fbfc0..a3f1bc74b44fc 100644 --- a/src/test/bench/rt-messaging-ping-pong.rs +++ b/src/test/bench/rt-messaging-ping-pong.rs @@ -19,7 +19,6 @@ use std::sync::mpsc::channel; use std::os; -use std::str::from_str; use std::thread::Thread; use std::uint; @@ -66,13 +65,13 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() == 3 { - from_str::<uint>(args[1].as_slice()).unwrap() + args[1].parse::<uint>().unwrap() } else { 10000 }; let m = if args.len() == 3 { - from_str::<uint>(args[2].as_slice()).unwrap() + args[2].parse::<uint>().unwrap() } else { 4 }; diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs index f7810d5d740c0..e66fffd04e358 100644 --- a/src/test/bench/shootout-ackermann.rs +++ b/src/test/bench/shootout-ackermann.rs @@ -9,7 +9,6 @@ // except according to those terms. use std::os; -use std::str::from_str; fn ack(m: int, n: int) -> int { if m == 0 { @@ -32,6 +31,6 @@ fn main() { } else { args.into_iter().collect() }; - let n = from_str::<int>(args[1].as_slice()).unwrap(); + let n = args[1].parse().unwrap(); println!("Ack(3,{}): {}\n", n, ack(3, n)); } diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs index 030c627b6f71e..96bca25d1c455 100644 --- a/src/test/bench/shootout-chameneos-redux.rs +++ b/src/test/bench/shootout-chameneos-redux.rs @@ -43,7 +43,6 @@ use self::Color::{Red, Yellow, Blue}; use std::sync::mpsc::{channel, Sender, Receiver}; use std::fmt; -use std::str::from_str; use std::thread::Thread; fn print_complements() { @@ -235,8 +234,8 @@ fn main() { } else { std::os::args().as_slice() .get(1) - .and_then(|arg| from_str(arg.as_slice())) - .unwrap_or(600) + .and_then(|arg| arg.parse()) + .unwrap_or(600u) }; print_complements(); diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index 09f7f236f19a7..bbbfb0051f99b 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -42,9 +42,9 @@ use std::cmp::min; use std::io::{stdout, IoResult}; +use std::iter::repeat; 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; @@ -124,7 +124,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> { fn make(&mut self, n: uint) -> IoResult<()> { let alu_len = self.alu.len(); - let mut buf = Vec::from_elem(alu_len + LINE_LEN, 0u8); + let mut buf = repeat(0u8).take(alu_len + LINE_LEN).collect::<Vec<_>>(); let alu: &[u8] = self.alu.as_bytes(); copy_memory(buf.as_mut_slice(), alu); @@ -214,7 +214,7 @@ fn main() { let args = os::args(); let args = args.as_slice(); let n = if args.len() > 1 { - from_str::<uint>(args[1].as_slice()).unwrap() + args[1].parse::<uint>().unwrap() } else { 5 }; diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs index eee42af4dbc76..8777fa9689f94 100644 --- a/src/test/bench/shootout-fasta.rs +++ b/src/test/bench/shootout-fasta.rs @@ -45,7 +45,6 @@ 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; @@ -113,7 +112,7 @@ fn run<W: Writer>(writer: &mut W) -> std::io::IoResult<()> { } else if args.len() <= 1u { 1000 } else { - from_str(args[1].as_slice()).unwrap() + args[1].parse().unwrap() }; let rng = &mut MyRandom::new(); diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs index cbacf415f6f7f..36854728ebf20 100644 --- a/src/test/bench/shootout-fibo.rs +++ b/src/test/bench/shootout-fibo.rs @@ -9,7 +9,6 @@ // except according to those terms. use std::os; -use std::str::from_str; fn fib(n: int) -> int { if n < 2 { @@ -28,6 +27,6 @@ fn main() { } else { args.into_iter().collect() }; - let n = from_str::<int>(args[1].as_slice()).unwrap(); + let n = args[1].parse().unwrap(); println!("{}\n", fib(n)); } diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index 44abd1d09d1d8..8c0ec667332d3 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -15,17 +15,14 @@ #![feature(slicing_syntax)] -extern crate collections; - use std::ascii::{AsciiExt, OwnedAsciiExt}; use std::cmp::Ordering::{self, Less, Greater, Equal}; use std::collections::HashMap; -use std::sync::mpsc::{channel, Sender, Receiver}; use std::mem::replace; use std::num::Float; use std::option; use std::os; -use std::string::IntoString; +use std::sync::mpsc::{channel, Sender, Receiver}; use std::thread::Thread; fn f64_cmp(x: f64, y: f64) -> Ordering { @@ -87,7 +84,7 @@ fn find(mm: &HashMap<Vec<u8> , uint>, key: String) -> uint { // given a map, increment the counter for a key fn update_freq(mm: &mut HashMap<Vec<u8> , uint>, key: &[u8]) { let key = key.to_vec(); - let newval = match mm.pop(&key) { + let newval = match mm.remove(&key) { Some(v) => v + 1, None => 1 }; @@ -142,7 +139,7 @@ fn make_sequence_processor(sz: uint, _ => { "".to_string() } }; - to_parent.send(buffer); + to_parent.send(buffer).unwrap(); } // given a FASTA file on stdin, process sequence THREE @@ -159,7 +156,9 @@ fn main() { // initialize each sequence sorter let sizes = vec!(1u,2,3,4,6,12,18); - let mut streams = Vec::from_fn(sizes.len(), |_| Some(channel::<String>())); + let mut streams = range(0, sizes.len()).map(|_| { + Some(channel::<String>()) + }).collect::<Vec<_>>(); let mut from_child = Vec::new(); let to_child = sizes.iter().zip(streams.iter_mut()).map(|(sz, stream_ref)| { let sz = *sz; @@ -206,7 +205,7 @@ fn main() { for (ii, _sz) in sizes.iter().enumerate() { let lb = line_bytes.to_vec(); - to_child[ii].send(lb); + to_child[ii].send(lb).unwrap(); } } @@ -217,7 +216,7 @@ fn main() { // finish... for (ii, _sz) in sizes.iter().enumerate() { - to_child[ii].send(Vec::new()); + to_child[ii].send(Vec::new()).unwrap(); } // now fetch and print result messages diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index df5baac7dbe4e..359f06d0cf5f9 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -43,8 +43,10 @@ #![feature(associated_types, slicing_syntax)] use std::ascii::OwnedAsciiExt; +use std::iter::repeat; use std::slice; -use std::sync::{Arc, Future}; +use std::sync::Arc; +use std::thread::Thread; static TABLE: [u8;4] = [ 'A' as u8, 'C' as u8, 'G' as u8, 'T' as u8 ]; static TABLE_SIZE: uint = 2 << 16; @@ -136,7 +138,7 @@ struct Items<'a> { impl Table { fn new() -> Table { Table { - items: Vec::from_fn(TABLE_SIZE, |_| None), + items: range(0, TABLE_SIZE).map(|_| None).collect() } } @@ -300,19 +302,19 @@ fn main() { }; let input = Arc::new(input); - let nb_freqs: Vec<(uint, Future<Table>)> = range(1u, 3).map(|i| { + let nb_freqs: Vec<_> = range(1u, 3).map(|i| { let input = input.clone(); - (i, Future::spawn(move|| generate_frequencies(input.as_slice(), i))) + (i, Thread::spawn(move|| generate_frequencies(input.as_slice(), i))) }).collect(); - let occ_freqs: Vec<Future<Table>> = OCCURRENCES.iter().map(|&occ| { + let occ_freqs: Vec<_> = OCCURRENCES.iter().map(|&occ| { let input = input.clone(); - Future::spawn(move|| generate_frequencies(input.as_slice(), occ.len())) + Thread::spawn(move|| generate_frequencies(input.as_slice(), occ.len())) }).collect(); for (i, freq) in nb_freqs.into_iter() { - print_frequencies(&freq.unwrap(), i); + print_frequencies(&freq.join().ok().unwrap(), i); } for (&occ, freq) in OCCURRENCES.iter().zip(occ_freqs.into_iter()) { - print_occurrences(&mut freq.unwrap(), occ); + print_occurrences(&mut freq.join().ok().unwrap(), occ); } } diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index 51ce4cbaa841d..4e8e0d64d52ce 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -47,8 +47,8 @@ use std::io; use std::os; use std::simd::f64x2; -use std::str::from_str; -use std::sync::{Arc, Future}; +use std::sync::Arc; +use std::thread::Thread; const ITER: int = 50; const LIMIT: f64 = 2.0; @@ -82,8 +82,8 @@ fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> { let mut precalc_r = Vec::with_capacity(w); let mut precalc_i = Vec::with_capacity(h); - let precalc_futures = Vec::from_fn(WORKERS, |i| { - Future::spawn(move|| { + let precalc_futures = range(0, WORKERS).map(|i| { + Thread::spawn(move|| { let mut rs = Vec::with_capacity(w / WORKERS); let mut is = Vec::with_capacity(w / WORKERS); @@ -106,10 +106,10 @@ fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> { (rs, is) }) - }); + }).collect::<Vec<_>>(); for res in precalc_futures.into_iter() { - let (rs, is) = res.unwrap(); + let (rs, is) = res.join().ok().unwrap(); precalc_r.extend(rs.into_iter()); precalc_i.extend(is.into_iter()); } @@ -120,11 +120,11 @@ fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> { let arc_init_r = Arc::new(precalc_r); let arc_init_i = Arc::new(precalc_i); - let data = Vec::from_fn(WORKERS, |i| { + let data = range(0, WORKERS).map(|i| { let vec_init_r = arc_init_r.clone(); let vec_init_i = arc_init_i.clone(); - Future::spawn(move|| { + Thread::spawn(move|| { let mut res: Vec<u8> = Vec::with_capacity((chunk_size * w) / 8); let init_r_slice = vec_init_r.as_slice(); @@ -141,11 +141,11 @@ fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> { res }) - }); + }).collect::<Vec<_>>(); try!(writeln!(&mut out as &mut Writer, "P4\n{} {}", w, h)); for res in data.into_iter() { - try!(out.write(res.unwrap().as_slice())); + try!(out.write(res.join().ok().unwrap().as_slice())); } out.flush() } @@ -206,7 +206,7 @@ fn main() { which interferes with the test runner."); mandelbrot(1000, io::util::NullWriter) } else { - mandelbrot(from_str(args[1].as_slice()).unwrap(), io::stdout()) + mandelbrot(args[1].parse().unwrap(), io::stdout()) }; res.unwrap(); } diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs index 94d99b9f118f7..438775d8ba0a4 100644 --- a/src/test/bench/shootout-meteor.rs +++ b/src/test/bench/shootout-meteor.rs @@ -42,8 +42,9 @@ #![feature(associated_types)] -use std::sync::mpsc::channel; +use std::iter::repeat; use std::sync::Arc; +use std::sync::mpsc::channel; use std::thread::Thread; // @@ -220,7 +221,7 @@ fn get_id(m: u64) -> u8 { // Converts a list of mask to a Vec<u8>. fn to_vec(raw_sol: &List<u64>) -> Vec<u8> { - let mut sol = Vec::from_elem(50, '.' as u8); + let mut sol = repeat('.' as u8).take(50).collect::<Vec<_>>(); for &m in raw_sol.iter() { let id = '0' as u8 + get_id(m); for i in range(0u, 50) { diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs index 6a325798f5805..7973af3722de4 100644 --- a/src/test/bench/shootout-nbody.rs +++ b/src/test/bench/shootout-nbody.rs @@ -39,7 +39,6 @@ // 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; @@ -176,7 +175,7 @@ fn main() { 5000000 } else { std::os::args().as_slice().get(1) - .and_then(|arg| from_str(arg.as_slice())) + .and_then(|arg| arg.parse()) .unwrap_or(1000) }; let mut bodies = BODIES; diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index 78b5ac00b45e0..84ceb432048bc 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -23,7 +23,6 @@ extern crate getopts; use std::sync::mpsc::{channel, Sender}; use std::os; use std::result::Result::{Ok, Err}; -use std::str::from_str; use std::thread::Thread; use std::time::Duration; @@ -103,7 +102,7 @@ fn main() { if opts.stress { stress(2); } else { - let max = from_str::<uint>(args[1].as_slice()).unwrap() as int; + let max = args[1].parse::<int>().unwrap(); let num_trials = 10; diff --git a/src/test/bench/shootout-regex-dna.rs b/src/test/bench/shootout-regex-dna.rs index 9b8fd51c1c5dd..4f87171f5d3fa 100644 --- a/src/test/bench/shootout-regex-dna.rs +++ b/src/test/bench/shootout-regex-dna.rs @@ -44,12 +44,15 @@ #![feature(macro_rules, phase, slicing_syntax)] extern crate regex; -#[phase(plugin)]extern crate regex_macros; use std::io; use regex::{NoExpand, Regex}; use std::sync::{Arc, Future}; +macro_rules! regex { + ($e:expr) => (Regex::new($e).unwrap()) +} + fn count_matches(seq: &str, variant: &Regex) -> int { let mut n = 0; for _ in variant.find_iter(seq) { diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs index 4e60c2bee4446..bbbd7aebd5475 100644 --- a/src/test/bench/shootout-reverse-complement.rs +++ b/src/test/bench/shootout-reverse-complement.rs @@ -46,7 +46,6 @@ 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::thread::Thread; @@ -189,7 +188,8 @@ fn reverse_complement(seq: &mut [u8], tables: &Tables) { i += LINE_LEN + 1; } - let (div, rem) = div_rem(len, 4); + let div = len / 4; + let rem = len % 4; unsafe { let mut left = seq.as_mut_ptr() as *mut u16; // This is slow if len % 2 != 0 but still faster than bytewise operations. diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index a5af1227a165d..f3a593472256a 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -43,14 +43,13 @@ #![allow(non_snake_case)] #![feature(unboxed_closures)] -use std::iter::AdditiveIterator; +use std::iter::{repeat, 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(); @@ -59,16 +58,16 @@ fn main() { } else if args.len() < 2 { 2000 } else { - from_str(args[1].as_slice()).unwrap() + args[1].parse().unwrap() }); println!("{:.9}", answer); } fn spectralnorm(n: uint) -> f64 { assert!(n % 2 == 0, "only even lengths are accepted"); - let mut u = Vec::from_elem(n, 1.0); - let mut v = Vec::from_elem(n, 1.0); - let mut tmp = Vec::from_elem(n, 1.0); + let mut u = repeat(1.0).take(n).collect::<Vec<_>>(); + let mut v = u.clone(); + let mut tmp = v.clone(); for _ in range(0u, 10) { mult_AtAv(u.as_slice(), v.as_mut_slice(), tmp.as_mut_slice()); mult_AtAv(v.as_slice(), u.as_mut_slice(), tmp.as_mut_slice()); diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs index 543597d8c8118..9dd1003785051 100644 --- a/src/test/bench/shootout-threadring.rs +++ b/src/test/bench/shootout-threadring.rs @@ -39,7 +39,6 @@ // OF THE POSSIBILITY OF SUCH DAMAGE. use std::sync::mpsc::{channel, Sender, Receiver}; -use std::str::from_str; use std::thread::Thread; fn start(n_tasks: int, token: int) { @@ -69,10 +68,10 @@ fn main() { let token = if std::os::getenv("RUST_BENCH").is_some() { 2000000 } else { - args.get(1).and_then(|arg| from_str(arg.as_slice())).unwrap_or(1000) + args.get(1).and_then(|arg| arg.parse()).unwrap_or(1000) }; let n_tasks = args.get(2) - .and_then(|arg| from_str(arg.as_slice())) + .and_then(|arg| arg.parse()) .unwrap_or(503); start(n_tasks, token); diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index 035b222e6ce62..c2e657151f099 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -12,7 +12,6 @@ use std::collections::VecMap; use std::os; -use std::str::from_str; use std::time::Duration; use std::uint; @@ -37,8 +36,8 @@ fn main() { } else { args.into_iter().collect() }; - let max = from_str::<uint>(args[1].as_slice()).unwrap(); - let rep = from_str::<uint>(args[2].as_slice()).unwrap(); + let max = args[1].parse::<uint>().unwrap(); + let rep = args[2].parse::<uint>().unwrap(); let mut checkf = Duration::seconds(0); let mut appendf = Duration::seconds(0); diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index cccc9362a729b..85e8288b5cde5 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -15,9 +15,9 @@ use std::io::BufferedReader; use std::io::stdio::StdReader; use std::io; +use std::iter::repeat; use std::num::Int; use std::os; -use std::str::from_str; // Computes a single solution to a given 9x9 sudoku // @@ -48,9 +48,9 @@ impl Sudoku { } pub fn from_vec(vec: &[[u8;9];9]) -> Sudoku { - let g = Vec::from_fn(9u, |i| { - Vec::from_fn(9u, |j| { vec[i][j] }) - }); + let g = range(0, 9u).map(|i| { + range(0, 9u).map(|j| { vec[i][j] }).collect() + }).collect(); return Sudoku::new(g) } @@ -70,7 +70,8 @@ impl Sudoku { /* assert first line is exactly "9,9" */ assert!(reader.read_line().unwrap() == "9,9".to_string()); - let mut g = Vec::from_fn(10u, { |_i| vec!(0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8) }); + let mut g = repeat(vec![0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]) + .take(10).collect::<Vec<_>>(); for line in reader.lines() { let line = line.unwrap(); let comps: Vec<&str> = line.as_slice() @@ -79,10 +80,9 @@ impl Sudoku { .collect(); if comps.len() == 3u { - let row = from_str::<uint>(comps[0]).unwrap() as u8; - let col = from_str::<uint>(comps[1]).unwrap() as u8; - g[row as uint][col as uint] = - from_str::<uint>(comps[2]).unwrap() as u8; + let row = comps[0].parse::<u8>().unwrap(); + let col = comps[1].parse::<u8>().unwrap(); + g[row as uint][col as uint] = comps[2].parse().unwrap(); } else { panic!("Invalid sudoku file"); diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs index b27a8710e326b..9e78ede74ca91 100644 --- a/src/test/bench/task-perf-alloc-unwind.rs +++ b/src/test/bench/task-perf-alloc-unwind.rs @@ -11,7 +11,7 @@ #![feature(unsafe_destructor)] use std::os; -use std::task; +use std::thread::Thread; use std::time::Duration; #[derive(Clone)] @@ -36,9 +36,9 @@ fn main() { fn run(repeat: int, depth: int) { for _ in range(0, repeat) { let dur = Duration::span(|| { - task::try(move|| { + let _ = Thread::spawn(move|| { recurse_or_panic(depth, None) - }); + }).join(); }); println!("iter: {}", dur); } diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs index a0278a63a51d9..30918d4909035 100644 --- a/src/test/bench/task-perf-jargon-metal-smoke.rs +++ b/src/test/bench/task-perf-jargon-metal-smoke.rs @@ -19,8 +19,6 @@ use std::sync::mpsc::{channel, Sender}; use std::os; -use std::str::from_str; -use std::task; use std::thread::Thread; use std::uint; @@ -30,7 +28,7 @@ fn child_generation(gens_left: uint, tx: Sender<()>) { // alive at a time, Thread::spawn(move|| { if gens_left & 1 == 1 { - task::deschedule(); // shake things up a bit + Thread::yield_now(); // shake things up a bit } if gens_left > 0 { child_generation(gens_left - 1, tx); // recurse @@ -51,7 +49,7 @@ fn main() { }; let (tx, rx) = channel(); - child_generation(from_str::<uint>(args[1].as_slice()).unwrap(), tx); + child_generation(args[1].parse().unwrap(), tx); if rx.recv().is_err() { panic!("it happened when we slumbered"); } diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs index 7e2c6fcf0ecd4..488a5ec9edada 100644 --- a/src/test/bench/task-perf-spawnalot.rs +++ b/src/test/bench/task-perf-spawnalot.rs @@ -9,14 +9,13 @@ // except according to those terms. use std::os; -use std::task; use std::uint; -use std::str::from_str; +use std::thread::Thread; fn f(n: uint) { let mut i = 0u; while i < n { - task::try(move|| g()); + let _ = Thread::spawn(move|| g()).join(); i += 1u; } } @@ -32,7 +31,7 @@ fn main() { } else { args.into_iter().collect() }; - let n = from_str::<uint>(args[1].as_slice()).unwrap(); + let n = args[1].parse().unwrap(); let mut i = 0u; - while i < n { task::spawn(move|| f(n) ); i += 1u; } + while i < n { Thread::spawn(move|| f(n) ).detach(); i += 1u; } } diff --git a/src/test/compile-fail-fulldeps/syntax-extension-regex-invalid.rs b/src/test/compile-fail-fulldeps/syntax-extension-regex-invalid.rs deleted file mode 100644 index 32e0bff19918b..0000000000000 --- a/src/test/compile-fail-fulldeps/syntax-extension-regex-invalid.rs +++ /dev/null @@ -1,26 +0,0 @@ -// 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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// ignore-stage1 - -#![feature(phase)] - -extern crate regex; -#[phase(plugin)] extern crate regex_macros; - -// Tests to make sure that `regex!` will produce a compile error when given -// an invalid regular expression. -// More exhaustive failure tests for the parser are done with the traditional -// unit testing infrastructure, since both dynamic and native regexes use the -// same parser. - -fn main() { - let _ = regex!("("); //~ ERROR Regex syntax error -} diff --git a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs b/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs deleted file mode 100644 index 8f83c9ec94fbd..0000000000000 --- a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs +++ /dev/null @@ -1,31 +0,0 @@ -// 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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// ignore-stage1 - -#![feature(phase)] - -extern crate regex; -#[phase(plugin)] extern crate regex_macros; - -#[deny(unused_variables)] -#[deny(dead_code)] -#[allow(non_upper_case_globals)] - -// Tests to make sure that extraneous dead code warnings aren't emitted from -// the code generated by regex!. -// -// The warning used for `static` items seems to be dead_code, which is why this -// is a distinct test from using a normal let binding (which generates an -// unused variable warning). - -fn main() { - static fubar: regex::Regex = regex!("abc"); //~ ERROR static item is never used: `fubar` -} diff --git a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused.rs b/src/test/compile-fail-fulldeps/syntax-extension-regex-unused.rs deleted file mode 100644 index b4dda05f42d2b..0000000000000 --- a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused.rs +++ /dev/null @@ -1,26 +0,0 @@ -// 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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// ignore-stage1 - -#![feature(phase)] - -extern crate regex; -#[phase(plugin)] extern crate regex_macros; - -#[deny(unused_variables)] -#[deny(dead_code)] - -// Tests to make sure that extraneous dead code warnings aren't emitted from -// the code generated by regex!. - -fn main() { - let fubar = regex!("abc"); //~ ERROR unused variable: `fubar` -} diff --git a/src/test/compile-fail/atomicoption-not-send-ref.rs b/src/test/compile-fail/atomicoption-not-send-ref.rs deleted file mode 100644 index 15c726be2fd23..0000000000000 --- a/src/test/compile-fail/atomicoption-not-send-ref.rs +++ /dev/null @@ -1,16 +0,0 @@ -// 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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use std::sync::atomic::AtomicOption; - -fn main() { - let x = 0u; - AtomicOption::new(box &x); //~ ERROR `x` does not live long enough -} diff --git a/src/test/compile-fail/atomicoption-not-send.rs b/src/test/compile-fail/atomicoption-not-send.rs deleted file mode 100644 index df3ebf530df99..0000000000000 --- a/src/test/compile-fail/atomicoption-not-send.rs +++ /dev/null @@ -1,16 +0,0 @@ -// 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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use std::kinds::marker; -use std::sync::atomic::AtomicOption; - -fn main() { - AtomicOption::new(box marker::NoSend); //~ ERROR `core::kinds::Send` is not implemented -} diff --git a/src/test/compile-fail/borrowck-for-loop-head-linkage.rs b/src/test/compile-fail/borrowck-for-loop-head-linkage.rs index d712810589200..cb673f9be34fc 100644 --- a/src/test/compile-fail/borrowck-for-loop-head-linkage.rs +++ b/src/test/compile-fail/borrowck-for-loop-head-linkage.rs @@ -8,11 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use std::iter::repeat; + fn main() { let mut vector = vec![1u, 2]; for &x in vector.iter() { let cap = vector.capacity(); - vector.grow(cap, 0u); //~ ERROR cannot borrow + vector.extend(repeat(0)); //~ ERROR cannot borrow vector[1u] = 5u; //~ ERROR cannot borrow } } diff --git a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs index cecb8a09c665a..9bd2d48b29a85 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; fn borrow(v: &int, f: |x: &int|) { f(v); @@ -17,7 +17,7 @@ fn borrow(v: &int, f: |x: &int|) { fn box_imm() { let v = box 3i; let _w = &v; - task::spawn(move|| { + Thread::spawn(move|| { println!("v={}", *v); //~^ ERROR cannot move `v` into closure }); @@ -26,7 +26,7 @@ fn box_imm() { fn box_imm_explicit() { let v = box 3i; let _w = &v; - task::spawn(move|| { + Thread::spawn(move|| { println!("v={}", *v); //~^ ERROR cannot move }); diff --git a/src/test/compile-fail/borrowck-multiple-captures.rs b/src/test/compile-fail/borrowck-multiple-captures.rs index a9c368fb05258..2a26ff7d4a162 100644 --- a/src/test/compile-fail/borrowck-multiple-captures.rs +++ b/src/test/compile-fail/borrowck-multiple-captures.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; fn borrow<T>(_: &T) { } @@ -17,7 +17,7 @@ fn different_vars_after_borrows() { let p1 = &x1; let x2 = box 2i; let p2 = &x2; - task::spawn(move|| { + Thread::spawn(move|| { drop(x1); //~ ERROR cannot move `x1` into closure because it is borrowed drop(x2); //~ ERROR cannot move `x2` into closure because it is borrowed }); @@ -30,7 +30,7 @@ fn different_vars_after_moves() { drop(x1); let x2 = box 2i; drop(x2); - task::spawn(move|| { + Thread::spawn(move|| { drop(x1); //~ ERROR capture of moved value: `x1` drop(x2); //~ ERROR capture of moved value: `x2` }); @@ -39,7 +39,7 @@ fn different_vars_after_moves() { fn same_var_after_borrow() { let x = box 1i; let p = &x; - task::spawn(move|| { + Thread::spawn(move|| { drop(x); //~ ERROR cannot move `x` into closure because it is borrowed drop(x); //~ ERROR use of moved value: `x` }); @@ -49,7 +49,7 @@ fn same_var_after_borrow() { fn same_var_after_move() { let x = box 1i; drop(x); - task::spawn(move|| { + Thread::spawn(move|| { drop(x); //~ ERROR capture of moved value: `x` drop(x); //~ ERROR use of moved value: `x` }); diff --git a/src/test/compile-fail/deriving-span-Zero-struct.rs b/src/test/compile-fail/deriving-span-Zero-struct.rs deleted file mode 100644 index 6b09c36523541..0000000000000 --- a/src/test/compile-fail/deriving-span-Zero-struct.rs +++ /dev/null @@ -1,23 +0,0 @@ -// 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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' - -extern crate rand; - - -struct Error; - -#[derive(Zero)] //~ ERROR not implemented -struct Struct { - x: Error -} - -fn main() {} diff --git a/src/test/compile-fail/deriving-span-Zero-tuple-struct.rs b/src/test/compile-fail/deriving-span-Zero-tuple-struct.rs deleted file mode 100644 index c11af72f5c983..0000000000000 --- a/src/test/compile-fail/deriving-span-Zero-tuple-struct.rs +++ /dev/null @@ -1,23 +0,0 @@ -// 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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' - -extern crate rand; - - -struct Error; - -#[derive(Zero)] //~ ERROR not implemented -struct Struct( - Error -); - -fn main() {} diff --git a/src/test/compile-fail/future_not_copyable.rs b/src/test/compile-fail/future_not_copyable.rs index da56792ec8820..6a5bde365b429 100644 --- a/src/test/compile-fail/future_not_copyable.rs +++ b/src/test/compile-fail/future_not_copyable.rs @@ -13,5 +13,5 @@ use std::sync::Future; fn main() { let f = Future::from_value(()); let g = f; - f.unwrap(); //~ ERROR use of moved value + f.into_inner(); //~ ERROR use of moved value } diff --git a/src/test/compile-fail/hashmap-lifetimes.rs b/src/test/compile-fail/hashmap-lifetimes.rs index 5bd6c73df1ab2..edd57477d7699 100644 --- a/src/test/compile-fail/hashmap-lifetimes.rs +++ b/src/test/compile-fail/hashmap-lifetimes.rs @@ -13,5 +13,5 @@ fn main() { my_stuff.insert(0i, 42i); let mut it = my_stuff.iter(); - my_stuff.swap(1, 43); //~ ERROR cannot borrow + my_stuff.insert(1, 43); //~ ERROR cannot borrow } diff --git a/src/test/compile-fail/issue-11374.rs b/src/test/compile-fail/issue-11374.rs index 9705994550bb9..6b048528a996e 100644 --- a/src/test/compile-fail/issue-11374.rs +++ b/src/test/compile-fail/issue-11374.rs @@ -32,6 +32,6 @@ pub fn for_stdin<'a>() -> Container<'a> { fn main() { let mut c = for_stdin(); - let mut v = vec::Vec::from_elem(10, 0u8); + let mut v = Vec::new(); c.read_to(v.as_mut_slice()); } diff --git a/src/test/compile-fail/issue-15783.rs b/src/test/compile-fail/issue-15783.rs index 32a920baa31b6..f3e7a65db481e 100644 --- a/src/test/compile-fail/issue-15783.rs +++ b/src/test/compile-fail/issue-15783.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn foo(params: Option<&[&str]>) -> uint { - params.unwrap().head().unwrap().len() + params.unwrap().first().unwrap().len() } fn main() { diff --git a/src/test/compile-fail/issue-17728.rs b/src/test/compile-fail/issue-17728.rs index 96f252967a8d0..ac2eb735637fa 100644 --- a/src/test/compile-fail/issue-17728.rs +++ b/src/test/compile-fail/issue-17728.rs @@ -20,7 +20,7 @@ trait HasInventory { trait TraversesWorld { fn attemptTraverse(&self, room: &Room, directionStr: &str) -> Result<&Room, &str> { let direction = str_to_direction(directionStr); - let maybe_room = room.direction_to_room.find(&direction); + let maybe_room = room.direction_to_room.get(&direction); //~^ ERROR cannot infer an appropriate lifetime for autoref due to conflicting requirements match maybe_room { Some(entry) => Ok(entry), diff --git a/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs b/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs index 458e2aaf451a0..dc90994fcc102 100644 --- a/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs +++ b/src/test/compile-fail/moves-based-on-type-capture-clause-bad.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; fn main() { let x = "Hello world!".to_string(); - task::spawn(move|| { + Thread::spawn(move|| { println!("{}", x); }); println!("{}", x); //~ ERROR use of moved value diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs index affe979268d21..9a09448ff01fe 100644 --- a/src/test/compile-fail/no-capture-arc.rs +++ b/src/test/compile-fail/no-capture-arc.rs @@ -11,13 +11,13 @@ // error-pattern: use of moved value use std::sync::Arc; -use std::task; +use std::thread::Thread; fn main() { let v = vec!(1i, 2, 3, 4, 5, 6, 7, 8, 9, 10); let arc_v = Arc::new(v); - task::spawn(move|| { + Thread::spawn(move|| { assert_eq!((*arc_v)[3], 4); }); diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs index 60982a84b791e..de23074368576 100644 --- a/src/test/compile-fail/no-reuse-move-arc.rs +++ b/src/test/compile-fail/no-reuse-move-arc.rs @@ -9,13 +9,13 @@ // except according to those terms. use std::sync::Arc; -use std::task; +use std::thread::Thread; fn main() { let v = vec!(1i, 2, 3, 4, 5, 6, 7, 8, 9, 10); let arc_v = Arc::new(v); - task::spawn(move|| { + Thread::spawn(move|| { assert_eq!((*arc_v)[3], 4); }); diff --git a/src/test/compile-fail/no-send-res-ports.rs b/src/test/compile-fail/no-send-res-ports.rs index f487ecf9f4582..9e56b27a05b6b 100644 --- a/src/test/compile-fail/no-send-res-ports.rs +++ b/src/test/compile-fail/no-send-res-ports.rs @@ -10,7 +10,7 @@ #![feature(unsafe_destructor)] -use std::task; +use std::thread::Thread; use std::rc::Rc; #[derive(Show)] @@ -35,7 +35,7 @@ fn main() { let x = foo(Port(Rc::new(()))); - task::spawn(move|| { + Thread::spawn(move|| { //~^ ERROR `core::kinds::Send` is not implemented //~^^ ERROR `core::kinds::Send` is not implemented let y = x; diff --git a/src/test/compile-fail/spawn-non-nil-fn.rs b/src/test/compile-fail/spawn-non-nil-fn.rs deleted file mode 100644 index 6cc45090b9024..0000000000000 --- a/src/test/compile-fail/spawn-non-nil-fn.rs +++ /dev/null @@ -1,17 +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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use std::task; - -fn main() { - // We get an error because return type is `->int` and not `->()`. - task::spawn(|| -> int { 10 }); - //~^ ERROR type mismatch -} diff --git a/src/test/compile-fail/std-uncopyable-atomics.rs b/src/test/compile-fail/std-uncopyable-atomics.rs index 501187ca9e543..a97a3e6167819 100644 --- a/src/test/compile-fail/std-uncopyable-atomics.rs +++ b/src/test/compile-fail/std-uncopyable-atomics.rs @@ -24,6 +24,4 @@ fn main() { let x = *&x; //~ ERROR: cannot move out of dereference let x: AtomicPtr<uint> = AtomicPtr::new(ptr::null_mut()); let x = *&x; //~ ERROR: cannot move out of dereference - let x: AtomicOption<uint> = AtomicOption::empty(); - let x = *&x; //~ ERROR: cannot move out of dereference } diff --git a/src/test/run-fail/rt-set-exit-status-panic2.rs b/src/test/run-fail/rt-set-exit-status-panic2.rs index 58de34e92a09d..972c85e376e51 100644 --- a/src/test/run-fail/rt-set-exit-status-panic2.rs +++ b/src/test/run-fail/rt-set-exit-status-panic2.rs @@ -13,7 +13,7 @@ #![feature(phase)] #[phase(plugin, link)] extern crate log; use std::os; -use std::task; +use std::thread::Thread; struct r { x:int, @@ -36,7 +36,7 @@ fn r(x:int) -> r { fn main() { error!("whatever"); - task::spawn(move|| { + let _t = Thread::spawn(move|| { let _i = r(5); }); panic!(); diff --git a/src/test/run-fail/task-spawn-barefn.rs b/src/test/run-fail/task-spawn-barefn.rs index dfc3238662cfe..8aade64163056 100644 --- a/src/test/run-fail/task-spawn-barefn.rs +++ b/src/test/run-fail/task-spawn-barefn.rs @@ -10,12 +10,12 @@ // error-pattern:Ensure that the child task runs by panicking -use std::task; +use std::thread::Thread; fn main() { // the purpose of this test is to make sure that task::spawn() // works when provided with a bare function: - let r = task::try(startfn); + let r = Thread::spawn(startfn).join(); if r.is_err() { panic!() } diff --git a/src/test/run-make/lto-syntax-extension/main.rs b/src/test/run-make/lto-syntax-extension/main.rs index 0f6bd10b15d3f..2028710cbd2bc 100644 --- a/src/test/run-make/lto-syntax-extension/main.rs +++ b/src/test/run-make/lto-syntax-extension/main.rs @@ -11,9 +11,6 @@ #![feature(phase)] extern crate lib; -extern crate regex; -#[phase(plugin)] extern crate regex_macros; +#[phase(plugin, link)] extern crate log; -fn main() { - regex!("1234"); -} +fn main() {} diff --git a/src/test/run-make/static-unwinding/main.rs b/src/test/run-make/static-unwinding/main.rs index e2cca4d11f9a9..faac858e76e0b 100644 --- a/src/test/run-make/static-unwinding/main.rs +++ b/src/test/run-make/static-unwinding/main.rs @@ -10,7 +10,7 @@ extern crate lib; -use std::task; +use std::thread::Thread; static mut statik: int = 0; @@ -22,11 +22,11 @@ impl Drop for A { } fn main() { - task::try(move|| { + Thread::spawn(move|| { let _a = A; lib::callback(|| panic!()); 1i - }); + }).join().err().unwrap(); unsafe { assert!(lib::statik == 1); diff --git a/src/test/run-make/unicode-input/span_length.rs b/src/test/run-make/unicode-input/span_length.rs index f83734b1502eb..ae638399450c9 100644 --- a/src/test/run-make/unicode-input/span_length.rs +++ b/src/test/run-make/unicode-input/span_length.rs @@ -8,9 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::{char, os}; use std::io::{File, Command}; +use std::iter::repeat; use std::rand::{thread_rng, Rng}; +use std::{char, os}; // creates a file with `fn main() { <random ident> }` and checks the // compiler emits a span of the appropriate length (for the @@ -60,7 +61,8 @@ fn main() { let err = String::from_utf8_lossy(result.error.as_slice()); // the span should end the line (e.g no extra ~'s) - let expected_span = format!("^{}\n", "~".repeat(n - 1)); + let expected_span = format!("^{}\n", repeat("~").take(n - 1) + .collect::<String>()); assert!(err.as_slice().contains(expected_span.as_slice())); } } diff --git a/src/test/run-pass/child-outlives-parent.rs b/src/test/run-pass/child-outlives-parent.rs index bdd92919ef05b..39af96a58e6e3 100644 --- a/src/test/run-pass/child-outlives-parent.rs +++ b/src/test/run-pass/child-outlives-parent.rs @@ -10,10 +10,10 @@ // Reported as issue #126, child leaks the string. -use std::task; +use std::thread::Thread; fn child2(_s: String) { } pub fn main() { - let _x = task::spawn(move|| child2("hi".to_string())); + let _x = Thread::spawn(move|| child2("hi".to_string())); } diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs index d3c703b258f73..cb495859708b6 100644 --- a/src/test/run-pass/clone-with-exterior.rs +++ b/src/test/run-pass/clone-with-exterior.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task::spawn; +use std::thread::Thread; struct Pair { a: int, @@ -18,7 +18,7 @@ struct Pair { pub fn main() { let z = box Pair { a : 10, b : 12}; - spawn(move|| { + let _t = Thread::spawn(move|| { assert_eq!(z.a, 10); assert_eq!(z.b, 12); }); diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index 5cfc692aae43d..16a21adc3fcf9 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; use std::sync::mpsc::{channel, Sender}; pub fn main() { let (tx, rx) = channel(); - let _t = task::spawn(move|| { child(&tx) }); + let _t = Thread::spawn(move|| { child(&tx) }); let y = rx.recv().unwrap(); println!("received"); println!("{}", y); diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs index e0e8ca5618e50..5e028d3774fc5 100644 --- a/src/test/run-pass/const-str-ptr.rs +++ b/src/test/run-pass/const-str-ptr.rs @@ -18,13 +18,13 @@ const C: *const u8 = B as *const u8; pub fn main() { unsafe { let foo = &A as *const u8; - assert_eq!(str::raw::from_utf8(&A), "hi"); - assert_eq!(string::raw::from_buf_len(foo, A.len()), "hi".to_string()); - assert_eq!(string::raw::from_buf_len(C, B.len()), "hi".to_string()); + assert_eq!(str::from_utf8_unchecked(&A), "hi"); + assert_eq!(String::from_raw_buf_len(foo, A.len()), "hi".to_string()); + assert_eq!(String::from_raw_buf_len(C, B.len()), "hi".to_string()); assert!(*C == A[0]); assert!(*(&B[0] as *const u8) == A[0]); - let bar = str::raw::from_utf8(&A).to_c_str(); + let bar = str::from_utf8_unchecked(&A).to_c_str(); assert_eq!(bar.as_str(), "hi".to_c_str().as_str()); } } diff --git a/src/test/run-pass/deriving-zero.rs b/src/test/run-pass/deriving-zero.rs deleted file mode 100644 index 442c330b27786..0000000000000 --- a/src/test/run-pass/deriving-zero.rs +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright 2012-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 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -#![feature(associated_types)] - -use std::num::Zero; -use std::ops::Add; - -#[derive(Zero)] -struct Vector2<T>(T, T); - -impl<T: Add<Output=T>> Add for Vector2<T> { - type Output = Vector2<T>; - - fn add(self, other: Vector2<T>) -> Vector2<T> { - match (self, other) { - (Vector2(x0, y0), Vector2(x1, y1)) => { - Vector2(x0 + x1, y0 + y1) - } - } - } -} - -#[derive(Zero)] -struct Vector3<T> { - x: T, y: T, z: T, -} - -impl<T: Add<Output=T>> Add for Vector3<T> { - type Output = Vector3<T>; - - fn add(self, other: Vector3<T>) -> Vector3<T> { - Vector3 { - x: self.x + other.x, - y: self.y + other.y, - z: self.z + other.z, - } - } -} - -#[derive(Zero)] -struct Matrix3x2<T> { - x: Vector2<T>, - y: Vector2<T>, - z: Vector2<T>, -} - -impl<T: Add<Output=T>> Add for Matrix3x2<T> { - type Output = Matrix3x2<T>; - - fn add(self, other: Matrix3x2<T>) -> Matrix3x2<T> { - Matrix3x2 { - x: self.x + other.x, - y: self.y + other.y, - z: self.z + other.z, - } - } -} - -pub fn main() { - let _: Vector2<int> = Zero::zero(); - let _: Vector3<f64> = Zero::zero(); - let _: Matrix3x2<u8> = Zero::zero(); -} diff --git a/src/test/run-pass/drop-trait-enum.rs b/src/test/run-pass/drop-trait-enum.rs index 381404d2e219d..f1cc4fb172409 100644 --- a/src/test/run-pass/drop-trait-enum.rs +++ b/src/test/run-pass/drop-trait-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; use std::sync::mpsc::{channel, Sender}; #[derive(PartialEq, Show)] @@ -66,23 +66,23 @@ pub fn main() { assert_eq!(receiver.recv().ok(), None); let (sender, receiver) = channel(); - task::spawn(move|| { + let _t = Thread::spawn(move|| { let v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } }; }); assert_eq!(receiver.recv().unwrap(), Message::Dropped); assert_eq!(receiver.recv().ok(), None); let (sender, receiver) = channel(); - { - task::spawn(move|| { + let _t = { + Thread::spawn(move|| { let mut v = Foo::NestedVariant(box 42u, SendOnDrop { sender: sender.clone() }, sender.clone()); v = Foo::NestedVariant(box 42u, SendOnDrop { sender: sender.clone() }, sender.clone()); v = Foo::SimpleVariant(sender.clone()); v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } }; - }); - } + }) + }; assert_eq!(receiver.recv().unwrap(), Message::DestructorRan); assert_eq!(receiver.recv().unwrap(), Message::Dropped); assert_eq!(receiver.recv().unwrap(), Message::DestructorRan); diff --git a/src/test/run-pass/extern-call-deep2.rs b/src/test/run-pass/extern-call-deep2.rs index aed1392c8b68b..3c4c1da52ea95 100644 --- a/src/test/run-pass/extern-call-deep2.rs +++ b/src/test/run-pass/extern-call-deep2.rs @@ -9,7 +9,7 @@ // except according to those terms. extern crate libc; -use std::task; +use std::thread::Thread; mod rustrt { extern crate libc; @@ -40,7 +40,7 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t { pub fn main() { // Make sure we're on a task with small Rust stacks (main currently // has a large stack) - task::spawn(move|| { + let _t = Thread::spawn(move|| { let result = count(1000); println!("result = {}", result); assert_eq!(result, 1000); diff --git a/src/test/run-pass/extern-call-scrub.rs b/src/test/run-pass/extern-call-scrub.rs index 3f5faabe59598..0dca7514dc5cf 100644 --- a/src/test/run-pass/extern-call-scrub.rs +++ b/src/test/run-pass/extern-call-scrub.rs @@ -13,7 +13,7 @@ // directions extern crate libc; -use std::task; +use std::thread::Thread; mod rustrt { extern crate libc; @@ -44,7 +44,7 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t { pub fn main() { // Make sure we're on a task with small Rust stacks (main currently // has a large stack) - task::spawn(move|| { + let _t = Thread::spawn(move|| { let result = count(12); println!("result = {}", result); assert_eq!(result, 2048); diff --git a/src/test/run-pass/extern-stress.rs b/src/test/run-pass/extern-stress.rs index 8b080712b9661..bb9e94073828a 100644 --- a/src/test/run-pass/extern-stress.rs +++ b/src/test/run-pass/extern-stress.rs @@ -12,7 +12,7 @@ // while holding onto C stacks extern crate libc; -use std::task; +use std::thread::Thread; mod rustrt { extern crate libc; @@ -29,7 +29,7 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t { if data == 1 { data } else { - task::deschedule(); + Thread::yield_now(); count(data - 1) + count(data - 1) } } @@ -41,9 +41,9 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t { } pub fn main() { - for _ in range(0u, 100) { - task::spawn(move|| { + range(0u, 100).map(|_| { + Thread::spawn(move|| { assert_eq!(count(5), 16); - }); - } + }) + }).collect::<Vec<_>>(); } diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs index 1c89d8ae1ce9d..46829e9ba6ef8 100644 --- a/src/test/run-pass/extern-yield.rs +++ b/src/test/run-pass/extern-yield.rs @@ -9,7 +9,7 @@ // except according to those terms. extern crate libc; -use std::task; +use std::thread::Thread; mod rustrt { extern crate libc; @@ -32,17 +32,17 @@ extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t { fn count(n: libc::uintptr_t) -> libc::uintptr_t { unsafe { - task::deschedule(); + Thread::yield_now(); rustrt::rust_dbg_call(cb, n) } } pub fn main() { - for _ in range(0, 10u) { - task::spawn(move|| { + range(0, 10u).map(|i| { + Thread::spawn(move|| { let result = count(5); println!("result = {}", result); assert_eq!(result, 16); - }); - } + }) + }).collect::<Vec<_>>(); } diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index 162d7f1025589..7fd8ca1fd8a9e 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -23,7 +23,7 @@ mod map_reduce { use std::collections::HashMap; use std::sync::mpsc::{channel, Sender}; use std::str; - use std::task; + use std::thread::Thread; pub type putter<'a> = |String, String|: 'a; @@ -35,7 +35,7 @@ mod map_reduce { for i in inputs.iter() { let ctrl = ctrl.clone(); let i = i.clone(); - task::spawn(move|| map_task(ctrl.clone(), i.clone()) ); + Thread::spawn(move|| map_task(ctrl.clone(), i.clone()) ).detach(); } } diff --git a/src/test/run-pass/issue-13323.rs b/src/test/run-pass/issue-13323.rs index d9149b0d7466e..b7cd8a9011276 100644 --- a/src/test/run-pass/issue-13323.rs +++ b/src/test/run-pass/issue-13323.rs @@ -14,7 +14,7 @@ struct StrWrap { impl StrWrap { fn new(s: &str) -> StrWrap { - StrWrap { s: s.into_string() } + StrWrap { s: s.to_string() } } fn get_s<'a>(&'a self) -> &'a str { diff --git a/src/test/run-pass/issue-15149.rs b/src/test/run-pass/issue-15149.rs index 1fb17d4d5fa85..57dc6fd75f08c 100644 --- a/src/test/run-pass/issue-15149.rs +++ b/src/test/run-pass/issue-15149.rs @@ -10,7 +10,6 @@ use std::io::{TempDir, Command, fs}; use std::os; -use std::task::TaskBuilder; fn main() { // If we're the child, make sure we were invoked correctly diff --git a/src/test/run-pass/issue-17718.rs b/src/test/run-pass/issue-17718.rs index 10ad0f620e9f3..44cf0dd8b8ee8 100644 --- a/src/test/run-pass/issue-17718.rs +++ b/src/test/run-pass/issue-17718.rs @@ -12,10 +12,10 @@ extern crate "issue-17718" as other; -use std::sync::atomic; +use std::sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering}; const C1: uint = 1; -const C2: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT; +const C2: AtomicUint = ATOMIC_UINT_INIT; const C3: fn() = foo; const C4: uint = C1 * C1 + C1 / C1; const C5: &'static uint = &C4; @@ -25,7 +25,7 @@ const C6: uint = { }; static S1: uint = 3; -static S2: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT; +static S2: AtomicUint = ATOMIC_UINT_INIT; mod test { static A: uint = 4; @@ -38,14 +38,14 @@ fn foo() {} fn main() { assert_eq!(C1, 1); assert_eq!(C3(), ()); - assert_eq!(C2.fetch_add(1, atomic::SeqCst), 0); - assert_eq!(C2.fetch_add(1, atomic::SeqCst), 0); + assert_eq!(C2.fetch_add(1, Ordering::SeqCst), 0); + assert_eq!(C2.fetch_add(1, Ordering::SeqCst), 0); assert_eq!(C4, 2); assert_eq!(*C5, 2); assert_eq!(C6, 3); assert_eq!(S1, 3); - assert_eq!(S2.fetch_add(1, atomic::SeqCst), 0); - assert_eq!(S2.fetch_add(1, atomic::SeqCst), 1); + assert_eq!(S2.fetch_add(1, Ordering::SeqCst), 0); + assert_eq!(S2.fetch_add(1, Ordering::SeqCst), 1); match 1 { C1 => {} @@ -62,13 +62,13 @@ fn main() { assert_eq!(other::C1, 1); assert_eq!(other::C3(), ()); - assert_eq!(other::C2.fetch_add(1, atomic::SeqCst), 0); - assert_eq!(other::C2.fetch_add(1, atomic::SeqCst), 0); + assert_eq!(other::C2.fetch_add(1, Ordering::SeqCst), 0); + assert_eq!(other::C2.fetch_add(1, Ordering::SeqCst), 0); assert_eq!(other::C4, 2); assert_eq!(*other::C5, 2); assert_eq!(other::S1, 3); - assert_eq!(other::S2.fetch_add(1, atomic::SeqCst), 0); - assert_eq!(other::S2.fetch_add(1, atomic::SeqCst), 1); + assert_eq!(other::S2.fetch_add(1, Ordering::SeqCst), 0); + assert_eq!(other::S2.fetch_add(1, Ordering::SeqCst), 1); let _a = other::C1; let _a = other::C2; diff --git a/src/test/run-pass/issue-2383.rs b/src/test/run-pass/issue-2383.rs index 39995db5a2f54..94bff890820dd 100644 --- a/src/test/run-pass/issue-2383.rs +++ b/src/test/run-pass/issue-2383.rs @@ -14,5 +14,5 @@ use std::collections::RingBuf; pub fn main() { let mut q = RingBuf::new(); - q.push(10i); + q.push_front(10i); } diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index 2a4ca5b421056..f414606340924 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -22,7 +22,7 @@ pub mod pipes { use std::mem::{forget, transmute}; use std::mem::{replace, swap}; use std::mem; - use std::task; + use std::thread::Thread; use std::kinds::Send; pub struct Stuff<T> { @@ -116,7 +116,7 @@ pub mod pipes { let old_state = swap_state_acq(&mut (*p).state, blocked); match old_state { - empty | blocked => { task::deschedule(); } + empty | blocked => { Thread::yield_now(); } full => { let payload = replace(&mut p.payload, None); return Some(payload.unwrap()) diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs index ab2d1d9009348..25b933b8f96fe 100644 --- a/src/test/run-pass/issue-2804.rs +++ b/src/test/run-pass/issue-2804.rs @@ -23,7 +23,7 @@ enum object { fn lookup(table: json::Object, key: String, default: String) -> String { - match table.find(&key.to_string()) { + match table.get(&key) { option::Option::Some(&Json::String(ref s)) => { s.to_string() } diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs index d625f6bcf92fa..bef082569b9c6 100644 --- a/src/test/run-pass/issue-2989.rs +++ b/src/test/run-pass/issue-2989.rs @@ -14,19 +14,19 @@ trait methods { impl methods for () { fn to_bytes(&self) -> Vec<u8> { - Vec::from_elem(0, 0u8) + Vec::new() } } // the position of this function is significant! - if it comes before methods // then it works, if it comes after it then it doesn't! fn to_bools(bitv: Storage) -> Vec<bool> { - Vec::from_fn(8, |i| { + range(0, 8).map(|i| { let w = i / 64; let b = i % 64; let x = 1u64 & (bitv.storage[w] >> b); x == 1u64 - }) + }).collect() } struct Storage { storage: Vec<u64> } diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs index d04d8f92ac40d..a3903128b6539 100644 --- a/src/test/run-pass/issue-3563-3.rs +++ b/src/test/run-pass/issue-3563-3.rs @@ -8,20 +8,23 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ASCII art shape renderer. -// Demonstrates traits, impls, operator overloading, non-copyable struct, unit testing. -// To run execute: rustc --test shapes.rs && ./shapes +// ASCII art shape renderer. Demonstrates traits, impls, operator overloading, +// non-copyable struct, unit testing. To run execute: rustc --test shapes.rs && +// ./shapes -// Rust's std library is tightly bound to the language itself so it is automatically linked in. -// However the extra library is designed to be optional (for code that must run on constrained -// environments like embedded devices or special environments like kernel code) so it must -// be explicitly linked in. +// Rust's std library is tightly bound to the language itself so it is +// automatically linked in. However the extra library is designed to be +// optional (for code that must run on constrained environments like embedded +// devices or special environments like kernel code) so it must be explicitly +// linked in. -// Extern mod controls linkage. Use controls the visibility of names to modules that are -// already linked in. Using WriterUtil allows us to use the write_line method. +// Extern mod controls linkage. Use controls the visibility of names to modules +// that are already linked in. Using WriterUtil allows us to use the write_line +// method. -use std::slice; use std::fmt; +use std::iter::repeat; +use std::slice; // Represents a position on a canvas. struct Point { @@ -70,7 +73,7 @@ fn AsciiArt(width: uint, height: uint, fill: char) -> AsciiArt { // blank characters for each position in our canvas. let mut lines = Vec::new(); for _ in range(0, height) { - lines.push(Vec::from_elem(width, '.')); + lines.push(repeat('.').take(width).collect::<Vec<_>>()); } // Rust code often returns values by omitting the trailing semi-colon @@ -105,7 +108,7 @@ impl fmt::Show for AsciiArt { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Convert each line into a string. let lines = self.lines.iter() - .map(|line| String::from_chars(line.as_slice())) + .map(|line| line.iter().cloned().collect()) .collect::<Vec<String>>(); // Concatenate the lines together using a new-line. diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs index a02dbb6035bfa..b89ee81a7274f 100644 --- a/src/test/run-pass/issue-3609.rs +++ b/src/test/run-pass/issue-3609.rs @@ -10,7 +10,7 @@ #![feature(default_type_params)] -use std::task; +use std::thread::Thread; use std::sync::mpsc::Sender; use std::thunk::Invoke; @@ -23,7 +23,7 @@ enum Msg } fn foo(name: String, samples_chan: Sender<Msg>) { - task::spawn(move|| { + let _t = Thread::spawn(move|| { let mut samples_chan = samples_chan; // `box() (...)` syntax is needed to make pretty printer converge in one try: diff --git a/src/test/run-pass/issue-8460.rs b/src/test/run-pass/issue-8460.rs index b9b365e3e660a..3d5e32972e724 100644 --- a/src/test/run-pass/issue-8460.rs +++ b/src/test/run-pass/issue-8460.rs @@ -9,27 +9,27 @@ // except according to those terms. use std::{int, i8, i16, i32, i64}; -use std::task; +use std::thread::Thread; fn main() { - assert!(task::try(move|| int::MIN / -1).is_err()); - assert!(task::try(move|| i8::MIN / -1).is_err()); - assert!(task::try(move|| i16::MIN / -1).is_err()); - assert!(task::try(move|| i32::MIN / -1).is_err()); - assert!(task::try(move|| i64::MIN / -1).is_err()); - assert!(task::try(move|| 1i / 0).is_err()); - assert!(task::try(move|| 1i8 / 0).is_err()); - assert!(task::try(move|| 1i16 / 0).is_err()); - assert!(task::try(move|| 1i32 / 0).is_err()); - assert!(task::try(move|| 1i64 / 0).is_err()); - assert!(task::try(move|| int::MIN % -1).is_err()); - assert!(task::try(move|| i8::MIN % -1).is_err()); - assert!(task::try(move|| i16::MIN % -1).is_err()); - assert!(task::try(move|| i32::MIN % -1).is_err()); - assert!(task::try(move|| i64::MIN % -1).is_err()); - assert!(task::try(move|| 1i % 0).is_err()); - assert!(task::try(move|| 1i8 % 0).is_err()); - assert!(task::try(move|| 1i16 % 0).is_err()); - assert!(task::try(move|| 1i32 % 0).is_err()); - assert!(task::try(move|| 1i64 % 0).is_err()); + assert!(Thread::spawn(move|| int::MIN / -1).join().is_err()); + assert!(Thread::spawn(move|| i8::MIN / -1).join().is_err()); + assert!(Thread::spawn(move|| i16::MIN / -1).join().is_err()); + assert!(Thread::spawn(move|| i32::MIN / -1).join().is_err()); + assert!(Thread::spawn(move|| i64::MIN / -1).join().is_err()); + assert!(Thread::spawn(move|| 1i / 0).join().is_err()); + assert!(Thread::spawn(move|| 1i8 / 0).join().is_err()); + assert!(Thread::spawn(move|| 1i16 / 0).join().is_err()); + assert!(Thread::spawn(move|| 1i32 / 0).join().is_err()); + assert!(Thread::spawn(move|| 1i64 / 0).join().is_err()); + assert!(Thread::spawn(move|| int::MIN % -1).join().is_err()); + assert!(Thread::spawn(move|| i8::MIN % -1).join().is_err()); + assert!(Thread::spawn(move|| i16::MIN % -1).join().is_err()); + assert!(Thread::spawn(move|| i32::MIN % -1).join().is_err()); + assert!(Thread::spawn(move|| i64::MIN % -1).join().is_err()); + assert!(Thread::spawn(move|| 1i % 0).join().is_err()); + assert!(Thread::spawn(move|| 1i8 % 0).join().is_err()); + assert!(Thread::spawn(move|| 1i16 % 0).join().is_err()); + assert!(Thread::spawn(move|| 1i32 % 0).join().is_err()); + assert!(Thread::spawn(move|| 1i64 % 0).join().is_err()); } diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs index a9a50b9ef25af..dd38a5f8b3ba7 100644 --- a/src/test/run-pass/ivec-tag.rs +++ b/src/test/run-pass/ivec-tag.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; use std::sync::mpsc::{channel, Sender}; fn producer(tx: &Sender<Vec<u8>>) { @@ -19,7 +19,7 @@ fn producer(tx: &Sender<Vec<u8>>) { pub fn main() { let (tx, rx) = channel::<Vec<u8>>(); - let _prod = task::spawn(move|| { + let _prod = Thread::spawn(move|| { producer(&tx) }); diff --git a/src/test/run-pass/kindck-implicit-close-over-mut-var.rs b/src/test/run-pass/kindck-implicit-close-over-mut-var.rs index d745226af4408..f2d509ee61ddd 100644 --- a/src/test/run-pass/kindck-implicit-close-over-mut-var.rs +++ b/src/test/run-pass/kindck-implicit-close-over-mut-var.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; fn user(_i: int) {} @@ -16,7 +16,7 @@ fn foo() { // Here, i is *copied* into the proc (heap closure). // Requires allocation. The proc's copy is not mutable. let mut i = 0; - task::spawn(move|| { + let _t = Thread::spawn(move|| { user(i); println!("spawned {}", i) }); @@ -29,7 +29,7 @@ fn bar() { // mutable outside of the proc. let mut i = 0; while i < 10 { - task::spawn(move|| { + let _t = Thread::spawn(move|| { user(i); }); i += 1; @@ -40,7 +40,7 @@ fn car() { // Here, i must be shadowed in the proc to be mutable. let mut i = 0; while i < 10 { - task::spawn(move|| { + let _t = Thread::spawn(move|| { let mut i = i; i += 1; user(i); diff --git a/src/test/run-pass/match-with-ret-arm.rs b/src/test/run-pass/match-with-ret-arm.rs index 2cba1dec2dc99..a1537e63e57b2 100644 --- a/src/test/run-pass/match-with-ret-arm.rs +++ b/src/test/run-pass/match-with-ret-arm.rs @@ -9,13 +9,12 @@ // except according to those terms. use std::uint; -use std::str::from_str; pub fn main() { // sometimes we have had trouble finding // the right type for f, as we unified // bot and u32 here - let f = match from_str::<uint>("1234") { + let f = match "1234".parse::<uint>() { None => return (), Some(num) => num as u32 }; diff --git a/src/test/run-pass/mod-view-items.rs b/src/test/run-pass/mod-view-items.rs index 2b23787dd0f7f..f03ec7b6f3e12 100644 --- a/src/test/run-pass/mod-view-items.rs +++ b/src/test/run-pass/mod-view-items.rs @@ -16,7 +16,7 @@ // begin failing. mod m { - pub fn f() -> Vec<int> { Vec::from_elem(1u, 0i) } + pub fn f() -> Vec<int> { Vec::new() } } pub fn main() { let _x = m::f(); } diff --git a/src/test/run-pass/moves-based-on-type-capture-clause.rs b/src/test/run-pass/moves-based-on-type-capture-clause.rs index e5694aefdf4c3..3596fa1a0063f 100644 --- a/src/test/run-pass/moves-based-on-type-capture-clause.rs +++ b/src/test/run-pass/moves-based-on-type-capture-clause.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; pub fn main() { let x = "Hello world!".to_string(); - task::spawn(move|| { + let _t = Thread::spawn(move|| { println!("{}", x); }); } diff --git a/src/test/run-pass/no-landing-pads.rs b/src/test/run-pass/no-landing-pads.rs index e8bf366df957d..6b1553cd9f600 100644 --- a/src/test/run-pass/no-landing-pads.rs +++ b/src/test/run-pass/no-landing-pads.rs @@ -10,7 +10,7 @@ // compile-flags: -Z no-landing-pads -use std::task; +use std::thread::Thread; static mut HIT: bool = false; @@ -23,9 +23,9 @@ impl Drop for A { } fn main() { - task::try(move|| -> () { + Thread::spawn(move|| -> () { let _a = A; panic!(); - }); + }).join().unwrap_err(); assert!(unsafe { !HIT }); } diff --git a/src/test/run-pass/panic-in-dtor-drops-fields.rs b/src/test/run-pass/panic-in-dtor-drops-fields.rs index 39252d6b14268..5c692bf880181 100644 --- a/src/test/run-pass/panic-in-dtor-drops-fields.rs +++ b/src/test/run-pass/panic-in-dtor-drops-fields.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; static mut dropped: bool = false; @@ -33,9 +33,9 @@ impl Drop for B { } pub fn main() { - let ret = task::try(move|| { + let ret = Thread::spawn(move|| { let _a = A { b: B { foo: 3 } }; - }); + }).join(); assert!(ret.is_err()); unsafe { assert!(dropped); } } diff --git a/src/test/run-pass/realloc-16687.rs b/src/test/run-pass/realloc-16687.rs index a29ed712d400b..80ee735be706e 100644 --- a/src/test/run-pass/realloc-16687.rs +++ b/src/test/run-pass/realloc-16687.rs @@ -17,6 +17,7 @@ extern crate alloc; use alloc::heap; use std::ptr; +use std::iter::repeat; fn main() { unsafe { @@ -26,7 +27,7 @@ fn main() { unsafe fn test_triangle() -> bool { static COUNT : uint = 16; - let mut ascend = Vec::from_elem(COUNT, ptr::null_mut()); + let mut ascend = repeat(ptr::null_mut()).take(COUNT).collect::<Vec<_>>(); let ascend = ascend.as_mut_slice(); static ALIGN : uint = 1; diff --git a/src/test/run-pass/running-with-no-runtime.rs b/src/test/run-pass/running-with-no-runtime.rs index 0aeade935dadb..fc53737bb445a 100644 --- a/src/test/run-pass/running-with-no-runtime.rs +++ b/src/test/run-pass/running-with-no-runtime.rs @@ -33,9 +33,9 @@ fn start(argc: int, argv: *const *const u8) -> int { } let args = unsafe { - Vec::from_fn(argc as uint, |i| { + range(0, argc as uint).map(|i| { String::from_raw_buf(*argv.offset(i as int)).into_bytes() - }) + }).collect::<Vec<_>>() }; let me = args[0].as_slice(); diff --git a/src/test/run-pass/send-resource.rs b/src/test/run-pass/send-resource.rs index 7fd9706bd0fea..a920d76e7ca1b 100644 --- a/src/test/run-pass/send-resource.rs +++ b/src/test/run-pass/send-resource.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; use std::sync::mpsc::channel; struct test { @@ -28,7 +28,7 @@ fn test(f: int) -> test { pub fn main() { let (tx, rx) = channel(); - task::spawn(move|| { + let _t = Thread::spawn(move|| { let (tx2, rx2) = channel(); tx.send(tx2).unwrap(); diff --git a/src/test/run-pass/send_str_hashmap.rs b/src/test/run-pass/send_str_hashmap.rs index bfeff58b802df..c58654670d1a3 100644 --- a/src/test/run-pass/send_str_hashmap.rs +++ b/src/test/run-pass/send_str_hashmap.rs @@ -11,8 +11,9 @@ extern crate collections; use std::collections::HashMap; -use std::str::SendStr; -use std::borrow::IntoCow; +use std::borrow::{Cow, IntoCow}; + +type SendStr = Cow<'static, String, str>; pub fn main() { let mut map: HashMap<SendStr, uint> = HashMap::new(); diff --git a/src/test/run-pass/send_str_treemap.rs b/src/test/run-pass/send_str_treemap.rs index 8c70738de48f1..438724a2b06bf 100644 --- a/src/test/run-pass/send_str_treemap.rs +++ b/src/test/run-pass/send_str_treemap.rs @@ -11,8 +11,9 @@ extern crate collections; use self::collections::BTreeMap; -use std::str::SendStr; -use std::borrow::IntoCow; +use std::borrow::{Cow, IntoCow}; + +type SendStr = Cow<'static, String, str>; pub fn main() { let mut map: BTreeMap<SendStr, uint> = BTreeMap::new(); diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs index 838c627040dbc..3ed835dc5bdf9 100644 --- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs +++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; pub fn main() { test05(); } @@ -22,7 +22,7 @@ fn test05() { println!("{}", *three + n); // will copy x into the closure assert_eq!(*three, 3); }; - task::spawn(move|| { + Thread::spawn(move|| { test05_start(fn_to_send); - }); + }).join().ok().unwrap(); } diff --git a/src/test/run-pass/sepcomp-unwind.rs b/src/test/run-pass/sepcomp-unwind.rs index ccebfa72384f9..246957a4f4608 100644 --- a/src/test/run-pass/sepcomp-unwind.rs +++ b/src/test/run-pass/sepcomp-unwind.rs @@ -19,6 +19,8 @@ // In any case, this test should let us know if enabling parallel codegen ever // breaks unwinding. +use std::thread::Thread; + fn pad() -> uint { 0 } mod a { @@ -34,5 +36,5 @@ mod b { } fn main() { - std::task::try(move|| { ::b::g() }).unwrap_err(); + Thread::spawn(move|| { ::b::g() }).join().unwrap_err(); } diff --git a/src/test/run-pass/slice-panic-1.rs b/src/test/run-pass/slice-panic-1.rs index b66641affc910..13f2971871ba8 100644 --- a/src/test/run-pass/slice-panic-1.rs +++ b/src/test/run-pass/slice-panic-1.rs @@ -12,7 +12,7 @@ #![feature(slicing_syntax)] -use std::task; +use std::thread::Thread; struct Foo; @@ -28,6 +28,6 @@ fn foo() { } fn main() { - let _ = task::try(move|| foo()); + let _ = Thread::spawn(move|| foo()).join(); unsafe { assert!(DTOR_COUNT == 2); } } diff --git a/src/test/run-pass/slice-panic-2.rs b/src/test/run-pass/slice-panic-2.rs index f7e241554c1e8..ccbb33d7768c4 100644 --- a/src/test/run-pass/slice-panic-2.rs +++ b/src/test/run-pass/slice-panic-2.rs @@ -12,7 +12,7 @@ #![feature(slicing_syntax)] -use std::task; +use std::thread::Thread; struct Foo; @@ -32,6 +32,6 @@ fn foo() { } fn main() { - let _ = task::try(move|| foo()); + let _ = Thread::spawn(move|| foo()).join(); unsafe { assert!(DTOR_COUNT == 2); } } diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs index b632bc77c7582..c8fe400c4c3c6 100644 --- a/src/test/run-pass/spawn-fn.rs +++ b/src/test/run-pass/spawn-fn.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; fn x(s: String, n: int) { println!("{}", s); @@ -16,13 +16,13 @@ fn x(s: String, n: int) { } pub fn main() { - task::spawn(move|| x("hello from first spawned fn".to_string(), 65) ); - task::spawn(move|| x("hello from second spawned fn".to_string(), 66) ); - task::spawn(move|| x("hello from third spawned fn".to_string(), 67) ); + let _t = Thread::spawn(|| x("hello from first spawned fn".to_string(), 65) ); + let _t = Thread::spawn(|| x("hello from second spawned fn".to_string(), 66) ); + let _t = Thread::spawn(|| x("hello from third spawned fn".to_string(), 67) ); let mut i: int = 30; while i > 0 { i = i - 1; println!("parent sleeping"); - task::deschedule(); + Thread::yield_now(); } } diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs index 1c86e3e6ea236..bb9de7cecc98c 100644 --- a/src/test/run-pass/spawn-types.rs +++ b/src/test/run-pass/spawn-types.rs @@ -14,7 +14,7 @@ Arnold. */ -use std::task; +use std::thread::Thread; use std::sync::mpsc::{channel, Sender}; type ctx = Sender<int>; @@ -25,5 +25,6 @@ fn iotask(_tx: &ctx, ip: String) { pub fn main() { let (tx, _rx) = channel::<int>(); - task::spawn(move|| iotask(&tx, "localhost".to_string()) ); + let t = Thread::spawn(move|| iotask(&tx, "localhost".to_string()) ); + t.join().ok().unwrap(); } diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs index cfc1967ae24f1..820dd49142ac6 100644 --- a/src/test/run-pass/spawn.rs +++ b/src/test/run-pass/spawn.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; pub fn main() { - task::spawn(move|| child(10) ); + Thread::spawn(move|| child(10)).join().ok().unwrap(); } fn child(i: int) { println!("{}", i); assert!((i == 10)); } diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs index 72db4de2c8d40..50c2d79132ef5 100644 --- a/src/test/run-pass/spawn2.rs +++ b/src/test/run-pass/spawn2.rs @@ -8,9 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; -pub fn main() { task::spawn(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) ); } +pub fn main() { + let t = Thread::spawn(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) ); + t.join().ok().unwrap(); +} fn child(args: (int, int, int, int, int, int, int, int, int)) { let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args; diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs index de077ffd19020..78826666f53ff 100644 --- a/src/test/run-pass/task-comm-0.rs +++ b/src/test/run-pass/task-comm-0.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; use std::sync::mpsc::{channel, Sender}; pub fn main() { test05(); } @@ -24,7 +24,7 @@ fn test05_start(tx : &Sender<int>) { fn test05() { let (tx, rx) = channel(); - task::spawn(move|| { test05_start(&tx) }); + let _t = Thread::spawn(move|| { test05_start(&tx) }); let mut value: int = rx.recv().unwrap(); println!("{}", value); value = rx.recv().unwrap(); diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs index 4117f201547b1..966bb6aa7358b 100644 --- a/src/test/run-pass/task-comm-1.rs +++ b/src/test/run-pass/task-comm-1.rs @@ -8,13 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; pub fn main() { test00(); } fn start() { println!("Started / Finished task."); } fn test00() { - task::try(move|| start() ); + let _ = Thread::spawn(move|| start() ).join(); println!("Completing."); } diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs index 93dca923b6b98..60af3afec2b3d 100644 --- a/src/test/run-pass/task-comm-10.rs +++ b/src/test/run-pass/task-comm-10.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; use std::sync::mpsc::{channel, Sender}; fn start(tx: &Sender<Sender<String>>) { @@ -27,10 +27,10 @@ fn start(tx: &Sender<Sender<String>>) { pub fn main() { let (tx, rx) = channel(); - let _child = task::spawn(move|| { start(&tx) }); + let _child = Thread::spawn(move|| { start(&tx) }); let mut c = rx.recv().unwrap(); c.send("A".to_string()).unwrap(); c.send("B".to_string()).unwrap(); - task::deschedule(); + Thread::yield_now(); } diff --git a/src/test/run-pass/task-comm-11.rs b/src/test/run-pass/task-comm-11.rs index 8168e84e42674..1740c49c7720b 100644 --- a/src/test/run-pass/task-comm-11.rs +++ b/src/test/run-pass/task-comm-11.rs @@ -9,17 +9,17 @@ // except according to those terms. use std::sync::mpsc::{channel, Sender}; -use std::task; +use std::thread::Thread; fn start(tx: &Sender<Sender<int>>) { let (tx2, _rx) = channel(); - tx.send(tx2); + tx.send(tx2).unwrap(); } pub fn main() { let (tx, rx) = channel(); - let _child = task::spawn(move|| { + let _child = Thread::spawn(move|| { start(&tx) }); - let _tx = rx.recv(); + let _tx = rx.recv().unwrap(); } diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs index bb92ef38728fa..50667d375a13c 100644 --- a/src/test/run-pass/task-comm-13.rs +++ b/src/test/run-pass/task-comm-13.rs @@ -9,16 +9,16 @@ // except according to those terms. use std::sync::mpsc::{channel, Sender}; -use std::task; +use std::thread::Thread; fn start(tx: &Sender<int>, start: int, number_of_messages: int) { let mut i: int = 0; - while i < number_of_messages { tx.send(start + i); i += 1; } + while i< number_of_messages { tx.send(start + i).unwrap(); i += 1; } } pub fn main() { println!("Check that we don't deadlock."); let (tx, rx) = channel(); - task::try(move|| { start(&tx, 0, 10) }); + let _ = Thread::spawn(move|| { start(&tx, 0, 10) }).join(); println!("Joined task"); } diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs index d63cbd5c8ba17..82e4bd8f6d2a1 100644 --- a/src/test/run-pass/task-comm-14.rs +++ b/src/test/run-pass/task-comm-14.rs @@ -9,7 +9,7 @@ // except according to those terms. use std::sync::mpsc::{channel, Sender}; -use std::task; +use std::thread::Thread; pub fn main() { let (tx, rx) = channel(); @@ -19,7 +19,7 @@ pub fn main() { while (i > 0) { println!("{}", i); let tx = tx.clone(); - task::spawn({let i = i; move|| { child(i, &tx) }}); + Thread::spawn({let i = i; move|| { child(i, &tx) }}).detach(); i = i - 1; } @@ -29,7 +29,7 @@ pub fn main() { i = 10; while (i > 0) { println!("{}", i); - rx.recv(); + rx.recv().unwrap(); i = i - 1; } @@ -38,5 +38,5 @@ pub fn main() { fn child(x: int, tx: &Sender<int>) { println!("{}", x); - tx.send(x); + tx.send(x).unwrap(); } diff --git a/src/test/run-pass/task-comm-15.rs b/src/test/run-pass/task-comm-15.rs index 7c652ddc406fc..28eea784f361c 100644 --- a/src/test/run-pass/task-comm-15.rs +++ b/src/test/run-pass/task-comm-15.rs @@ -9,12 +9,12 @@ // except according to those terms. use std::sync::mpsc::{channel, Sender}; -use std::task; +use std::thread::Thread; fn start(tx: &Sender<int>, i0: int) { let mut i = i0; while i > 0 { - tx.send(0); + tx.send(0).unwrap(); i = i - 1; } } @@ -25,7 +25,7 @@ pub fn main() { // the child's point of view the receiver may die. We should // drop messages on the floor in this case, and not crash! let (tx, rx) = channel(); - task::spawn(move|| { + let _t = Thread::spawn(move|| { start(&tx, 10) }); rx.recv(); diff --git a/src/test/run-pass/task-comm-17.rs b/src/test/run-pass/task-comm-17.rs index 3a591d12864af..e9f7cdf96a83a 100644 --- a/src/test/run-pass/task-comm-17.rs +++ b/src/test/run-pass/task-comm-17.rs @@ -12,11 +12,11 @@ // This test is specifically about spawning temporary closures. -use std::task; +use std::thread::Thread; fn f() { } pub fn main() { - task::spawn(move|| f() ); + let _t = Thread::spawn(move|| f() ).join(); } diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs index 054090eca3903..6f3b47b8bfa7a 100644 --- a/src/test/run-pass/task-comm-7.rs +++ b/src/test/run-pass/task-comm-7.rs @@ -11,7 +11,7 @@ #![allow(dead_assignment)] use std::sync::mpsc::{channel, Sender}; -use std::task; +use std::thread::Thread; pub fn main() { test00(); } @@ -28,19 +28,19 @@ fn test00() { let number_of_messages: int = 10; let tx2 = tx.clone(); - task::spawn(move|| { + let _t = Thread::spawn(move|| { test00_start(&tx2, number_of_messages * 0, number_of_messages); }); let tx2 = tx.clone(); - task::spawn(move|| { + let _t = Thread::spawn(move|| { test00_start(&tx2, number_of_messages * 1, number_of_messages); }); let tx2 = tx.clone(); - task::spawn(move|| { + let _t = Thread::spawn(move|| { test00_start(&tx2, number_of_messages * 2, number_of_messages); }); let tx2 = tx.clone(); - task::spawn(move|| { + let _t = Thread::spawn(move|| { test00_start(&tx2, number_of_messages * 3, number_of_messages); }); diff --git a/src/test/run-pass/task-life-0.rs b/src/test/run-pass/task-life-0.rs index 5c73f44f2d66a..3f229926480a9 100644 --- a/src/test/run-pass/task-life-0.rs +++ b/src/test/run-pass/task-life-0.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; pub fn main() { - task::spawn(move|| child("Hello".to_string()) ); + let _t = Thread::spawn(move|| child("Hello".to_string()) ); } fn child(_s: String) { 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 623a30eda1a4b..b2bcf395783ae 100644 --- a/src/test/run-pass/task-spawn-move-and-copy.rs +++ b/src/test/run-pass/task-spawn-move-and-copy.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; use std::sync::mpsc::channel; pub fn main() { @@ -17,7 +17,7 @@ pub fn main() { let x = box 1; let x_in_parent = &(*x) as *const int as uint; - task::spawn(move || { + let _t = Thread::spawn(move || { let x_in_child = &(*x) as *const int as uint; tx.send(x_in_child).unwrap(); }); diff --git a/src/test/run-pass/tcp-accept-stress.rs b/src/test/run-pass/tcp-accept-stress.rs index 07f71fe580e9f..3e6158ca82193 100644 --- a/src/test/run-pass/tcp-accept-stress.rs +++ b/src/test/run-pass/tcp-accept-stress.rs @@ -13,9 +13,10 @@ // quite quickly and it takes a few seconds for the sockets to get // recycled. -use std::sync::mpsc::channel; use std::io::{TcpListener, Listener, Acceptor, EndOfFile, TcpStream}; -use std::sync::{atomic, Arc}; +use std::sync::Arc; +use std::sync::atomic::{AtomicUint, Ordering}; +use std::sync::mpsc::channel; use std::thread::Thread; static N: uint = 8; @@ -29,7 +30,7 @@ fn test() { let mut l = TcpListener::bind("127.0.0.1:0").unwrap(); let addr = l.socket_name().unwrap(); let mut a = l.listen().unwrap(); - let cnt = Arc::new(atomic::AtomicUint::new(0)); + let cnt = Arc::new(AtomicUint::new(0)); let (srv_tx, srv_rx) = channel(); let (cli_tx, cli_rx) = channel(); @@ -42,7 +43,7 @@ fn test() { loop { match a.accept() { Ok(..) => { - if cnt.fetch_add(1, atomic::SeqCst) == N * M - 1 { + if cnt.fetch_add(1, Ordering::SeqCst) == N * M - 1 { break } } @@ -81,5 +82,5 @@ fn test() { assert_eq!(srv_rx.iter().take(N - 1).count(), N - 1); // Everything should have been accepted. - assert_eq!(cnt.load(atomic::SeqCst), N * M); + assert_eq!(cnt.load(Ordering::SeqCst), N * M); } diff --git a/src/test/run-pass/tcp-connect-timeouts.rs b/src/test/run-pass/tcp-connect-timeouts.rs index 38a762d58032c..6812255d82ca0 100644 --- a/src/test/run-pass/tcp-connect-timeouts.rs +++ b/src/test/run-pass/tcp-connect-timeouts.rs @@ -27,6 +27,7 @@ use std::io::test::*; use std::io; use std::time::Duration; use std::sync::mpsc::channel; +use std::thread::Thread; #[cfg_attr(target_os = "freebsd", ignore)] fn eventual_timeout() { @@ -34,7 +35,7 @@ fn eventual_timeout() { let (tx1, rx1) = channel(); let (_tx2, rx2) = channel::<()>(); - std::task::spawn(move|| { + let _t = Thread::spawn(move|| { let _l = TcpListener::bind(addr).unwrap().listen(); tx1.send(()).unwrap(); let _ = rx2.recv(); diff --git a/src/test/run-pass/tempfile.rs b/src/test/run-pass/tempfile.rs index 9e67095bb3031..8fda8a951693f 100644 --- a/src/test/run-pass/tempfile.rs +++ b/src/test/run-pass/tempfile.rs @@ -22,8 +22,8 @@ use std::io::fs::PathExtensions; use std::io::{fs, TempDir}; use std::io; use std::os; -use std::task; use std::sync::mpsc::channel; +use std::thread::Thread; fn test_tempdir() { let path = { @@ -42,7 +42,7 @@ fn test_rm_tempdir() { tx.send(tmp.path().clone()).unwrap(); panic!("panic to unwind past `tmp`"); }; - task::try(f); + let _ = Thread::spawn(f).join(); let path = rx.recv().unwrap(); assert!(!path.exists()); @@ -52,7 +52,7 @@ fn test_rm_tempdir() { let _tmp = tmp; panic!("panic to unwind past `tmp`"); }; - task::try(f); + let _ = Thread::spawn(f).join(); assert!(!path.exists()); let path; @@ -60,7 +60,7 @@ fn test_rm_tempdir() { let f = move|:| { TempDir::new("test_rm_tempdir").unwrap() }; - let tmp = task::try(f).ok().expect("test_rm_tmdir"); + let tmp = Thread::spawn(f).join().ok().expect("test_rm_tmdir"); path = tmp.path().clone(); assert!(path.exists()); } @@ -69,7 +69,7 @@ fn test_rm_tempdir() { let path; { let tmp = TempDir::new("test_rm_tempdir").unwrap(); - path = tmp.unwrap(); + path = tmp.into_inner(); } assert!(path.exists()); fs::rmdir_recursive(&path); @@ -84,7 +84,7 @@ fn test_rm_tempdir_close() { tmp.close(); panic!("panic when unwinding past `tmp`"); }; - task::try(f); + let _ = Thread::spawn(f).join(); let path = rx.recv().unwrap(); assert!(!path.exists()); @@ -95,7 +95,7 @@ fn test_rm_tempdir_close() { tmp.close(); panic!("panic when unwinding past `tmp`"); }; - task::try(f); + let _ = Thread::spawn(f).join(); assert!(!path.exists()); let path; @@ -103,7 +103,7 @@ fn test_rm_tempdir_close() { let f = move|:| { TempDir::new("test_rm_tempdir").unwrap() }; - let tmp = task::try(f).ok().expect("test_rm_tmdir"); + let tmp = Thread::spawn(f).join().ok().expect("test_rm_tmdir"); path = tmp.path().clone(); assert!(path.exists()); tmp.close(); @@ -113,7 +113,7 @@ fn test_rm_tempdir_close() { let path; { let tmp = TempDir::new("test_rm_tempdir").unwrap(); - path = tmp.unwrap(); + path = tmp.into_inner(); } assert!(path.exists()); fs::rmdir_recursive(&path); @@ -177,7 +177,7 @@ pub fn test_rmdir_recursive_ok() { } pub fn dont_double_panic() { - let r: Result<(), _> = task::try(move|| { + let r: Result<(), _> = Thread::spawn(move|| { let tmpdir = TempDir::new("test").unwrap(); // Remove the temporary directory so that TempDir sees // an error on drop @@ -185,7 +185,7 @@ pub fn dont_double_panic() { // Panic. If TempDir panics *again* due to the rmdir // error then the process will abort. panic!(); - }); + }).join(); assert!(r.is_err()); } diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs index 28bbac1d0871c..4270ecc745092 100644 --- a/src/test/run-pass/terminate-in-initializer.rs +++ b/src/test/run-pass/terminate-in-initializer.rs @@ -12,7 +12,7 @@ // Issue #787 // Don't try to clean up uninitialized locals -use std::task; +use std::thread::Thread; fn test_break() { loop { let _x: Box<int> = break; } } @@ -22,13 +22,13 @@ fn test_ret() { let _x: Box<int> = return; } fn test_panic() { fn f() { let _x: Box<int> = panic!(); } - task::try(move|| f() ); + Thread::spawn(move|| f() ).join().err().unwrap(); } fn test_panic_indirect() { fn f() -> ! { panic!(); } fn g() { let _x: Box<int> = f(); } - task::try(move|| g() ); + Thread::spawn(move|| g() ).join().err().unwrap(); } pub fn main() { diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs index 71adf16c0511a..02817a285ddf5 100644 --- a/src/test/run-pass/threads.rs +++ b/src/test/run-pass/threads.rs @@ -8,11 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; pub fn main() { let mut i = 10; - while i > 0 { task::spawn({let i = i; move|| child(i)}); i = i - 1; } + while i > 0 { + Thread::spawn({let i = i; move|| child(i)}).detach(); + i = i - 1; + } println!("main thread exiting"); } diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs index 0d2cb60c213c1..c8abfcaa721de 100644 --- a/src/test/run-pass/trait-bounds-in-arc.rs +++ b/src/test/run-pass/trait-bounds-in-arc.rs @@ -13,7 +13,7 @@ use std::sync::Arc; use std::sync::mpsc::channel; -use std::task; +use std::thread::Thread; trait Pet { fn name(&self, blk: |&str|); @@ -77,13 +77,13 @@ pub fn main() { box dogge2 as Box<Pet+Sync+Send>)); let (tx1, rx1) = channel(); let arc1 = arc.clone(); - task::spawn(move|| { check_legs(arc1); tx1.send(()); }); + let _t1 = Thread::spawn(move|| { check_legs(arc1); tx1.send(()); }); let (tx2, rx2) = channel(); let arc2 = arc.clone(); - task::spawn(move|| { check_names(arc2); tx2.send(()); }); + let _t2 = Thread::spawn(move|| { check_names(arc2); tx2.send(()); }); let (tx3, rx3) = channel(); let arc3 = arc.clone(); - task::spawn(move|| { check_pedigree(arc3); tx3.send(()); }); + let _t3 = Thread::spawn(move|| { check_pedigree(arc3); tx3.send(()); }); rx1.recv(); rx2.recv(); rx3.recv(); diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs index f88c458f2ed76..bd4143348b886 100644 --- a/src/test/run-pass/unique-send-2.rs +++ b/src/test/run-pass/unique-send-2.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::sync::mpsc::{channel, Sender}; +use std::thread::Thread; fn child(tx: &Sender<Box<uint>>, i: uint) { tx.send(box i).unwrap(); @@ -21,9 +21,9 @@ pub fn main() { let mut expected = 0u; for i in range(0u, n) { let tx = tx.clone(); - task::spawn(move|| { + Thread::spawn(move|| { child(&tx, i) - }); + }).detach(); expected += i; } diff --git a/src/test/run-pass/unit-like-struct-drop-run.rs b/src/test/run-pass/unit-like-struct-drop-run.rs index e3cd694c0de6b..9aeb5b10cf5f8 100644 --- a/src/test/run-pass/unit-like-struct-drop-run.rs +++ b/src/test/run-pass/unit-like-struct-drop-run.rs @@ -11,7 +11,7 @@ // Make sure the destructor is run for unit-like structs. use std::boxed::BoxAny; -use std::task; +use std::thread::Thread; struct Foo; @@ -22,9 +22,9 @@ impl Drop for Foo { } pub fn main() { - let x = task::try(move|| { + let x = Thread::spawn(move|| { let _b = Foo; - }); + }).join(); let s = x.unwrap_err().downcast::<&'static str>().unwrap(); assert_eq!(s.as_slice(), "This panic should happen."); diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs index 943b2d3edd12e..3f59b2c6c7641 100644 --- a/src/test/run-pass/unwind-resource.rs +++ b/src/test/run-pass/unwind-resource.rs @@ -9,7 +9,7 @@ // except according to those terms. use std::sync::mpsc::{channel, Sender}; -use std::task; +use std::thread::Thread; struct complainer { tx: Sender<bool>, @@ -37,7 +37,7 @@ fn f(tx: Sender<bool>) { pub fn main() { let (tx, rx) = channel(); - task::spawn(move|| f(tx.clone())); + let _t = Thread::spawn(move|| f(tx.clone())); println!("hiiiiiiiii"); assert!(rx.recv().unwrap()); } diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs index 2f31ee25b5daa..554a08ea64460 100644 --- a/src/test/run-pass/unwind-unique.rs +++ b/src/test/run-pass/unwind-unique.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; fn f() { let _a = box 0i; @@ -16,5 +16,5 @@ fn f() { } pub fn main() { - task::spawn(f); + let _t = Thread::spawn(f); } diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs index d343e485b2481..1b2aa88cabe53 100644 --- a/src/test/run-pass/utf8_chars.rs +++ b/src/test/run-pass/utf8_chars.rs @@ -15,29 +15,29 @@ use std::str; pub fn main() { // Chars of 1, 2, 3, and 4 bytes let chs: Vec<char> = vec!('e', 'é', '€', '\U00010000'); - let s: String = String::from_chars(chs.as_slice()).to_string(); - let schs: Vec<char> = s.as_slice().chars().collect(); + let s: String = chs.iter().cloned().collect(); + let schs: Vec<char> = s.chars().collect(); assert!(s.len() == 10u); - assert!(s.as_slice().char_len() == 4u); + assert!(s.chars().count() == 4u); assert!(schs.len() == 4u); - assert!(String::from_chars(schs.as_slice()) == s); - assert!(s.as_slice().char_at(0u) == 'e'); - assert!(s.as_slice().char_at(1u) == 'é'); + assert!(schs.iter().cloned().collect::<String>() == s); + assert!(s.char_at(0u) == 'e'); + assert!(s.char_at(1u) == 'é'); - assert!((str::is_utf8(s.as_bytes()))); + assert!((str::from_utf8(s.as_bytes()).is_ok())); // invalid prefix - assert!((!str::is_utf8(&[0x80_u8]))); + assert!((!str::from_utf8(&[0x80_u8]).is_ok())); // invalid 2 byte prefix - assert!((!str::is_utf8(&[0xc0_u8]))); - assert!((!str::is_utf8(&[0xc0_u8, 0x10_u8]))); + assert!((!str::from_utf8(&[0xc0_u8]).is_ok())); + assert!((!str::from_utf8(&[0xc0_u8, 0x10_u8]).is_ok())); // invalid 3 byte prefix - assert!((!str::is_utf8(&[0xe0_u8]))); - assert!((!str::is_utf8(&[0xe0_u8, 0x10_u8]))); - assert!((!str::is_utf8(&[0xe0_u8, 0xff_u8, 0x10_u8]))); + assert!((!str::from_utf8(&[0xe0_u8]).is_ok())); + assert!((!str::from_utf8(&[0xe0_u8, 0x10_u8]).is_ok())); + assert!((!str::from_utf8(&[0xe0_u8, 0xff_u8, 0x10_u8]).is_ok())); // invalid 4 byte prefix - assert!((!str::is_utf8(&[0xf0_u8]))); - assert!((!str::is_utf8(&[0xf0_u8, 0x10_u8]))); - assert!((!str::is_utf8(&[0xf0_u8, 0xff_u8, 0x10_u8]))); - assert!((!str::is_utf8(&[0xf0_u8, 0xff_u8, 0xff_u8, 0x10_u8]))); + assert!((!str::from_utf8(&[0xf0_u8]).is_ok())); + assert!((!str::from_utf8(&[0xf0_u8, 0x10_u8]).is_ok())); + assert!((!str::from_utf8(&[0xf0_u8, 0xff_u8, 0x10_u8]).is_ok())); + assert!((!str::from_utf8(&[0xf0_u8, 0xff_u8, 0xff_u8, 0x10_u8]).is_ok())); } diff --git a/src/test/run-pass/vector-sort-panic-safe.rs b/src/test/run-pass/vector-sort-panic-safe.rs index 2da0ecd6d51b3..bdd62995e0a31 100644 --- a/src/test/run-pass/vector-sort-panic-safe.rs +++ b/src/test/run-pass/vector-sort-panic-safe.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; -use std::sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Relaxed}; +use std::sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering}; use std::rand::{thread_rng, Rng, Rand}; +use std::thread::Thread; const REPEATS: uint = 5; const MAX_LEN: uint = 32; @@ -36,7 +36,7 @@ struct DropCounter { x: uint, creation_id: uint } impl Rand for DropCounter { fn rand<R: Rng>(rng: &mut R) -> DropCounter { // (we're not using this concurrently, so Relaxed is fine.) - let num = creation_count.fetch_add(1, Relaxed); + let num = creation_count.fetch_add(1, Ordering::Relaxed); DropCounter { x: rng.gen(), creation_id: num @@ -46,7 +46,7 @@ impl Rand for DropCounter { impl Drop for DropCounter { fn drop(&mut self) { - drop_counts[self.creation_id].fetch_add(1, Relaxed); + drop_counts[self.creation_id].fetch_add(1, Ordering::Relaxed); } } @@ -57,7 +57,7 @@ pub fn main() { for _ in range(0, REPEATS) { // reset the count for these new DropCounters, so their // IDs start from 0. - creation_count.store(0, Relaxed); + creation_count.store(0, Ordering::Relaxed); let main = thread_rng().gen_iter::<DropCounter>() .take(len) @@ -72,27 +72,27 @@ pub fn main() { for panic_countdown in range(0i, count) { // refresh the counters. for c in drop_counts.iter() { - c.store(0, Relaxed); + c.store(0, Ordering::Relaxed); } let v = main.clone(); - let _ = task::try(move|| { - let mut v = v; - let mut panic_countdown = panic_countdown; - v.as_mut_slice().sort_by(|a, b| { - if panic_countdown == 0 { - panic!() - } - panic_countdown -= 1; - a.cmp(b) - }) - }); + let _ = Thread::spawn(move|| { + let mut v = v; + let mut panic_countdown = panic_countdown; + v.as_mut_slice().sort_by(|a, b| { + if panic_countdown == 0 { + panic!() + } + panic_countdown -= 1; + a.cmp(b) + }) + }).join(); // check that the number of things dropped is exactly // what we expect (i.e. the contents of `v`). for (i, c) in drop_counts.iter().enumerate().take(len) { - let count = c.load(Relaxed); + let count = c.load(Ordering::Relaxed); assert!(count == 1, "found drop count == {} for i == {}, len == {}", count, i, len); 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 624b41767049c..eb7205b5e0a83 100644 --- a/src/test/run-pass/wait-forked-but-failed-child.rs +++ b/src/test/run-pass/wait-forked-but-failed-child.rs @@ -11,8 +11,6 @@ extern crate libc; use std::io::process::Command; -use std::iter::IteratorExt; -use std::str::from_str; use libc::funcs::posix88::unistd; @@ -41,9 +39,10 @@ fn find_zombies() { for (line_no, line) in ps_output.split('\n').enumerate() { if 0 < line_no && 0 < line.len() && - my_pid == from_str(line.split(' ').filter(|w| 0 < w.len()).nth(1) - .expect("1st column should be PPID") - ).expect("PPID string into integer") && + my_pid == line.split(' ').filter(|w| 0 < w.len()).nth(1) + .expect("1st column should be PPID") + .parse() + .expect("PPID string into integer") && line.contains("defunct") { panic!("Zombie child {}", line); } @@ -56,12 +55,12 @@ fn find_zombies() { } fn main() { let too_long = format!("/NoSuchCommand{:0300}", 0u8); - let _failures = Vec::from_fn(100, |_i| { + let _failures = range(0, 100).map(|_| { let cmd = Command::new(too_long.as_slice()); let failed = cmd.spawn(); assert!(failed.is_err(), "Make sure the command fails to spawn(): {}", cmd); failed - }); + }).collect::<Vec<_>>(); find_zombies(); // then _failures goes out of scope diff --git a/src/test/run-pass/weak-lang-item.rs b/src/test/run-pass/weak-lang-item.rs index 87226eedfdcbf..08dac5c7c82da 100644 --- a/src/test/run-pass/weak-lang-item.rs +++ b/src/test/run-pass/weak-lang-item.rs @@ -12,10 +12,10 @@ extern crate "weak-lang-items" as other; -use std::task; +use std::thread::Thread; fn main() { - let _ = task::try(move|| { + let _ = Thread::spawn(move|| { other::foo() }); } diff --git a/src/test/run-pass/yield2.rs b/src/test/run-pass/yield2.rs index c6cb0dd65e772..66ad7de0296b1 100644 --- a/src/test/run-pass/yield2.rs +++ b/src/test/run-pass/yield2.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::task; +use std::thread::Thread; pub fn main() { let mut i: int = 0; - while i < 100 { i = i + 1; println!("{}", i); task::deschedule(); } + while i < 100 { i = i + 1; println!("{}", i); Thread::yield_now(); } }