From d992d3d9f3006f898dd0ad09458c85c66b23841c Mon Sep 17 00:00:00 2001 From: Steve Klabnik Date: Wed, 4 Feb 2015 02:19:54 -0500 Subject: [PATCH 01/35] Fix issue with rt::unwind::try() docs This is now a Result, not an Option. --- src/libstd/rt/unwind.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index 81ca5aa0e8a6e..cb2172d1dfc25 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -98,8 +98,8 @@ thread_local! { static PANICKING: Cell = Cell::new(false) } /// Invoke a closure, capturing the cause of panic if one occurs. /// -/// This function will return `None` if the closure did not panic, and will -/// return `Some(cause)` if the closure panics. The `cause` returned is the +/// This function will return `Ok(())` if the closure did not panic, and will +/// return `Err(cause)` if the closure panics. The `cause` returned is the /// object with which panic was originally invoked. /// /// This function also is unsafe for a variety of reasons: From 85a85c2070a6a967f1ccb1495391217fdb793112 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Tue, 3 Feb 2015 23:15:52 -0800 Subject: [PATCH 02/35] Switch missing_copy_implementations to default-allow This was particularly helpful in the time just after OIBIT's implementation to make sure things that were supposed to be Copy continued to be, but it's now creates a lot of noise for types that intentionally don't want to be Copy. --- src/doc/reference.md | 1 - src/libcollections/string.rs | 1 - src/libcore/hash/sip.rs | 1 - src/libcore/marker.rs | 2 -- src/libcore/str/mod.rs | 1 - src/liblibc/lib.rs | 5 ---- src/librand/lib.rs | 1 - src/librustc/lint/builtin.rs | 2 +- .../middle/infer/region_inference/mod.rs | 1 - src/librustc/middle/traits/coherence.rs | 1 - src/librustc/session/config.rs | 2 -- src/librustc/util/nodemap.rs | 1 - src/librustc/util/snapshot_vec.rs | 1 - src/librustc_borrowck/borrowck/mod.rs | 1 - src/librustc_llvm/lib.rs | 25 ------------------- src/librustc_trans/trans/value.rs | 1 - src/librustc_typeck/rscope.rs | 1 - src/libstd/collections/hash/map.rs | 2 -- src/libstd/dynamic_lib.rs | 1 - src/libstd/os.rs | 1 - src/libstd/rand/os.rs | 1 - src/libstd/rt/unwind.rs | 3 --- src/libstd/rt/util.rs | 1 - src/libstd/sync/barrier.rs | 1 - src/libstd/sync/poison.rs | 1 - src/test/compile-fail/lint-dead-code-1.rs | 1 - src/test/compile-fail/lint-missing-doc.rs | 1 - src/test/compile-fail/missing_debug_impls.rs | 2 +- 28 files changed, 2 insertions(+), 61 deletions(-) diff --git a/src/doc/reference.md b/src/doc/reference.md index 64ddb3ffdd39f..ecddb627c6590 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -1813,7 +1813,6 @@ default visibility with the `priv` keyword. When an item is declared as `pub`, it can be thought of as being accessible to the outside world. For example: ``` -# #![allow(missing_copy_implementations)] # fn main() {} // Declare a private struct struct Foo; diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 554eee765f3eb..508bd7e668621 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -49,7 +49,6 @@ pub struct FromUtf8Error { /// A possible error value from the `String::from_utf16` function. #[stable(feature = "rust1", since = "1.0.0")] -#[allow(missing_copy_implementations)] #[derive(Debug)] pub struct FromUtf16Error(()); diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index bef196d482460..d405d0d28beb3 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -30,7 +30,6 @@ use super::{Hasher, Writer}; /// strong, this implementation has not been reviewed for such purposes. /// As such, all cryptographic uses of this implementation are strongly /// discouraged. -#[allow(missing_copy_implementations)] pub struct SipHasher { k0: u64, k1: u64, diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 299cdbda3cc74..2d14b31748e5f 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -396,7 +396,6 @@ pub struct InvariantLifetime<'a>; reason = "likely to change with new variance strategy")] #[lang="no_copy_bound"] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] -#[allow(missing_copy_implementations)] pub struct NoCopy; /// A type which is considered managed by the GC. This is typically @@ -405,5 +404,4 @@ pub struct NoCopy; reason = "likely to change with new variance strategy")] #[lang="managed_bound"] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] -#[allow(missing_copy_implementations)] pub struct Managed; diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 8c0c16bafc4c5..030b4597e1247 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -149,7 +149,6 @@ impl FromStr for bool { /// An error returned when parsing a `bool` from a string fails. #[derive(Debug, Clone, PartialEq)] -#[allow(missing_copy_implementations)] #[stable(feature = "rust1", since = "1.0.0")] pub struct ParseBoolError { _priv: () } diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs index c5ea10beb83c5..b643b04035f2a 100644 --- a/src/liblibc/lib.rs +++ b/src/liblibc/lib.rs @@ -332,15 +332,12 @@ pub mod types { /// variants, because the compiler complains about the repr attribute /// otherwise. #[repr(u8)] - #[allow(missing_copy_implementations)] pub enum c_void { __variant1, __variant2, } - #[allow(missing_copy_implementations)] pub enum FILE {} - #[allow(missing_copy_implementations)] pub enum fpos_t {} } pub mod c99 { @@ -354,9 +351,7 @@ pub mod types { pub type uint64_t = u64; } pub mod posix88 { - #[allow(missing_copy_implementations)] pub enum DIR {} - #[allow(missing_copy_implementations)] pub enum dirent_t {} } pub mod posix01 {} diff --git a/src/librand/lib.rs b/src/librand/lib.rs index afb5d0c6eaab1..5f4df12ba45d0 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -383,7 +383,6 @@ pub trait SeedableRng: Rng { /// [1]: Marsaglia, George (July 2003). ["Xorshift /// RNGs"](http://www.jstatsoft.org/v08/i14/paper). *Journal of /// Statistical Software*. Vol. 8 (Issue 14). -#[allow(missing_copy_implementations)] #[derive(Clone)] pub struct XorShiftRng { x: u32, diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 53054f462c8b6..8a7617cce2d5e 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -2038,7 +2038,7 @@ declare_lint! { declare_lint! { pub MISSING_COPY_IMPLEMENTATIONS, - Warn, + Allow, "detects potentially-forgotten implementations of `Copy`" } diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 919ea0a25202c..0521a1dac69e0 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -224,7 +224,6 @@ pub struct RegionVarBindings<'a, 'tcx: 'a> { } #[derive(Debug)] -#[allow(missing_copy_implementations)] pub struct RegionSnapshot { length: uint, skolemization_count: u32, diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 44cd17caaecbb..3a7522cafee90 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -59,7 +59,6 @@ pub fn impl_can_satisfy(infcx: &InferCtxt, |o| selcx.evaluate_obligation(o)) } -#[allow(missing_copy_implementations)] pub enum OrphanCheckErr<'tcx> { NoLocalInputType, UncoveredTy(Ty<'tcx>), diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 88f6dc673cf18..645077b97869e 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -132,7 +132,6 @@ pub enum UnstableFeatures { } #[derive(Clone, PartialEq, Eq)] -#[allow(missing_copy_implementations)] pub enum PrintRequest { FileNames, Sysroot, @@ -290,7 +289,6 @@ macro_rules! options { $($opt:ident : $t:ty = ($init:expr, $parse:ident, $desc:expr)),* ,) => ( #[derive(Clone)] - #[allow(missing_copy_implementations)] pub struct $struct_name { $(pub $opt: $t),* } pub fn $defaultfn() -> $struct_name { diff --git a/src/librustc/util/nodemap.rs b/src/librustc/util/nodemap.rs index 8da06e63daefc..f8e3defe19d63 100644 --- a/src/librustc/util/nodemap.rs +++ b/src/librustc/util/nodemap.rs @@ -46,7 +46,6 @@ pub fn DefIdSet() -> DefIdSet { FnvHashSet() } /// /// This uses FNV hashing, as described here: /// http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function -#[allow(missing_copy_implementations)] pub struct FnvHasher(u64); impl Default for FnvHasher { diff --git a/src/librustc/util/snapshot_vec.rs b/src/librustc/util/snapshot_vec.rs index 151173b3a4085..8fbc682246f47 100644 --- a/src/librustc/util/snapshot_vec.rs +++ b/src/librustc/util/snapshot_vec.rs @@ -46,7 +46,6 @@ pub struct SnapshotVec { } // Snapshots are tokens that should be created/consumed linearly. -#[allow(missing_copy_implementations)] pub struct Snapshot { // Length of the undo log at the time the snapshot was taken. length: uint, diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index e5271cfde5a44..c94149105163d 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -464,7 +464,6 @@ pub fn opt_loan_path<'tcx>(cmt: &mc::cmt<'tcx>) -> Option>> { // Errors that can occur #[derive(PartialEq)] -#[allow(missing_copy_implementations)] pub enum bckerr_code { err_mutbl, err_out_of_scope(ty::Region, ty::Region), // superscope, subscope diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index a1532c044e3dc..b45a27214db56 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -430,73 +430,50 @@ pub enum DiagnosticKind { } // Opaque pointer types -#[allow(missing_copy_implementations)] pub enum Module_opaque {} pub type ModuleRef = *mut Module_opaque; -#[allow(missing_copy_implementations)] pub enum Context_opaque {} pub type ContextRef = *mut Context_opaque; -#[allow(missing_copy_implementations)] pub enum Type_opaque {} pub type TypeRef = *mut Type_opaque; -#[allow(missing_copy_implementations)] pub enum Value_opaque {} pub type ValueRef = *mut Value_opaque; -#[allow(missing_copy_implementations)] pub enum Metadata_opaque {} pub type MetadataRef = *mut Metadata_opaque; -#[allow(missing_copy_implementations)] pub enum BasicBlock_opaque {} pub type BasicBlockRef = *mut BasicBlock_opaque; -#[allow(missing_copy_implementations)] pub enum Builder_opaque {} pub type BuilderRef = *mut Builder_opaque; -#[allow(missing_copy_implementations)] pub enum ExecutionEngine_opaque {} pub type ExecutionEngineRef = *mut ExecutionEngine_opaque; -#[allow(missing_copy_implementations)] pub enum RustJITMemoryManager_opaque {} pub type RustJITMemoryManagerRef = *mut RustJITMemoryManager_opaque; -#[allow(missing_copy_implementations)] pub enum MemoryBuffer_opaque {} pub type MemoryBufferRef = *mut MemoryBuffer_opaque; -#[allow(missing_copy_implementations)] pub enum PassManager_opaque {} pub type PassManagerRef = *mut PassManager_opaque; -#[allow(missing_copy_implementations)] pub enum PassManagerBuilder_opaque {} pub type PassManagerBuilderRef = *mut PassManagerBuilder_opaque; -#[allow(missing_copy_implementations)] pub enum Use_opaque {} pub type UseRef = *mut Use_opaque; -#[allow(missing_copy_implementations)] pub enum TargetData_opaque {} pub type TargetDataRef = *mut TargetData_opaque; -#[allow(missing_copy_implementations)] pub enum ObjectFile_opaque {} pub type ObjectFileRef = *mut ObjectFile_opaque; -#[allow(missing_copy_implementations)] pub enum SectionIterator_opaque {} pub type SectionIteratorRef = *mut SectionIterator_opaque; -#[allow(missing_copy_implementations)] pub enum Pass_opaque {} pub type PassRef = *mut Pass_opaque; -#[allow(missing_copy_implementations)] pub enum TargetMachine_opaque {} pub type TargetMachineRef = *mut TargetMachine_opaque; -#[allow(missing_copy_implementations)] pub enum Archive_opaque {} pub type ArchiveRef = *mut Archive_opaque; -#[allow(missing_copy_implementations)] pub enum Twine_opaque {} pub type TwineRef = *mut Twine_opaque; -#[allow(missing_copy_implementations)] pub enum DiagnosticInfo_opaque {} pub type DiagnosticInfoRef = *mut DiagnosticInfo_opaque; -#[allow(missing_copy_implementations)] pub enum DebugLoc_opaque {} pub type DebugLocRef = *mut DebugLoc_opaque; -#[allow(missing_copy_implementations)] pub enum SMDiagnostic_opaque {} pub type SMDiagnosticRef = *mut SMDiagnostic_opaque; @@ -507,7 +484,6 @@ pub mod debuginfo { pub use self::DIDescriptorFlags::*; use super::{MetadataRef}; - #[allow(missing_copy_implementations)] pub enum DIBuilder_opaque {} pub type DIBuilderRef = *mut DIBuilder_opaque; @@ -2209,7 +2185,6 @@ pub fn get_param(llfn: ValueRef, index: c_uint) -> ValueRef { } } -#[allow(missing_copy_implementations)] pub enum RustString_opaque {} pub type RustStringRef = *mut RustString_opaque; type RustStringRepr = *mut RefCell>; diff --git a/src/librustc_trans/trans/value.rs b/src/librustc_trans/trans/value.rs index b6fd2eb57be27..464522f167b47 100644 --- a/src/librustc_trans/trans/value.rs +++ b/src/librustc_trans/trans/value.rs @@ -150,7 +150,6 @@ impl Use { } /// Iterator for the users of a value -#[allow(missing_copy_implementations)] pub struct Users { next: Option } diff --git a/src/librustc_typeck/rscope.rs b/src/librustc_typeck/rscope.rs index ddb485d9776d1..60e969c4f99dd 100644 --- a/src/librustc_typeck/rscope.rs +++ b/src/librustc_typeck/rscope.rs @@ -79,7 +79,6 @@ impl RegionScope for UnelidableRscope { // A scope in which any omitted region defaults to `default`. This is // used after the `->` in function signatures, but also for backwards // compatibility with object types. The latter use may go away. -#[allow(missing_copy_implementations)] pub struct SpecificRscope { default: ty::Region } diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index 205eeb75b5b79..81acd87a27619 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -1580,7 +1580,6 @@ impl Extend<(K, V)> for HashMap /// `Hasher`, but the hashers created by two different `RandomState` /// instances are unlikely to produce the same result for the same values. #[derive(Clone)] -#[allow(missing_copy_implementations)] #[unstable(feature = "std_misc", reason = "hashing an hash maps may be altered")] pub struct RandomState { @@ -1622,7 +1621,6 @@ impl Default for RandomState { /// This is the default hasher used in a `HashMap` to hash keys. Types do not /// typically declare an ability to explicitly hash into this particular type, /// but rather in a `H: hash::Writer` type parameter. -#[allow(missing_copy_implementations)] #[unstable(feature = "std_misc", reason = "hashing an hash maps may be altered")] pub struct Hasher { inner: SipHasher } diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index 68ae0f7e5b5f3..51a889360342d 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -22,7 +22,6 @@ use mem; use env; use str; -#[allow(missing_copy_implementations)] pub struct DynamicLibrary { handle: *mut u8 } diff --git a/src/libstd/os.rs b/src/libstd/os.rs index d92f361af0bf2..93dc8c49079e2 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -759,7 +759,6 @@ pub fn page_size() -> uint { /// /// The memory map is released (unmapped) when the destructor is run, so don't /// let it leave scope by accident if you want it to stick around. -#[allow(missing_copy_implementations)] pub struct MemoryMap { data: *mut u8, len: uint, diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index 4b45d5501c235..f24867d6d0183 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -206,7 +206,6 @@ mod imp { /// - iOS: calls SecRandomCopyBytes as /dev/(u)random is sandboxed. /// /// This does not block. - #[allow(missing_copy_implementations)] pub struct OsRng { // dummy field to ensure that this struct cannot be constructed outside of this module _dummy: (), diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index 81ca5aa0e8a6e..b37996fa9d9de 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -390,13 +390,10 @@ pub mod eabi { use libc::{c_void, c_int}; #[repr(C)] - #[allow(missing_copy_implementations)] pub struct EXCEPTION_RECORD; #[repr(C)] - #[allow(missing_copy_implementations)] pub struct CONTEXT; #[repr(C)] - #[allow(missing_copy_implementations)] pub struct DISPATCHER_CONTEXT; #[repr(C)] diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index 86d21cf72782e..703dca4d29bf9 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -88,7 +88,6 @@ pub fn default_sched_threads() -> uint { pub const ENFORCE_SANITY: bool = true || !cfg!(rtopt) || cfg!(rtdebug) || cfg!(rtassert); -#[allow(missing_copy_implementations)] pub struct Stdio(libc::c_int); #[allow(non_upper_case_globals)] diff --git a/src/libstd/sync/barrier.rs b/src/libstd/sync/barrier.rs index 581e540d3b6ed..cca376f7b6d05 100644 --- a/src/libstd/sync/barrier.rs +++ b/src/libstd/sync/barrier.rs @@ -46,7 +46,6 @@ struct BarrierState { /// /// Currently this opaque structure only has one method, `.is_leader()`. Only /// one thread will receive a result that will return `true` from this function. -#[allow(missing_copy_implementations)] pub struct BarrierWaitResult(bool); impl Barrier { diff --git a/src/libstd/sync/poison.rs b/src/libstd/sync/poison.rs index 18680b96592ce..d9bc37d312e86 100644 --- a/src/libstd/sync/poison.rs +++ b/src/libstd/sync/poison.rs @@ -42,7 +42,6 @@ impl Flag { } } -#[allow(missing_copy_implementations)] pub struct Guard { panicking: bool, } diff --git a/src/test/compile-fail/lint-dead-code-1.rs b/src/test/compile-fail/lint-dead-code-1.rs index 519839ae2f4cb..b1bb28f7ce716 100644 --- a/src/test/compile-fail/lint-dead-code-1.rs +++ b/src/test/compile-fail/lint-dead-code-1.rs @@ -12,7 +12,6 @@ #![allow(unused_variables)] #![allow(non_camel_case_types)] #![allow(non_upper_case_globals)] -#![allow(missing_copy_implementations)] #![deny(dead_code)] #![feature(core)] diff --git a/src/test/compile-fail/lint-missing-doc.rs b/src/test/compile-fail/lint-missing-doc.rs index 55103f10f2ce1..3b96fd64fa200 100644 --- a/src/test/compile-fail/lint-missing-doc.rs +++ b/src/test/compile-fail/lint-missing-doc.rs @@ -12,7 +12,6 @@ // injected intrinsics by the compiler. #![deny(missing_docs)] #![allow(dead_code)] -#![allow(missing_copy_implementations)] //! Some garbage docs for the crate here #![doc="More garbage"] diff --git a/src/test/compile-fail/missing_debug_impls.rs b/src/test/compile-fail/missing_debug_impls.rs index bc4bfef4d48c4..ddc9081e33bb6 100644 --- a/src/test/compile-fail/missing_debug_impls.rs +++ b/src/test/compile-fail/missing_debug_impls.rs @@ -10,7 +10,7 @@ // compile-flags: --crate-type lib #![deny(missing_debug_implementations)] -#![allow(unused, missing_copy_implementations)] +#![allow(unused)] use std::fmt; From db8f2d590385786c176b5f7d9e887814d31db9ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Steinbrink?= Date: Thu, 4 Sep 2014 13:36:39 +0200 Subject: [PATCH 03/35] Avoid unnecessary codegen in with_cond() Currently "k / 2" generates one (k: uint) or two (k: int) "br false, ..." instructions and the corresponding basic blocks, producing quite some noise and making the code unnecessarily hard to read. Additionally we can skip translation if the code would end up unreachable anyway. --- src/librustc_trans/trans/_match.rs | 6 ++++-- src/librustc_trans/trans/base.rs | 6 ++++++ 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index 52fe8797592b5..6d9c157985fd9 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -889,11 +889,13 @@ fn compile_guard<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } } + for (_, &binding_info) in &data.bindings_map { + bcx.fcx.lllocals.borrow_mut().remove(&binding_info.id); + } + with_cond(bcx, Not(bcx, val, guard_expr.debug_loc()), |bcx| { - // Guard does not match: remove all bindings from the lllocals table for (_, &binding_info) in &data.bindings_map { call_lifetime_end(bcx, binding_info.llmatch); - bcx.fcx.lllocals.borrow_mut().remove(&binding_info.id); } match chk { // If the default arm is the only one left, move on to the next diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 6901eb25b31fe..1c43daf35bf82 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -1079,6 +1079,12 @@ pub fn with_cond<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, F: FnOnce(Block<'blk, 'tcx>) -> Block<'blk, 'tcx>, { let _icx = push_ctxt("with_cond"); + + if bcx.unreachable.get() || + (common::is_const(val) && common::const_to_uint(val) == 0) { + return bcx; + } + let fcx = bcx.fcx; let next_cx = fcx.new_temp_block("next"); let cond_cx = fcx.new_temp_block("cond"); From 5cbbc1282726102a796b1475490e884144bb7146 Mon Sep 17 00:00:00 2001 From: Alexis Date: Wed, 4 Feb 2015 19:36:02 -0500 Subject: [PATCH 04/35] stabilize core Entry API --- src/libcollections/btree/map.rs | 26 +++++++++----------------- src/libcollections/vec_map.rs | 23 ++++++++--------------- src/libstd/collections/hash/map.rs | 16 ++++++++-------- 3 files changed, 25 insertions(+), 40 deletions(-) diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 99ee5957913dc..d7f89b0cc72f1 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -15,7 +15,7 @@ // writing (August 2014) freely licensed under the following Creative Commons Attribution // License: [CC BY 2.5 CA](http://creativecommons.org/licenses/by/2.5/ca/). -pub use self::Entry::*; +use self::Entry::*; use core::prelude::*; @@ -1137,8 +1137,7 @@ impl<'a, K: Ord, V> Entry<'a, K, V> { impl<'a, K: Ord, V> VacantEntry<'a, K, V> { /// Sets the value of the entry with the VacantEntry's key, /// and returns a mutable reference to it. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn insert(self, value: V) -> &'a mut V { self.stack.insert(self.key, value) } @@ -1146,38 +1145,33 @@ impl<'a, K: Ord, V> VacantEntry<'a, K, V> { impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> { /// Gets a reference to the value in the entry. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn get(&self) -> &V { self.stack.peek() } /// Gets a mutable reference to the value in the entry. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut(&mut self) -> &mut V { self.stack.peek_mut() } /// Converts the entry into a mutable reference to its value. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn into_mut(self) -> &'a mut V { self.stack.into_top() } /// Sets the value of the entry with the OccupiedEntry's key, /// and returns the entry's old value. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn insert(&mut self, mut value: V) -> V { mem::swap(self.stack.peek_mut(), &mut value); value } /// Takes the value of the entry out of the map, and returns it. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn remove(self) -> V { self.stack.remove() } @@ -1563,10 +1557,8 @@ impl BTreeMap { /// /// assert_eq!(count["a"], 3u); /// ``` - /// The key must have the same ordering before or after `.to_owned()` is called. - #[unstable(feature = "collections", - reason = "precise API still under development")] - pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> { + #[stable(feature = "rust1", since = "1.0.0")] + pub fn entry(&mut self, mut key: K) -> Entry { // same basic logic of `swap` and `pop`, blended together let mut stack = stack::PartialSearchStack::new(self); loop { diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index abcf358a1926c..a907d6241697f 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -13,7 +13,7 @@ #![allow(missing_docs)] -pub use self::Entry::*; +use self::Entry::*; use core::prelude::*; @@ -539,8 +539,7 @@ impl VecMap { /// /// assert_eq!(count[1], 3); /// ``` - #[unstable(feature = "collections", - reason = "precise API still under development")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn entry(&mut self, key: usize) -> Entry { // FIXME(Gankro): this is basically the dumbest implementation of // entry possible, because weird non-lexical borrows issues make it @@ -576,8 +575,7 @@ impl<'a, V> Entry<'a, V> { impl<'a, V> VacantEntry<'a, V> { /// Sets the value of the entry with the VacantEntry's key, /// and returns a mutable reference to it. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn insert(self, value: V) -> &'a mut V { let index = self.index; self.map.insert(index, value); @@ -587,24 +585,21 @@ impl<'a, V> VacantEntry<'a, V> { impl<'a, V> OccupiedEntry<'a, V> { /// Gets a reference to the value in the entry. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn get(&self) -> &V { let index = self.index; &self.map[index] } /// Gets a mutable reference to the value in the entry. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut(&mut self) -> &mut V { let index = self.index; &mut self.map[index] } /// Converts the entry into a mutable reference to its value. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn into_mut(self) -> &'a mut V { let index = self.index; &mut self.map[index] @@ -612,16 +607,14 @@ impl<'a, V> OccupiedEntry<'a, V> { /// Sets the value of the entry with the OccupiedEntry's key, /// and returns the entry's old value. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn insert(&mut self, value: V) -> V { let index = self.index; self.map.insert(index, value).unwrap() } /// Takes the value of the entry out of the map, and returns it. - #[unstable(feature = "collections", - reason = "matches collection reform v2 specification, waiting for dust to settle")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn remove(self) -> V { let index = self.index; self.map.remove(&index).unwrap() diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index 6327061047248..d23d806ef5983 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -929,10 +929,8 @@ impl HashMap } /// Gets the given key's corresponding entry in the map for in-place manipulation. - #[unstable(feature = "std_misc", - reason = "precise API still being fleshed out")] - pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V> - { + #[stable(feature = "rust1", since = "1.0.0")] + pub fn entry(&mut self, key: K) -> Entry { // Gotta resize now. self.reserve(1); @@ -1496,26 +1494,28 @@ impl<'a, K, V> Entry<'a, K, V> { } } -#[unstable(feature = "std_misc", - reason = "matches collection reform v2 specification, waiting for dust to settle")] impl<'a, K, V> OccupiedEntry<'a, K, V> { /// Gets a reference to the value in the entry. + #[stable(feature = "rust1", since = "1.0.0")] pub fn get(&self) -> &V { self.elem.read().1 } /// Gets a mutable reference to the value in the entry. + #[stable(feature = "rust1", since = "1.0.0")] pub fn get_mut(&mut self) -> &mut V { self.elem.read_mut().1 } /// Converts the OccupiedEntry into a mutable reference to the value in the entry /// with a lifetime bound to the map itself + #[stable(feature = "rust1", since = "1.0.0")] pub fn into_mut(self) -> &'a mut V { self.elem.into_mut_refs().1 } /// Sets the value of the entry, and returns the entry's old value + #[stable(feature = "rust1", since = "1.0.0")] pub fn insert(&mut self, mut value: V) -> V { let old_value = self.get_mut(); mem::swap(&mut value, old_value); @@ -1523,16 +1523,16 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { } /// Takes the value out of the entry, and returns it + #[stable(feature = "rust1", since = "1.0.0")] pub fn remove(self) -> V { pop_internal(self.elem).1 } } -#[unstable(feature = "std_misc", - reason = "matches collection reform v2 specification, waiting for dust to settle")] impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { /// Sets the value of the entry with the VacantEntry's key, /// and returns a mutable reference to it + #[stable(feature = "rust1", since = "1.0.0")] pub fn insert(self, value: V) -> &'a mut V { match self.elem { NeqElem(bucket, ib) => { From dc2e444e506c31e8f4a4331c7f6264ca6c107bb6 Mon Sep 17 00:00:00 2001 From: Joseph Crail Date: Wed, 4 Feb 2015 23:00:02 -0500 Subject: [PATCH 05/35] Fix for misspelled comments. The spelling corrections were made in both documentation comments and regular comments. --- src/doc/trpl/ownership.md | 2 +- src/grammar/parser-lalr.y | 2 +- src/liballoc/arc.rs | 4 ++-- src/liballoc/rc.rs | 4 ++-- src/libcollections/btree/node.rs | 2 +- src/libcore/iter.rs | 2 +- src/librustc/diagnostics.rs | 4 ++-- src/librustc/middle/traits/select.rs | 4 ++-- src/librustc/middle/ty.rs | 2 +- src/librustc_borrowck/borrowck/doc.rs | 2 +- src/librustc_driver/driver.rs | 2 +- src/librustc_resolve/diagnostics.rs | 2 +- src/librustc_trans/trans/intrinsic.rs | 2 +- src/librustc_typeck/check/compare_method.rs | 4 ++-- src/librustc_typeck/check/vtable.rs | 2 +- src/librustc_typeck/diagnostics.rs | 4 ++-- src/libstd/collections/mod.rs | 2 +- src/libstd/env.rs | 2 +- src/libstd/io/mod.rs | 4 ++-- src/libstd/path.rs | 4 ++-- src/libstd/sync/mpsc/oneshot.rs | 2 +- src/libstd/sys/common/wtf8.rs | 2 +- src/libstd/sys/windows/thread_local.rs | 2 +- src/libstd/time/duration.rs | 4 ++-- src/libsyntax/feature_gate.rs | 2 +- src/libsyntax/parse/mod.rs | 2 +- src/rustbook/javascript.rs | 2 +- 27 files changed, 36 insertions(+), 36 deletions(-) diff --git a/src/doc/trpl/ownership.md b/src/doc/trpl/ownership.md index 9e3a3f12d1d21..3b5aa085e055a 100644 --- a/src/doc/trpl/ownership.md +++ b/src/doc/trpl/ownership.md @@ -523,7 +523,7 @@ fn print<'a>(s: &'a str); // expanded fn debug(lvl: u32, s: &str); // elided fn debug<'a>(lvl: u32, s: &'a str); // expanded -// In the preceeding example, `lvl` doesn't need a lifetime because it's not a +// In the preceding example, `lvl` doesn't need a lifetime because it's not a // reference (`&`). Only things relating to references (such as a `struct` // which contains a reference) need lifetimes. diff --git a/src/grammar/parser-lalr.y b/src/grammar/parser-lalr.y index 24185ed65d5c5..d3d3a2b997c99 100644 --- a/src/grammar/parser-lalr.y +++ b/src/grammar/parser-lalr.y @@ -1195,7 +1195,7 @@ maybe_stmts // // There are also two other expr subtypes: first, nonparen_expr // disallows exprs surrounded by parens (including tuple expressions), -// this is neccesary for BOX (place) expressions, so a parens expr +// this is necessary for BOX (place) expressions, so a parens expr // following the BOX is always parsed as the place. There is also // expr_norange used in index_expr, which disallows '..' in // expressions as that has special meaning inside of brackets. diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 21b9c060f6f3b..24b4abbff4ae2 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -311,7 +311,7 @@ impl Drop for Arc { /// /// // stuff /// - /// drop(five); // explict drop + /// drop(five); // explicit drop /// } /// { /// let five = Arc::new(5); @@ -441,7 +441,7 @@ impl Drop for Weak { /// /// // stuff /// - /// drop(weak_five); // explict drop + /// drop(weak_five); // explicit drop /// } /// { /// let five = Arc::new(5); diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 464f20e9cac53..ed7a2832f7a10 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -382,7 +382,7 @@ impl Drop for Rc { /// /// // stuff /// - /// drop(five); // explict drop + /// drop(five); // explicit drop /// } /// { /// let five = Rc::new(5); @@ -687,7 +687,7 @@ impl Drop for Weak { /// /// // stuff /// - /// drop(weak_five); // explict drop + /// drop(weak_five); // explicit drop /// } /// { /// let five = Rc::new(5); diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 8fdfe9ed56a48..7f6eee343b90b 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -669,7 +669,7 @@ impl<'a, K: 'a, V: 'a> Handle<&'a mut Node, handle::Edge, handle::Internal impl>> Handle { // This doesn't exist because there are no uses for it, - // but is fine to add, analagous to edge_mut. + // but is fine to add, analogous to edge_mut. // // /// Returns a reference to the edge pointed-to by this handle. This should not be // /// confused with `node`, which references the parent node of what is returned here. diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 23157072d536b..f3b42e4f0a577 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -260,7 +260,7 @@ pub trait IteratorExt: Iterator + Sized { } /// Creates an iterator that applies the predicate to each element returned - /// by this iterator. The only elements that will be yieled are those that + /// by this iterator. The only elements that will be yielded are those that /// make the predicate evaluate to `true`. /// /// # Examples diff --git a/src/librustc/diagnostics.rs b/src/librustc/diagnostics.rs index b48df36a67931..a808b417b4c6b 100644 --- a/src/librustc/diagnostics.rs +++ b/src/librustc/diagnostics.rs @@ -14,9 +14,9 @@ register_long_diagnostics! { E0001: r##" This error suggests that the expression arm corresponding to the noted pattern will never be reached as for all possible values of the expression being matched, - one of the preceeding patterns will match. + one of the preceding patterns will match. - This means that perhaps some of the preceeding patterns are too general, this + This means that perhaps some of the preceding patterns are too general, this one is too specific or the ordering is incorrect. "##, diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index b8af91add9efb..709f714eb6725 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -775,7 +775,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { -> bool { // In general, it's a good idea to cache results, even - // ambigious ones, to save us some trouble later. But we have + // ambiguous ones, to save us some trouble later. But we have // to be careful not to cache results that could be // invalidated later by advances in inference. Normally, this // is not an issue, because any inference variables whose @@ -1273,7 +1273,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { /// /// - The impl is conditional, in which case we may not have winnowed it out /// because we don't know if the conditions apply, but the where clause is basically - /// telling us taht there is some impl, though not necessarily the one we see. + /// telling us that there is some impl, though not necessarily the one we see. /// /// In both cases we prefer to take the where clause, which is /// essentially harmless. See issue #18453 for more details of diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index a772555d8fcb6..3c5edd166bbfa 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2520,7 +2520,7 @@ impl FlagComputation { fn add_bound_computation(&mut self, computation: &FlagComputation) { self.add_flags(computation.flags); - // The types that contributed to `computation` occured within + // The types that contributed to `computation` occurred within // a region binder, so subtract one from the region depth // within when adding the depth to `self`. let depth = computation.depth; diff --git a/src/librustc_borrowck/borrowck/doc.rs b/src/librustc_borrowck/borrowck/doc.rs index 2100d5a9bc307..682a5f2f5ace6 100644 --- a/src/librustc_borrowck/borrowck/doc.rs +++ b/src/librustc_borrowck/borrowck/doc.rs @@ -142,7 +142,7 @@ //! which contains an empty set of actions, still has a purpose---it //! prevents moves from `LV`. I chose not to make `MOVE` a fourth kind of //! action because that would imply that sometimes moves are permitted -//! from restrictived values, which is not the case. +//! from restricted values, which is not the case. //! //! #### Example //! diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 8ede037594a00..d1326ab8d7bac 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -171,7 +171,7 @@ pub fn source_name(input: &Input) -> String { /// CompileController is used to customise compilation, it allows compilation to /// be stopped and/or to call arbitrary code at various points in compilation. /// It also allows for various flags to be set to influence what information gets -/// colelcted during compilation. +/// collected during compilation. /// /// This is a somewhat higher level controller than a Session - the Session /// controls what happens in each phase, whereas the CompileController controls diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs index dd9ccfbda7ca6..7b6ee3a729776 100644 --- a/src/librustc_resolve/diagnostics.rs +++ b/src/librustc_resolve/diagnostics.rs @@ -20,7 +20,7 @@ register_diagnostics! { E0254, // import conflicts with imported crate in this module E0255, // import conflicts with value in this module E0256, // import conflicts with type in this module - E0257, // inherent implementations are only allowen on types defined in the current module + E0257, // inherent implementations are only allowed on types defined in the current module E0258, // import conflicts with existing submodule E0259, // an extern crate has already been imported into this module E0260 // name conflicts with an external crate that has been imported into this module diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index 6228043eeb1a9..d9769e04fb13b 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -365,7 +365,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, (_, "init") => { let tp_ty = *substs.types.get(FnSpace, 0); if !return_type_is_void(ccx, tp_ty) { - // Just zero out the stack slot. (See comment on base::memzero for explaination) + // Just zero out the stack slot. (See comment on base::memzero for explanation) zero_mem(bcx, llresult, tp_ty); } C_nil(ccx) diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index dc4d7d4664728..a5b938c7600c2 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -159,11 +159,11 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, // vs 'b). However, the normal subtyping rules on fn types handle // this kind of equivalency just fine. // - // We now use these subsititions to ensure that all declared bounds are + // We now use these substitutions to ensure that all declared bounds are // satisfied by the implementation's method. // // We do this by creating a parameter environment which contains a - // substition corresponding to impl_to_skol_substs. We then build + // substitution corresponding to impl_to_skol_substs. We then build // trait_to_skol_substs and use it to convert the predicates contained // in the trait_m.generics to the skolemized form. // diff --git a/src/librustc_typeck/check/vtable.rs b/src/librustc_typeck/check/vtable.rs index 6f66010925ec0..a3d32e8b3889e 100644 --- a/src/librustc_typeck/check/vtable.rs +++ b/src/librustc_typeck/check/vtable.rs @@ -288,7 +288,7 @@ pub fn select_all_fcx_obligations_and_apply_defaults(fcx: &FnCtxt) { pub fn select_all_fcx_obligations_or_error(fcx: &FnCtxt) { debug!("select_all_fcx_obligations_or_error"); - // upvar inference should have ensured that all deferrred call + // upvar inference should have ensured that all deferred call // resolutions are handled by now. assert!(fcx.inh.deferred_call_resolutions.borrow().is_empty()); diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs index 680ff2fcda64c..17cf92d39d8f5 100644 --- a/src/librustc_typeck/diagnostics.rs +++ b/src/librustc_typeck/diagnostics.rs @@ -108,7 +108,7 @@ register_diagnostics! { E0189, // can only cast a boxed pointer to a boxed object E0190, // can only cast a &-pointer to an &-object E0191, // value of the associated type must be specified - E0192, // negative imples are allowed just fo `Send` and `Sync` + E0192, // negative imples are allowed just for `Send` and `Sync` E0193, // cannot bound type where clause bounds may only be attached to types // involving type parameters E0194, @@ -119,7 +119,7 @@ register_diagnostics! { E0199, // implementing trait is not unsafe E0200, // trait requires an `unsafe impl` declaration E0201, // duplicate method in trait impl - E0202, // associated items are not allowed in inherint impls + E0202, // associated items are not allowed in inherent impls E0203, // type parameter has more than one relaxed default bound, // and only one is supported E0204, // trait `Copy` may not be implemented for this type; field diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index 0c55850b32a2d..6e64542211133 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -313,7 +313,7 @@ //! //! assert_eq!(count.get(&'s'), Some(&8)); //! -//! println!("Number of occurences of each character"); +//! println!("Number of occurrences of each character"); //! for (char, count) in count.iter() { //! println!("{}: {}", char, count); //! } diff --git a/src/libstd/env.rs b/src/libstd/env.rs index 559a68542efc8..7ff25d1a1fea1 100644 --- a/src/libstd/env.rs +++ b/src/libstd/env.rs @@ -337,7 +337,7 @@ pub fn temp_dir() -> Path { /// /// # Errors /// -/// Acquring the path to the current executable is a platform-specific operation +/// Acquiring the path to the current executable is a platform-specific operation /// that can fail for a good number of reasons. Some errors can include, but not /// be limited to filesystem operations failing or general syscall failures. /// diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 0832206a48b60..f931e6a377387 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -97,7 +97,7 @@ fn with_end_to_cap(v: &mut Vec, f: F) -> Result // // To this end, we use an RAII guard (to protect against panics) which updates // the length of the string when it is dropped. This guard initially truncates -// the string to the prior length and only afer we've validated that the +// the string to the prior length and only after we've validated that the // new contents are valid UTF-8 do we allow it to set a longer length. // // The unsafety in this function is twofold: @@ -664,7 +664,7 @@ impl Take { /// /// # Note /// - /// This instance may reach EOF after reading fewer bytes than indiccated by + /// This instance may reach EOF after reading fewer bytes than indicated by /// this method if the underlying `Read` instance reaches EOF. pub fn limit(&self) -> u64 { self.limit } } diff --git a/src/libstd/path.rs b/src/libstd/path.rs index 3f4f1ec4c0db5..cb2138630307f 100755 --- a/src/libstd/path.rs +++ b/src/libstd/path.rs @@ -922,7 +922,7 @@ impl PathBuf { /// /// If `self.file_name()` is `None`, does nothing and returns `false`. /// - /// Otherwise, returns `tru`; if `self.exension()` is `None`, the extension + /// Otherwise, returns `true`; if `self.extension()` is `None`, the extension /// is added; otherwise it is replaced. pub fn set_extension(&mut self, extension: &S) -> bool { if self.file_name().is_none() { return false; } @@ -1062,7 +1062,7 @@ impl Path { PathBuf::new(self) } - /// A path is *absolute* if it is indepedent of the current directory. + /// A path is *absolute* if it is independent of the current directory. /// /// * On Unix, a path is absolute if it starts with the root, so /// `is_absolute` and `has_root` are equivalent. diff --git a/src/libstd/sync/mpsc/oneshot.rs b/src/libstd/sync/mpsc/oneshot.rs index ca667e65e30cc..eb45681fa626d 100644 --- a/src/libstd/sync/mpsc/oneshot.rs +++ b/src/libstd/sync/mpsc/oneshot.rs @@ -45,7 +45,7 @@ use core::mem; use sync::atomic::{AtomicUsize, Ordering}; // Various states you can find a port in. -const EMPTY: uint = 0; // initial state: no data, no blocked reciever +const EMPTY: uint = 0; // initial state: no data, no blocked receiver const DATA: uint = 1; // data ready for receiver to take const DISCONNECTED: uint = 2; // channel is disconnected OR upgraded // Any other value represents a pointer to a SignalToken value. The diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index b30af10986b99..158c491aeae90 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -84,7 +84,7 @@ impl CodePoint { /// Create a new `CodePoint` from a `char`. /// - /// Since all Unicode scalar values are code points, this always succeds. + /// Since all Unicode scalar values are code points, this always succeeds. #[inline] pub fn from_char(value: char) -> CodePoint { CodePoint { value: value as u32 } diff --git a/src/libstd/sys/windows/thread_local.rs b/src/libstd/sys/windows/thread_local.rs index 54a32e43daf59..0c24ab1fa09b4 100644 --- a/src/libstd/sys/windows/thread_local.rs +++ b/src/libstd/sys/windows/thread_local.rs @@ -191,7 +191,7 @@ unsafe fn unregister_dtor(key: Key) -> bool { // # What's up with this callback? // // The callback specified receives a number of parameters from... someone! -// (the kernel? the runtime? I'm not qute sure!) There are a few events that +// (the kernel? the runtime? I'm not quite sure!) There are a few events that // this gets invoked for, but we're currently only interested on when a // thread or a process "detaches" (exits). The process part happens for the // last thread and the thread part happens for any normal thread. diff --git a/src/libstd/time/duration.rs b/src/libstd/time/duration.rs index 76b8d736aad54..42ef3459a0ed7 100644 --- a/src/libstd/time/duration.rs +++ b/src/libstd/time/duration.rs @@ -232,7 +232,7 @@ impl Duration { secs_part.checked_add(nanos_part as i64) } - /// Add two durations, returning `None` if overflow occured. + /// Add two durations, returning `None` if overflow occurred. #[unstable(feature = "std_misc")] pub fn checked_add(&self, rhs: &Duration) -> Option { let mut secs = try_opt!(self.secs.checked_add(rhs.secs)); @@ -247,7 +247,7 @@ impl Duration { if d < MIN || d > MAX { None } else { Some(d) } } - /// Subtract two durations, returning `None` if overflow occured. + /// Subtract two durations, returning `None` if overflow occurred. #[unstable(feature = "std_misc")] pub fn checked_sub(&self, rhs: &Duration) -> Option { let mut secs = try_opt!(self.secs.checked_sub(rhs.secs)); diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index d7a51e1149f30..435713d99d146 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -109,7 +109,7 @@ static KNOWN_FEATURES: &'static [(&'static str, &'static str, Status)] = &[ // int and uint are now deprecated ("int_uint", "1.0.0", Active), - // macro reexport needs more discusion and stabilization + // macro reexport needs more discussion and stabilization ("macro_reexport", "1.0.0", Active), // These are used to test this portion of the compiler, they don't actually diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index eecd7d8718543..d8a5ef048525f 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -560,7 +560,7 @@ fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>, } pub fn float_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> ast::Lit_ { debug!("float_lit: {:?}, {:?}", s, suffix); - // FIXME #2252: bounds checking float literals is defered until trans + // FIXME #2252: bounds checking float literals is deferred until trans let s = s.chars().filter(|&c| c != '_').collect::(); let data = token::intern_and_get_ident(&*s); filtered_float_lit(data, suffix, sd, sp) diff --git a/src/rustbook/javascript.rs b/src/rustbook/javascript.rs index d34887d2b08b5..6ee8230e9f8ba 100644 --- a/src/rustbook/javascript.rs +++ b/src/rustbook/javascript.rs @@ -43,7 +43,7 @@ document.addEventListener("DOMContentLoaded", function(event) { // of each of the sections. // It works by extracting the current page based on the url and iterates over // the menu links until it finds the menu item for the current page. We then - // create a copy of the preceeding and following menu links and add the + // create a copy of the preceding and following menu links and add the // correct css class and insert them into the bottom of the page. var toc = document.getElementById('toc').getElementsByTagName('a'); var href = document.location.pathname.split('/').pop(); From fc0fd289c93d99a5176950e5ae6bfa023595410e Mon Sep 17 00:00:00 2001 From: Joseph Crail Date: Wed, 4 Feb 2015 23:04:10 -0500 Subject: [PATCH 06/35] Fix for misspelled comments in tests. Just spelling corrections. --- src/test/bench/shootout-reverse-complement.rs | 4 ++-- src/test/compile-fail/assoc-inherent.rs | 2 +- src/test/compile-fail/issue-7364.rs | 2 +- src/test/compile-fail/issue-9243.rs | 2 +- src/test/run-pass/issue-7660.rs | 2 +- 5 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs index 3a35bea0d5997..373c0304bb5ed 100644 --- a/src/test/bench/shootout-reverse-complement.rs +++ b/src/test/bench/shootout-reverse-complement.rs @@ -90,12 +90,12 @@ impl Tables { } } - /// Retreives the complement for `i`. + /// Retrieves the complement for `i`. fn cpl8(&self, i: u8) -> u8 { self.table8[i as uint] } - /// Retreives the complement for `i`. + /// Retrieves the complement for `i`. fn cpl16(&self, i: u16) -> u16 { self.table16[i as uint] } diff --git a/src/test/compile-fail/assoc-inherent.rs b/src/test/compile-fail/assoc-inherent.rs index ba8e4a652d337..e68c3e30b9a7b 100644 --- a/src/test/compile-fail/assoc-inherent.rs +++ b/src/test/compile-fail/assoc-inherent.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test associated types are forbidden in inherant impls. +// Test associated types are forbidden in inherent impls. struct Foo; diff --git a/src/test/compile-fail/issue-7364.rs b/src/test/compile-fail/issue-7364.rs index 2e644b6540234..465a38111babc 100644 --- a/src/test/compile-fail/issue-7364.rs +++ b/src/test/compile-fail/issue-7364.rs @@ -12,7 +12,7 @@ use std::cell::RefCell; -// Regresion test for issue 7364 +// Regression test for issue 7364 static boxed: Box> = box RefCell::new(0); //~^ ERROR statics are not allowed to have custom pointers //~| ERROR: the trait `core::marker::Sync` is not implemented for the type diff --git a/src/test/compile-fail/issue-9243.rs b/src/test/compile-fail/issue-9243.rs index 808aa098c5a28..7424a45d04405 100644 --- a/src/test/compile-fail/issue-9243.rs +++ b/src/test/compile-fail/issue-9243.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Regresion test for issue 9243 +// Regression test for issue 9243 struct Test { mem: isize, diff --git a/src/test/run-pass/issue-7660.rs b/src/test/run-pass/issue-7660.rs index 8a953cea9048d..9e36b1f5082d0 100644 --- a/src/test/run-pass/issue-7660.rs +++ b/src/test/run-pass/issue-7660.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Regresion test for issue 7660 +// Regression test for issue 7660 // rvalue lifetime too short when equivalent `match` works extern crate collections; From 456d23e73ee5d8c22b67336061ed7b457742d7ff Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Mon, 2 Feb 2015 20:25:42 -0800 Subject: [PATCH 07/35] Add a lint for writing `#[feature]` for stable features, warn by default. The 'stable_features' lint helps people progress from unstable to stable Rust by telling them when they no longer need a `feature` attribute because upstream Rust has declared it stable. This compares to the existing 'unstable_features', which is used to implement feature staging, and triggers on *any* use of `#[feature]`. --- src/librustc/lint/builtin.rs | 7 +++ src/librustc/middle/stability.rs | 53 ++++++++++++++++------ src/librustc_driver/driver.rs | 4 +- src/libsyntax/feature_gate.rs | 15 ++++-- src/test/compile-fail/gated-bad-feature.rs | 1 - src/test/compile-fail/stable-features.rs | 20 ++++++++ 6 files changed, 77 insertions(+), 23 deletions(-) create mode 100644 src/test/compile-fail/stable-features.rs diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 53054f462c8b6..685922cea1140 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -2018,6 +2018,12 @@ declare_lint! { "unused or unknown features found in crate-level #[feature] directives" } +declare_lint! { + pub STABLE_FEATURES, + Warn, + "stable features found in #[feature] directive" +} + declare_lint! { pub UNKNOWN_CRATE_TYPES, Deny, @@ -2060,6 +2066,7 @@ impl LintPass for HardwiredLints { UNREACHABLE_CODE, WARNINGS, UNUSED_FEATURES, + STABLE_FEATURES, UNKNOWN_CRATE_TYPES, VARIANT_SIZE_DIFFERENCES, FAT_PTR_TRANSMUTES diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 3304bd4ae2952..a005ae9c2227f 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -201,8 +201,9 @@ impl Index { /// Cross-references the feature names of unstable APIs with enabled /// features and possibly prints errors. Returns a list of all /// features used. -pub fn check_unstable_api_usage(tcx: &ty::ctxt) -> FnvHashSet { - let ref active_lib_features = tcx.sess.features.borrow().lib_features; +pub fn check_unstable_api_usage(tcx: &ty::ctxt) + -> FnvHashMap { + let ref active_lib_features = tcx.sess.features.borrow().declared_lib_features; // Put the active features into a map for quick lookup let active_features = active_lib_features.iter().map(|&(ref s, _)| s.clone()).collect(); @@ -210,7 +211,7 @@ pub fn check_unstable_api_usage(tcx: &ty::ctxt) -> FnvHashSet { let mut checker = Checker { tcx: tcx, active_features: active_features, - used_features: FnvHashSet() + used_features: FnvHashMap() }; let krate = tcx.map.krate(); @@ -223,7 +224,7 @@ pub fn check_unstable_api_usage(tcx: &ty::ctxt) -> FnvHashSet { struct Checker<'a, 'tcx: 'a> { tcx: &'a ty::ctxt<'tcx>, active_features: FnvHashSet, - used_features: FnvHashSet + used_features: FnvHashMap } impl<'a, 'tcx> Checker<'a, 'tcx> { @@ -234,7 +235,7 @@ impl<'a, 'tcx> Checker<'a, 'tcx> { match *stab { Some(Stability { level: attr::Unstable, ref feature, ref reason, .. }) => { - self.used_features.insert(feature.clone()); + self.used_features.insert(feature.clone(), attr::Unstable); if !self.active_features.contains(feature) { let msg = match *reason { @@ -247,7 +248,9 @@ impl<'a, 'tcx> Checker<'a, 'tcx> { feature.get(), span, &msg[]); } } - Some(..) => { + Some(Stability { level, ref feature, .. }) => { + self.used_features.insert(feature.clone(), level); + // Stable APIs are always ok to call and deprecated APIs are // handled by a lint. } @@ -433,17 +436,37 @@ pub fn lookup(tcx: &ty::ctxt, id: DefId) -> Option { /// Given the list of enabled features that were not language features (i.e. that /// were expected to be library features), and the list of features used from /// libraries, identify activated features that don't exist and error about them. -pub fn check_unused_features(sess: &Session, - used_lib_features: &FnvHashSet) { - let ref lib_features = sess.features.borrow().lib_features; - let mut active_lib_features: FnvHashMap - = lib_features.clone().into_iter().collect(); - - for used_feature in used_lib_features { - active_lib_features.remove(used_feature); +pub fn check_unused_or_stable_features(sess: &Session, + lib_features_used: &FnvHashMap) { + let ref declared_lib_features = sess.features.borrow().declared_lib_features; + let mut remaining_lib_features: FnvHashMap + = declared_lib_features.clone().into_iter().collect(); + + let stable_msg = "this feature is stable. attribute no longer needed"; + + for &span in sess.features.borrow().declared_stable_lang_features.iter() { + sess.add_lint(lint::builtin::STABLE_FEATURES, + ast::CRATE_NODE_ID, + span, + stable_msg.to_string()); + } + + for (used_lib_feature, level) in lib_features_used.iter() { + match remaining_lib_features.remove(used_lib_feature) { + Some(span) => { + if *level == attr::Stable { + sess.add_lint(lint::builtin::STABLE_FEATURES, + ast::CRATE_NODE_ID, + span, + stable_msg.to_string()); + } + } + None => ( /* used but undeclared, handled during the previous ast visit */ ) + } } - for (_, &span) in &active_lib_features { + for (_, &span) in remaining_lib_features.iter() { sess.add_lint(lint::builtin::UNUSED_FEATURES, ast::CRATE_NODE_ID, span, diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 8ede037594a00..8c89f66f7a177 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -668,8 +668,8 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session, time(time_passes, "stability checking", (), |_| stability::check_unstable_api_usage(&ty_cx)); - time(time_passes, "unused feature checking", (), |_| - stability::check_unused_features( + time(time_passes, "unused lib feature checking", (), |_| + stability::check_unused_or_stable_features( &ty_cx.sess, lib_features_used)); time(time_passes, "lint checking", (), |_| diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index d7a51e1149f30..59cdb15296ac9 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -149,7 +149,10 @@ pub struct Features { pub old_orphan_check: bool, pub simd_ffi: bool, pub unmarked_api: bool, - pub lib_features: Vec<(InternedString, Span)> + /// spans of #![feature] attrs for stable language features. for error reporting + pub declared_stable_lang_features: Vec, + /// #![feature] attrs for non-language (library) features + pub declared_lib_features: Vec<(InternedString, Span)> } impl Features { @@ -162,7 +165,8 @@ impl Features { old_orphan_check: false, simd_ffi: false, unmarked_api: false, - lib_features: Vec::new() + declared_stable_lang_features: Vec::new(), + declared_lib_features: Vec::new() } } } @@ -511,6 +515,7 @@ fn check_crate_inner(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::C cm: cm, }; + let mut accepted_features = Vec::new(); let mut unknown_features = Vec::new(); for attr in &krate.attrs { @@ -550,8 +555,7 @@ fn check_crate_inner(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::C span_handler.span_err(mi.span, "feature has been removed"); } Some(&(_, _, Accepted)) => { - span_handler.span_warn(mi.span, "feature has been added to Rust, \ - directive not necessary"); + accepted_features.push(mi.span); } None => { unknown_features.push((name, mi.span)); @@ -572,7 +576,8 @@ fn check_crate_inner(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::C old_orphan_check: cx.has_feature("old_orphan_check"), simd_ffi: cx.has_feature("simd_ffi"), unmarked_api: cx.has_feature("unmarked_api"), - lib_features: unknown_features + declared_stable_lang_features: accepted_features, + declared_lib_features: unknown_features } } diff --git a/src/test/compile-fail/gated-bad-feature.rs b/src/test/compile-fail/gated-bad-feature.rs index 39cd3e3b86afe..5baafd4153159 100644 --- a/src/test/compile-fail/gated-bad-feature.rs +++ b/src/test/compile-fail/gated-bad-feature.rs @@ -20,4 +20,3 @@ #![feature = "foo"] //~ ERROR: malformed feature #![feature(test_removed_feature)] //~ ERROR: feature has been removed -#![feature(test_accepted_feature)] //~ WARNING: feature has been added diff --git a/src/test/compile-fail/stable-features.rs b/src/test/compile-fail/stable-features.rs new file mode 100644 index 0000000000000..30eb4112c3fb2 --- /dev/null +++ b/src/test/compile-fail/stable-features.rs @@ -0,0 +1,20 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Testing that the stable_features lint catches use of stable +// language and lib features. + +#![deny(stable_features)] +#![feature(test_accepted_feature)] //~ ERROR this feature is stable +#![feature(rust1)] //~ ERROR this feature is stable + +fn main() { + let _foo: Vec<()> = Vec::new(); +} From 3ac862816fc57fb6047986624d98f986cbfd40b9 Mon Sep 17 00:00:00 2001 From: Mikhail Zabaluev Date: Wed, 4 Feb 2015 01:00:38 +0200 Subject: [PATCH 08/35] Replace usage of slice::from_raw_buf with slice::from_raw_parts New functions, slice::from_raw_parts and slice::from_raw_parts_mut, are added to implement the lifetime convention as agreed in RFC PR #556. The functions slice::from_raw_buf and slice::from_raw_mut_buf are left deprecated for the time being. --- src/libcollections/slice.rs | 1 + src/libcore/slice.rs | 56 ++++++++++++++++++++++++++++++--- src/libflate/lib.rs | 2 +- src/librand/isaac.rs | 4 +-- src/librustc/metadata/loader.rs | 8 ++--- src/librustdoc/html/markdown.rs | 28 +++++++++-------- src/libstd/ffi/c_str.rs | 4 +-- src/libstd/os.rs | 2 +- src/libstd/sys/windows/os.rs | 4 +-- 9 files changed, 80 insertions(+), 29 deletions(-) diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 4b4ea3e4c3ca5..2f547c72d0543 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -113,6 +113,7 @@ pub use core::slice::{Iter, IterMut}; pub use core::slice::{IntSliceExt, SplitMut, ChunksMut, Split}; pub use core::slice::{SplitN, RSplitN, SplitNMut, RSplitNMut}; pub use core::slice::{bytes, mut_ref_slice, ref_slice}; +pub use core::slice::{from_raw_parts, from_raw_parts_mut}; pub use core::slice::{from_raw_buf, from_raw_mut_buf}; //////////////////////////////////////////////////////////////////////////////// diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index a750e81bf596b..c622baa0cc22d 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -1357,6 +1357,52 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] { } } +/// Forms a slice from a pointer and a length. +/// +/// The `len` argument is the number of **elements**, not the number of bytes. +/// +/// This function is unsafe as there is no guarantee that the given pointer is +/// valid for `len` elements, nor whether the lifetime inferred is a suitable +/// lifetime for the returned slice. +/// +/// # Caveat +/// +/// The lifetime for the returned slice is inferred from its usage. To +/// prevent accidental misuse, it's suggested to tie the lifetime to whichever +/// source lifetime is safe in the context, such as by providing a helper +/// function taking the lifetime of a host value for the slice, or by explicit +/// annotation. +/// +/// # Example +/// +/// ```rust +/// use std::slice; +/// +/// // manifest a slice out of thin air! +/// let ptr = 0x1234 as *const uint; +/// let amt = 10; +/// unsafe { +/// let slice = slice::from_raw_parts(ptr, amt); +/// } +/// ``` +#[inline] +#[unstable(feature = "core")] +pub unsafe fn from_raw_parts<'a, T>(p: *const T, len: uint) -> &'a [T] { + transmute(RawSlice { data: p, len: len }) +} + +/// Performs the same functionality as `from_raw_parts`, except that a mutable +/// slice is returned. +/// +/// This function is unsafe for the same reasons as `from_raw_parts`, as well +/// as not being able to provide a non-aliasing guarantee of the returned +/// mutable slice. +#[inline] +#[unstable(feature = "core")] +pub unsafe fn from_raw_parts_mut<'a, T>(p: *mut T, len: uint) -> &'a mut [T] { + transmute(RawSlice { data: p, len: len }) +} + /// Forms a slice from a pointer and a length. /// /// The pointer given is actually a reference to the base of the slice. This @@ -1383,8 +1429,9 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] { /// } /// ``` #[inline] -#[unstable(feature = "core", - reason = "should be renamed to from_raw_parts")] +#[unstable(feature = "core")] +#[deprecated(since = "1.0.0", + reason = "use from_raw_parts")] pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] { transmute(RawSlice { data: *p, len: len }) } @@ -1396,8 +1443,9 @@ pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] { /// not being able to provide a non-aliasing guarantee of the returned mutable /// slice. #[inline] -#[unstable(feature = "core", - reason = "should be renamed to from_raw_parts_mut")] +#[unstable(feature = "core")] +#[deprecated(since = "1.0.0", + reason = "use from_raw_parts_mut")] pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] { transmute(RawSlice { data: *p, len: len }) } diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index a3bbba6d7b432..6c0c00002142a 100644 --- a/src/libflate/lib.rs +++ b/src/libflate/lib.rs @@ -45,7 +45,7 @@ pub struct Bytes { impl Deref for Bytes { type Target = [u8]; fn deref(&self) -> &[u8] { - unsafe { slice::from_raw_mut_buf(&self.ptr.0, self.len) } + unsafe { slice::from_raw_parts_mut(self.ptr.0, self.len) } } } diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index d399c244e83b8..67942a7e5b6eb 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -246,7 +246,7 @@ impl Rand for IsaacRng { unsafe { let ptr = ret.rsl.as_mut_ptr() as *mut u8; - let slice = slice::from_raw_mut_buf(&ptr, (RAND_SIZE * 4) as uint); + let slice = slice::from_raw_parts_mut(ptr, (RAND_SIZE * 4) as uint); other.fill_bytes(slice); } ret.cnt = 0; @@ -489,7 +489,7 @@ impl Rand for Isaac64Rng { unsafe { let ptr = ret.rsl.as_mut_ptr() as *mut u8; - let slice = slice::from_raw_mut_buf(&ptr, (RAND_SIZE_64 * 8) as uint); + let slice = slice::from_raw_parts_mut(ptr, (RAND_SIZE_64 * 8) as uint); other.fill_bytes(slice); } ret.cnt = 0; diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 2fb5a6b64a652..b7111d49d06ac 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -744,8 +744,8 @@ fn get_metadata_section_imp(is_osx: bool, filename: &Path) -> Result Result Result return Ok(MetadataVec(inflated)), None => {} diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index 7e08226019f98..8680604d3683d 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -165,6 +165,13 @@ extern { } +// hoedown_buffer helpers +impl hoedown_buffer { + fn as_bytes(&self) -> &[u8] { + unsafe { slice::from_raw_parts(self.data, self.size as usize) } + } +} + /// Returns Some(code) if `s` is a line that should be stripped from /// documentation but used in example code. `code` is the portion of /// `s` that should be used in tests. (None for lines that should be @@ -194,15 +201,13 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { let opaque = opaque as *mut hoedown_html_renderer_state; let my_opaque: &MyOpaque = &*((*opaque).opaque as *const MyOpaque); - let text = slice::from_raw_buf(&(*orig_text).data, - (*orig_text).size as uint); + let text = (*orig_text).as_bytes(); let origtext = str::from_utf8(text).unwrap(); debug!("docblock: ==============\n{:?}\n=======", text); let rendered = if lang.is_null() { false } else { - let rlang = slice::from_raw_buf(&(*lang).data, - (*lang).size as uint); + let rlang = (*lang).as_bytes(); let rlang = str::from_utf8(rlang).unwrap(); if !LangString::parse(rlang).rust { (my_opaque.dfltblk)(ob, orig_text, lang, @@ -248,9 +253,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { let s = if text.is_null() { "".to_string() } else { - let s = unsafe { - slice::from_raw_buf(&(*text).data, (*text).size as uint) - }; + let s = unsafe { (*text).as_bytes() }; str::from_utf8(s).unwrap().to_string() }; @@ -323,7 +326,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result { }; if ret.is_ok() { - let buf = slice::from_raw_buf(&(*ob).data, (*ob).size as uint); + let buf = (*ob).as_bytes(); ret = w.write_str(str::from_utf8(buf).unwrap()); } hoedown_buffer_free(ob); @@ -341,13 +344,12 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) { let block_info = if lang.is_null() { LangString::all_false() } else { - let lang = slice::from_raw_buf(&(*lang).data, - (*lang).size as uint); + let lang = (*lang).as_bytes(); let s = str::from_utf8(lang).unwrap(); LangString::parse(s) }; if !block_info.rust { return } - let text = slice::from_raw_buf(&(*text).data, (*text).size as uint); + let text = (*text).as_bytes(); let opaque = opaque as *mut hoedown_html_renderer_state; let tests = &mut *((*opaque).opaque as *mut ::test::Collector); let text = str::from_utf8(text).unwrap(); @@ -370,7 +372,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) { if text.is_null() { tests.register_header("", level as u32); } else { - let text = slice::from_raw_buf(&(*text).data, (*text).size as uint); + let text = (*text).as_bytes(); let text = str::from_utf8(text).unwrap(); tests.register_header(text, level as u32); } @@ -510,7 +512,7 @@ pub fn plain_summary_line(md: &str) -> String { hoedown_document_render(document, ob, md.as_ptr(), md.len() as libc::size_t); hoedown_document_free(document); - let plain_slice = slice::from_raw_buf(&(*ob).data, (*ob).size as uint); + let plain_slice = (*ob).as_bytes(); let plain = match str::from_utf8(plain_slice) { Ok(s) => s.to_string(), Err(_) => "".to_string(), diff --git a/src/libstd/ffi/c_str.rs b/src/libstd/ffi/c_str.rs index 2e55c007b551b..fcc4509aa9417 100644 --- a/src/libstd/ffi/c_str.rs +++ b/src/libstd/ffi/c_str.rs @@ -162,7 +162,7 @@ impl fmt::Debug for CString { /// ``` pub unsafe fn c_str_to_bytes<'a>(raw: &'a *const libc::c_char) -> &'a [u8] { let len = libc::strlen(*raw); - slice::from_raw_buf(&*(raw as *const _ as *const *const u8), len as uint) + slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize) } /// Interpret a C string as a byte slice with the nul terminator. @@ -171,7 +171,7 @@ pub unsafe fn c_str_to_bytes<'a>(raw: &'a *const libc::c_char) -> &'a [u8] { /// will include the nul terminator of the string. pub unsafe fn c_str_to_bytes_with_nul<'a>(raw: &'a *const libc::c_char) -> &'a [u8] { let len = libc::strlen(*raw) + 1; - slice::from_raw_buf(&*(raw as *const _ as *const *const u8), len as uint) + slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize) } #[cfg(test)] diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 64f9e16aee4fd..dcdd31639d39c 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -671,7 +671,7 @@ fn real_args() -> Vec { // Push it onto the list. let ptr = ptr as *const u16; - let buf = slice::from_raw_buf(&ptr, len); + let buf = slice::from_raw_parts(ptr, len); let opt_s = String::from_utf16(sys::truncate_utf16_at_nul(buf)); opt_s.ok().expect("CommandLineToArgvW returned invalid UTF-16") }).collect(); diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index c71e2d057c351..d8e3e6981df76 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -109,7 +109,7 @@ impl Iterator for Env { len += 1; } let p = p as *const u16; - let s = slice::from_raw_buf(&p, len as usize); + let s = slice::from_raw_parts(p, len as usize); self.cur = self.cur.offset(len + 1); let (k, v) = match s.iter().position(|&b| b == '=' as u16) { @@ -296,7 +296,7 @@ impl Iterator for Args { // Push it onto the list. let ptr = ptr as *const u16; - let buf = slice::from_raw_buf(&ptr, len as usize); + let buf = slice::from_raw_parts(ptr, len as usize); OsStringExt::from_wide(buf) }) } From fb6b970bf8d12182a69b1e7ae222f3e2ebbb9003 Mon Sep 17 00:00:00 2001 From: Mikhail Zabaluev Date: Thu, 5 Feb 2015 13:53:32 +0200 Subject: [PATCH 09/35] Replace one more slice::from_raw_mut_buf added with new io --- src/libstd/io/mod.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 0832206a48b60..419bee1a624d3 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -24,7 +24,6 @@ use error::Error as StdError; use fmt; use iter::Iterator; use marker::Sized; -use mem; use ops::{Drop, FnOnce}; use option::Option::{self, Some, None}; use ptr::PtrExt; @@ -69,8 +68,8 @@ fn with_end_to_cap(v: &mut Vec, f: F) -> Result unsafe { let n = try!(f({ let base = v.as_mut_ptr().offset(v.len() as isize); - black_box(slice::from_raw_mut_buf(mem::copy_lifetime(v, &base), - v.capacity() - v.len())) + black_box(slice::from_raw_parts_mut(base, + v.capacity() - v.len())) })); // If the closure (typically a `read` implementation) reported that it From 5ad3488f29bbccfcee074bb0f3971acec97cfc45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Marie?= Date: Thu, 5 Feb 2015 15:24:17 +0100 Subject: [PATCH 10/35] unbreak tree for openbsd after #21787 - add `_SC_GETPW_R_SIZE_MAX` constant - declare `struct passwd` - convert `load_self` to `current_exe` Note: OpenBSD don't provide system function to return a valuable Path for `env::current_exe`. The implementation is currently based on the value of `argv[0]`, which couldn't be used when executable is called via PATH. --- src/libstd/sys/unix/c.rs | 5 ++++- src/libstd/sys/unix/os.rs | 13 +++++++------ src/rt/rust_builtin.c | 2 +- 3 files changed, 12 insertions(+), 8 deletions(-) diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs index 50a8e6b73e386..22194145252ee 100644 --- a/src/libstd/sys/unix/c.rs +++ b/src/libstd/sys/unix/c.rs @@ -74,6 +74,8 @@ pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 70; #[cfg(any(target_os = "macos", target_os = "freebsd"))] pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 71; +#[cfg(target_os = "openbsd")] +pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 101; #[cfg(target_os = "android")] pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 0x0048; @@ -91,7 +93,8 @@ pub struct passwd { #[repr(C)] #[cfg(any(target_os = "macos", - target_os = "freebsd"))] + target_os = "freebsd", + target_os = "openbsd"))] pub struct passwd { pub pw_name: *mut libc::c_char, pub pw_passwd: *mut libc::c_char, diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index 5004ff713c45f..be52c7dc69290 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -197,23 +197,23 @@ pub fn current_exe() -> IoResult { } #[cfg(target_os = "openbsd")] -pub fn load_self() -> Option> { +pub fn current_exe() -> IoResult { use sync::{StaticMutex, MUTEX_INIT}; static LOCK: StaticMutex = MUTEX_INIT; extern { - fn rust_load_self() -> *const c_char; + fn rust_current_exe() -> *const c_char; } let _guard = LOCK.lock(); unsafe { - let v = rust_load_self(); + let v = rust_current_exe(); if v.is_null() { - None + Err(IoError::last_error()) } else { - Some(ffi::c_str_to_bytes(&v).to_vec()) + Ok(Path::new(ffi::c_str_to_bytes(&v).to_vec())) } } } @@ -333,7 +333,8 @@ pub fn args() -> Args { #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd", - target_os = "dragonfly"))] + target_os = "dragonfly", + target_os = "openbsd"))] pub fn args() -> Args { use rt; let bytes = rt::args::clone().unwrap_or(Vec::new()); diff --git a/src/rt/rust_builtin.c b/src/rt/rust_builtin.c index 382cbf0d5d129..255fbdcbfcf5e 100644 --- a/src/rt/rust_builtin.c +++ b/src/rt/rust_builtin.c @@ -204,7 +204,7 @@ int *__dfly_error(void) { return __error(); } #include #include -const char * rust_load_self() { +const char * rust_current_exe() { static char *self = NULL; if (self == NULL) { From 8fded29586041ac8877bc35dadc60bdf873459a0 Mon Sep 17 00:00:00 2001 From: Alexander Light Date: Thu, 5 Feb 2015 10:51:17 -0500 Subject: [PATCH 11/35] Made external_crates feature work again. Also added test for it. Fixes #21928 --- src/liballoc/lib.rs | 4 ++- .../run-make/alloc-extern-crates/Makefile | 5 +++ .../run-make/alloc-extern-crates/fakealloc.rs | 36 +++++++++++++++++++ 3 files changed, 44 insertions(+), 1 deletion(-) create mode 100644 src/test/run-make/alloc-extern-crates/Makefile create mode 100644 src/test/run-make/alloc-extern-crates/fakealloc.rs diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index 9942334902039..d99a5e2cc6d4a 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -73,7 +73,9 @@ #![feature(unboxed_closures)] #![feature(core)] #![feature(hash)] -#![feature(libc)] +#![cfg_attr(all(not(feature = "external_funcs"), not(feature = "external_crate")), + feature(libc))] + #[macro_use] extern crate core; diff --git a/src/test/run-make/alloc-extern-crates/Makefile b/src/test/run-make/alloc-extern-crates/Makefile new file mode 100644 index 0000000000000..b8c52378554ba --- /dev/null +++ b/src/test/run-make/alloc-extern-crates/Makefile @@ -0,0 +1,5 @@ +-include ../tools.mk + +all: + $(RUSTC) fakealloc.rs + $(RUSTC) ../../../liballoc/lib.rs --cfg feature=\"external_crate\" --extern external=$(TMPDIR)/$(shell $(RUSTC) --print file-names fakealloc.rs) diff --git a/src/test/run-make/alloc-extern-crates/fakealloc.rs b/src/test/run-make/alloc-extern-crates/fakealloc.rs new file mode 100644 index 0000000000000..563a527b94194 --- /dev/null +++ b/src/test/run-make/alloc-extern-crates/fakealloc.rs @@ -0,0 +1,36 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![crate_type = "rlib"] +#![no_std] +#![feature(core)] +extern crate core; + + +#[inline] +pub unsafe fn allocate(_size: usize, _align: usize) -> *mut u8 { 0 as *mut u8 } + +#[inline] +pub unsafe fn deallocate(_ptr: *mut u8, _old_size: usize, _align: usize) { } + +#[inline] +pub unsafe fn reallocate(_ptr: *mut u8, _old_size: usize, _size: usize, _align: usize) -> *mut u8 { + 0 as *mut u8 +} + +#[inline] +pub unsafe fn reallocate_inplace(_ptr: *mut u8, old_size: usize, _size: usize, + _align: usize) -> usize { old_size } + +#[inline] +pub fn usable_size(size: usize, _align: usize) -> usize { size } + +#[inline] +pub fn stats_print() { } From be8d9bb98a140d4a4df762e2ea44109c2f05ce6c Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 5 Feb 2015 11:48:20 -0500 Subject: [PATCH 12/35] When elaborating predicates, purge duplicates from the initial vector. Fixes #21965. --- src/librustc/middle/traits/util.rs | 13 ++++----- ...sociated-types-duplicate-binding-in-env.rs | 27 +++++++++++++++++++ 2 files changed, 32 insertions(+), 8 deletions(-) create mode 100644 src/test/run-pass/associated-types-duplicate-binding-in-env.rs diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs index 45ce692bb0763..6cbac7d01e7b7 100644 --- a/src/librustc/middle/traits/util.rs +++ b/src/librustc/middle/traits/util.rs @@ -11,12 +11,12 @@ use middle::subst::{Substs, VecPerParamSpace}; use middle::infer::InferCtxt; use middle::ty::{self, Ty, AsPredicate, ToPolyTraitRef}; -use std::collections::HashSet; use std::fmt; use std::rc::Rc; use syntax::ast; use syntax::codemap::Span; use util::common::ErrorReported; +use util::nodemap::FnvHashSet; use util::ppaux::Repr; use super::{Obligation, ObligationCause, PredicateObligation, @@ -36,7 +36,7 @@ use super::{Obligation, ObligationCause, PredicateObligation, pub struct Elaborator<'cx, 'tcx:'cx> { tcx: &'cx ty::ctxt<'tcx>, stack: Vec>, - visited: HashSet>, + visited: FnvHashSet>, } struct StackEntry<'tcx> { @@ -65,14 +65,11 @@ pub fn elaborate_trait_refs<'cx, 'tcx>( pub fn elaborate_predicates<'cx, 'tcx>( tcx: &'cx ty::ctxt<'tcx>, - predicates: Vec>) + mut predicates: Vec>) -> Elaborator<'cx, 'tcx> { - let visited: HashSet> = - predicates.iter() - .map(|b| (*b).clone()) - .collect(); - + let mut visited = FnvHashSet(); + predicates.retain(|pred| visited.insert(pred.clone())); let entry = StackEntry { position: 0, predicates: predicates }; Elaborator { tcx: tcx, stack: vec![entry], visited: visited } } diff --git a/src/test/run-pass/associated-types-duplicate-binding-in-env.rs b/src/test/run-pass/associated-types-duplicate-binding-in-env.rs new file mode 100644 index 0000000000000..62ac21879520b --- /dev/null +++ b/src/test/run-pass/associated-types-duplicate-binding-in-env.rs @@ -0,0 +1,27 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Check that we do not report ambiguities when the same predicate +// appears in the environment twice. Issue #21965. + +trait Foo { + type B; + + fn get() -> Self::B; +} + +fn foo() -> () + where T : Foo, T : Foo +{ + ::get() +} + +fn main() { +} From cb4965ef3a826af8150ef863e98709b4ffa83767 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Marie?= Date: Thu, 5 Feb 2015 18:56:10 +0100 Subject: [PATCH 13/35] complete openbsd support for `std::env` - add `std::env:consts` - deprecating `std::os::consts` - refactoring errno_location() --- src/libstd/env.rs | 32 ++++++++++++++++++++++++++++++++ src/libstd/os.rs | 2 ++ src/libstd/sys/unix/os.rs | 10 +++------- 3 files changed, 37 insertions(+), 7 deletions(-) diff --git a/src/libstd/env.rs b/src/libstd/env.rs index 559a68542efc8..c3aacf6f6b0c4 100644 --- a/src/libstd/env.rs +++ b/src/libstd/env.rs @@ -562,6 +562,38 @@ pub mod consts { pub const EXE_EXTENSION: &'static str = ""; } +/// Constants associated with the current target +#[cfg(target_os = "openbsd")] +pub mod consts { + pub use super::arch_consts::ARCH; + + pub const FAMILY: &'static str = "unix"; + + /// A string describing the specific operating system in use: in this + /// case, `dragonfly`. + pub const OS: &'static str = "openbsd"; + + /// Specifies the filename prefix used for shared libraries on this + /// platform: in this case, `lib`. + pub const DLL_PREFIX: &'static str = "lib"; + + /// Specifies the filename suffix used for shared libraries on this + /// platform: in this case, `.so`. + pub const DLL_SUFFIX: &'static str = ".so"; + + /// Specifies the file extension used for shared libraries on this + /// platform that goes after the dot: in this case, `so`. + pub const DLL_EXTENSION: &'static str = "so"; + + /// Specifies the filename suffix used for executable binaries on this + /// platform: in this case, the empty string. + pub const EXE_SUFFIX: &'static str = ""; + + /// Specifies the file extension, if any, used for executable binaries + /// on this platform: in this case, the empty string. + pub const EXE_EXTENSION: &'static str = ""; +} + /// Constants associated with the current target #[cfg(target_os = "android")] pub mod consts { diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 64f9e16aee4fd..72a8ac049117b 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -1289,6 +1289,8 @@ pub mod consts { } #[cfg(target_os = "openbsd")] +#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] +#[unstable(feature = "os")] pub mod consts { pub use os::arch_consts::ARCH; diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index be52c7dc69290..b191eda583c9b 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -47,13 +47,9 @@ pub fn errno() -> i32 { } #[cfg(target_os = "openbsd")] - fn errno_location() -> *const c_int { - extern { - fn __errno() -> *const c_int; - } - unsafe { - __errno() - } + unsafe fn errno_location() -> *const c_int { + extern { fn __errno() -> *const c_int; } + __errno() } #[cfg(any(target_os = "linux", target_os = "android"))] From 023a931309c17dab1b9d2332369626a26a5227cc Mon Sep 17 00:00:00 2001 From: Mikhail Zabaluev Date: Thu, 5 Feb 2015 22:19:11 +0200 Subject: [PATCH 14/35] Make the lifetime anchor immutable on std::mem::copy_mut_lifetime Only the second reference's mutability is relevant to the mutability of the returned reference. --- src/libcore/mem.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 0d26c8e79142a..51bf3c1648f56 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -331,8 +331,9 @@ pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S, #[unstable(feature = "core", reason = "this function may be removed in the future due to its \ questionable utility")] -pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S, - ptr: &mut T) - -> &'a mut T { +pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S, + ptr: &mut T) + -> &'a mut T +{ transmute(ptr) } From 8d9bb17204c0b3b9c8ade3569ac4501fac18b885 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 5 Feb 2015 15:50:34 -0500 Subject: [PATCH 15/35] Extend the solution to encompass HRTB --- src/librustc/middle/traits/util.rs | 49 +++++++++++++++++-- ...ted-types-duplicate-binding-in-env-hrtb.rs | 9 ++++ 2 files changed, 54 insertions(+), 4 deletions(-) create mode 100644 src/test/run-pass/associated-types-duplicate-binding-in-env-hrtb.rs diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs index 6cbac7d01e7b7..be8a4fbb1a821 100644 --- a/src/librustc/middle/traits/util.rs +++ b/src/librustc/middle/traits/util.rs @@ -22,6 +22,47 @@ use util::ppaux::Repr; use super::{Obligation, ObligationCause, PredicateObligation, VtableImpl, VtableParam, VtableImplData}; +struct PredicateSet<'a,'tcx:'a> { + tcx: &'a ty::ctxt<'tcx>, + set: FnvHashSet>, +} + +impl<'a,'tcx> PredicateSet<'a,'tcx> { + fn new(tcx: &'a ty::ctxt<'tcx>) -> PredicateSet<'a,'tcx> { + PredicateSet { tcx: tcx, set: FnvHashSet() } + } + + fn insert(&mut self, pred: &ty::Predicate<'tcx>) -> bool { + // We have to be careful here because we want + // + // for<'a> Foo<&'a int> + // + // and + // + // for<'b> Foo<&'b int> + // + // to be considered equivalent. So normalize all late-bound + // regions before we throw things into the underlying set. + let normalized_pred = match *pred { + ty::Predicate::Trait(ref data) => + ty::Predicate::Trait(ty::anonymize_late_bound_regions(self.tcx, data)), + + ty::Predicate::Equate(ref data) => + ty::Predicate::Equate(ty::anonymize_late_bound_regions(self.tcx, data)), + + ty::Predicate::RegionOutlives(ref data) => + ty::Predicate::RegionOutlives(ty::anonymize_late_bound_regions(self.tcx, data)), + + ty::Predicate::TypeOutlives(ref data) => + ty::Predicate::TypeOutlives(ty::anonymize_late_bound_regions(self.tcx, data)), + + ty::Predicate::Projection(ref data) => + ty::Predicate::Projection(ty::anonymize_late_bound_regions(self.tcx, data)), + }; + self.set.insert(normalized_pred) + } +} + /////////////////////////////////////////////////////////////////////////// // `Elaboration` iterator /////////////////////////////////////////////////////////////////////////// @@ -36,7 +77,7 @@ use super::{Obligation, ObligationCause, PredicateObligation, pub struct Elaborator<'cx, 'tcx:'cx> { tcx: &'cx ty::ctxt<'tcx>, stack: Vec>, - visited: FnvHashSet>, + visited: PredicateSet<'cx,'tcx>, } struct StackEntry<'tcx> { @@ -68,8 +109,8 @@ pub fn elaborate_predicates<'cx, 'tcx>( mut predicates: Vec>) -> Elaborator<'cx, 'tcx> { - let mut visited = FnvHashSet(); - predicates.retain(|pred| visited.insert(pred.clone())); + let mut visited = PredicateSet::new(tcx); + predicates.retain(|pred| visited.insert(pred)); let entry = StackEntry { position: 0, predicates: predicates }; Elaborator { tcx: tcx, stack: vec![entry], visited: visited } } @@ -91,7 +132,7 @@ impl<'cx, 'tcx> Elaborator<'cx, 'tcx> { // recursion in some cases. One common case is when // people define `trait Sized: Sized { }` rather than `trait // Sized { }`. - predicates.retain(|r| self.visited.insert(r.clone())); + predicates.retain(|r| self.visited.insert(r)); self.stack.push(StackEntry { position: 0, predicates: predicates }); diff --git a/src/test/run-pass/associated-types-duplicate-binding-in-env-hrtb.rs b/src/test/run-pass/associated-types-duplicate-binding-in-env-hrtb.rs new file mode 100644 index 0000000000000..f4b765d14b072 --- /dev/null +++ b/src/test/run-pass/associated-types-duplicate-binding-in-env-hrtb.rs @@ -0,0 +1,9 @@ +fn foo(t: T) -> i32 + where T : for<'a> Fn(&'a u8) -> i32, + T : for<'b> Fn(&'b u8) -> i32, +{ + t(&3) +} + +fn main() { +} From fab32b41676c6c9d75733ce78d8d5f455a4f27fc Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 5 Feb 2015 16:24:12 -0500 Subject: [PATCH 16/35] Now that the elaboration mechanism is suppressing defaults, we can remove this overeager code that was pruning out ambig where-clause matches in trait selection. cc #21974. --- src/librustc/middle/traits/select.rs | 19 ------------------- src/test/compile-fail/issue-21974.rs | 28 ++++++++++++++++++++++++++++ 2 files changed, 28 insertions(+), 19 deletions(-) create mode 100644 src/test/compile-fail/issue-21974.rs diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index b8af91add9efb..e9909cc512c10 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -1335,25 +1335,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // the where clauses are in scope. true } - (&ParamCandidate(ref bound1), &ParamCandidate(ref bound2)) => { - self.infcx.probe(|_| { - let bound1 = - project::normalize_with_depth(self, - stack.obligation.cause.clone(), - stack.obligation.recursion_depth+1, - bound1); - let bound2 = - project::normalize_with_depth(self, - stack.obligation.cause.clone(), - stack.obligation.recursion_depth+1, - bound2); - let origin = - infer::RelateOutputImplTypes(stack.obligation.cause.span); - self.infcx - .sub_poly_trait_refs(false, origin, bound1.value, bound2.value) - .is_ok() - }) - } _ => { false } diff --git a/src/test/compile-fail/issue-21974.rs b/src/test/compile-fail/issue-21974.rs new file mode 100644 index 0000000000000..f768d6c00ecdb --- /dev/null +++ b/src/test/compile-fail/issue-21974.rs @@ -0,0 +1,28 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test that (for now) we report an ambiguity error here, because +// specific trait relationships are ignored for the purposes of trait +// matching. This behavior should likely be improved such that this +// test passes. See #21974 for more details. + +trait Foo { + fn foo(self); +} + +fn foo<'a,'b,T>(x: &'a T, y: &'b T) + where &'a T : Foo, + &'b T : Foo +{ + x.foo(); //~ ERROR type annotations required + y.foo(); +} + +fn main() { } From bbf0898013d0e2cb9655987cbef1f00569e6299a Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 5 Feb 2015 17:01:11 -0500 Subject: [PATCH 17/35] Fix license --- ...sociated-types-duplicate-binding-in-env-hrtb.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/test/run-pass/associated-types-duplicate-binding-in-env-hrtb.rs b/src/test/run-pass/associated-types-duplicate-binding-in-env-hrtb.rs index f4b765d14b072..8b7ea61dc77e9 100644 --- a/src/test/run-pass/associated-types-duplicate-binding-in-env-hrtb.rs +++ b/src/test/run-pass/associated-types-duplicate-binding-in-env-hrtb.rs @@ -1,3 +1,17 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Check that we do not report ambiguities when equivalent predicates +// (modulo bound lifetime names) appears in the environment +// twice. Issue #21965. + fn foo(t: T) -> i32 where T : for<'a> Fn(&'a u8) -> i32, T : for<'b> Fn(&'b u8) -> i32, From fa9d2230a65689289f64c897ad30c83251762320 Mon Sep 17 00:00:00 2001 From: "Felix S. Klock II" Date: Thu, 5 Feb 2015 16:02:22 +0100 Subject: [PATCH 18/35] make codemap more robust in face of ill-formed spans. This can be considered partial work on #8256. The main observable change: macro expansion sometimes results in spans where `lo > hi`; so for now, when we have such a span, do not attempt to return a snippet result. (Longer term, we might think about whether we could still present a snippet for the cases where this arises, e.g. perhaps by showing the whole macro as the snippet, assuming that is the sole cause of such spans; or by somehow looking up the closest AST node that holds both `lo` and `hi`, and showing that.) As a drive-by, revised the API to return a `Result` rather than an `Option`, with better information-packed error value that should help us (and maybe also our users) identify the causes of such problems in the future. Ideally the call-sites that really want an actual snippet would be updated to catch the newly added `Err` case and print something meaningful about it, but that is not part of this PR. --- src/librustc_trans/save/span_utils.rs | 4 +- src/librustc_trans/trans/debuginfo.rs | 2 +- src/librustdoc/clean/mod.rs | 4 +- src/libsyntax/codemap.rs | 54 +++++++++++++++++++++++---- src/libsyntax/parse/mod.rs | 4 +- 5 files changed, 53 insertions(+), 15 deletions(-) diff --git a/src/librustc_trans/save/span_utils.rs b/src/librustc_trans/save/span_utils.rs index beec8071a72ba..a724cdc0229d2 100644 --- a/src/librustc_trans/save/span_utils.rs +++ b/src/librustc_trans/save/span_utils.rs @@ -69,8 +69,8 @@ impl<'a> SpanUtils<'a> { pub fn snippet(&self, span: Span) -> String { match self.sess.codemap().span_to_snippet(span) { - Some(s) => s, - None => String::new(), + Ok(s) => s, + Err(_) => String::new(), } } diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index 1e788351172fc..4d4a2bf48548a 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -1094,7 +1094,7 @@ pub fn get_cleanup_debug_loc_for_ast_node<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // bodies), in which case we also just want to return the span of the // whole expression. let code_snippet = cx.sess().codemap().span_to_snippet(node_span); - if let Some(code_snippet) = code_snippet { + if let Ok(code_snippet) = code_snippet { let bytes = code_snippet.as_bytes(); if bytes.len() > 0 && &bytes[bytes.len()-1..] == b"}" { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 248ce99ff9b72..611251d4cfae1 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -2301,8 +2301,8 @@ impl ToSource for syntax::codemap::Span { fn to_src(&self, cx: &DocContext) -> String { debug!("converting span {:?} to snippet", self.clean(cx)); let sn = match cx.sess().codemap().span_to_snippet(*self) { - Some(x) => x.to_string(), - None => "".to_string() + Ok(x) => x.to_string(), + Err(_) => "".to_string() }; debug!("got snippet {}", sn); sn diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 00857d10f439e..3231342cb50c8 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -437,18 +437,35 @@ impl CodeMap { FileLines {file: lo.file, lines: lines} } - pub fn span_to_snippet(&self, sp: Span) -> Option { + pub fn span_to_snippet(&self, sp: Span) -> Result { + if sp.lo > sp.hi { + return Err(SpanSnippetError::IllFormedSpan(sp)); + } + let begin = self.lookup_byte_offset(sp.lo); let end = self.lookup_byte_offset(sp.hi); - // FIXME #8256: this used to be an assert but whatever precondition - // it's testing isn't true for all spans in the AST, so to allow the - // caller to not have to panic (and it can't catch it since the CodeMap - // isn't sendable), return None if begin.fm.start_pos != end.fm.start_pos { - None + return Err(SpanSnippetError::DistinctSources(DistinctSources { + begin: (begin.fm.name.clone(), + begin.fm.start_pos), + end: (end.fm.name.clone(), + end.fm.start_pos) + })); } else { - Some((&begin.fm.src[begin.pos.to_usize()..end.pos.to_usize()]).to_string()) + let start = begin.pos.to_usize(); + let limit = end.pos.to_usize(); + if start > limit || limit > begin.fm.src.len() { + return Err(SpanSnippetError::MalformedForCodemap( + MalformedCodemapPositions { + name: begin.fm.name.clone(), + source_len: begin.fm.src.len(), + begin_pos: begin.pos, + end_pos: end.pos, + })); + } + + return Ok((&begin.fm.src[start..limit]).to_string()) } } @@ -622,6 +639,27 @@ impl CodeMap { } } +#[derive(Clone, PartialEq, Eq, Debug)] +pub enum SpanSnippetError { + IllFormedSpan(Span), + DistinctSources(DistinctSources), + MalformedForCodemap(MalformedCodemapPositions), +} + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct DistinctSources { + begin: (String, BytePos), + end: (String, BytePos) +} + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct MalformedCodemapPositions { + name: String, + source_len: usize, + begin_pos: BytePos, + end_pos: BytePos +} + #[cfg(test)] mod test { use super::*; @@ -773,7 +811,7 @@ mod test { let span = Span {lo: BytePos(12), hi: BytePos(23), expn_id: NO_EXPANSION}; let snippet = cm.span_to_snippet(span); - assert_eq!(snippet, Some("second line".to_string())); + assert_eq!(snippet, Ok("second line".to_string())); } #[test] diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 6ff5c77f5079a..9e9ec08da038e 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -1233,8 +1233,8 @@ mod test { let span = tts.iter().rev().next().unwrap().get_span(); match sess.span_diagnostic.cm.span_to_snippet(span) { - Some(s) => assert_eq!(&s[], "{ body }"), - None => panic!("could not get snippet"), + Ok(s) => assert_eq!(&s[], "{ body }"), + Err(_) => panic!("could not get snippet"), } } } From 1e8e7dcdd00b552ef78ce83f6dc5f24a45d91b8f Mon Sep 17 00:00:00 2001 From: "Felix S. Klock II" Date: Mon, 22 Dec 2014 19:02:11 +0100 Subject: [PATCH 19/35] improve `compiletest` error message when path option missing. (I often run `compiletest` by hand by cut-and-pasting from what `make` runs, but then I need to tweak it (cut out options) and its useful to be told when I have removed an option that is actually required, such as `--android-cross-path=path`.) --- src/compiletest/compiletest.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index e3e7ca7691134..e6d2a691cf563 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -118,7 +118,10 @@ pub fn parse_config(args: Vec ) -> Config { } fn opt_path(m: &getopts::Matches, nm: &str) -> Path { - Path::new(m.opt_str(nm).unwrap()) + match m.opt_str(nm) { + Some(s) => Path::new(s), + None => panic!("no option (=path) found for {}", nm), + } } let filter = if !matches.free.is_empty() { From e4a678ddab7727a8336fc51a6cf8ea2a2952f27c Mon Sep 17 00:00:00 2001 From: "Felix S. Klock II" Date: Mon, 2 Feb 2015 13:26:54 +0100 Subject: [PATCH 20/35] Ported regions-mock-tcx to use TypedArena rather than Arena since it holds cyclic structure (which the Arena API updated for dropck cannot handle). --- src/test/run-pass/regions-mock-tcx.rs | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/src/test/run-pass/regions-mock-tcx.rs b/src/test/run-pass/regions-mock-tcx.rs index be7db25201afd..bf789d5364500 100644 --- a/src/test/run-pass/regions-mock-tcx.rs +++ b/src/test/run-pass/regions-mock-tcx.rs @@ -21,7 +21,7 @@ extern crate libc; use TypeStructure::{TypeInt, TypeFunction}; use AstKind::{ExprInt, ExprVar, ExprLambda}; -use arena::Arena; +use arena::TypedArena; use std::collections::HashMap; use std::mem; @@ -45,17 +45,20 @@ impl<'tcx> PartialEq for TypeStructure<'tcx> { impl<'tcx> Eq for TypeStructure<'tcx> {} +type TyArena<'tcx> = TypedArena>; +type AstArena<'ast> = TypedArena>; + struct TypeContext<'tcx, 'ast> { - ty_arena: &'tcx Arena, + ty_arena: &'tcx TyArena<'tcx>, types: Vec> , type_table: HashMap>, - ast_arena: &'ast Arena, + ast_arena: &'ast AstArena<'ast>, ast_counter: uint, } impl<'tcx,'ast> TypeContext<'tcx, 'ast> { - fn new(ty_arena: &'tcx Arena, ast_arena: &'ast Arena) + fn new(ty_arena: &'tcx TyArena<'tcx>, ast_arena: &'ast AstArena<'ast>) -> TypeContext<'tcx, 'ast> { TypeContext { ty_arena: ty_arena, types: Vec::new(), @@ -72,7 +75,7 @@ impl<'tcx,'ast> TypeContext<'tcx, 'ast> { } } - let ty = self.ty_arena.alloc(|| s); + let ty = self.ty_arena.alloc(s); self.types.push(ty); ty } @@ -85,7 +88,7 @@ impl<'tcx,'ast> TypeContext<'tcx, 'ast> { fn ast(&mut self, a: AstKind<'ast>) -> Ast<'ast> { let id = self.ast_counter; self.ast_counter += 1; - self.ast_arena.alloc(|| AstStructure { id: NodeId {id:id}, kind: a }) + self.ast_arena.alloc(AstStructure { id: NodeId {id:id}, kind: a }) } } @@ -127,8 +130,8 @@ fn compute_types<'tcx,'ast>(tcx: &mut TypeContext<'tcx,'ast>, } pub fn main() { - let ty_arena = arena::Arena::new(); - let ast_arena = arena::Arena::new(); + let ty_arena = TypedArena::new(); + let ast_arena = TypedArena::new(); let mut tcx = TypeContext::new(&ty_arena, &ast_arena); let ast = tcx.ast(ExprInt); let ty = compute_types(&mut tcx, ast); From 50c674211390ea56e8c54d8d52ee1e3a6a8f675e Mon Sep 17 00:00:00 2001 From: "Felix S. Klock II" Date: Mon, 2 Feb 2015 01:04:59 +0100 Subject: [PATCH 21/35] Use a TypedArena rather than an Arena for the backing storage of variance analysis. (The code was not using the main feature of Arena in the first place, since all of the `alloc` calls were on the same type. --- src/librustc_typeck/variance.rs | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 2596f90bfc626..567a388836f25 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -192,7 +192,7 @@ use self::VarianceTerm::*; use self::ParamKind::*; use arena; -use arena::Arena; +use arena::TypedArena; use middle::resolve_lifetime as rl; use middle::subst; use middle::subst::{ParamSpace, FnSpace, TypeSpace, SelfSpace, VecPerParamSpace}; @@ -210,7 +210,7 @@ use util::ppaux::Repr; pub fn infer_variance(tcx: &ty::ctxt) { let krate = tcx.map.krate(); - let mut arena = arena::Arena::new(); + let mut arena = arena::TypedArena::new(); let terms_cx = determine_parameters_to_be_inferred(tcx, &mut arena, krate); let constraints_cx = add_constraints_from_crate(terms_cx, krate); solve_constraints(constraints_cx); @@ -254,7 +254,7 @@ impl<'a> fmt::Debug for VarianceTerm<'a> { struct TermsContext<'a, 'tcx: 'a> { tcx: &'a ty::ctxt<'tcx>, - arena: &'a Arena, + arena: &'a TypedArena>, empty_variances: Rc, @@ -282,7 +282,7 @@ struct InferredInfo<'a> { } fn determine_parameters_to_be_inferred<'a, 'tcx>(tcx: &'a ty::ctxt<'tcx>, - arena: &'a mut Arena, + arena: &'a mut TypedArena>, krate: &ast::Crate) -> TermsContext<'a, 'tcx> { let mut terms_cx = TermsContext { @@ -312,7 +312,7 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { index: uint, param_id: ast::NodeId) { let inf_index = InferredIndex(self.inferred_infos.len()); - let term = self.arena.alloc(|| InferredTerm(inf_index)); + let term = self.arena.alloc(InferredTerm(inf_index)); self.inferred_infos.push(InferredInfo { item_id: item_id, kind: kind, space: space, @@ -455,10 +455,10 @@ fn add_constraints_from_crate<'a, 'tcx>(terms_cx: TermsContext<'a, 'tcx>, let unsafe_lang_item = terms_cx.tcx.lang_items.unsafe_type(); - let covariant = terms_cx.arena.alloc(|| ConstantTerm(ty::Covariant)); - let contravariant = terms_cx.arena.alloc(|| ConstantTerm(ty::Contravariant)); - let invariant = terms_cx.arena.alloc(|| ConstantTerm(ty::Invariant)); - let bivariant = terms_cx.arena.alloc(|| ConstantTerm(ty::Bivariant)); + let covariant = terms_cx.arena.alloc(ConstantTerm(ty::Covariant)); + let contravariant = terms_cx.arena.alloc(ConstantTerm(ty::Contravariant)); + let invariant = terms_cx.arena.alloc(ConstantTerm(ty::Invariant)); + let bivariant = terms_cx.arena.alloc(ConstantTerm(ty::Bivariant)); let mut constraint_cx = ConstraintContext { terms_cx: terms_cx, @@ -719,7 +719,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } _ => { - &*self.terms_cx.arena.alloc(|| TransformTerm(v1, v2)) + &*self.terms_cx.arena.alloc(TransformTerm(v1, v2)) } } } From e250fe388b3455c067ad87dd3e3b5f6585850fcb Mon Sep 17 00:00:00 2001 From: Alexis Date: Wed, 4 Feb 2015 21:17:19 -0500 Subject: [PATCH 22/35] misc collections code cleanup --- src/libcollections/bench.rs | 35 +- src/libcollections/binary_heap.rs | 121 +++--- src/libcollections/bit.rs | 192 ++++----- src/libcollections/btree/map.rs | 110 +++-- src/libcollections/btree/node.rs | 122 +++--- src/libcollections/btree/set.rs | 62 ++- src/libcollections/dlist.rs | 74 ++-- src/libcollections/enum_set.rs | 58 +-- src/libcollections/ring_buf.rs | 214 +++++----- src/libcollections/slice.rs | 598 +++++++++++++-------------- src/libcollections/str.rs | 216 +++++----- src/libcollections/string.rs | 42 +- src/libcollections/vec.rs | 244 +++++------ src/libcollections/vec_map.rs | 156 ++++--- src/librustc/middle/ty.rs | 4 +- src/libserialize/collection_impls.rs | 4 +- src/libstd/collections/hash/bench.rs | 2 +- src/libstd/collections/hash/map.rs | 112 ++--- src/libstd/collections/hash/set.rs | 66 +-- src/libstd/collections/hash/table.rs | 68 +-- 20 files changed, 1233 insertions(+), 1267 deletions(-) diff --git a/src/libcollections/bench.rs b/src/libcollections/bench.rs index c5c19ee56bf0c..b0a5911720a40 100644 --- a/src/libcollections/bench.rs +++ b/src/libcollections/bench.rs @@ -13,40 +13,40 @@ use std::rand; use std::rand::Rng; use test::{Bencher, black_box}; -pub fn insert_rand_n(n: uint, +pub fn insert_rand_n(n: usize, map: &mut M, b: &mut Bencher, mut insert: I, mut remove: R) where - I: FnMut(&mut M, uint), - R: FnMut(&mut M, uint), + I: FnMut(&mut M, usize), + R: FnMut(&mut M, usize), { // setup let mut rng = rand::weak_rng(); for _ in 0..n { - insert(map, rng.gen::() % n); + insert(map, rng.gen::() % n); } // measure b.iter(|| { - let k = rng.gen::() % n; + let k = rng.gen::() % n; insert(map, k); remove(map, k); }); black_box(map); } -pub fn insert_seq_n(n: uint, +pub fn insert_seq_n(n: usize, map: &mut M, b: &mut Bencher, mut insert: I, mut remove: R) where - I: FnMut(&mut M, uint), - R: FnMut(&mut M, uint), + I: FnMut(&mut M, usize), + R: FnMut(&mut M, usize), { // setup - for i in 0u..n { + for i in 0..n { insert(map, i * 2); } @@ -60,18 +60,17 @@ pub fn insert_seq_n(n: uint, black_box(map); } -pub fn find_rand_n(n: uint, +pub fn find_rand_n(n: usize, map: &mut M, b: &mut Bencher, mut insert: I, mut find: F) where - I: FnMut(&mut M, uint), - F: FnMut(&M, uint) -> T, + I: FnMut(&mut M, usize), + F: FnMut(&M, usize) -> T, { // setup let mut rng = rand::weak_rng(); - let mut keys = (0..n).map(|_| rng.gen::() % n) - .collect::>(); + let mut keys: Vec<_> = (0..n).map(|_| rng.gen::() % n).collect(); for k in &keys { insert(map, *k); @@ -88,16 +87,16 @@ pub fn find_rand_n(n: uint, }) } -pub fn find_seq_n(n: uint, +pub fn find_seq_n(n: usize, map: &mut M, b: &mut Bencher, mut insert: I, mut find: F) where - I: FnMut(&mut M, uint), - F: FnMut(&M, uint) -> T, + I: FnMut(&mut M, usize), + F: FnMut(&M, usize) -> T, { // setup - for i in 0u..n { + for i in 0..n { insert(map, i); } diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index b51ec13335e0e..fe477c3495f81 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -28,12 +28,12 @@ //! ``` //! use std::cmp::Ordering; //! use std::collections::BinaryHeap; -//! use std::uint; +//! use std::usize; //! //! #[derive(Copy, Eq, PartialEq)] //! struct State { -//! cost: uint, -//! position: uint, +//! cost: usize, +//! position: usize, //! } //! //! // The priority queue depends on `Ord`. @@ -53,21 +53,21 @@ //! } //! } //! -//! // Each node is represented as an `uint`, for a shorter implementation. +//! // Each node is represented as an `usize`, for a shorter implementation. //! struct Edge { -//! node: uint, -//! cost: uint, +//! node: usize, +//! cost: usize, //! } //! //! // Dijkstra's shortest path algorithm. //! //! // Start at `start` and use `dist` to track the current shortest distance //! // to each node. This implementation isn't memory-efficient as it may leave duplicate -//! // nodes in the queue. It also uses `uint::MAX` as a sentinel value, +//! // nodes in the queue. It also uses `usize::MAX` as a sentinel value, //! // for a simpler implementation. -//! fn shortest_path(adj_list: &Vec>, start: uint, goal: uint) -> uint { +//! fn shortest_path(adj_list: &Vec>, start: usize, goal: usize) -> usize { //! // dist[node] = current shortest distance from `start` to `node` -//! let mut dist: Vec<_> = (0..adj_list.len()).map(|_| uint::MAX).collect(); +//! let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect(); //! //! let mut heap = BinaryHeap::new(); //! @@ -98,7 +98,7 @@ //! } //! //! // Goal not reachable -//! uint::MAX +//! usize::MAX //! } //! //! fn main() { @@ -143,7 +143,7 @@ //! assert_eq!(shortest_path(&graph, 0, 3), 3); //! assert_eq!(shortest_path(&graph, 3, 0), 7); //! assert_eq!(shortest_path(&graph, 0, 4), 5); -//! assert_eq!(shortest_path(&graph, 4, 0), uint::MAX); +//! assert_eq!(shortest_path(&graph, 4, 0), usize::MAX); //! } //! ``` @@ -201,7 +201,7 @@ impl BinaryHeap { /// heap.push(4u); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(capacity: uint) -> BinaryHeap { + pub fn with_capacity(capacity: usize) -> BinaryHeap { BinaryHeap { data: Vec::with_capacity(capacity) } } @@ -295,7 +295,7 @@ impl BinaryHeap { /// heap.push(4u); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> uint { self.data.capacity() } + pub fn capacity(&self) -> usize { self.data.capacity() } /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the /// given `BinaryHeap`. Does nothing if the capacity is already sufficient. @@ -306,7 +306,7 @@ impl BinaryHeap { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -318,7 +318,7 @@ impl BinaryHeap { /// heap.push(4u); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve_exact(&mut self, additional: uint) { + pub fn reserve_exact(&mut self, additional: usize) { self.data.reserve_exact(additional); } @@ -327,7 +327,7 @@ impl BinaryHeap { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -339,7 +339,7 @@ impl BinaryHeap { /// heap.push(4u); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve(&mut self, additional: uint) { + pub fn reserve(&mut self, additional: usize) { self.data.reserve(additional); } @@ -497,7 +497,7 @@ impl BinaryHeap { // zeroed element), shift along the others and move it back into the // vector over the junk element. This reduces the constant factor // compared to using swaps, which involves twice as many moves. - fn sift_up(&mut self, start: uint, mut pos: uint) { + fn sift_up(&mut self, start: usize, mut pos: usize) { unsafe { let new = replace(&mut self.data[pos], zeroed()); @@ -514,7 +514,7 @@ impl BinaryHeap { } } - fn sift_down_range(&mut self, mut pos: uint, end: uint) { + fn sift_down_range(&mut self, mut pos: usize, end: usize) { unsafe { let start = pos; let new = replace(&mut self.data[pos], zeroed()); @@ -536,14 +536,14 @@ impl BinaryHeap { } } - fn sift_down(&mut self, pos: uint) { + fn sift_down(&mut self, pos: usize) { let len = self.len(); self.sift_down_range(pos, len); } /// Returns the length of the binary heap. #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { self.data.len() } + pub fn len(&self) -> usize { self.data.len() } /// Checks if the binary heap is empty. #[stable(feature = "rust1", since = "1.0.0")] @@ -584,7 +584,7 @@ impl<'a, T> Iterator for Iter<'a, T> { fn next(&mut self) -> Option<&'a T> { self.iter.next() } #[inline] - fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] @@ -610,7 +610,7 @@ impl Iterator for IntoIter { fn next(&mut self) -> Option { self.iter.next() } #[inline] - fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] @@ -636,7 +636,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> { fn next(&mut self) -> Option { self.iter.next() } #[inline] - fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] @@ -692,7 +692,7 @@ mod tests { #[test] fn test_iterator() { - let data = vec!(5, 9, 3); + let data = vec![5, 9, 3]; let iterout = [9, 5, 3]; let heap = BinaryHeap::from_vec(data); let mut i = 0; @@ -704,27 +704,27 @@ mod tests { #[test] fn test_iterator_reverse() { - let data = vec!(5, 9, 3); - let iterout = vec!(3, 5, 9); + let data = vec![5, 9, 3]; + let iterout = vec![3, 5, 9]; let pq = BinaryHeap::from_vec(data); - let v: Vec = pq.iter().rev().map(|&x| x).collect(); + let v: Vec<_> = pq.iter().rev().map(|&x| x).collect(); assert_eq!(v, iterout); } #[test] fn test_move_iter() { - let data = vec!(5, 9, 3); - let iterout = vec!(9, 5, 3); + let data = vec![5, 9, 3]; + let iterout = vec![9, 5, 3]; let pq = BinaryHeap::from_vec(data); - let v: Vec = pq.into_iter().collect(); + let v: Vec<_> = pq.into_iter().collect(); assert_eq!(v, iterout); } #[test] fn test_move_iter_size_hint() { - let data = vec!(5, 9); + let data = vec![5, 9]; let pq = BinaryHeap::from_vec(data); let mut it = pq.into_iter(); @@ -741,17 +741,17 @@ mod tests { #[test] fn test_move_iter_reverse() { - let data = vec!(5, 9, 3); - let iterout = vec!(3, 5, 9); + let data = vec![5, 9, 3]; + let iterout = vec![3, 5, 9]; let pq = BinaryHeap::from_vec(data); - let v: Vec = pq.into_iter().rev().collect(); + let v: Vec<_> = pq.into_iter().rev().collect(); assert_eq!(v, iterout); } #[test] fn test_peek_and_pop() { - let data = vec!(2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1); + let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]; let mut sorted = data.clone(); sorted.sort(); let mut heap = BinaryHeap::from_vec(data); @@ -763,7 +763,7 @@ mod tests { #[test] fn test_push() { - let mut heap = BinaryHeap::from_vec(vec!(2, 4, 9)); + let mut heap = BinaryHeap::from_vec(vec![2, 4, 9]); assert_eq!(heap.len(), 3); assert!(*heap.peek().unwrap() == 9); heap.push(11); @@ -785,7 +785,7 @@ mod tests { #[test] fn test_push_unique() { - let mut heap = BinaryHeap::from_vec(vec!(box 2, box 4, box 9)); + let mut heap = BinaryHeap::from_vec(vec![box 2, box 4, box 9]); assert_eq!(heap.len(), 3); assert!(*heap.peek().unwrap() == box 9); heap.push(box 11); @@ -807,7 +807,7 @@ mod tests { #[test] fn test_push_pop() { - let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3)); + let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]); assert_eq!(heap.len(), 5); assert_eq!(heap.push_pop(6), 6); assert_eq!(heap.len(), 5); @@ -821,7 +821,7 @@ mod tests { #[test] fn test_replace() { - let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3)); + let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]); assert_eq!(heap.len(), 5); assert_eq!(heap.replace(6).unwrap(), 5); assert_eq!(heap.len(), 5); @@ -833,7 +833,7 @@ mod tests { assert_eq!(heap.len(), 5); } - fn check_to_vec(mut data: Vec) { + fn check_to_vec(mut data: Vec) { let heap = BinaryHeap::from_vec(data.clone()); let mut v = heap.clone().into_vec(); v.sort(); @@ -845,44 +845,44 @@ mod tests { #[test] fn test_to_vec() { - check_to_vec(vec!()); - check_to_vec(vec!(5)); - check_to_vec(vec!(3, 2)); - check_to_vec(vec!(2, 3)); - check_to_vec(vec!(5, 1, 2)); - check_to_vec(vec!(1, 100, 2, 3)); - check_to_vec(vec!(1, 3, 5, 7, 9, 2, 4, 6, 8, 0)); - check_to_vec(vec!(2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1)); - check_to_vec(vec!(9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0)); - check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); - check_to_vec(vec!(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); - check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2)); - check_to_vec(vec!(5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1)); + check_to_vec(vec![]); + check_to_vec(vec![5]); + check_to_vec(vec![3, 2]); + check_to_vec(vec![2, 3]); + check_to_vec(vec![5, 1, 2]); + check_to_vec(vec![1, 100, 2, 3]); + check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]); + check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]); + check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]); + check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); + check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]); + check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]); + check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]); } #[test] fn test_empty_pop() { - let mut heap = BinaryHeap::::new(); + let mut heap = BinaryHeap::::new(); assert!(heap.pop().is_none()); } #[test] fn test_empty_peek() { - let empty = BinaryHeap::::new(); + let empty = BinaryHeap::::new(); assert!(empty.peek().is_none()); } #[test] fn test_empty_replace() { - let mut heap = BinaryHeap::::new(); + let mut heap = BinaryHeap::new(); assert!(heap.replace(5).is_none()); } #[test] fn test_from_iter() { - let xs = vec!(9u, 8, 7, 6, 5, 4, 3, 2, 1); + let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1]; - let mut q: BinaryHeap = xs.iter().rev().map(|&x| x).collect(); + let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect(); for &x in &xs { assert_eq!(q.pop().unwrap(), x); @@ -891,8 +891,7 @@ mod tests { #[test] fn test_drain() { - let mut q: BinaryHeap<_> = - [9u, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect(); + let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect(); assert_eq!(q.drain().take(5).count(), 5); diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index c9b3f72526f8c..2728e08d6158c 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -18,7 +18,7 @@ // rather `or` and `and`. // (1) Be careful, most things can overflow here because the amount of bits in -// memory can overflow `uint`. +// memory can overflow `usize`. // (2) Make sure that the underlying vector has no excess length: // E. g. `nbits == 16`, `storage.len() == 2` would be excess length, // because the last word isn't used at all. This is important because some @@ -54,7 +54,7 @@ //! bv.set(0, false); //! bv.set(1, false); //! -//! for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as uint) { +//! for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as usize) { //! // if i is a prime //! if bv[i] { //! // Mark all multiples of i as non-prime (any multiples below i * i @@ -66,7 +66,7 @@ //! }; //! //! // Simple primality tests below our max bound -//! let print_primes = 20u; +//! let print_primes = 20; //! print!("The primes below {} are: ", print_primes); //! for x in 0..print_primes { //! if primes.contains(&x) { @@ -93,7 +93,7 @@ use core::iter::{self, FromIterator, IntoIterator}; use core::num::Int; use core::ops::Index; use core::slice; -use core::{u8, u32, uint}; +use core::{u8, u32, usize}; use bitv_set; //so meta use Vec; @@ -162,15 +162,15 @@ pub struct Bitv { /// Internal representation of the bit vector storage: Vec, /// The number of valid bits in the internal representation - nbits: uint + nbits: usize } // FIXME(Gankro): NopeNopeNopeNopeNope (wait for IndexGet to be a thing) -impl Index for Bitv { +impl Index for Bitv { type Output = bool; #[inline] - fn index(&self, i: &uint) -> &bool { + fn index(&self, i: &usize) -> &bool { if self.get(*i).expect("index out of bounds") { &TRUE } else { @@ -180,7 +180,7 @@ impl Index for Bitv { } /// Computes how many blocks are needed to store that many bits -fn blocks_for_bits(bits: uint) -> uint { +fn blocks_for_bits(bits: usize) -> usize { // If we want 17 bits, dividing by 32 will produce 0. So we add 1 to make sure we // reserve enough. But if we want exactly a multiple of 32, this will actually allocate // one too many. So we need to check if that's the case. We can do that by computing if @@ -188,7 +188,7 @@ fn blocks_for_bits(bits: uint) -> uint { // superior modulo operator on a power of two to this. // // Note that we can technically avoid this branch with the expression - // `(nbits + u32::BITS - 1) / 32::BITS`, but if nbits is almost uint::MAX this will overflow. + // `(nbits + u32::BITS - 1) / 32::BITS`, but if nbits is almost usize::MAX this will overflow. if bits % u32::BITS == 0 { bits / u32::BITS } else { @@ -197,7 +197,7 @@ fn blocks_for_bits(bits: uint) -> uint { } /// Computes the bitmask for the final word of the vector -fn mask_for_bits(bits: uint) -> u32 { +fn mask_for_bits(bits: usize) -> u32 { // Note especially that a perfect multiple of u32::BITS should mask all 1s. !0u32 >> (u32::BITS - bits % u32::BITS) % u32::BITS } @@ -272,7 +272,7 @@ impl Bitv { /// assert_eq!(x, false); /// } /// ``` - pub fn from_elem(nbits: uint, bit: bool) -> Bitv { + pub fn from_elem(nbits: usize, bit: bool) -> Bitv { let nblocks = blocks_for_bits(nbits); let mut bitv = Bitv { storage: repeat(if bit { !0u32 } else { 0u32 }).take(nblocks).collect(), @@ -290,7 +290,7 @@ impl Bitv { /// It is important to note that this function does not specify the /// *length* of the returned bitvector, but only the *capacity*. #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(nbits: uint) -> Bitv { + pub fn with_capacity(nbits: usize) -> Bitv { Bitv { storage: Vec::with_capacity(blocks_for_bits(nbits)), nbits: 0, @@ -351,7 +351,7 @@ impl Bitv { /// let bv = Bitv::from_fn(5, |i| { i % 2 == 0 }); /// assert!(bv.eq_vec(&[true, false, true, false, true])); /// ``` - pub fn from_fn(len: uint, mut f: F) -> Bitv where F: FnMut(uint) -> bool { + pub fn from_fn(len: usize, mut f: F) -> Bitv where F: FnMut(usize) -> bool { let mut bitv = Bitv::from_elem(len, false); for i in 0u..len { bitv.set(i, f(i)); @@ -376,7 +376,7 @@ impl Bitv { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn get(&self, i: uint) -> Option { + pub fn get(&self, i: usize) -> Option { if i >= self.nbits { return None; } @@ -405,7 +405,7 @@ impl Bitv { #[inline] #[unstable(feature = "collections", reason = "panic semantics are likely to change in the future")] - pub fn set(&mut self, i: uint, x: bool) { + pub fn set(&mut self, i: usize, x: bool) { assert!(i < self.nbits); let w = i / u32::BITS; let b = i % u32::BITS; @@ -649,7 +649,7 @@ impl Bitv { /// assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000)); /// ``` pub fn to_bytes(&self) -> Vec { - fn bit(bitv: &Bitv, byte: uint, bit: uint) -> u8 { + fn bit(bitv: &Bitv, byte: usize, bit: usize) -> u8 { let offset = byte * 8 + bit; if offset >= bitv.nbits { 0 @@ -709,7 +709,7 @@ impl Bitv { /// assert!(bv.eq_vec(&[false, true])); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn truncate(&mut self, len: uint) { + pub fn truncate(&mut self, len: usize) { if len < self.len() { self.nbits = len; // This fixes (2). @@ -723,7 +723,7 @@ impl Bitv { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -736,7 +736,7 @@ impl Bitv { /// assert!(bv.capacity() >= 13); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve(&mut self, additional: uint) { + pub fn reserve(&mut self, additional: usize) { let desired_cap = self.len().checked_add(additional).expect("capacity overflow"); let storage_len = self.storage.len(); if desired_cap > self.capacity() { @@ -753,7 +753,7 @@ impl Bitv { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -766,7 +766,7 @@ impl Bitv { /// assert!(bv.capacity() >= 13); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve_exact(&mut self, additional: uint) { + pub fn reserve_exact(&mut self, additional: usize) { let desired_cap = self.len().checked_add(additional).expect("capacity overflow"); let storage_len = self.storage.len(); if desired_cap > self.capacity() { @@ -788,15 +788,15 @@ impl Bitv { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> uint { - self.storage.capacity().checked_mul(u32::BITS).unwrap_or(uint::MAX) + pub fn capacity(&self) -> usize { + self.storage.capacity().checked_mul(u32::BITS).unwrap_or(usize::MAX) } /// Grows the `Bitv` in-place, adding `n` copies of `value` to the `Bitv`. /// /// # Panics /// - /// Panics if the new len overflows a `uint`. + /// Panics if the new len overflows a `usize`. /// /// # Examples /// @@ -808,7 +808,7 @@ impl Bitv { /// assert_eq!(bv.len(), 10); /// assert_eq!(bv.to_bytes(), vec!(0b01001011, 0b11000000)); /// ``` - pub fn grow(&mut self, n: uint, value: bool) { + pub fn grow(&mut self, n: usize, value: bool) { // Note: we just bulk set all the bits in the last word in this fn in multiple places // which is technically wrong if not all of these bits are to be used. However, at the end // of this fn we call `fix_last_block` at the end of this fn, which should fix this. @@ -901,7 +901,7 @@ impl Bitv { /// Return the total number of bits in this vector #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { self.nbits } + pub fn len(&self) -> usize { self.nbits } /// Returns true if there are no bits in this vector #[inline] @@ -1012,8 +1012,8 @@ impl cmp::Eq for Bitv {} #[derive(Clone)] pub struct Iter<'a> { bitv: &'a Bitv, - next_idx: uint, - end_idx: uint, + next_idx: usize, + end_idx: usize, } #[stable(feature = "rust1", since = "1.0.0")] @@ -1031,7 +1031,7 @@ impl<'a> Iterator for Iter<'a> { } } - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { let rem = self.end_idx - self.next_idx; (rem, Some(rem)) } @@ -1056,12 +1056,12 @@ impl<'a> ExactSizeIterator for Iter<'a> {} #[stable(feature = "rust1", since = "1.0.0")] impl<'a> RandomAccessIterator for Iter<'a> { #[inline] - fn indexable(&self) -> uint { + fn indexable(&self) -> usize { self.end_idx - self.next_idx } #[inline] - fn idx(&mut self, index: uint) -> Option { + fn idx(&mut self, index: usize) -> Option { if index >= self.indexable() { None } else { @@ -1083,7 +1083,7 @@ impl<'a> IntoIterator for &'a Bitv { /// /// It should also be noted that the amount of storage necessary for holding a /// set of objects is proportional to the maximum of the objects when viewed -/// as a `uint`. +/// as a `usize`. /// /// # Examples /// @@ -1130,8 +1130,8 @@ impl Default for BitvSet { } #[stable(feature = "rust1", since = "1.0.0")] -impl FromIterator for BitvSet { - fn from_iter>(iterator: I) -> BitvSet { +impl FromIterator for BitvSet { + fn from_iter>(iterator: I) -> BitvSet { let mut ret = BitvSet::new(); ret.extend(iterator); ret @@ -1139,9 +1139,9 @@ impl FromIterator for BitvSet { } #[stable(feature = "rust1", since = "1.0.0")] -impl Extend for BitvSet { +impl Extend for BitvSet { #[inline] - fn extend>(&mut self, iterator: I) { + fn extend>(&mut self, iterator: I) { for i in iterator { self.insert(i); } @@ -1207,7 +1207,7 @@ impl BitvSet { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(nbits: uint) -> BitvSet { + pub fn with_capacity(nbits: usize) -> BitvSet { let bitv = Bitv::from_elem(nbits, false); BitvSet::from_bitv(bitv) } @@ -1245,7 +1245,7 @@ impl BitvSet { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> uint { + pub fn capacity(&self) -> usize { self.bitv.capacity() } @@ -1266,7 +1266,7 @@ impl BitvSet { /// assert!(s.capacity() >= 10); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve_len(&mut self, len: uint) { + pub fn reserve_len(&mut self, len: usize) { let cur_len = self.bitv.len(); if len >= cur_len { self.bitv.reserve(len - cur_len); @@ -1292,7 +1292,7 @@ impl BitvSet { /// assert!(s.capacity() >= 10); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve_len_exact(&mut self, len: uint) { + pub fn reserve_len_exact(&mut self, len: usize) { let cur_len = self.bitv.len(); if len >= cur_len { self.bitv.reserve_exact(len - cur_len); @@ -1448,7 +1448,7 @@ impl BitvSet { }) } - /// Iterator over each uint stored in `self` intersect `other`. + /// Iterator over each usize stored in `self` intersect `other`. /// See [intersect_with](#method.intersect_with) for an efficient in-place version. /// /// # Examples @@ -1478,7 +1478,7 @@ impl BitvSet { }.take(min)) } - /// Iterator over each uint stored in the `self` setminus `other`. + /// Iterator over each usize stored in the `self` setminus `other`. /// See [difference_with](#method.difference_with) for an efficient in-place version. /// /// # Examples @@ -1651,7 +1651,7 @@ impl BitvSet { /// Return the number of set bits in this set. #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { + pub fn len(&self) -> usize { self.bitv.blocks().fold(0, |acc, n| acc + n.count_ones()) } @@ -1672,7 +1672,7 @@ impl BitvSet { /// Returns `true` if this set contains the specified integer. #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn contains(&self, value: &uint) -> bool { + pub fn contains(&self, value: &usize) -> bool { let bitv = &self.bitv; *value < bitv.nbits && bitv[*value] } @@ -1709,7 +1709,7 @@ impl BitvSet { /// Adds a value to the set. Returns `true` if the value was not already /// present in the set. #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(&mut self, value: uint) -> bool { + pub fn insert(&mut self, value: usize) -> bool { if self.contains(&value) { return false; } @@ -1727,7 +1727,7 @@ impl BitvSet { /// Removes a value from the set. Returns `true` if the value was /// present in the set. #[stable(feature = "rust1", since = "1.0.0")] - pub fn remove(&mut self, value: &uint) -> bool { + pub fn remove(&mut self, value: &usize) -> bool { if !self.contains(value) { return false; } @@ -1767,7 +1767,7 @@ impl hash::Hash for BitvSet { #[stable(feature = "rust1", since = "1.0.0")] pub struct SetIter<'a> { set: &'a BitvSet, - next_idx: uint + next_idx: usize } /// An iterator combining two `BitvSet` iterators. @@ -1777,7 +1777,7 @@ struct TwoBitPositions<'a> { other: &'a BitvSet, merge: fn(u32, u32) -> u32, current_word: u32, - next_idx: uint + next_idx: usize } #[stable(feature = "rust1", since = "1.0.0")] @@ -1791,9 +1791,9 @@ pub struct SymmetricDifference<'a>(TwoBitPositions<'a>); #[stable(feature = "rust1", since = "1.0.0")] impl<'a> Iterator for SetIter<'a> { - type Item = uint; + type Item = usize; - fn next(&mut self) -> Option { + fn next(&mut self) -> Option { while self.next_idx < self.set.bitv.len() { let idx = self.next_idx; self.next_idx += 1; @@ -1807,16 +1807,16 @@ impl<'a> Iterator for SetIter<'a> { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { (0, Some(self.set.bitv.len() - self.next_idx)) } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a> Iterator for TwoBitPositions<'a> { - type Item = uint; + type Item = usize; - fn next(&mut self) -> Option { + fn next(&mut self) -> Option { while self.next_idx < self.set.bitv.len() || self.next_idx < self.other.bitv.len() { let bit_idx = self.next_idx % u32::BITS; @@ -1844,7 +1844,7 @@ impl<'a> Iterator for TwoBitPositions<'a> { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { let cap = cmp::max(self.set.bitv.len(), self.other.bitv.len()); (0, Some(cap - self.next_idx)) } @@ -1852,34 +1852,34 @@ impl<'a> Iterator for TwoBitPositions<'a> { #[stable(feature = "rust1", since = "1.0.0")] impl<'a> Iterator for Union<'a> { - type Item = uint; + type Item = usize; - #[inline] fn next(&mut self) -> Option { self.0.next() } - #[inline] fn size_hint(&self) -> (uint, Option) { self.0.size_hint() } + #[inline] fn next(&mut self) -> Option { self.0.next() } + #[inline] fn size_hint(&self) -> (usize, Option) { self.0.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a> Iterator for Intersection<'a> { - type Item = uint; + type Item = usize; - #[inline] fn next(&mut self) -> Option { self.0.next() } - #[inline] fn size_hint(&self) -> (uint, Option) { self.0.size_hint() } + #[inline] fn next(&mut self) -> Option { self.0.next() } + #[inline] fn size_hint(&self) -> (usize, Option) { self.0.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a> Iterator for Difference<'a> { - type Item = uint; + type Item = usize; - #[inline] fn next(&mut self) -> Option { self.0.next() } - #[inline] fn size_hint(&self) -> (uint, Option) { self.0.size_hint() } + #[inline] fn next(&mut self) -> Option { self.0.next() } + #[inline] fn size_hint(&self) -> (usize, Option) { self.0.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a> Iterator for SymmetricDifference<'a> { - type Item = uint; + type Item = usize; - #[inline] fn next(&mut self) -> Option { self.0.next() } - #[inline] fn size_hint(&self) -> (uint, Option) { self.0.size_hint() } + #[inline] fn next(&mut self) -> Option { self.0.next() } + #[inline] fn size_hint(&self) -> (usize, Option) { self.0.size_hint() } } impl<'a> IntoIterator for &'a BitvSet { @@ -2288,7 +2288,7 @@ mod tests { #[test] fn test_to_bools() { - let bools = vec!(false, false, true, false, false, true, true, false); + let bools = vec![false, false, true, false, false, true, true, false]; assert_eq!(Bitv::from_bytes(&[0b00100110]).iter().collect::>(), bools); } @@ -2299,7 +2299,7 @@ mod tests { assert_eq!(bitv.iter().collect::>(), bools); - let long = (0i32..10000).map(|i| i % 2 == 0).collect::>(); + let long: Vec<_> = (0i32..10000).map(|i| i % 2 == 0).collect(); let bitv: Bitv = long.iter().map(|n| *n).collect(); assert_eq!(bitv.iter().collect::>(), long) } @@ -2530,7 +2530,7 @@ mod bitv_bench { use super::Bitv; - static BENCH_BITS : uint = 1 << 14; + static BENCH_BITS : usize = 1 << 14; fn rng() -> rand::IsaacRng { let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]; @@ -2538,12 +2538,12 @@ mod bitv_bench { } #[bench] - fn bench_uint_small(b: &mut Bencher) { + fn bench_usize_small(b: &mut Bencher) { let mut r = rng(); - let mut bitv = 0 as uint; + let mut bitv = 0 as usize; b.iter(|| { for _ in 0u..100 { - bitv |= 1 << ((r.next_u32() as uint) % u32::BITS); + bitv |= 1 << ((r.next_u32() as usize) % u32::BITS); } black_box(&bitv); }); @@ -2555,7 +2555,7 @@ mod bitv_bench { let mut bitv = Bitv::from_elem(BENCH_BITS, false); b.iter(|| { for _ in 0u..100 { - bitv.set((r.next_u32() as uint) % BENCH_BITS, true); + bitv.set((r.next_u32() as usize) % BENCH_BITS, true); } black_box(&bitv); }); @@ -2567,7 +2567,7 @@ mod bitv_bench { let mut bitv = Bitv::from_elem(BENCH_BITS, false); b.iter(|| { for _ in 0u..100 { - bitv.set((r.next_u32() as uint) % BENCH_BITS, r.gen()); + bitv.set((r.next_u32() as usize) % BENCH_BITS, r.gen()); } black_box(&bitv); }); @@ -2579,7 +2579,7 @@ mod bitv_bench { let mut bitv = Bitv::from_elem(u32::BITS, false); b.iter(|| { for _ in 0u..100 { - bitv.set((r.next_u32() as uint) % u32::BITS, true); + bitv.set((r.next_u32() as usize) % u32::BITS, true); } black_box(&bitv); }); @@ -2601,7 +2601,7 @@ mod bitv_bench { let mut sum = 0u; for _ in 0u..10 { for pres in &bitv { - sum += pres as uint; + sum += pres as usize; } } sum @@ -2614,7 +2614,7 @@ mod bitv_bench { b.iter(|| { let mut sum = 0u; for pres in &bitv { - sum += pres as uint; + sum += pres as usize; } sum }) @@ -2645,9 +2645,9 @@ mod bitv_set_test { } #[test] - fn test_bitv_set_from_uints() { - let uints = vec![0, 2, 2, 3]; - let a: BitvSet = uints.into_iter().collect(); + fn test_bitv_set_from_usizes() { + let usizes = vec![0, 2, 2, 3]; + let a: BitvSet = usizes.into_iter().collect(); let mut b = BitvSet::new(); b.insert(0); b.insert(2); @@ -2657,16 +2657,16 @@ mod bitv_set_test { #[test] fn test_bitv_set_iterator() { - let uints = vec![0, 2, 2, 3]; - let bitv: BitvSet = uints.into_iter().collect(); + let usizes = vec![0, 2, 2, 3]; + let bitv: BitvSet = usizes.into_iter().collect(); - let idxs: Vec = bitv.iter().collect(); + let idxs: Vec<_> = bitv.iter().collect(); assert_eq!(idxs, vec![0, 2, 3]); let long: BitvSet = (0u..10000).filter(|&n| n % 2 == 0).collect(); - let real = range_step(0, 10000, 2).collect::>(); + let real: Vec<_> = range_step(0, 10000, 2).collect(); - let idxs: Vec = long.iter().collect(); + let idxs: Vec<_> = long.iter().collect(); assert_eq!(idxs, real); } @@ -2731,7 +2731,7 @@ mod bitv_set_test { assert!(b.insert(3)); let expected = [3, 5, 11, 77]; - let actual = a.intersection(&b).collect::>(); + let actual: Vec<_> = a.intersection(&b).collect(); assert_eq!(actual, expected); } @@ -2750,7 +2750,7 @@ mod bitv_set_test { assert!(b.insert(200)); let expected = [1, 5, 500]; - let actual = a.difference(&b).collect::>(); + let actual: Vec<_> = a.difference(&b).collect(); assert_eq!(actual, expected); } @@ -2771,7 +2771,7 @@ mod bitv_set_test { assert!(b.insert(220)); let expected = [1, 5, 11, 14, 220]; - let actual = a.symmetric_difference(&b).collect::>(); + let actual: Vec<_> = a.symmetric_difference(&b).collect(); assert_eq!(actual, expected); } @@ -2796,7 +2796,7 @@ mod bitv_set_test { assert!(b.insert(19)); let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160, 200]; - let actual = a.union(&b).collect::>(); + let actual: Vec<_> = a.union(&b).collect(); assert_eq!(actual, expected); } @@ -3025,7 +3025,7 @@ mod bitv_set_bench { use super::{Bitv, BitvSet}; - static BENCH_BITS : uint = 1 << 14; + static BENCH_BITS : usize = 1 << 14; fn rng() -> rand::IsaacRng { let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]; @@ -3037,8 +3037,8 @@ mod bitv_set_bench { let mut r = rng(); let mut bitv = BitvSet::new(); b.iter(|| { - for _ in 0u..100 { - bitv.insert((r.next_u32() as uint) % u32::BITS); + for _ in 0..100 { + bitv.insert((r.next_u32() as usize) % u32::BITS); } black_box(&bitv); }); @@ -3049,8 +3049,8 @@ mod bitv_set_bench { let mut r = rng(); let mut bitv = BitvSet::new(); b.iter(|| { - for _ in 0u..100 { - bitv.insert((r.next_u32() as uint) % BENCH_BITS); + for _ in 0..100 { + bitv.insert((r.next_u32() as usize) % BENCH_BITS); } black_box(&bitv); }); @@ -3061,9 +3061,9 @@ mod bitv_set_bench { let bitv = BitvSet::from_bitv(Bitv::from_fn(BENCH_BITS, |idx| {idx % 3 == 0})); b.iter(|| { - let mut sum = 0u; + let mut sum = 0; for idx in &bitv { - sum += idx as uint; + sum += idx as usize; } sum }) diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 99ee5957913dc..d792bd8d1522d 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -63,36 +63,20 @@ use super::node::{self, Node, Found, GoDown}; /// would like to further explore choosing the optimal search strategy based on the choice of B, /// and possibly other factors. Using linear search, searching for a random element is expected /// to take O(B logBn) comparisons, which is generally worse than a BST. In practice, -/// however, performance is excellent. `BTreeMap` is able to readily outperform `TreeMap` under -/// many workloads, and is competitive where it doesn't. BTreeMap also generally *scales* better -/// than TreeMap, making it more appropriate for large datasets. -/// -/// However, `TreeMap` may still be more appropriate to use in many contexts. If elements are very -/// large or expensive to compare, `TreeMap` may be more appropriate. It won't allocate any -/// more space than is needed, and will perform the minimal number of comparisons necessary. -/// `TreeMap` also provides much better performance stability guarantees. Generally, very few -/// changes need to be made to update a BST, and two updates are expected to take about the same -/// amount of time on roughly equal sized BSTs. However a B-Tree's performance is much more -/// amortized. If a node is overfull, it must be split into two nodes. If a node is underfull, it -/// may be merged with another. Both of these operations are relatively expensive to perform, and -/// it's possible to force one to occur at every single level of the tree in a single insertion or -/// deletion. In fact, a malicious or otherwise unlucky sequence of insertions and deletions can -/// force this degenerate behaviour to occur on every operation. While the total amount of work -/// done on each operation isn't *catastrophic*, and *is* still bounded by O(B logBn), -/// it is certainly much slower when it does. +/// however, performance is excellent. #[derive(Clone)] #[stable(feature = "rust1", since = "1.0.0")] pub struct BTreeMap { root: Node, - length: uint, - depth: uint, - b: uint, + length: usize, + depth: usize, + b: usize, } /// An abstract base over-which all other BTree iterators are built. struct AbsIter { traversals: RingBuf, - size: uint, + size: usize, } /// An iterator over a BTreeMap's entries. @@ -171,7 +155,7 @@ impl BTreeMap { /// Makes a new empty BTreeMap with the given B. /// /// B cannot be less than 2. - pub fn with_b(b: uint) -> BTreeMap { + pub fn with_b(b: usize) -> BTreeMap { assert!(b > 1, "B must be greater than 1"); BTreeMap { length: 0, @@ -1001,7 +985,7 @@ impl Iterator for AbsIter where } } - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { (self.size, Some(self.size)) } } @@ -1038,7 +1022,7 @@ impl<'a, K, V> Iterator for Iter<'a, K, V> { type Item = (&'a K, &'a V); fn next(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next() } - fn size_hint(&self) -> (uint, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> { @@ -1052,7 +1036,7 @@ impl<'a, K, V> Iterator for IterMut<'a, K, V> { type Item = (&'a K, &'a mut V); fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next() } - fn size_hint(&self) -> (uint, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> { @@ -1066,7 +1050,7 @@ impl Iterator for IntoIter { type Item = (K, V); fn next(&mut self) -> Option<(K, V)> { self.inner.next() } - fn size_hint(&self) -> (uint, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl DoubleEndedIterator for IntoIter { @@ -1080,7 +1064,7 @@ impl<'a, K, V> Iterator for Keys<'a, K, V> { type Item = &'a K; fn next(&mut self) -> Option<(&'a K)> { self.inner.next() } - fn size_hint(&self) -> (uint, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> { @@ -1095,7 +1079,7 @@ impl<'a, K, V> Iterator for Values<'a, K, V> { type Item = &'a V; fn next(&mut self) -> Option<(&'a V)> { self.inner.next() } - fn size_hint(&self) -> (uint, Option) { self.inner.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.inner.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> { @@ -1289,7 +1273,7 @@ impl BTreeMap { /// a.insert(1u, "a"); /// a.insert(2u, "b"); /// - /// let keys: Vec = a.keys().cloned().collect(); + /// let keys: Vec = a.keys().cloned().collect(); /// assert_eq!(keys, vec![1u,2,]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -1335,7 +1319,7 @@ impl BTreeMap { /// assert_eq!(a.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { self.length } + pub fn len(&self) -> usize { self.length } /// Return true if the map contains no elements. /// @@ -1546,7 +1530,7 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// use std::collections::btree_map::Entry; /// - /// let mut count: BTreeMap<&str, uint> = BTreeMap::new(); + /// let mut count: BTreeMap<&str, usize> = BTreeMap::new(); /// /// // count the number of occurrences of letters in the vec /// for x in vec!["a","b","a","c","a","b"].iter() { @@ -1622,7 +1606,7 @@ mod test { #[test] fn test_basic_large() { let mut map = BTreeMap::new(); - let size = 10000u; + let size = 10000; assert_eq!(map.len(), 0); for i in 0..size { @@ -1669,7 +1653,7 @@ mod test { let mut map = BTreeMap::new(); assert_eq!(map.remove(&1), None); assert_eq!(map.get(&1), None); - assert_eq!(map.insert(1u, 1u), None); + assert_eq!(map.insert(1, 1), None); assert_eq!(map.get(&1), Some(&1)); assert_eq!(map.insert(1, 2), Some(1)); assert_eq!(map.get(&1), Some(&2)); @@ -1682,12 +1666,12 @@ mod test { #[test] fn test_iter() { - let size = 10000u; + let size = 10000; // Forwards - let mut map: BTreeMap = (0..size).map(|i| (i, i)).collect(); + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); - fn test(size: uint, mut iter: T) where T: Iterator { + fn test(size: usize, mut iter: T) where T: Iterator { for i in 0..size { assert_eq!(iter.size_hint(), (size - i, Some(size - i))); assert_eq!(iter.next().unwrap(), (i, i)); @@ -1702,12 +1686,12 @@ mod test { #[test] fn test_iter_rev() { - let size = 10000u; + let size = 10000; // Forwards - let mut map: BTreeMap = (0..size).map(|i| (i, i)).collect(); + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); - fn test(size: uint, mut iter: T) where T: Iterator { + fn test(size: usize, mut iter: T) where T: Iterator { for i in 0..size { assert_eq!(iter.size_hint(), (size - i, Some(size - i))); assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1)); @@ -1722,13 +1706,13 @@ mod test { #[test] fn test_iter_mixed() { - let size = 10000u; + let size = 10000; // Forwards - let mut map: BTreeMap = (0..size).map(|i| (i, i)).collect(); + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); - fn test(size: uint, mut iter: T) - where T: Iterator + DoubleEndedIterator { + fn test(size: usize, mut iter: T) + where T: Iterator + DoubleEndedIterator { for i in 0..size / 4 { assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2))); assert_eq!(iter.next().unwrap(), (i, i)); @@ -1748,13 +1732,13 @@ mod test { #[test] fn test_range_small() { - let size = 5u; + let size = 5; // Forwards - let map: BTreeMap = (0..size).map(|i| (i, i)).collect(); + let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); - let mut j = 0u; - for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2u..size) { + let mut j = 0; + for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2..size) { assert_eq!(k, i); assert_eq!(v, i); j += 1; @@ -1764,10 +1748,10 @@ mod test { #[test] fn test_range_1000() { - let size = 1000u; - let map: BTreeMap = (0..size).map(|i| (i, i)).collect(); + let size = 1000; + let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); - fn test(map: &BTreeMap, size: uint, min: Bound<&uint>, max: Bound<&uint>) { + fn test(map: &BTreeMap, size: u32, min: Bound<&u32>, max: Bound<&u32>) { let mut kvs = map.range(min, max).map(|(&k, &v)| (k, v)); let mut pairs = (0..size).map(|i| (i, i)); @@ -1787,8 +1771,8 @@ mod test { #[test] fn test_range() { - let size = 200u; - let map: BTreeMap = (0..size).map(|i| (i, i)).collect(); + let size = 200; + let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); for i in 0..size { for j in i..size { @@ -1808,7 +1792,7 @@ mod test { fn test_entry(){ let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; - let mut map: BTreeMap = xs.iter().map(|&x| x).collect(); + let mut map: BTreeMap<_, _> = xs.iter().map(|&x| x).collect(); // Existing key (insert) match map.entry(1) { @@ -1872,7 +1856,7 @@ mod bench { #[bench] pub fn insert_rand_100(b: &mut Bencher) { - let mut m : BTreeMap = BTreeMap::new(); + let mut m = BTreeMap::new(); insert_rand_n(100, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.remove(&i); }); @@ -1880,7 +1864,7 @@ mod bench { #[bench] pub fn insert_rand_10_000(b: &mut Bencher) { - let mut m : BTreeMap = BTreeMap::new(); + let mut m = BTreeMap::new(); insert_rand_n(10_000, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.remove(&i); }); @@ -1889,7 +1873,7 @@ mod bench { // Insert seq #[bench] pub fn insert_seq_100(b: &mut Bencher) { - let mut m : BTreeMap = BTreeMap::new(); + let mut m = BTreeMap::new(); insert_seq_n(100, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.remove(&i); }); @@ -1897,7 +1881,7 @@ mod bench { #[bench] pub fn insert_seq_10_000(b: &mut Bencher) { - let mut m : BTreeMap = BTreeMap::new(); + let mut m = BTreeMap::new(); insert_seq_n(10_000, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.remove(&i); }); @@ -1906,7 +1890,7 @@ mod bench { // Find rand #[bench] pub fn find_rand_100(b: &mut Bencher) { - let mut m : BTreeMap = BTreeMap::new(); + let mut m = BTreeMap::new(); find_rand_n(100, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.get(&i); }); @@ -1914,7 +1898,7 @@ mod bench { #[bench] pub fn find_rand_10_000(b: &mut Bencher) { - let mut m : BTreeMap = BTreeMap::new(); + let mut m = BTreeMap::new(); find_rand_n(10_000, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.get(&i); }); @@ -1923,7 +1907,7 @@ mod bench { // Find seq #[bench] pub fn find_seq_100(b: &mut Bencher) { - let mut m : BTreeMap = BTreeMap::new(); + let mut m = BTreeMap::new(); find_seq_n(100, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.get(&i); }); @@ -1931,14 +1915,14 @@ mod bench { #[bench] pub fn find_seq_10_000(b: &mut Bencher) { - let mut m : BTreeMap = BTreeMap::new(); + let mut m = BTreeMap::new(); find_seq_n(10_000, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.get(&i); }); } - fn bench_iter(b: &mut Bencher, size: uint) { - let mut map = BTreeMap::::new(); + fn bench_iter(b: &mut Bencher, size: i32) { + let mut map = BTreeMap::::new(); let mut rng = weak_rng(); for _ in 0..size { diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 8fdfe9ed56a48..429c62c857116 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -65,7 +65,7 @@ pub struct Node { // // Note: instead of accessing this field directly, please call the `len()` method, which should // be more stable in the face of representation changes. - _len: uint, + _len: usize, // FIXME(gereeter) It shouldn't be necessary to store the capacity in every node, as it should // be constant throughout the tree. Once a solution to this is found, it might be possible to @@ -74,7 +74,7 @@ pub struct Node { // // Note: instead of accessing this field directly, please call the `capacity()` method, which // should be more stable in the face of representation changes. - _capacity: uint, + _capacity: usize, } struct NodeSlice<'a, K: 'a, V: 'a> { @@ -102,7 +102,7 @@ struct MutNodeSlice<'a, K: 'a, V: 'a> { /// /// Fails if `target_alignment` is not a power of two. #[inline] -fn round_up_to_next(unrounded: uint, target_alignment: uint) -> uint { +fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize { assert!(num::UnsignedInt::is_power_of_two(target_alignment)); (unrounded + target_alignment - 1) & !(target_alignment - 1) } @@ -120,10 +120,10 @@ fn test_rounding() { // Returns a tuple of (val_offset, edge_offset), // from the start of a mallocated array. #[inline] -fn calculate_offsets(keys_size: uint, - vals_size: uint, vals_align: uint, - edges_align: uint) - -> (uint, uint) { +fn calculate_offsets(keys_size: usize, + vals_size: usize, vals_align: usize, + edges_align: usize) + -> (usize, usize) { let vals_offset = round_up_to_next(keys_size, vals_align); let end_of_vals = vals_offset + vals_size; @@ -135,10 +135,10 @@ fn calculate_offsets(keys_size: uint, // Returns a tuple of (minimum required alignment, array_size), // from the start of a mallocated array. #[inline] -fn calculate_allocation(keys_size: uint, keys_align: uint, - vals_size: uint, vals_align: uint, - edges_size: uint, edges_align: uint) - -> (uint, uint) { +fn calculate_allocation(keys_size: usize, keys_align: usize, + vals_size: usize, vals_align: usize, + edges_size: usize, edges_align: usize) + -> (usize, usize) { let (_, edges_offset) = calculate_offsets(keys_size, vals_size, vals_align, edges_align); @@ -159,7 +159,7 @@ fn test_offset_calculation() { assert_eq!(calculate_offsets(6, 12, 4, 8), (8, 24)); } -fn calculate_allocation_generic(capacity: uint, is_leaf: bool) -> (uint, uint) { +fn calculate_allocation_generic(capacity: usize, is_leaf: bool) -> (usize, usize) { let (keys_size, keys_align) = (capacity * mem::size_of::(), mem::min_align_of::()); let (vals_size, vals_align) = (capacity * mem::size_of::(), mem::min_align_of::()); let (edges_size, edges_align) = if is_leaf { @@ -175,7 +175,7 @@ fn calculate_allocation_generic(capacity: uint, is_leaf: bool) -> (uint, u ) } -fn calculate_offsets_generic(capacity: uint, is_leaf: bool) -> (uint, uint) { +fn calculate_offsets_generic(capacity: usize, is_leaf: bool) -> (usize, usize) { let keys_size = capacity * mem::size_of::(); let vals_size = capacity * mem::size_of::(); let vals_align = mem::min_align_of::(); @@ -203,16 +203,16 @@ impl RawItems { RawItems::from_parts(slice.as_ptr(), slice.len()) } - unsafe fn from_parts(ptr: *const T, len: uint) -> RawItems { + unsafe fn from_parts(ptr: *const T, len: usize) -> RawItems { if mem::size_of::() == 0 { RawItems { head: ptr, - tail: (ptr as uint + len) as *const T, + tail: (ptr as usize + len) as *const T, } } else { RawItems { head: ptr, - tail: ptr.offset(len as int), + tail: ptr.offset(len as isize), } } } @@ -221,7 +221,7 @@ impl RawItems { ptr::write(self.tail as *mut T, val); if mem::size_of::() == 0 { - self.tail = (self.tail as uint + 1) as *const T; + self.tail = (self.tail as usize + 1) as *const T; } else { self.tail = self.tail.offset(1); } @@ -239,7 +239,7 @@ impl Iterator for RawItems { let ret = Some(ptr::read(self.head)); if mem::size_of::() == 0 { - self.head = (self.head as uint + 1) as *const T; + self.head = (self.head as usize + 1) as *const T; } else { self.head = self.head.offset(1); } @@ -257,7 +257,7 @@ impl DoubleEndedIterator for RawItems { } else { unsafe { if mem::size_of::() == 0 { - self.tail = (self.tail as uint - 1) as *const T; + self.tail = (self.tail as usize - 1) as *const T; } else { self.tail = self.tail.offset(-1); } @@ -299,7 +299,7 @@ impl Drop for Node { impl Node { /// Make a new internal node. The caller must initialize the result to fix the invariant that /// there are `len() + 1` edges. - unsafe fn new_internal(capacity: uint) -> Node { + unsafe fn new_internal(capacity: usize) -> Node { let (alignment, size) = calculate_allocation_generic::(capacity, false); let buffer = heap::allocate(size, alignment); @@ -309,15 +309,15 @@ impl Node { Node { keys: Unique(buffer as *mut K), - vals: Unique(buffer.offset(vals_offset as int) as *mut V), - edges: Unique(buffer.offset(edges_offset as int) as *mut Node), + vals: Unique(buffer.offset(vals_offset as isize) as *mut V), + edges: Unique(buffer.offset(edges_offset as isize) as *mut Node), _len: 0, _capacity: capacity, } } /// Make a new leaf node - fn new_leaf(capacity: uint) -> Node { + fn new_leaf(capacity: usize) -> Node { let (alignment, size) = calculate_allocation_generic::(capacity, true); let buffer = unsafe { heap::allocate(size, alignment) }; @@ -327,7 +327,7 @@ impl Node { Node { keys: Unique(buffer as *mut K), - vals: Unique(unsafe { buffer.offset(vals_offset as int) as *mut V }), + vals: Unique(unsafe { buffer.offset(vals_offset as isize) as *mut V }), edges: Unique(ptr::null_mut()), _len: 0, _capacity: capacity, @@ -479,15 +479,15 @@ impl Clone for Node { /// /// ```rust,ignore /// struct Nasty<'a> { -/// first: &'a Node, -/// second: &'a Node, +/// first: &'a Node, +/// second: &'a Node, /// flag: &'a Cell, /// } /// /// impl<'a> Deref for Nasty<'a> { -/// type Target = Node; +/// type Target = Node; /// -/// fn deref(&self) -> &Node { +/// fn deref(&self) -> &Node { /// if self.flag.get() { /// &*self.second /// } else { @@ -524,7 +524,7 @@ impl Clone for Node { #[derive(Copy)] pub struct Handle { node: NodeRef, - index: uint + index: usize } pub mod handle { @@ -546,7 +546,7 @@ impl Node { -> SearchResult where Q: BorrowFrom + Ord { // FIXME(Gankro): Tune when to search linear or binary based on B (and maybe K/V). // For the B configured as of this writing (B = 6), binary search was *significantly* - // worse for uints. + // worse for usizes. match node.as_slices_internal().search_linear(key) { (index, true) => Found(Handle { node: node, index: index }), (index, false) => GoDown(Handle { node: node, index: index }), @@ -557,12 +557,12 @@ impl Node { // Public interface impl Node { /// Make a leaf root from scratch - pub fn make_leaf_root(b: uint) -> Node { + pub fn make_leaf_root(b: usize) -> Node { Node::new_leaf(capacity_from_b(b)) } /// Make an internal root and swap it with an old root - pub fn make_internal_root(left_and_out: &mut Node, b: uint, key: K, value: V, + pub fn make_internal_root(left_and_out: &mut Node, b: usize, key: K, value: V, right: Node) { let node = mem::replace(left_and_out, unsafe { Node::new_internal(capacity_from_b(b)) }); left_and_out._len = 1; @@ -575,12 +575,12 @@ impl Node { } /// How many key-value pairs the node contains - pub fn len(&self) -> uint { + pub fn len(&self) -> usize { self._len } /// How many key-value pairs the node can fit - pub fn capacity(&self) -> uint { + pub fn capacity(&self) -> usize { self._capacity } @@ -1038,7 +1038,7 @@ impl Node { /// # Panics (in debug build) /// /// Panics if the given index is out of bounds. - pub fn kv_handle(&mut self, index: uint) -> Handle<&mut Node, handle::KV, + pub fn kv_handle(&mut self, index: usize) -> Handle<&mut Node, handle::KV, handle::LeafOrInternal> { // Necessary for correctness, but in a private module debug_assert!(index < self.len(), "kv_handle index out of bounds"); @@ -1114,15 +1114,15 @@ impl Node { // This must be followed by insert_edge on an internal node. #[inline] - unsafe fn insert_kv(&mut self, index: uint, key: K, val: V) -> &mut V { + unsafe fn insert_kv(&mut self, index: usize, key: K, val: V) -> &mut V { ptr::copy_memory( - self.keys_mut().as_mut_ptr().offset(index as int + 1), - self.keys().as_ptr().offset(index as int), + self.keys_mut().as_mut_ptr().offset(index as isize + 1), + self.keys().as_ptr().offset(index as isize), self.len() - index ); ptr::copy_memory( - self.vals_mut().as_mut_ptr().offset(index as int + 1), - self.vals().as_ptr().offset(index as int), + self.vals_mut().as_mut_ptr().offset(index as isize + 1), + self.vals().as_ptr().offset(index as isize), self.len() - index ); @@ -1136,10 +1136,10 @@ impl Node { // This can only be called immediately after a call to insert_kv. #[inline] - unsafe fn insert_edge(&mut self, index: uint, edge: Node) { + unsafe fn insert_edge(&mut self, index: usize, edge: Node) { ptr::copy_memory( - self.edges_mut().as_mut_ptr().offset(index as int + 1), - self.edges().as_ptr().offset(index as int), + self.edges_mut().as_mut_ptr().offset(index as isize + 1), + self.edges().as_ptr().offset(index as isize), self.len() - index ); ptr::write(self.edges_mut().get_unchecked_mut(index), edge); @@ -1166,18 +1166,18 @@ impl Node { // This must be followed by remove_edge on an internal node. #[inline] - unsafe fn remove_kv(&mut self, index: uint) -> (K, V) { + unsafe fn remove_kv(&mut self, index: usize) -> (K, V) { let key = ptr::read(self.keys().get_unchecked(index)); let val = ptr::read(self.vals().get_unchecked(index)); ptr::copy_memory( - self.keys_mut().as_mut_ptr().offset(index as int), - self.keys().as_ptr().offset(index as int + 1), + self.keys_mut().as_mut_ptr().offset(index as isize), + self.keys().as_ptr().offset(index as isize + 1), self.len() - index - 1 ); ptr::copy_memory( - self.vals_mut().as_mut_ptr().offset(index as int), - self.vals().as_ptr().offset(index as int + 1), + self.vals_mut().as_mut_ptr().offset(index as isize), + self.vals().as_ptr().offset(index as isize + 1), self.len() - index - 1 ); @@ -1188,12 +1188,12 @@ impl Node { // This can only be called immediately after a call to remove_kv. #[inline] - unsafe fn remove_edge(&mut self, index: uint) -> Node { + unsafe fn remove_edge(&mut self, index: usize) -> Node { let edge = ptr::read(self.edges().get_unchecked(index)); ptr::copy_memory( - self.edges_mut().as_mut_ptr().offset(index as int), - self.edges().as_ptr().offset(index as int + 1), + self.edges_mut().as_mut_ptr().offset(index as isize), + self.edges().as_ptr().offset(index as isize + 1), self.len() - index + 1 ); @@ -1220,18 +1220,18 @@ impl Node { let right_offset = self.len() - right.len(); ptr::copy_nonoverlapping_memory( right.keys_mut().as_mut_ptr(), - self.keys().as_ptr().offset(right_offset as int), + self.keys().as_ptr().offset(right_offset as isize), right.len() ); ptr::copy_nonoverlapping_memory( right.vals_mut().as_mut_ptr(), - self.vals().as_ptr().offset(right_offset as int), + self.vals().as_ptr().offset(right_offset as isize), right.len() ); if !self.is_leaf() { ptr::copy_nonoverlapping_memory( right.edges_mut().as_mut_ptr(), - self.edges().as_ptr().offset(right_offset as int), + self.edges().as_ptr().offset(right_offset as isize), right.len() + 1 ); } @@ -1260,18 +1260,18 @@ impl Node { ptr::write(self.vals_mut().get_unchecked_mut(old_len), val); ptr::copy_nonoverlapping_memory( - self.keys_mut().as_mut_ptr().offset(old_len as int + 1), + self.keys_mut().as_mut_ptr().offset(old_len as isize + 1), right.keys().as_ptr(), right.len() ); ptr::copy_nonoverlapping_memory( - self.vals_mut().as_mut_ptr().offset(old_len as int + 1), + self.vals_mut().as_mut_ptr().offset(old_len as isize + 1), right.vals().as_ptr(), right.len() ); if !self.is_leaf() { ptr::copy_nonoverlapping_memory( - self.edges_mut().as_mut_ptr().offset(old_len as int + 1), + self.edges_mut().as_mut_ptr().offset(old_len as isize + 1), right.edges().as_ptr(), right.len() + 1 ); @@ -1284,12 +1284,12 @@ impl Node { } /// Get the capacity of a node from the order of the parent B-Tree -fn capacity_from_b(b: uint) -> uint { +fn capacity_from_b(b: usize) -> usize { 2 * b - 1 } /// Get the minimum load of a node from its capacity -fn min_load_from_capacity(cap: uint) -> uint { +fn min_load_from_capacity(cap: usize) -> usize { // B - 1 cap / 2 } @@ -1334,7 +1334,7 @@ struct MoveTraversalImpl { // For deallocation when we are done iterating. ptr: *mut u8, - capacity: uint, + capacity: usize, is_leaf: bool } @@ -1490,7 +1490,7 @@ macro_rules! node_slice_impl { $as_slices_internal:ident, $index:ident, $iter:ident) => { impl<'a, K: Ord + 'a, V: 'a> $NodeSlice<'a, K, V> { /// Performs linear search in a slice. Returns a tuple of (index, is_exact_match). - fn search_linear(&self, key: &Q) -> (uint, bool) + fn search_linear(&self, key: &Q) -> (usize, bool) where Q: BorrowFrom + Ord { for (i, k) in self.keys.iter().enumerate() { match key.cmp(BorrowFrom::borrow_from(k)) { diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 1997fe189be44..b02c522f86da9 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -101,7 +101,7 @@ impl BTreeSet { /// B cannot be less than 2. #[unstable(feature = "collections", reason = "probably want this to be on the type, eventually")] - pub fn with_b(b: uint) -> BTreeSet { + pub fn with_b(b: usize) -> BTreeSet { BTreeSet { map: BTreeMap::with_b(b) } } } @@ -114,13 +114,13 @@ impl BTreeSet { /// ``` /// use std::collections::BTreeSet; /// - /// let set: BTreeSet = [1u, 2, 3, 4].iter().map(|&x| x).collect(); + /// let set: BTreeSet = [1u, 2, 3, 4].iter().map(|&x| x).collect(); /// /// for x in set.iter() { /// println!("{}", x); /// } /// - /// let v: Vec = set.iter().map(|&x| x).collect(); + /// let v: Vec = set.iter().map(|&x| x).collect(); /// assert_eq!(v, vec![1u,2,3,4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -135,9 +135,9 @@ impl BTreeSet { /// ``` /// use std::collections::BTreeSet; /// - /// let set: BTreeSet = [1u, 2, 3, 4].iter().map(|&x| x).collect(); + /// let set: BTreeSet = [1u, 2, 3, 4].iter().map(|&x| x).collect(); /// - /// let v: Vec = set.into_iter().collect(); + /// let v: Vec = set.into_iter().collect(); /// assert_eq!(v, vec![1u,2,3,4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -196,7 +196,7 @@ impl BTreeSet { /// b.insert(2u); /// b.insert(3u); /// - /// let diff: Vec = a.difference(&b).cloned().collect(); + /// let diff: Vec = a.difference(&b).cloned().collect(); /// assert_eq!(diff, vec![1u]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -219,7 +219,7 @@ impl BTreeSet { /// b.insert(2u); /// b.insert(3u); /// - /// let sym_diff: Vec = a.symmetric_difference(&b).cloned().collect(); + /// let sym_diff: Vec = a.symmetric_difference(&b).cloned().collect(); /// assert_eq!(sym_diff, vec![1u,3]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -243,7 +243,7 @@ impl BTreeSet { /// b.insert(2u); /// b.insert(3u); /// - /// let intersection: Vec = a.intersection(&b).cloned().collect(); + /// let intersection: Vec = a.intersection(&b).cloned().collect(); /// assert_eq!(intersection, vec![2u]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -265,7 +265,7 @@ impl BTreeSet { /// let mut b = BTreeSet::new(); /// b.insert(2u); /// - /// let union: Vec = a.union(&b).cloned().collect(); + /// let union: Vec = a.union(&b).cloned().collect(); /// assert_eq!(union, vec![1u,2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -286,7 +286,7 @@ impl BTreeSet { /// assert_eq!(v.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { self.map.len() } + pub fn len(&self) -> usize { self.map.len() } /// Returns true if the set contains no elements /// @@ -625,7 +625,7 @@ impl<'a, T> Iterator for Iter<'a, T> { type Item = &'a T; fn next(&mut self) -> Option<&'a T> { self.iter.next() } - fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> DoubleEndedIterator for Iter<'a, T> { @@ -640,7 +640,7 @@ impl Iterator for IntoIter { type Item = T; fn next(&mut self) -> Option { self.iter.next() } - fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl DoubleEndedIterator for IntoIter { @@ -770,23 +770,23 @@ mod test { } struct Counter<'a, 'b> { - i: &'a mut uint, - expected: &'b [int], + i: &'a mut usize, + expected: &'b [i32], } - impl<'a, 'b, 'c> FnMut<(&'c int,)> for Counter<'a, 'b> { + impl<'a, 'b, 'c> FnMut<(&'c i32,)> for Counter<'a, 'b> { type Output = bool; - extern "rust-call" fn call_mut(&mut self, (&x,): (&'c int,)) -> bool { + extern "rust-call" fn call_mut(&mut self, (&x,): (&'c i32,)) -> bool { assert_eq!(x, self.expected[*self.i]); *self.i += 1; true } } - fn check(a: &[int], b: &[int], expected: &[int], f: F) where + fn check(a: &[i32], b: &[i32], expected: &[i32], f: F) where // FIXME Replace Counter with `Box _>` - F: FnOnce(&BTreeSet, &BTreeSet, Counter) -> bool, + F: FnOnce(&BTreeSet, &BTreeSet, Counter) -> bool, { let mut set_a = BTreeSet::new(); let mut set_b = BTreeSet::new(); @@ -801,7 +801,7 @@ mod test { #[test] fn test_intersection() { - fn check_intersection(a: &[int], b: &[int], expected: &[int]) { + fn check_intersection(a: &[i32], b: &[i32], expected: &[i32]) { check(a, b, expected, |x, y, f| x.intersection(y).all(f)) } @@ -817,7 +817,7 @@ mod test { #[test] fn test_difference() { - fn check_difference(a: &[int], b: &[int], expected: &[int]) { + fn check_difference(a: &[i32], b: &[i32], expected: &[i32]) { check(a, b, expected, |x, y, f| x.difference(y).all(f)) } @@ -834,8 +834,7 @@ mod test { #[test] fn test_symmetric_difference() { - fn check_symmetric_difference(a: &[int], b: &[int], - expected: &[int]) { + fn check_symmetric_difference(a: &[i32], b: &[i32], expected: &[i32]) { check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f)) } @@ -849,8 +848,7 @@ mod test { #[test] fn test_union() { - fn check_union(a: &[int], b: &[int], - expected: &[int]) { + fn check_union(a: &[i32], b: &[i32], expected: &[i32]) { check(a, b, expected, |x, y, f| x.union(y).all(f)) } @@ -865,9 +863,9 @@ mod test { #[test] fn test_zip() { let mut x = BTreeSet::new(); - x.insert(5u); - x.insert(12u); - x.insert(11u); + x.insert(5); + x.insert(12); + x.insert(11); let mut y = BTreeSet::new(); y.insert("foo"); @@ -878,13 +876,13 @@ mod test { let mut z = x.iter().zip(y.iter()); // FIXME: #5801: this needs a type hint to compile... - let result: Option<(&uint, & &'static str)> = z.next(); - assert_eq!(result.unwrap(), (&5u, &("bar"))); + let result: Option<(&usize, & &'static str)> = z.next(); + assert_eq!(result.unwrap(), (&5, &("bar"))); - let result: Option<(&uint, & &'static str)> = z.next(); - assert_eq!(result.unwrap(), (&11u, &("foo"))); + let result: Option<(&usize, & &'static str)> = z.next(); + assert_eq!(result.unwrap(), (&11, &("foo"))); - let result: Option<(&uint, & &'static str)> = z.next(); + let result: Option<(&usize, & &'static str)> = z.next(); assert!(result.is_none()); } diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index d93e61b91f200..748230c5d24cf 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -35,7 +35,7 @@ use core::ptr; /// A doubly-linked list. #[stable(feature = "rust1", since = "1.0.0")] pub struct DList { - length: uint, + length: usize, list_head: Link, list_tail: Rawlink>, } @@ -61,7 +61,7 @@ struct Node { pub struct Iter<'a, T:'a> { head: &'a Link, tail: Rawlink>, - nelem: uint, + nelem: usize, } // FIXME #19839: deriving is too aggressive on the bounds (T doesn't need to be Clone). @@ -82,7 +82,7 @@ pub struct IterMut<'a, T:'a> { list: &'a mut DList, head: Rawlink>, tail: Rawlink>, - nelem: uint, + nelem: usize, } /// An iterator over mutable references to the items of a `DList`. @@ -345,7 +345,7 @@ impl DList { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { + pub fn len(&self) -> usize { self.length } @@ -578,7 +578,7 @@ impl DList { /// assert_eq!(splitted.pop_front(), None); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn split_off(&mut self, at: uint) -> DList { + pub fn split_off(&mut self, at: usize) -> DList { let len = self.len(); assert!(at < len, "Cannot split off at a nonexistent index"); if at == 0 { @@ -659,7 +659,7 @@ impl<'a, A> Iterator for Iter<'a, A> { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { (self.nelem, Some(self.nelem)) } } @@ -701,7 +701,7 @@ impl<'a, A> Iterator for IterMut<'a, A> { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { (self.nelem, Some(self.nelem)) } } @@ -810,7 +810,7 @@ impl Iterator for IntoIter { fn next(&mut self) -> Option { self.list.pop_front() } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { (self.list.length, Some(self.list.length)) } } @@ -935,11 +935,11 @@ mod tests { use super::{DList, Node}; pub fn check_links(list: &DList) { - let mut len = 0u; + let mut len = 0; let mut last_ptr: Option<&Node> = None; let mut node_ptr: &Node; match list.list_head { - None => { assert_eq!(0u, list.length); return } + None => { assert_eq!(0, list.length); return } Some(ref node) => node_ptr = &**node, } loop { @@ -968,7 +968,7 @@ mod tests { #[test] fn test_basic() { - let mut m: DList> = DList::new(); + let mut m = DList::new(); assert_eq!(m.pop_front(), None); assert_eq!(m.pop_back(), None); assert_eq!(m.pop_front(), None); @@ -1007,7 +1007,7 @@ mod tests { } #[cfg(test)] - fn generate_test() -> DList { + fn generate_test() -> DList { list_from(&[0,1,2,3,4,5,6]) } @@ -1020,7 +1020,7 @@ mod tests { fn test_append() { // Empty to empty { - let mut m: DList = DList::new(); + let mut m = DList::::new(); let mut n = DList::new(); m.append(&mut n); check_links(&m); @@ -1122,7 +1122,7 @@ mod tests { fn test_iterator() { let m = generate_test(); for (i, elt) in m.iter().enumerate() { - assert_eq!(i as int, *elt); + assert_eq!(i as i32, *elt); } let mut n = DList::new(); assert_eq!(n.iter().next(), None); @@ -1170,7 +1170,7 @@ mod tests { fn test_rev_iter() { let m = generate_test(); for (i, elt) in m.iter().rev().enumerate() { - assert_eq!((6 - i) as int, *elt); + assert_eq!((6 - i) as i32, *elt); } let mut n = DList::new(); assert_eq!(n.iter().rev().next(), None); @@ -1187,7 +1187,7 @@ mod tests { let mut m = generate_test(); let mut len = m.len(); for (i, elt) in m.iter_mut().enumerate() { - assert_eq!(i as int, *elt); + assert_eq!(i as i32, *elt); len -= 1; } assert_eq!(len, 0); @@ -1245,14 +1245,14 @@ mod tests { } check_links(&m); assert_eq!(m.len(), 3 + len * 2); - assert_eq!(m.into_iter().collect::>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]); + assert_eq!(m.into_iter().collect::>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]); } #[test] fn test_mut_rev_iter() { let mut m = generate_test(); for (i, elt) in m.iter_mut().rev().enumerate() { - assert_eq!((6-i) as int, *elt); + assert_eq!((6 - i) as i32, *elt); } let mut n = DList::new(); assert!(n.iter_mut().rev().next().is_none()); @@ -1268,13 +1268,13 @@ mod tests { Thread::scoped(move || { check_links(&n); let a: &[_] = &[&1,&2,&3]; - assert_eq!(a, n.iter().collect::>()); + assert_eq!(a, n.iter().collect::>()); }).join().ok().unwrap(); } #[test] fn test_eq() { - let mut n: DList = list_from(&[]); + let mut n = list_from(&[]); let mut m = list_from(&[]); assert!(n == m); n.push_front(1); @@ -1307,7 +1307,7 @@ mod tests { #[test] fn test_ord() { - let n: DList = list_from(&[]); + let n = list_from(&[]); let m = list_from(&[1,2,3]); assert!(n < m); assert!(m > n); @@ -1349,7 +1349,7 @@ mod tests { #[test] fn test_fuzz() { - for _ in 0u..25 { + for _ in 0..25 { fuzz_test(3); fuzz_test(16); fuzz_test(189); @@ -1358,18 +1358,16 @@ mod tests { #[test] fn test_show() { - let list: DList = (0..10).collect(); + let list: DList<_> = (0..10).collect(); assert_eq!(format!("{:?}", list), "DList [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"); - let list: DList<&str> = vec!["just", "one", "test", "more"].iter() - .map(|&s| s) - .collect(); + let list: DList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect(); assert_eq!(format!("{:?}", list), "DList [\"just\", \"one\", \"test\", \"more\"]"); } #[cfg(test)] - fn fuzz_test(sz: int) { - let mut m: DList = DList::new(); + fn fuzz_test(sz: i32) { + let mut m: DList<_> = DList::new(); let mut v = vec![]; for i in 0..sz { check_links(&m); @@ -1398,7 +1396,7 @@ mod tests { check_links(&m); - let mut i = 0u; + let mut i = 0; for (a, &b) in m.into_iter().zip(v.iter()) { i += 1; assert_eq!(a, b); @@ -1410,13 +1408,13 @@ mod tests { fn bench_collect_into(b: &mut test::Bencher) { let v = &[0; 64]; b.iter(|| { - let _: DList = v.iter().map(|x| *x).collect(); + let _: DList<_> = v.iter().cloned().collect(); }) } #[bench] fn bench_push_front(b: &mut test::Bencher) { - let mut m: DList = DList::new(); + let mut m: DList<_> = DList::new(); b.iter(|| { m.push_front(0); }) @@ -1424,7 +1422,7 @@ mod tests { #[bench] fn bench_push_back(b: &mut test::Bencher) { - let mut m: DList = DList::new(); + let mut m: DList<_> = DList::new(); b.iter(|| { m.push_back(0); }) @@ -1432,7 +1430,7 @@ mod tests { #[bench] fn bench_push_back_pop_back(b: &mut test::Bencher) { - let mut m: DList = DList::new(); + let mut m: DList<_> = DList::new(); b.iter(|| { m.push_back(0); m.pop_back(); @@ -1441,7 +1439,7 @@ mod tests { #[bench] fn bench_push_front_pop_front(b: &mut test::Bencher) { - let mut m: DList = DList::new(); + let mut m: DList<_> = DList::new(); b.iter(|| { m.push_front(0); m.pop_front(); @@ -1451,7 +1449,7 @@ mod tests { #[bench] fn bench_iter(b: &mut test::Bencher) { let v = &[0; 128]; - let m: DList = v.iter().map(|&x|x).collect(); + let m: DList<_> = v.iter().cloned().collect(); b.iter(|| { assert!(m.iter().count() == 128); }) @@ -1459,7 +1457,7 @@ mod tests { #[bench] fn bench_iter_mut(b: &mut test::Bencher) { let v = &[0; 128]; - let mut m: DList = v.iter().map(|&x|x).collect(); + let mut m: DList<_> = v.iter().cloned().collect(); b.iter(|| { assert!(m.iter_mut().count() == 128); }) @@ -1467,7 +1465,7 @@ mod tests { #[bench] fn bench_iter_rev(b: &mut test::Bencher) { let v = &[0; 128]; - let m: DList = v.iter().map(|&x|x).collect(); + let m: DList<_> = v.iter().cloned().collect(); b.iter(|| { assert!(m.iter().rev().count() == 128); }) @@ -1475,7 +1473,7 @@ mod tests { #[bench] fn bench_iter_mut_rev(b: &mut test::Bencher) { let v = &[0; 128]; - let mut m: DList = v.iter().map(|&x|x).collect(); + let mut m: DList<_> = v.iter().cloned().collect(); b.iter(|| { assert!(m.iter_mut().rev().count() == 128); }) diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 8cbf50d29f23b..da14650607747 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -26,7 +26,7 @@ use core::ops::{Sub, BitOr, BitAnd, BitXor}; pub struct EnumSet { // We must maintain the invariant that no bits are set // for which no variant exists - bits: uint + bits: usize } impl Copy for EnumSet {} @@ -47,37 +47,37 @@ impl fmt::Debug for EnumSet { } } -/// An interface for casting C-like enum to uint and back. +/// An interface for casting C-like enum to usize and back. /// A typically implementation is as below. /// /// ```{rust,ignore} -/// #[repr(uint)] +/// #[repr(usize)] /// enum Foo { /// A, B, C /// } /// /// impl CLike for Foo { -/// fn to_uint(&self) -> uint { -/// *self as uint +/// fn to_usize(&self) -> usize { +/// *self as usize /// } /// -/// fn from_uint(v: uint) -> Foo { +/// fn from_usize(v: usize) -> Foo { /// unsafe { mem::transmute(v) } /// } /// } /// ``` pub trait CLike { - /// Converts a C-like enum to a `uint`. - fn to_uint(&self) -> uint; - /// Converts a `uint` to a C-like enum. - fn from_uint(uint) -> Self; + /// Converts a C-like enum to a `usize`. + fn to_usize(&self) -> usize; + /// Converts a `usize` to a C-like enum. + fn from_usize(usize) -> Self; } -fn bit(e: &E) -> uint { - use core::uint; - let value = e.to_uint(); - assert!(value < uint::BITS, - "EnumSet only supports up to {} variants.", uint::BITS - 1); +fn bit(e: &E) -> usize { + use core::usize; + let value = e.to_usize(); + assert!(value < usize::BITS, + "EnumSet only supports up to {} variants.", usize::BITS - 1); 1 << value } @@ -92,7 +92,7 @@ impl EnumSet { /// Returns the number of elements in the given `EnumSet`. #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] - pub fn len(&self) -> uint { + pub fn len(&self) -> usize { self.bits.count_ones() } @@ -205,8 +205,8 @@ impl BitXor for EnumSet { /// An iterator over an EnumSet pub struct Iter { - index: uint, - bits: uint, + index: usize, + bits: usize, } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -220,7 +220,7 @@ impl Clone for Iter { } impl Iter { - fn new(bits: uint) -> Iter { + fn new(bits: usize) -> Iter { Iter { index: 0, bits: bits } } } @@ -237,13 +237,13 @@ impl Iterator for Iter { self.index += 1; self.bits >>= 1; } - let elem = CLike::from_uint(self.index); + let elem = CLike::from_usize(self.index); self.index += 1; self.bits >>= 1; Some(elem) } - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { let exact = self.bits.count_ones(); (exact, Some(exact)) } @@ -282,17 +282,17 @@ mod test { use super::{EnumSet, CLike}; #[derive(Copy, PartialEq, Debug)] - #[repr(uint)] + #[repr(usize)] enum Foo { A, B, C } impl CLike for Foo { - fn to_uint(&self) -> uint { - *self as uint + fn to_usize(&self) -> usize { + *self as usize } - fn from_uint(v: uint) -> Foo { + fn from_usize(v: usize) -> Foo { unsafe { mem::transmute(v) } } } @@ -486,7 +486,7 @@ mod test { fn test_overflow() { #[allow(dead_code)] #[derive(Copy)] - #[repr(uint)] + #[repr(usize)] enum Bar { V00, V01, V02, V03, V04, V05, V06, V07, V08, V09, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, @@ -498,11 +498,11 @@ mod test { } impl CLike for Bar { - fn to_uint(&self) -> uint { - *self as uint + fn to_usize(&self) -> usize { + *self as usize } - fn from_uint(v: uint) -> Bar { + fn from_usize(v: usize) -> Bar { unsafe { mem::transmute(v) } } } diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 18021dea9f29e..85c4a64c0c172 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -32,8 +32,8 @@ use std::cmp; use alloc::heap; -static INITIAL_CAPACITY: uint = 7u; // 2^3 - 1 -static MINIMUM_CAPACITY: uint = 1u; // 2 - 1 +static INITIAL_CAPACITY: usize = 7u; // 2^3 - 1 +static MINIMUM_CAPACITY: usize = 1u; // 2 - 1 /// `RingBuf` is a circular buffer, which can be used as a double-ended queue efficiently. #[stable(feature = "rust1", since = "1.0.0")] @@ -44,9 +44,9 @@ pub struct RingBuf { // If tail == head the buffer is empty. The length of the ringbuf // is defined as the distance between the two. - tail: uint, - head: uint, - cap: uint, + tail: usize, + head: usize, + cap: usize, ptr: *mut T } @@ -59,7 +59,7 @@ unsafe impl Sync for RingBuf {} #[stable(feature = "rust1", since = "1.0.0")] impl Clone for RingBuf { fn clone(&self) -> RingBuf { - self.iter().map(|t| t.clone()).collect() + self.iter().cloned().collect() } } @@ -99,14 +99,14 @@ impl RingBuf { /// Moves an element out of the buffer #[inline] - unsafe fn buffer_read(&mut self, off: uint) -> T { - ptr::read(self.ptr.offset(off as int)) + unsafe fn buffer_read(&mut self, off: usize) -> T { + ptr::read(self.ptr.offset(off as isize)) } /// Writes an element into the buffer, moving it. #[inline] - unsafe fn buffer_write(&mut self, off: uint, t: T) { - ptr::write(self.ptr.offset(off as int), t); + unsafe fn buffer_write(&mut self, off: usize, t: T) { + ptr::write(self.ptr.offset(off as isize), t); } /// Returns true iff the buffer is at capacity @@ -115,31 +115,31 @@ impl RingBuf { /// Returns the index in the underlying buffer for a given logical element index. #[inline] - fn wrap_index(&self, idx: uint) -> uint { wrap_index(idx, self.cap) } + fn wrap_index(&self, idx: usize) -> usize { wrap_index(idx, self.cap) } /// Copies a contiguous block of memory len long from src to dst #[inline] - unsafe fn copy(&self, dst: uint, src: uint, len: uint) { + unsafe fn copy(&self, dst: usize, src: usize, len: usize) { debug_assert!(dst + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len, self.cap); debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len, self.cap); ptr::copy_memory( - self.ptr.offset(dst as int), - self.ptr.offset(src as int), + self.ptr.offset(dst as isize), + self.ptr.offset(src as isize), len); } /// Copies a contiguous block of memory len long from src to dst #[inline] - unsafe fn copy_nonoverlapping(&self, dst: uint, src: uint, len: uint) { + unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) { debug_assert!(dst + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len, self.cap); debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len, self.cap); ptr::copy_nonoverlapping_memory( - self.ptr.offset(dst as int), - self.ptr.offset(src as int), + self.ptr.offset(dst as isize), + self.ptr.offset(src as isize), len); } } @@ -153,7 +153,7 @@ impl RingBuf { /// Creates an empty `RingBuf` with space for at least `n` elements. #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(n: uint) -> RingBuf { + pub fn with_capacity(n: usize) -> RingBuf { // +1 since the ringbuffer always leaves one space empty let cap = cmp::max(n + 1, MINIMUM_CAPACITY + 1).next_power_of_two(); assert!(cap > n, "capacity overflow"); @@ -192,10 +192,10 @@ impl RingBuf { /// assert_eq!(buf.get(1).unwrap(), &4); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get(&self, i: uint) -> Option<&T> { + pub fn get(&self, i: usize) -> Option<&T> { if i < self.len() { let idx = self.wrap_index(self.tail + i); - unsafe { Some(&*self.ptr.offset(idx as int)) } + unsafe { Some(&*self.ptr.offset(idx as isize)) } } else { None } @@ -222,10 +222,10 @@ impl RingBuf { /// assert_eq!(buf[1], 7); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_mut(&mut self, i: uint) -> Option<&mut T> { + pub fn get_mut(&mut self, i: usize) -> Option<&mut T> { if i < self.len() { let idx = self.wrap_index(self.tail + i); - unsafe { Some(&mut *self.ptr.offset(idx as int)) } + unsafe { Some(&mut *self.ptr.offset(idx as isize)) } } else { None } @@ -251,13 +251,13 @@ impl RingBuf { /// assert_eq!(buf[2], 3); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn swap(&mut self, i: uint, j: uint) { + pub fn swap(&mut self, i: usize, j: usize) { assert!(i < self.len()); assert!(j < self.len()); let ri = self.wrap_index(self.tail + i); let rj = self.wrap_index(self.tail + j); unsafe { - ptr::swap(self.ptr.offset(ri as int), self.ptr.offset(rj as int)) + ptr::swap(self.ptr.offset(ri as isize), self.ptr.offset(rj as isize)) } } @@ -274,7 +274,7 @@ impl RingBuf { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> uint { self.cap - 1 } + pub fn capacity(&self) -> usize { self.cap - 1 } /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the /// given `RingBuf`. Does nothing if the capacity is already sufficient. @@ -285,7 +285,7 @@ impl RingBuf { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -297,7 +297,7 @@ impl RingBuf { /// assert!(buf.capacity() >= 11); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve_exact(&mut self, additional: uint) { + pub fn reserve_exact(&mut self, additional: usize) { self.reserve(additional); } @@ -306,7 +306,7 @@ impl RingBuf { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -318,7 +318,7 @@ impl RingBuf { /// assert!(buf.capacity() >= 11); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve(&mut self, additional: uint) { + pub fn reserve(&mut self, additional: usize) { let new_len = self.len() + additional; assert!(new_len + 1 > self.len(), "capacity overflow"); if new_len > self.capacity() { @@ -482,7 +482,7 @@ impl RingBuf { /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification; waiting on panic semantics")] - pub fn truncate(&mut self, len: uint) { + pub fn truncate(&mut self, len: usize) { for _ in len..self.len() { self.pop_back(); } @@ -604,7 +604,7 @@ impl RingBuf { /// assert_eq!(v.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { count(self.tail, self.head, self.cap) } + pub fn len(&self) -> usize { count(self.tail, self.head, self.cap) } /// Returns true if the buffer contains no elements /// @@ -878,7 +878,7 @@ impl RingBuf { /// ``` #[unstable(feature = "collections", reason = "the naming of this function may be altered")] - pub fn swap_back_remove(&mut self, index: uint) -> Option { + pub fn swap_back_remove(&mut self, index: usize) -> Option { let length = self.len(); if length > 0 && index < length - 1 { self.swap(index, length - 1); @@ -911,7 +911,7 @@ impl RingBuf { /// ``` #[unstable(feature = "collections", reason = "the naming of this function may be altered")] - pub fn swap_front_remove(&mut self, index: uint) -> Option { + pub fn swap_front_remove(&mut self, index: usize) -> Option { let length = self.len(); if length > 0 && index < length && index != 0 { self.swap(index, 0); @@ -939,7 +939,7 @@ impl RingBuf { /// buf.insert(1,11); /// assert_eq!(Some(&11), buf.get(1)); /// ``` - pub fn insert(&mut self, i: uint, t: T) { + pub fn insert(&mut self, i: usize, t: T) { assert!(i <= self.len(), "index out of bounds"); if self.is_full() { self.reserve(1); @@ -1144,7 +1144,7 @@ impl RingBuf { /// assert_eq!(Some(&15), buf.get(2)); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn remove(&mut self, i: uint) -> Option { + pub fn remove(&mut self, i: usize) -> Option { if self.is_empty() || self.len() <= i { return None; } @@ -1312,7 +1312,7 @@ impl RingBuf { /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification; waiting on panic semantics")] - pub fn resize(&mut self, new_len: uint, value: T) { + pub fn resize(&mut self, new_len: usize, value: T) { let len = self.len(); if new_len > len { @@ -1325,14 +1325,14 @@ impl RingBuf { /// Returns the index in the underlying buffer for a given logical element index. #[inline] -fn wrap_index(index: uint, size: uint) -> uint { +fn wrap_index(index: usize, size: usize) -> usize { // size is always a power of 2 index & (size - 1) } /// Calculate the number of elements left to be read in the buffer #[inline] -fn count(tail: uint, head: uint, size: uint) -> uint { +fn count(tail: usize, head: usize, size: usize) -> usize { // size is always a power of 2 (head - tail) & (size - 1) } @@ -1341,8 +1341,8 @@ fn count(tail: uint, head: uint, size: uint) -> uint { #[stable(feature = "rust1", since = "1.0.0")] pub struct Iter<'a, T:'a> { ring: &'a [T], - tail: uint, - head: uint + tail: usize, + head: usize } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -1371,7 +1371,7 @@ impl<'a, T> Iterator for Iter<'a, T> { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { let len = count(self.tail, self.head, self.ring.len()); (len, Some(len)) } @@ -1395,13 +1395,13 @@ impl<'a, T> ExactSizeIterator for Iter<'a, T> {} #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> RandomAccessIterator for Iter<'a, T> { #[inline] - fn indexable(&self) -> uint { + fn indexable(&self) -> usize { let (len, _) = self.size_hint(); len } #[inline] - fn idx(&mut self, j: uint) -> Option<&'a T> { + fn idx(&mut self, j: usize) -> Option<&'a T> { if j >= self.indexable() { None } else { @@ -1418,9 +1418,9 @@ impl<'a, T> RandomAccessIterator for Iter<'a, T> { #[stable(feature = "rust1", since = "1.0.0")] pub struct IterMut<'a, T:'a> { ptr: *mut T, - tail: uint, - head: uint, - cap: uint, + tail: usize, + head: usize, + cap: usize, marker: marker::ContravariantLifetime<'a>, } @@ -1437,12 +1437,12 @@ impl<'a, T> Iterator for IterMut<'a, T> { self.tail = wrap_index(self.tail + 1, self.cap); unsafe { - Some(&mut *self.ptr.offset(tail as int)) + Some(&mut *self.ptr.offset(tail as isize)) } } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { let len = count(self.tail, self.head, self.cap); (len, Some(len)) } @@ -1458,7 +1458,7 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> { self.head = wrap_index(self.head - 1, self.cap); unsafe { - Some(&mut *self.ptr.offset(self.head as int)) + Some(&mut *self.ptr.offset(self.head as isize)) } } } @@ -1482,7 +1482,7 @@ impl Iterator for IntoIter { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { let len = self.inner.len(); (len, Some(len)) } @@ -1526,7 +1526,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { let len = self.inner.len(); (len, Some(len)) } @@ -1580,21 +1580,21 @@ impl> Hash for RingBuf { } #[stable(feature = "rust1", since = "1.0.0")] -impl Index for RingBuf { +impl Index for RingBuf { type Output = A; #[inline] - fn index<'a>(&'a self, i: &uint) -> &'a A { + fn index<'a>(&'a self, i: &usize) -> &'a A { self.get(*i).expect("Out of bounds access") } } #[stable(feature = "rust1", since = "1.0.0")] -impl IndexMut for RingBuf { +impl IndexMut for RingBuf { type Output = A; #[inline] - fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut A { + fn index_mut<'a>(&'a mut self, i: &usize) -> &'a mut A { self.get_mut(*i).expect("Out of bounds access") } } @@ -1673,13 +1673,13 @@ mod tests { #[allow(deprecated)] fn test_simple() { let mut d = RingBuf::new(); - assert_eq!(d.len(), 0u); + assert_eq!(d.len(), 0); d.push_front(17); d.push_front(42); d.push_back(137); - assert_eq!(d.len(), 3u); + assert_eq!(d.len(), 3); d.push_back(137); - assert_eq!(d.len(), 4u); + assert_eq!(d.len(), 4); assert_eq!(*d.front().unwrap(), 42); assert_eq!(*d.back().unwrap(), 137); let mut i = d.pop_front(); @@ -1690,15 +1690,15 @@ mod tests { assert_eq!(i, Some(137)); i = d.pop_back(); assert_eq!(i, Some(17)); - assert_eq!(d.len(), 0u); + assert_eq!(d.len(), 0); d.push_back(3); - assert_eq!(d.len(), 1u); + assert_eq!(d.len(), 1); d.push_front(2); - assert_eq!(d.len(), 2u); + assert_eq!(d.len(), 2); d.push_back(4); - assert_eq!(d.len(), 3u); + assert_eq!(d.len(), 3); d.push_front(1); - assert_eq!(d.len(), 4u); + assert_eq!(d.len(), 4); debug!("{}", d[0]); debug!("{}", d[1]); debug!("{}", d[2]); @@ -1743,21 +1743,21 @@ mod tests { #[test] fn test_push_front_grow() { let mut deq = RingBuf::new(); - for i in 0u..66 { + for i in 0..66 { deq.push_front(i); } assert_eq!(deq.len(), 66); - for i in 0u..66 { + for i in 0..66 { assert_eq!(deq[i], 65 - i); } let mut deq = RingBuf::new(); - for i in 0u..66 { + for i in 0..66 { deq.push_back(i); } - for i in 0u..66 { + for i in 0..66 { assert_eq!(deq[i], i); } } @@ -1765,7 +1765,7 @@ mod tests { #[test] fn test_index() { let mut deq = RingBuf::new(); - for i in 1u..4 { + for i in 1..4 { deq.push_front(i); } assert_eq!(deq[1], 2); @@ -1775,7 +1775,7 @@ mod tests { #[should_fail] fn test_index_out_of_bounds() { let mut deq = RingBuf::new(); - for i in 1u..4 { + for i in 1..4 { deq.push_front(i); } deq[3]; @@ -1784,7 +1784,7 @@ mod tests { #[bench] fn bench_new(b: &mut test::Bencher) { b.iter(|| { - let ring: RingBuf = RingBuf::new(); + let ring: RingBuf = RingBuf::new(); test::black_box(ring); }) } @@ -1815,7 +1815,7 @@ mod tests { #[bench] fn bench_pop_back_100(b: &mut test::Bencher) { - let mut deq: RingBuf = RingBuf::with_capacity(101); + let mut deq= RingBuf::::with_capacity(101); b.iter(|| { deq.head = 100; @@ -1828,7 +1828,7 @@ mod tests { #[bench] fn bench_pop_front_100(b: &mut test::Bencher) { - let mut deq: RingBuf = RingBuf::with_capacity(101); + let mut deq = RingBuf::::with_capacity(101); b.iter(|| { deq.head = 100; @@ -1852,7 +1852,7 @@ mod tests { #[bench] fn bench_iter_1000(b: &mut test::Bencher) { - let ring: RingBuf = (0..1000).collect(); + let ring: RingBuf<_> = (0..1000).collect(); b.iter(|| { let mut sum = 0; @@ -1865,7 +1865,7 @@ mod tests { #[bench] fn bench_mut_iter_1000(b: &mut test::Bencher) { - let mut ring: RingBuf = (0..1000).collect(); + let mut ring: RingBuf<_> = (0..1000).collect(); b.iter(|| { let mut sum = 0; @@ -1978,11 +1978,7 @@ mod tests { #[test] fn test_reserve_exact() { let mut d = RingBuf::new(); - d.push_back(0u64); - d.reserve_exact(50); - assert!(d.capacity() >= 51); - let mut d = RingBuf::new(); - d.push_back(0u32); + d.push_back(0); d.reserve_exact(50); assert!(d.capacity() >= 51); } @@ -1990,21 +1986,17 @@ mod tests { #[test] fn test_reserve() { let mut d = RingBuf::new(); - d.push_back(0u64); - d.reserve(50); - assert!(d.capacity() >= 51); - let mut d = RingBuf::new(); - d.push_back(0u32); + d.push_back(0); d.reserve(50); assert!(d.capacity() >= 51); } #[test] fn test_swap() { - let mut d: RingBuf = (0..5).collect(); + let mut d: RingBuf<_> = (0..5).collect(); d.pop_front(); d.swap(0, 3); - assert_eq!(d.iter().map(|&x|x).collect::>(), vec!(4, 2, 3, 1)); + assert_eq!(d.iter().cloned().collect::>(), vec!(4, 2, 3, 1)); } #[test] @@ -2018,7 +2010,7 @@ mod tests { } { let b: &[_] = &[&0,&1,&2,&3,&4]; - assert_eq!(d.iter().collect::>(), b); + assert_eq!(d.iter().collect::>(), b); } for i in 6..9 { @@ -2026,7 +2018,7 @@ mod tests { } { let b: &[_] = &[&8,&7,&6,&0,&1,&2,&3,&4]; - assert_eq!(d.iter().collect::>(), b); + assert_eq!(d.iter().collect::>(), b); } let mut it = d.iter(); @@ -2049,14 +2041,14 @@ mod tests { } { let b: &[_] = &[&4,&3,&2,&1,&0]; - assert_eq!(d.iter().rev().collect::>(), b); + assert_eq!(d.iter().rev().collect::>(), b); } for i in 6..9 { d.push_front(i); } let b: &[_] = &[&4,&3,&2,&1,&0,&6,&7,&8]; - assert_eq!(d.iter().rev().collect::>(), b); + assert_eq!(d.iter().rev().collect::>(), b); } #[test] @@ -2070,8 +2062,8 @@ mod tests { assert_eq!(d.pop_front(), Some(1)); d.push_back(4); - assert_eq!(d.iter_mut().rev().map(|x| *x).collect::>(), - vec!(4, 3, 2)); + assert_eq!(d.iter_mut().rev().cloned().collect::>(), + vec![4, 3, 2]); } #[test] @@ -2079,7 +2071,7 @@ mod tests { let mut d = RingBuf::new(); assert!(d.iter_mut().next().is_none()); - for i in 0u..3 { + for i in 0..3 { d.push_front(i); } @@ -2102,7 +2094,7 @@ mod tests { let mut d = RingBuf::new(); assert!(d.iter_mut().rev().next().is_none()); - for i in 0u..3 { + for i in 0..3 { d.push_front(i); } @@ -2141,7 +2133,7 @@ mod tests { } let b = vec![0,1,2,3,4]; - assert_eq!(d.into_iter().collect::>(), b); + assert_eq!(d.into_iter().collect::>(), b); } // wrapped iter @@ -2155,7 +2147,7 @@ mod tests { } let b = vec![8,7,6,0,1,2,3,4]; - assert_eq!(d.into_iter().collect::>(), b); + assert_eq!(d.into_iter().collect::>(), b); } // partially used @@ -2224,7 +2216,7 @@ mod tests { // partially used { - let mut d: RingBuf = RingBuf::new(); + let mut d: RingBuf<_> = RingBuf::new(); for i in 0..5 { d.push_back(i); } @@ -2250,12 +2242,12 @@ mod tests { fn test_from_iter() { use core::iter; let v = vec!(1,2,3,4,5,6,7); - let deq: RingBuf = v.iter().map(|&x| x).collect(); - let u: Vec = deq.iter().map(|&x| x).collect(); + let deq: RingBuf<_> = v.iter().cloned().collect(); + let u: Vec<_> = deq.iter().cloned().collect(); assert_eq!(u, v); - let seq = iter::count(0u, 2).take(256); - let deq: RingBuf = seq.collect(); + let seq = iter::count(0, 2).take(256); + let deq: RingBuf<_> = seq.collect(); for (i, &x) in deq.iter().enumerate() { assert_eq!(2*i, x); } @@ -2269,14 +2261,14 @@ mod tests { d.push_front(42); d.push_back(137); d.push_back(137); - assert_eq!(d.len(), 4u); + assert_eq!(d.len(), 4); let mut e = d.clone(); - assert_eq!(e.len(), 4u); + assert_eq!(e.len(), 4); while !d.is_empty() { assert_eq!(d.pop_back(), e.pop_back()); } - assert_eq!(d.len(), 0u); - assert_eq!(e.len(), 0u); + assert_eq!(d.len(), 0); + assert_eq!(e.len(), 0); } #[test] @@ -2333,18 +2325,18 @@ mod tests { #[test] fn test_show() { - let ringbuf: RingBuf = (0..10).collect(); + let ringbuf: RingBuf<_> = (0..10).collect(); assert_eq!(format!("{:?}", ringbuf), "RingBuf [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"); - let ringbuf: RingBuf<&str> = vec!["just", "one", "test", "more"].iter() - .map(|&s| s) + let ringbuf: RingBuf<_> = vec!["just", "one", "test", "more"].iter() + .cloned() .collect(); assert_eq!(format!("{:?}", ringbuf), "RingBuf [\"just\", \"one\", \"test\", \"more\"]"); } #[test] fn test_drop() { - static mut drops: uint = 0; + static mut drops: i32 = 0; struct Elem; impl Drop for Elem { fn drop(&mut self) { @@ -2364,7 +2356,7 @@ mod tests { #[test] fn test_drop_with_pop() { - static mut drops: uint = 0; + static mut drops: i32 = 0; struct Elem; impl Drop for Elem { fn drop(&mut self) { @@ -2388,7 +2380,7 @@ mod tests { #[test] fn test_drop_clear() { - static mut drops: uint = 0; + static mut drops: i32 = 0; struct Elem; impl Drop for Elem { fn drop(&mut self) { diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 8721de1299fb2..3fe3fe04a5432 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -26,7 +26,7 @@ //! block of memory that a mutable slice points to: //! //! ```rust -//! let x: &mut[int] = &mut [1, 2, 3]; +//! let x: &mut[i32] = &mut [1, 2, 3]; //! x[1] = 7; //! assert_eq!(x[0], 1); //! assert_eq!(x[1], 7); @@ -168,25 +168,25 @@ pub trait SliceExt { /// ``` #[unstable(feature = "collections", reason = "uncertain about this API approach")] - fn move_from(&mut self, src: Vec, start: uint, end: uint) -> uint; + fn move_from(&mut self, src: Vec, start: usize, end: usize) -> usize; /// Deprecated: use `&s[start .. end]` notation instead. #[unstable(feature = "collections", reason = "will be replaced by slice syntax")] #[deprecated(since = "1.0.0", reason = "use &s[start .. end] instead")] - fn slice(&self, start: uint, end: uint) -> &[Self::Item]; + fn slice(&self, start: usize, end: usize) -> &[Self::Item]; /// Deprecated: use `&s[start..]` notation instead. #[unstable(feature = "collections", reason = "will be replaced by slice syntax")] #[deprecated(since = "1.0.0", reason = "use &s[start..] instead")] - fn slice_from(&self, start: uint) -> &[Self::Item]; + fn slice_from(&self, start: usize) -> &[Self::Item]; /// Deprecated: use `&s[..end]` notation instead. #[unstable(feature = "collections", reason = "will be replaced by slice syntax")] #[deprecated(since = "1.0.0", reason = "use &s[..end] instead")] - fn slice_to(&self, end: uint) -> &[Self::Item]; + fn slice_to(&self, end: usize) -> &[Self::Item]; /// Divides one slice into two at an index. /// @@ -205,7 +205,7 @@ pub trait SliceExt { /// assert_eq!([30, 20, 50], v2); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn split_at(&self, mid: uint) -> (&[Self::Item], &[Self::Item]); + fn split_at(&self, mid: usize) -> (&[Self::Item], &[Self::Item]); /// Returns an iterator over the slice. #[stable(feature = "rust1", since = "1.0.0")] @@ -245,7 +245,7 @@ pub trait SliceExt { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn splitn(&self, n: uint, pred: F) -> SplitN + fn splitn(&self, n: usize, pred: F) -> SplitN where F: FnMut(&Self::Item) -> bool; /// Returns an iterator over subslices separated by elements that match @@ -265,7 +265,7 @@ pub trait SliceExt { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn rsplitn(&self, n: uint, pred: F) -> RSplitN + fn rsplitn(&self, n: usize, pred: F) -> RSplitN where F: FnMut(&Self::Item) -> bool; /// Returns an iterator over all contiguous windows of length @@ -288,7 +288,7 @@ pub trait SliceExt { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn windows(&self, size: uint) -> Windows; + fn windows(&self, size: usize) -> Windows; /// Returns an iterator over `size` elements of the slice at a /// time. The chunks do not overlap. If `size` does not divide the @@ -311,7 +311,7 @@ pub trait SliceExt { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn chunks(&self, size: uint) -> Chunks; + fn chunks(&self, size: usize) -> Chunks; /// Returns the element of a slice at the given index, or `None` if the /// index is out of bounds. @@ -324,7 +324,7 @@ pub trait SliceExt { /// assert_eq!(None, v.get(3)); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn get(&self, index: uint) -> Option<&Self::Item>; + fn get(&self, index: usize) -> Option<&Self::Item>; /// Returns the first element of a slice, or `None` if it is empty. /// @@ -365,7 +365,7 @@ pub trait SliceExt { /// Returns a pointer to the element at the given index, without doing /// bounds checking. #[stable(feature = "rust1", since = "1.0.0")] - unsafe fn get_unchecked(&self, index: uint) -> &Self::Item; + unsafe fn get_unchecked(&self, index: usize) -> &Self::Item; /// Returns an unsafe pointer to the slice's buffer /// @@ -410,7 +410,7 @@ pub trait SliceExt { /// assert!(match r { Ok(1...4) => true, _ => false, }); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn binary_search_by(&self, f: F) -> Result where + fn binary_search_by(&self, f: F) -> Result where F: FnMut(&Self::Item) -> Ordering; /// Return the number of elements in the slice @@ -422,7 +422,7 @@ pub trait SliceExt { /// assert_eq!(a.len(), 3); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn len(&self) -> uint; + fn len(&self) -> usize; /// Returns true if the slice has a length of 0 /// @@ -438,7 +438,7 @@ pub trait SliceExt { /// Returns a mutable reference to the element at the given index, /// or `None` if the index is out of bounds #[stable(feature = "rust1", since = "1.0.0")] - fn get_mut(&mut self, index: uint) -> Option<&mut Self::Item>; + fn get_mut(&mut self, index: usize) -> Option<&mut Self::Item>; /// Work with `self` as a mut slice. /// Primarily intended for getting a &mut [T] from a [T; N]. @@ -449,19 +449,19 @@ pub trait SliceExt { #[unstable(feature = "collections", reason = "will be replaced by slice syntax")] #[deprecated(since = "1.0.0", reason = "use &mut s[start .. end] instead")] - fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item]; + fn slice_mut(&mut self, start: usize, end: usize) -> &mut [Self::Item]; /// Deprecated: use `&mut s[start ..]` instead. #[unstable(feature = "collections", reason = "will be replaced by slice syntax")] #[deprecated(since = "1.0.0", reason = "use &mut s[start ..] instead")] - fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item]; + fn slice_from_mut(&mut self, start: usize) -> &mut [Self::Item]; /// Deprecated: use `&mut s[.. end]` instead. #[unstable(feature = "collections", reason = "will be replaced by slice syntax")] #[deprecated(since = "1.0.0", reason = "use &mut s[.. end] instead")] - fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item]; + fn slice_to_mut(&mut self, end: usize) -> &mut [Self::Item]; /// Returns an iterator that allows modifying each value #[stable(feature = "rust1", since = "1.0.0")] @@ -495,7 +495,7 @@ pub trait SliceExt { /// `pred`, limited to splitting at most `n` times. The matched element is /// not contained in the subslices. #[stable(feature = "rust1", since = "1.0.0")] - fn splitn_mut(&mut self, n: uint, pred: F) -> SplitNMut + fn splitn_mut(&mut self, n: usize, pred: F) -> SplitNMut where F: FnMut(&Self::Item) -> bool; /// Returns an iterator over subslices separated by elements that match @@ -503,7 +503,7 @@ pub trait SliceExt { /// the slice and works backwards. The matched element is not contained in /// the subslices. #[stable(feature = "rust1", since = "1.0.0")] - fn rsplitn_mut(&mut self, n: uint, pred: F) -> RSplitNMut + fn rsplitn_mut(&mut self, n: usize, pred: F) -> RSplitNMut where F: FnMut(&Self::Item) -> bool; /// Returns an iterator over `chunk_size` elements of the slice at a time. @@ -515,7 +515,7 @@ pub trait SliceExt { /// /// Panics if `chunk_size` is 0. #[stable(feature = "rust1", since = "1.0.0")] - fn chunks_mut(&mut self, chunk_size: uint) -> ChunksMut; + fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut; /// Swaps two elements in a slice. /// @@ -536,7 +536,7 @@ pub trait SliceExt { /// assert!(v == ["a", "d", "c", "b"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn swap(&mut self, a: uint, b: uint); + fn swap(&mut self, a: usize, b: usize); /// Divides one `&mut` into two at an index. /// @@ -573,7 +573,7 @@ pub trait SliceExt { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn split_at_mut(&mut self, mid: uint) -> (&mut [Self::Item], &mut [Self::Item]); + fn split_at_mut(&mut self, mid: usize) -> (&mut [Self::Item], &mut [Self::Item]); /// Reverse the order of elements in a slice, in place. /// @@ -589,7 +589,7 @@ pub trait SliceExt { /// Returns an unsafe mutable pointer to the element in index #[stable(feature = "rust1", since = "1.0.0")] - unsafe fn get_unchecked_mut(&mut self, index: uint) -> &mut Self::Item; + unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut Self::Item; /// Return an unsafe mutable pointer to the slice's buffer. /// @@ -651,7 +651,7 @@ pub trait SliceExt { /// assert!(dst == [3, 4, 5]); /// ``` #[unstable(feature = "collections")] - fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone; + fn clone_from_slice(&mut self, &[Self::Item]) -> usize where Self::Item: Clone; /// Sorts the slice, in place. /// @@ -692,12 +692,12 @@ pub trait SliceExt { /// assert!(match r { Ok(1...4) => true, _ => false, }); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn binary_search(&self, x: &Self::Item) -> Result where Self::Item: Ord; + fn binary_search(&self, x: &Self::Item) -> Result where Self::Item: Ord; /// Deprecated: use `binary_search` instead. #[unstable(feature = "collections")] #[deprecated(since = "1.0.0", reason = "use binary_search instead")] - fn binary_search_elem(&self, x: &Self::Item) -> Result where Self::Item: Ord { + fn binary_search_elem(&self, x: &Self::Item) -> Result where Self::Item: Ord { self.binary_search(x) } @@ -743,11 +743,11 @@ pub trait SliceExt { /// Find the first index containing a matching value. #[unstable(feature = "collections")] - fn position_elem(&self, t: &Self::Item) -> Option where Self::Item: PartialEq; + fn position_elem(&self, t: &Self::Item) -> Option where Self::Item: PartialEq; /// Find the last index containing a matching value. #[unstable(feature = "collections")] - fn rposition_elem(&self, t: &Self::Item) -> Option where Self::Item: PartialEq; + fn rposition_elem(&self, t: &Self::Item) -> Option where Self::Item: PartialEq; /// Returns true if the slice contains an element with the given value. /// @@ -804,7 +804,7 @@ impl SliceExt for [T] { } #[inline] - fn move_from(&mut self, mut src: Vec, start: uint, end: uint) -> uint { + fn move_from(&mut self, mut src: Vec, start: usize, end: usize) -> usize { for (a, b) in self.iter_mut().zip(src[start .. end].iter_mut()) { mem::swap(a, b); } @@ -812,22 +812,22 @@ impl SliceExt for [T] { } #[inline] - fn slice<'a>(&'a self, start: uint, end: uint) -> &'a [T] { + fn slice<'a>(&'a self, start: usize, end: usize) -> &'a [T] { &self[start .. end] } #[inline] - fn slice_from<'a>(&'a self, start: uint) -> &'a [T] { + fn slice_from<'a>(&'a self, start: usize) -> &'a [T] { &self[start ..] } #[inline] - fn slice_to<'a>(&'a self, end: uint) -> &'a [T] { + fn slice_to<'a>(&'a self, end: usize) -> &'a [T] { &self[.. end] } #[inline] - fn split_at<'a>(&'a self, mid: uint) -> (&'a [T], &'a [T]) { + fn split_at<'a>(&'a self, mid: usize) -> (&'a [T], &'a [T]) { core_slice::SliceExt::split_at(self, mid) } @@ -843,29 +843,29 @@ impl SliceExt for [T] { } #[inline] - fn splitn(&self, n: uint, pred: F) -> SplitN + fn splitn(&self, n: usize, pred: F) -> SplitN where F: FnMut(&T) -> bool { core_slice::SliceExt::splitn(self, n, pred) } #[inline] - fn rsplitn(&self, n: uint, pred: F) -> RSplitN + fn rsplitn(&self, n: usize, pred: F) -> RSplitN where F: FnMut(&T) -> bool { core_slice::SliceExt::rsplitn(self, n, pred) } #[inline] - fn windows<'a>(&'a self, size: uint) -> Windows<'a, T> { + fn windows<'a>(&'a self, size: usize) -> Windows<'a, T> { core_slice::SliceExt::windows(self, size) } #[inline] - fn chunks<'a>(&'a self, size: uint) -> Chunks<'a, T> { + fn chunks<'a>(&'a self, size: usize) -> Chunks<'a, T> { core_slice::SliceExt::chunks(self, size) } #[inline] - fn get<'a>(&'a self, index: uint) -> Option<&'a T> { + fn get<'a>(&'a self, index: usize) -> Option<&'a T> { core_slice::SliceExt::get(self, index) } @@ -890,7 +890,7 @@ impl SliceExt for [T] { } #[inline] - unsafe fn get_unchecked<'a>(&'a self, index: uint) -> &'a T { + unsafe fn get_unchecked<'a>(&'a self, index: usize) -> &'a T { core_slice::SliceExt::get_unchecked(self, index) } @@ -900,13 +900,13 @@ impl SliceExt for [T] { } #[inline] - fn binary_search_by(&self, f: F) -> Result + fn binary_search_by(&self, f: F) -> Result where F: FnMut(&T) -> Ordering { core_slice::SliceExt::binary_search_by(self, f) } #[inline] - fn len(&self) -> uint { + fn len(&self) -> usize { core_slice::SliceExt::len(self) } @@ -916,7 +916,7 @@ impl SliceExt for [T] { } #[inline] - fn get_mut<'a>(&'a mut self, index: uint) -> Option<&'a mut T> { + fn get_mut<'a>(&'a mut self, index: usize) -> Option<&'a mut T> { core_slice::SliceExt::get_mut(self, index) } @@ -926,17 +926,17 @@ impl SliceExt for [T] { } #[inline] - fn slice_mut<'a>(&'a mut self, start: uint, end: uint) -> &'a mut [T] { + fn slice_mut<'a>(&'a mut self, start: usize, end: usize) -> &'a mut [T] { &mut self[start .. end] } #[inline] - fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T] { + fn slice_from_mut<'a>(&'a mut self, start: usize) -> &'a mut [T] { &mut self[start ..] } #[inline] - fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T] { + fn slice_to_mut<'a>(&'a mut self, end: usize) -> &'a mut [T] { &mut self[.. end] } @@ -972,29 +972,29 @@ impl SliceExt for [T] { } #[inline] - fn splitn_mut(&mut self, n: uint, pred: F) -> SplitNMut + fn splitn_mut(&mut self, n: usize, pred: F) -> SplitNMut where F: FnMut(&T) -> bool { core_slice::SliceExt::splitn_mut(self, n, pred) } #[inline] - fn rsplitn_mut(&mut self, n: uint, pred: F) -> RSplitNMut + fn rsplitn_mut(&mut self, n: usize, pred: F) -> RSplitNMut where F: FnMut(&T) -> bool { core_slice::SliceExt::rsplitn_mut(self, n, pred) } #[inline] - fn chunks_mut<'a>(&'a mut self, chunk_size: uint) -> ChunksMut<'a, T> { + fn chunks_mut<'a>(&'a mut self, chunk_size: usize) -> ChunksMut<'a, T> { core_slice::SliceExt::chunks_mut(self, chunk_size) } #[inline] - fn swap(&mut self, a: uint, b: uint) { + fn swap(&mut self, a: usize, b: usize) { core_slice::SliceExt::swap(self, a, b) } #[inline] - fn split_at_mut<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) { + fn split_at_mut<'a>(&'a mut self, mid: usize) -> (&'a mut [T], &'a mut [T]) { core_slice::SliceExt::split_at_mut(self, mid) } @@ -1004,7 +1004,7 @@ impl SliceExt for [T] { } #[inline] - unsafe fn get_unchecked_mut<'a>(&'a mut self, index: uint) -> &'a mut T { + unsafe fn get_unchecked_mut<'a>(&'a mut self, index: usize) -> &'a mut T { core_slice::SliceExt::get_unchecked_mut(self, index) } @@ -1029,7 +1029,7 @@ impl SliceExt for [T] { } } - fn clone_from_slice(&mut self, src: &[T]) -> uint where T: Clone { + fn clone_from_slice(&mut self, src: &[T]) -> usize where T: Clone { core_slice::SliceExt::clone_from_slice(self, src) } @@ -1038,7 +1038,7 @@ impl SliceExt for [T] { self.sort_by(|a, b| a.cmp(b)) } - fn binary_search(&self, x: &T) -> Result where T: Ord { + fn binary_search(&self, x: &T) -> Result where T: Ord { core_slice::SliceExt::binary_search(self, x) } @@ -1050,11 +1050,11 @@ impl SliceExt for [T] { core_slice::SliceExt::prev_permutation(self) } - fn position_elem(&self, t: &T) -> Option where T: PartialEq { + fn position_elem(&self, t: &T) -> Option where T: PartialEq { core_slice::SliceExt::position_elem(self, t) } - fn rposition_elem(&self, t: &T) -> Option where T: PartialEq { + fn rposition_elem(&self, t: &T) -> Option where T: PartialEq { core_slice::SliceExt::rposition_elem(self, t) } @@ -1153,13 +1153,13 @@ pub struct ElementSwaps { /// If `true`, emit the last swap that returns the sequence to initial /// state. emit_reset: bool, - swaps_made : uint, + swaps_made : usize, } impl ElementSwaps { /// Creates an `ElementSwaps` iterator for a sequence of `length` elements. #[unstable(feature = "collections")] - pub fn new(length: uint) -> ElementSwaps { + pub fn new(length: usize) -> ElementSwaps { // Initialize `sdir` with a direction that position should move in // (all negative at the beginning) and the `size` of the // element (equal to the original index). @@ -1200,17 +1200,17 @@ enum Direction { Pos, Neg } /// An `Index` and `Direction` together. #[derive(Copy, Clone)] struct SizeDirection { - size: uint, + size: usize, dir: Direction, } #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for ElementSwaps { - type Item = (uint, uint); + type Item = (usize, usize); #[inline] - fn next(&mut self) -> Option<(uint, uint)> { - fn new_pos(i: uint, s: Direction) -> uint { + fn next(&mut self) -> Option<(usize, usize)> { + fn new_pos(i: usize, s: Direction) -> usize { i + match s { Pos => 1, Neg => -1 } } @@ -1252,7 +1252,7 @@ impl Iterator for ElementSwaps { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { // For a vector of size n, there are exactly n! permutations. let n = (2..self.sdir.len() + 1).product(); (n - self.swaps_made, Some(n - self.swaps_made)) @@ -1291,7 +1291,7 @@ impl Iterator for Permutations { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { self.swaps.size_hint() } } @@ -1332,7 +1332,7 @@ fn insertion_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> O let tmp = ptr::read(read_ptr); ptr::copy_memory(buf_v.offset(j + 1), &*buf_v.offset(j), - (i - j) as uint); + (i - j) as usize); ptr::copy_nonoverlapping_memory(buf_v.offset(j), &tmp, 1); @@ -1344,8 +1344,8 @@ fn insertion_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> O fn merge_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Ordering { // warning: this wildly uses unsafe. - static BASE_INSERTION: uint = 32; - static LARGE_INSERTION: uint = 16; + static BASE_INSERTION: usize = 32; + static LARGE_INSERTION: usize = 16; // FIXME #12092: smaller insertion runs seems to make sorting // vectors of large elements a little faster on some platforms, @@ -1410,7 +1410,7 @@ fn merge_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order // `.offset(j)` is always in bounds. ptr::copy_memory(buf_dat.offset(j + 1), &*buf_dat.offset(j), - i - j as uint); + i - j as usize); ptr::copy_nonoverlapping_memory(buf_dat.offset(j), read_ptr, 1); } } @@ -1458,11 +1458,11 @@ fn merge_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order // case). if left == right_start { // the number remaining in this run. - let elems = (right_end as uint - right as uint) / mem::size_of::(); + let elems = (right_end as usize - right as usize) / mem::size_of::(); ptr::copy_nonoverlapping_memory(out, &*right, elems); break; } else if right == right_end { - let elems = (right_start as uint - left as uint) / mem::size_of::(); + let elems = (right_start as usize - left as usize) / mem::size_of::(); ptr::copy_nonoverlapping_memory(out, &*left, elems); break; } @@ -1506,7 +1506,7 @@ fn merge_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order #[cfg(test)] mod tests { use core::cmp::Ordering::{Greater, Less, Equal}; - use core::prelude::{Some, None, range, Clone}; + use core::prelude::{Some, None, Clone}; use core::prelude::{Iterator, IteratorExt}; use core::prelude::{AsSlice}; use core::prelude::Ord; @@ -1519,56 +1519,56 @@ mod tests { use vec::Vec; use super::{ElementSwaps, SliceConcatExt, SliceExt}; - fn square(n: uint) -> uint { n * n } + fn square(n: usize) -> usize { n * n } - fn is_odd(n: &uint) -> bool { *n % 2u == 1u } + fn is_odd(n: &usize) -> bool { *n % 2 == 1 } #[test] fn test_from_fn() { // Test on-stack from_fn. - let mut v = (0u..3).map(square).collect::>(); + let mut v: Vec<_> = (0..3).map(square).collect(); { let v = v; - assert_eq!(v.len(), 3u); - assert_eq!(v[0], 0u); - assert_eq!(v[1], 1u); - assert_eq!(v[2], 4u); + assert_eq!(v.len(), 3); + assert_eq!(v[0], 0); + assert_eq!(v[1], 1); + assert_eq!(v[2], 4); } // Test on-heap from_fn. - v = (0u..5).map(square).collect::>(); + v = (0..5).map(square).collect(); { let v = v; - assert_eq!(v.len(), 5u); - assert_eq!(v[0], 0u); - assert_eq!(v[1], 1u); - assert_eq!(v[2], 4u); - assert_eq!(v[3], 9u); - assert_eq!(v[4], 16u); + assert_eq!(v.len(), 5); + assert_eq!(v[0], 0); + assert_eq!(v[1], 1); + assert_eq!(v[2], 4); + assert_eq!(v[3], 9); + assert_eq!(v[4], 16); } } #[test] fn test_from_elem() { // Test on-stack from_elem. - let mut v = vec![10u, 10u]; + let mut v = vec![10, 10]; { let v = v; - assert_eq!(v.len(), 2u); - assert_eq!(v[0], 10u); - assert_eq!(v[1], 10u); + assert_eq!(v.len(), 2); + assert_eq!(v[0], 10); + assert_eq!(v[1], 10); } // Test on-heap from_elem. - v = vec![20u, 20u, 20u, 20u, 20u, 20u]; + v = vec![20; 6]; { - let v = v; - assert_eq!(v[0], 20u); - assert_eq!(v[1], 20u); - assert_eq!(v[2], 20u); - assert_eq!(v[3], 20u); - assert_eq!(v[4], 20u); - assert_eq!(v[5], 20u); + let v = v.as_slice(); + assert_eq!(v[0], 20); + assert_eq!(v[1], 20); + assert_eq!(v[2], 20); + assert_eq!(v[3], 20); + assert_eq!(v[4], 20); + assert_eq!(v[5], 20); } } @@ -1624,68 +1624,68 @@ mod tests { #[test] fn test_tail() { let mut a = vec![11]; - let b: &[int] = &[]; + let b: &[i32] = &[]; assert_eq!(a.tail(), b); a = vec![11, 12]; - let b: &[int] = &[12]; + let b: &[i32] = &[12]; assert_eq!(a.tail(), b); } #[test] fn test_tail_mut() { let mut a = vec![11]; - let b: &mut [int] = &mut []; + let b: &mut [i32] = &mut []; assert!(a.tail_mut() == b); a = vec![11, 12]; - let b: &mut [int] = &mut [12]; + let b: &mut [_] = &mut [12]; assert!(a.tail_mut() == b); } #[test] #[should_fail] fn test_tail_empty() { - let a: Vec = vec![]; + let a = Vec::::new(); a.tail(); } #[test] #[should_fail] fn test_tail_mut_empty() { - let mut a: Vec = vec![]; + let mut a = Vec::::new(); a.tail_mut(); } #[test] fn test_init() { let mut a = vec![11]; - let b: &[int] = &[]; + let b: &[i32] = &[]; assert_eq!(a.init(), b); a = vec![11, 12]; - let b: &[int] = &[11]; + let b: &[_] = &[11]; assert_eq!(a.init(), b); } #[test] fn test_init_mut() { let mut a = vec![11]; - let b: &mut [int] = &mut []; + let b: &mut [i32] = &mut []; assert!(a.init_mut() == b); a = vec![11, 12]; - let b: &mut [int] = &mut [11]; + let b: &mut [_] = &mut [11]; assert!(a.init_mut() == b); } #[test] #[should_fail] fn test_init_empty() { - let a: Vec = vec![]; + let a = Vec::::new(); a.init(); } #[test] #[should_fail] fn test_init_mut_empty() { - let mut a: Vec = vec![]; + let mut a = Vec::::new(); a.init_mut(); } @@ -1713,26 +1713,26 @@ mod tests { fn test_slice() { // Test fixed length vector. let vec_fixed = [1, 2, 3, 4]; - let v_a = vec_fixed[1u..vec_fixed.len()].to_vec(); - assert_eq!(v_a.len(), 3u); - let v_a = v_a; + let v_a = vec_fixed[1..vec_fixed.len()].to_vec(); + assert_eq!(v_a.len(), 3); + assert_eq!(v_a[0], 2); assert_eq!(v_a[1], 3); assert_eq!(v_a[2], 4); // Test on stack. let vec_stack: &[_] = &[1, 2, 3]; - let v_b = vec_stack[1u..3u].to_vec(); - assert_eq!(v_b.len(), 2u); - let v_b = v_b; + let v_b = vec_stack[1..3].to_vec(); + assert_eq!(v_b.len(), 2); + assert_eq!(v_b[0], 2); assert_eq!(v_b[1], 3); // Test `Box<[T]>` let vec_unique = vec![1, 2, 3, 4, 5, 6]; - let v_d = vec_unique[1u..6u].to_vec(); - assert_eq!(v_d.len(), 5u); - let v_d = v_d; + let v_d = vec_unique[1..6].to_vec(); + assert_eq!(v_d.len(), 5); + assert_eq!(v_d[0], 2); assert_eq!(v_d[1], 3); assert_eq!(v_d[2], 4); @@ -1742,21 +1742,21 @@ mod tests { #[test] fn test_slice_from() { - let vec: &[int] = &[1, 2, 3, 4]; + let vec: &[_] = &[1, 2, 3, 4]; assert_eq!(&vec[], vec); - let b: &[int] = &[3, 4]; + let b: &[_] = &[3, 4]; assert_eq!(&vec[2..], b); - let b: &[int] = &[]; + let b: &[_] = &[]; assert_eq!(&vec[4..], b); } #[test] fn test_slice_to() { - let vec: &[int] = &[1, 2, 3, 4]; + let vec: &[_] = &[1, 2, 3, 4]; assert_eq!(&vec[..4], vec); - let b: &[int] = &[1, 2]; + let b: &[_] = &[1, 2]; assert_eq!(&vec[..2], b); - let b: &[int] = &[]; + let b: &[_] = &[]; assert_eq!(&vec[..0], b); } @@ -1812,12 +1812,12 @@ mod tests { // Test on-stack push(). let mut v = vec![]; v.push(1); - assert_eq!(v.len(), 1u); + assert_eq!(v.len(), 1); assert_eq!(v[0], 1); // Test on-heap push(). v.push(2); - assert_eq!(v.len(), 2u); + assert_eq!(v.len(), 2); assert_eq!(v[0], 1); assert_eq!(v[1], 2); } @@ -1842,19 +1842,19 @@ mod tests { #[test] fn test_dedup() { - fn case(a: Vec, b: Vec) { + fn case(a: Vec, b: Vec) { let mut v = a; v.dedup(); assert_eq!(v, b); } case(vec![], vec![]); - case(vec![1u], vec![1]); - case(vec![1u,1], vec![1]); - case(vec![1u,2,3], vec![1,2,3]); - case(vec![1u,1,2,3], vec![1,2,3]); - case(vec![1u,2,2,3], vec![1,2,3]); - case(vec![1u,2,3,3], vec![1,2,3]); - case(vec![1u,1,2,2,2,3,3], vec![1,2,3]); + case(vec![1], vec![1]); + case(vec![1,1], vec![1]); + case(vec![1,2,3], vec![1,2,3]); + case(vec![1,1,2,3], vec![1,2,3]); + case(vec![1,2,2,3], vec![1,2,3]); + case(vec![1,2,3,3], vec![1,2,3]); + case(vec![1,1,2,2,2,3,3], vec![1,2,3]); } #[test] @@ -1887,9 +1887,9 @@ mod tests { #[test] fn test_retain() { - let mut v = vec![1u, 2, 3, 4, 5]; + let mut v = vec![1, 2, 3, 4, 5]; v.retain(is_odd); - assert_eq!(v, vec![1u, 3, 5]); + assert_eq!(v, vec![1, 3, 5]); } #[test] @@ -1964,56 +1964,56 @@ mod tests { #[test] fn test_lexicographic_permutations() { - let v : &mut[int] = &mut[1, 2, 3, 4, 5]; + let v : &mut[_] = &mut[1, 2, 3, 4, 5]; assert!(v.prev_permutation() == false); assert!(v.next_permutation()); - let b: &mut[int] = &mut[1, 2, 3, 5, 4]; + let b: &mut[_] = &mut[1, 2, 3, 5, 4]; assert!(v == b); assert!(v.prev_permutation()); - let b: &mut[int] = &mut[1, 2, 3, 4, 5]; + let b: &mut[_] = &mut[1, 2, 3, 4, 5]; assert!(v == b); assert!(v.next_permutation()); assert!(v.next_permutation()); - let b: &mut[int] = &mut[1, 2, 4, 3, 5]; + let b: &mut[_] = &mut[1, 2, 4, 3, 5]; assert!(v == b); assert!(v.next_permutation()); - let b: &mut[int] = &mut[1, 2, 4, 5, 3]; + let b: &mut[_] = &mut[1, 2, 4, 5, 3]; assert!(v == b); - let v : &mut[int] = &mut[1, 0, 0, 0]; + let v : &mut[_] = &mut[1, 0, 0, 0]; assert!(v.next_permutation() == false); assert!(v.prev_permutation()); - let b: &mut[int] = &mut[0, 1, 0, 0]; + let b: &mut[_] = &mut[0, 1, 0, 0]; assert!(v == b); assert!(v.prev_permutation()); - let b: &mut[int] = &mut[0, 0, 1, 0]; + let b: &mut[_] = &mut[0, 0, 1, 0]; assert!(v == b); assert!(v.prev_permutation()); - let b: &mut[int] = &mut[0, 0, 0, 1]; + let b: &mut[_] = &mut[0, 0, 0, 1]; assert!(v == b); assert!(v.prev_permutation() == false); } #[test] fn test_lexicographic_permutations_empty_and_short() { - let empty : &mut[int] = &mut[]; + let empty : &mut[i32] = &mut[]; assert!(empty.next_permutation() == false); - let b: &mut[int] = &mut[]; + let b: &mut[i32] = &mut[]; assert!(empty == b); assert!(empty.prev_permutation() == false); assert!(empty == b); - let one_elem : &mut[int] = &mut[4]; + let one_elem : &mut[_] = &mut[4]; assert!(one_elem.prev_permutation() == false); - let b: &mut[int] = &mut[4]; + let b: &mut[_] = &mut[4]; assert!(one_elem == b); assert!(one_elem.next_permutation() == false); assert!(one_elem == b); - let two_elem : &mut[int] = &mut[1, 2]; + let two_elem : &mut[_] = &mut[1, 2]; assert!(two_elem.prev_permutation() == false); - let b : &mut[int] = &mut[1, 2]; - let c : &mut[int] = &mut[2, 1]; + let b : &mut[_] = &mut[1, 2]; + let c : &mut[_] = &mut[2, 1]; assert!(two_elem == b); assert!(two_elem.next_permutation()); assert!(two_elem == c); @@ -2030,9 +2030,9 @@ mod tests { assert!([].position_elem(&1).is_none()); let v1 = vec![1, 2, 3, 3, 2, 5]; - assert_eq!(v1.position_elem(&1), Some(0u)); - assert_eq!(v1.position_elem(&2), Some(1u)); - assert_eq!(v1.position_elem(&5), Some(5u)); + assert_eq!(v1.position_elem(&1), Some(0)); + assert_eq!(v1.position_elem(&2), Some(1)); + assert_eq!(v1.position_elem(&5), Some(5)); assert!(v1.position_elem(&4).is_none()); } @@ -2083,24 +2083,23 @@ mod tests { #[test] fn test_reverse() { - let mut v: Vec = vec![10, 20]; + let mut v = vec![10, 20]; assert_eq!(v[0], 10); assert_eq!(v[1], 20); v.reverse(); assert_eq!(v[0], 20); assert_eq!(v[1], 10); - let mut v3: Vec = vec![]; + let mut v3 = Vec::::new(); v3.reverse(); assert!(v3.is_empty()); } #[test] fn test_sort() { - for len in 4u..25 { + for len in 4..25 { for _ in 0..100 { - let mut v = thread_rng().gen_iter::().take(len) - .collect::>(); + let mut v: Vec<_> = thread_rng().gen_iter::().take(len).collect(); let mut v1 = v.clone(); v.sort(); @@ -2115,10 +2114,10 @@ mod tests { } // shouldn't panic - let mut v: [uint; 0] = []; + let mut v: [i32; 0] = []; v.sort(); - let mut v = [0xDEADBEEFu]; + let mut v = [0xDEADBEEFu64]; v.sort(); assert!(v == [0xDEADBEEF]); } @@ -2126,7 +2125,7 @@ mod tests { #[test] fn test_sort_stability() { for len in 4..25 { - for _ in 0u..10 { + for _ in 0..10 { let mut counts = [0; 10]; // create a vector like [(6, 1), (5, 1), (6, 2), ...], @@ -2134,11 +2133,11 @@ mod tests { // the second item represents which occurrence of that // number this element is, i.e. the second elements // will occur in sorted order. - let mut v = (0..len).map(|_| { - let n = thread_rng().gen::() % 10; + let mut v: Vec<_> = (0..len).map(|_| { + let n = thread_rng().gen::() % 10; counts[n] += 1; (n, counts[n]) - }).collect::>(); + }).collect(); // only sort on the first element, so an unstable sort // may mix up the counts. @@ -2156,28 +2155,28 @@ mod tests { #[test] fn test_concat() { - let v: [Vec; 0] = []; - let c: Vec = v.concat(); + let v: [Vec; 0] = []; + let c = v.concat(); assert_eq!(c, []); - let d: Vec = [vec![1], vec![2,3]].concat(); + let d = [vec![1], vec![2,3]].concat(); assert_eq!(d, vec![1, 2, 3]); - let v: [&[int]; 2] = [&[1], &[2, 3]]; + let v: &[&[_]] = &[&[1], &[2, 3]]; assert_eq!(v.connect(&0), vec![1, 0, 2, 3]); - let v: [&[int]; 3] = [&[1], &[2], &[3]]; + let v: &[&[_]] = &[&[1], &[2], &[3]]; assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]); } #[test] fn test_connect() { - let v: [Vec; 0] = []; + let v: [Vec; 0] = []; assert_eq!(v.connect(&0), vec![]); assert_eq!([vec![1], vec![2, 3]].connect(&0), vec![1, 0, 2, 3]); assert_eq!([vec![1], vec![2], vec![3]].connect(&0), vec![1, 0, 2, 0, 3]); - let v: [&[int]; 2] = [&[1], &[2, 3]]; + let v: [&[_]; 2] = [&[1], &[2, 3]]; assert_eq!(v.connect(&0), vec![1, 0, 2, 3]); - let v: [&[int]; 3] = [&[1], &[2], &[3]]; + let v: [&[_]; 3] = [&[1], &[2], &[3]]; assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]); } @@ -2209,13 +2208,13 @@ mod tests { #[test] fn test_remove() { - let mut a = vec![1,2,3,4]; + let mut a = vec![1, 2, 3, 4]; assert_eq!(a.remove(2), 3); - assert_eq!(a, vec![1,2,4]); + assert_eq!(a, vec![1, 2, 4]); assert_eq!(a.remove(2), 4); - assert_eq!(a, vec![1,2]); + assert_eq!(a, vec![1, 2]); assert_eq!(a.remove(0), 1); assert_eq!(a, vec![2]); @@ -2234,19 +2233,16 @@ mod tests { #[test] fn test_capacity() { - let mut v = vec![0u64]; - v.reserve_exact(10u); - assert!(v.capacity() >= 11u); - let mut v = vec![0u32]; - v.reserve_exact(10u); - assert!(v.capacity() >= 11u); + let mut v = vec![0]; + v.reserve_exact(10); + assert!(v.capacity() >= 11); } #[test] fn test_slice_2() { let v = vec![1, 2, 3, 4, 5]; - let v = v.slice(1u, 3u); - assert_eq!(v.len(), 2u); + let v = v.slice(1, 3); + assert_eq!(v.len(), 2); assert_eq!(v[0], 2); assert_eq!(v[1], 3); } @@ -2256,7 +2252,7 @@ mod tests { fn test_permute_fail() { let v = [(box 0, Rc::new(0)), (box 0, Rc::new(0)), (box 0, Rc::new(0)), (box 0, Rc::new(0))]; - let mut i = 0u; + let mut i = 0; for _ in v.permutations() { if i == 2 { panic!() @@ -2267,15 +2263,15 @@ mod tests { #[test] fn test_total_ord() { - let c: &[int] = &[1, 2, 3]; + let c = &[1, 2, 3]; [1, 2, 3, 4][].cmp(c) == Greater; - let c: &[int] = &[1, 2, 3, 4]; + let c = &[1, 2, 3, 4]; [1, 2, 3][].cmp(c) == Less; - let c: &[int] = &[1, 2, 3, 6]; + let c = &[1, 2, 3, 6]; [1, 2, 3, 4][].cmp(c) == Equal; - let c: &[int] = &[1, 2, 3, 4, 5, 6]; + let c = &[1, 2, 3, 4, 5, 6]; [1, 2, 3, 4, 5, 5, 5, 5][].cmp(c) == Less; - let c: &[int] = &[1, 2, 3, 4]; + let c = &[1, 2, 3, 4]; [2, 2][].cmp(c) == Greater; } @@ -2387,76 +2383,76 @@ mod tests { #[test] fn test_move_iterator() { let xs = vec![1u,2,3,4,5]; - assert_eq!(xs.into_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345); + assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345); } #[test] fn test_move_rev_iterator() { let xs = vec![1u,2,3,4,5]; - assert_eq!(xs.into_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321); + assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321); } #[test] fn test_splitator() { let xs = &[1,2,3,4,5]; - let splits: &[&[int]] = &[&[1], &[3], &[5]]; - assert_eq!(xs.split(|x| *x % 2 == 0).collect::>(), + let splits: &[&[_]] = &[&[1], &[3], &[5]]; + assert_eq!(xs.split(|x| *x % 2 == 0).collect::>(), splits); - let splits: &[&[int]] = &[&[], &[2,3,4,5]]; - assert_eq!(xs.split(|x| *x == 1).collect::>(), + let splits: &[&[_]] = &[&[], &[2,3,4,5]]; + assert_eq!(xs.split(|x| *x == 1).collect::>(), splits); - let splits: &[&[int]] = &[&[1,2,3,4], &[]]; - assert_eq!(xs.split(|x| *x == 5).collect::>(), + let splits: &[&[_]] = &[&[1,2,3,4], &[]]; + assert_eq!(xs.split(|x| *x == 5).collect::>(), splits); - let splits: &[&[int]] = &[&[1,2,3,4,5]]; - assert_eq!(xs.split(|x| *x == 10).collect::>(), + let splits: &[&[_]] = &[&[1,2,3,4,5]]; + assert_eq!(xs.split(|x| *x == 10).collect::>(), splits); - let splits: &[&[int]] = &[&[], &[], &[], &[], &[], &[]]; - assert_eq!(xs.split(|_| true).collect::>(), + let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]]; + assert_eq!(xs.split(|_| true).collect::>(), splits); - let xs: &[int] = &[]; - let splits: &[&[int]] = &[&[]]; - assert_eq!(xs.split(|x| *x == 5).collect::>(), splits); + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.split(|x| *x == 5).collect::>(), splits); } #[test] fn test_splitnator() { let xs = &[1,2,3,4,5]; - let splits: &[&[int]] = &[&[1,2,3,4,5]]; - assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::>(), + let splits: &[&[_]] = &[&[1,2,3,4,5]]; + assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::>(), splits); - let splits: &[&[int]] = &[&[1], &[3,4,5]]; - assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::>(), + let splits: &[&[_]] = &[&[1], &[3,4,5]]; + assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::>(), splits); - let splits: &[&[int]] = &[&[], &[], &[], &[4,5]]; - assert_eq!(xs.splitn(3, |_| true).collect::>(), + let splits: &[&[_]] = &[&[], &[], &[], &[4,5]]; + assert_eq!(xs.splitn(3, |_| true).collect::>(), splits); - let xs: &[int] = &[]; - let splits: &[&[int]] = &[&[]]; - assert_eq!(xs.splitn(1, |x| *x == 5).collect::>(), splits); + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.splitn(1, |x| *x == 5).collect::>(), splits); } #[test] fn test_splitnator_mut() { let xs = &mut [1,2,3,4,5]; - let splits: &[&mut [int]] = &[&mut [1,2,3,4,5]]; - assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::>(), + let splits: &[&mut[_]] = &[&mut [1,2,3,4,5]]; + assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::>(), splits); - let splits: &[&mut [int]] = &[&mut [1], &mut [3,4,5]]; - assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::>(), + let splits: &[&mut[_]] = &[&mut [1], &mut [3,4,5]]; + assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::>(), splits); - let splits: &[&mut [int]] = &[&mut [], &mut [], &mut [], &mut [4,5]]; - assert_eq!(xs.splitn_mut(3, |_| true).collect::>(), + let splits: &[&mut[_]] = &[&mut [], &mut [], &mut [], &mut [4,5]]; + assert_eq!(xs.splitn_mut(3, |_| true).collect::>(), splits); - let xs: &mut [int] = &mut []; - let splits: &[&mut [int]] = &[&mut []]; - assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::>(), + let xs: &mut [i32] = &mut []; + let splits: &[&mut[i32]] = &[&mut []]; + assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::>(), splits); } @@ -2464,51 +2460,52 @@ mod tests { fn test_rsplitator() { let xs = &[1,2,3,4,5]; - let splits: &[&[int]] = &[&[5], &[3], &[1]]; - assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::>(), + let splits: &[&[_]] = &[&[5], &[3], &[1]]; + assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::>(), splits); - let splits: &[&[int]] = &[&[2,3,4,5], &[]]; - assert_eq!(xs.split(|x| *x == 1).rev().collect::>(), + let splits: &[&[_]] = &[&[2,3,4,5], &[]]; + assert_eq!(xs.split(|x| *x == 1).rev().collect::>(), splits); - let splits: &[&[int]] = &[&[], &[1,2,3,4]]; - assert_eq!(xs.split(|x| *x == 5).rev().collect::>(), + let splits: &[&[_]] = &[&[], &[1,2,3,4]]; + assert_eq!(xs.split(|x| *x == 5).rev().collect::>(), splits); - let splits: &[&[int]] = &[&[1,2,3,4,5]]; - assert_eq!(xs.split(|x| *x == 10).rev().collect::>(), + let splits: &[&[_]] = &[&[1,2,3,4,5]]; + assert_eq!(xs.split(|x| *x == 10).rev().collect::>(), splits); - let xs: &[int] = &[]; - let splits: &[&[int]] = &[&[]]; - assert_eq!(xs.split(|x| *x == 5).rev().collect::>(), splits); + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.split(|x| *x == 5).rev().collect::>(), splits); } #[test] fn test_rsplitnator() { let xs = &[1,2,3,4,5]; - let splits: &[&[int]] = &[&[1,2,3,4,5]]; - assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::>(), + let splits: &[&[_]] = &[&[1,2,3,4,5]]; + assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::>(), splits); - let splits: &[&[int]] = &[&[5], &[1,2,3]]; - assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::>(), + let splits: &[&[_]] = &[&[5], &[1,2,3]]; + assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::>(), splits); - let splits: &[&[int]] = &[&[], &[], &[], &[1,2]]; - assert_eq!(xs.rsplitn(3, |_| true).collect::>(), + let splits: &[&[_]] = &[&[], &[], &[], &[1,2]]; + assert_eq!(xs.rsplitn(3, |_| true).collect::>(), splits); - let xs: &[int] = &[]; - let splits: &[&[int]] = &[&[]]; - assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::>(), splits); + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::>(), splits); } #[test] fn test_windowsator() { let v = &[1,2,3,4]; - let wins: &[&[int]] = &[&[1,2], &[2,3], &[3,4]]; - assert_eq!(v.windows(2).collect::>(), wins); - let wins: &[&[int]] = &[&[1,2,3], &[2,3,4]]; - assert_eq!(v.windows(3).collect::>(), wins); + let wins: &[&[_]] = &[&[1,2], &[2,3], &[3,4]]; + assert_eq!(v.windows(2).collect::>(), wins); + + let wins: &[&[_]] = &[&[1,2,3], &[2,3,4]]; + assert_eq!(v.windows(3).collect::>(), wins); assert!(v.windows(6).next().is_none()); } @@ -2527,22 +2524,23 @@ mod tests { assert_eq!(v.chunks(2).len(), 3); - let chunks: &[&[int]] = &[&[1,2], &[3,4], &[5]]; - assert_eq!(v.chunks(2).collect::>(), chunks); - let chunks: &[&[int]] = &[&[1,2,3], &[4,5]]; - assert_eq!(v.chunks(3).collect::>(), chunks); - let chunks: &[&[int]] = &[&[1,2,3,4,5]]; - assert_eq!(v.chunks(6).collect::>(), chunks); + let chunks: &[&[_]] = &[&[1,2], &[3,4], &[5]]; + assert_eq!(v.chunks(2).collect::>(), chunks); + let chunks: &[&[_]] = &[&[1,2,3], &[4,5]]; + assert_eq!(v.chunks(3).collect::>(), chunks); + let chunks: &[&[_]] = &[&[1,2,3,4,5]]; + assert_eq!(v.chunks(6).collect::>(), chunks); - let chunks: &[&[int]] = &[&[5], &[3,4], &[1,2]]; - assert_eq!(v.chunks(2).rev().collect::>(), chunks); + let chunks: &[&[_]] = &[&[5], &[3,4], &[1,2]]; + assert_eq!(v.chunks(2).rev().collect::>(), chunks); let mut it = v.chunks(2); assert_eq!(it.indexable(), 3); - let chunk: &[int] = &[1,2]; + + let chunk: &[_] = &[1,2]; assert_eq!(it.idx(0).unwrap(), chunk); - let chunk: &[int] = &[3,4]; + let chunk: &[_] = &[3,4]; assert_eq!(it.idx(1).unwrap(), chunk); - let chunk: &[int] = &[5]; + let chunk: &[_] = &[5]; assert_eq!(it.idx(2).unwrap(), chunk); assert_eq!(it.idx(3), None); } @@ -2590,20 +2588,20 @@ mod tests { assert_eq!(format!("{:?}", x), x_str); }) } - let empty: Vec = vec![]; + let empty = Vec::::new(); test_show_vec!(empty, "[]"); test_show_vec!(vec![1], "[1]"); test_show_vec!(vec![1, 2, 3], "[1, 2, 3]"); test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]], "[[], [1], [1, 1]]"); - let empty_mut: &mut [int] = &mut[]; + let empty_mut: &mut [i32] = &mut[]; test_show_vec!(empty_mut, "[]"); - let v: &mut[int] = &mut[1]; + let v = &mut[1]; test_show_vec!(v, "[1]"); - let v: &mut[int] = &mut[1, 2, 3]; + let v = &mut[1, 2, 3]; test_show_vec!(v, "[1, 2, 3]"); - let v: &mut [&mut[uint]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]]; + let v: &mut[&mut[_]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]]; test_show_vec!(v, "[[], [1], [1, 1]]"); } @@ -2616,8 +2614,8 @@ mod tests { }} } - t!(&[int]); - t!(Vec); + t!(&[i32]); + t!(Vec); } #[test] @@ -2829,15 +2827,15 @@ mod tests { let h = x.last_mut(); assert_eq!(*h.unwrap(), 5); - let y: &mut [int] = &mut []; + let y: &mut [i32] = &mut []; assert!(y.last_mut().is_none()); } #[test] fn test_to_vec() { - let xs = box [1u, 2, 3]; + let xs = box [1, 2, 3]; let ys = xs.to_vec(); - assert_eq!(ys, [1u, 2, 3]); + assert_eq!(ys, [1, 2, 3]); } } @@ -2854,7 +2852,7 @@ mod bench { fn iterator(b: &mut Bencher) { // peculiar numbers to stop LLVM from optimising the summation // out. - let v = (0u..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect::>(); + let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect(); b.iter(|| { let mut sum = 0; @@ -2868,7 +2866,7 @@ mod bench { #[bench] fn mut_iterator(b: &mut Bencher) { - let mut v = repeat(0).take(100).collect::>(); + let mut v: Vec<_> = repeat(0).take(100).collect(); b.iter(|| { let mut i = 0; @@ -2881,8 +2879,8 @@ mod bench { #[bench] fn concat(b: &mut Bencher) { - let xss: Vec> = - (0..100u).map(|i| (0..i).collect()).collect(); + let xss: Vec> = + (0..100).map(|i| (0..i).collect()).collect(); b.iter(|| { xss.concat(); }); @@ -2890,8 +2888,8 @@ mod bench { #[bench] fn connect(b: &mut Bencher) { - let xss: Vec> = - (0..100u).map(|i| (0..i).collect()).collect(); + let xss: Vec> = + (0..100).map(|i| (0..i).collect()).collect(); b.iter(|| { xss.connect(&0) }); @@ -2899,7 +2897,7 @@ mod bench { #[bench] fn push(b: &mut Bencher) { - let mut vec: Vec = vec![]; + let mut vec = Vec::::new(); b.iter(|| { vec.push(0); black_box(&vec); @@ -2908,7 +2906,7 @@ mod bench { #[bench] fn starts_with_same_vector(b: &mut Bencher) { - let vec: Vec = (0u..100).collect(); + let vec: Vec<_> = (0..100).collect(); b.iter(|| { vec.starts_with(&vec) }) @@ -2916,7 +2914,7 @@ mod bench { #[bench] fn starts_with_single_element(b: &mut Bencher) { - let vec: Vec = vec![0]; + let vec: Vec<_> = vec![0]; b.iter(|| { vec.starts_with(&vec) }) @@ -2924,8 +2922,8 @@ mod bench { #[bench] fn starts_with_diff_one_element_at_end(b: &mut Bencher) { - let vec: Vec = (0u..100).collect(); - let mut match_vec: Vec = (0u..99).collect(); + let vec: Vec<_> = (0..100).collect(); + let mut match_vec: Vec<_> = (0..99).collect(); match_vec.push(0); b.iter(|| { vec.starts_with(&match_vec) @@ -2934,7 +2932,7 @@ mod bench { #[bench] fn ends_with_same_vector(b: &mut Bencher) { - let vec: Vec = (0u..100).collect(); + let vec: Vec<_> = (0..100).collect(); b.iter(|| { vec.ends_with(&vec) }) @@ -2942,7 +2940,7 @@ mod bench { #[bench] fn ends_with_single_element(b: &mut Bencher) { - let vec: Vec = vec![0]; + let vec: Vec<_> = vec![0]; b.iter(|| { vec.ends_with(&vec) }) @@ -2950,8 +2948,8 @@ mod bench { #[bench] fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) { - let vec: Vec = (0u..100).collect(); - let mut match_vec: Vec = (0u..100).collect(); + let vec: Vec<_> = (0..100).collect(); + let mut match_vec: Vec<_> = (0..100).collect(); match_vec[0] = 200; b.iter(|| { vec.starts_with(&match_vec) @@ -2960,9 +2958,9 @@ mod bench { #[bench] fn contains_last_element(b: &mut Bencher) { - let vec: Vec = (0u..100).collect(); + let vec: Vec<_> = (0..100).collect(); b.iter(|| { - vec.contains(&99u) + vec.contains(&99) }) } @@ -2976,7 +2974,7 @@ mod bench { #[bench] fn zero_1kb_set_memory(b: &mut Bencher) { b.iter(|| { - let mut v: Vec = Vec::with_capacity(1024); + let mut v = Vec::::with_capacity(1024); unsafe { let vp = v.as_mut_ptr(); ptr::set_memory(vp, 0, 1024); @@ -2989,11 +2987,11 @@ mod bench { #[bench] fn zero_1kb_loop_set(b: &mut Bencher) { b.iter(|| { - let mut v: Vec = Vec::with_capacity(1024); + let mut v = Vec::::with_capacity(1024); unsafe { v.set_len(1024); } - for i in 0u..1024 { + for i in 0..1024 { v[i] = 0; } }); @@ -3002,7 +3000,7 @@ mod bench { #[bench] fn zero_1kb_mut_iter(b: &mut Bencher) { b.iter(|| { - let mut v = Vec::with_capacity(1024); + let mut v = Vec::::with_capacity(1024); unsafe { v.set_len(1024); } @@ -3017,10 +3015,10 @@ mod bench { fn random_inserts(b: &mut Bencher) { let mut rng = weak_rng(); b.iter(|| { - let mut v = repeat((0u, 0u)).take(30).collect::>(); + let mut v: Vec<_> = repeat((0, 0)).take(30).collect(); for _ in 0u..100 { let l = v.len(); - v.insert(rng.gen::() % (l + 1), + v.insert(rng.gen::() % (l + 1), (1, 1)); } }) @@ -3029,10 +3027,10 @@ mod bench { fn random_removes(b: &mut Bencher) { let mut rng = weak_rng(); b.iter(|| { - let mut v = repeat((0u, 0u)).take(130).collect::>(); + let mut v: Vec<_> = repeat((0, 0)).take(130).collect(); for _ in 0u..100 { let l = v.len(); - v.remove(rng.gen::() % l); + v.remove(rng.gen::() % l); } }) } @@ -3041,7 +3039,7 @@ mod bench { fn sort_random_small(b: &mut Bencher) { let mut rng = weak_rng(); b.iter(|| { - let mut v = rng.gen_iter::().take(5).collect::>(); + let mut v: Vec<_> = rng.gen_iter::().take(5).collect(); v.sort(); }); b.bytes = 5 * mem::size_of::() as u64; @@ -3051,7 +3049,7 @@ mod bench { fn sort_random_medium(b: &mut Bencher) { let mut rng = weak_rng(); b.iter(|| { - let mut v = rng.gen_iter::().take(100).collect::>(); + let mut v: Vec<_> = rng.gen_iter::().take(100).collect(); v.sort(); }); b.bytes = 100 * mem::size_of::() as u64; @@ -3061,7 +3059,7 @@ mod bench { fn sort_random_large(b: &mut Bencher) { let mut rng = weak_rng(); b.iter(|| { - let mut v = rng.gen_iter::().take(10000).collect::>(); + let mut v: Vec<_> = rng.gen_iter::().take(10000).collect(); v.sort(); }); b.bytes = 10000 * mem::size_of::() as u64; @@ -3069,14 +3067,14 @@ mod bench { #[bench] fn sort_sorted(b: &mut Bencher) { - let mut v = (0u..10000).collect::>(); + let mut v: Vec<_> = (0..10000).collect(); b.iter(|| { v.sort(); }); b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64; } - type BigSortable = (u64,u64,u64,u64); + type BigSortable = (u64, u64, u64, u64); #[bench] fn sort_big_random_small(b: &mut Bencher) { @@ -3113,7 +3111,7 @@ mod bench { #[bench] fn sort_big_sorted(b: &mut Bencher) { - let mut v = (0..10000u).map(|i| (i, i, i, i)).collect::>(); + let mut v: Vec = (0..10000).map(|i| (i, i, i, i)).collect(); b.iter(|| { v.sort(); }); diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 336d9fcf5da1e..e6fb3005ff38c 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -241,7 +241,7 @@ impl<'a> Iterator for Decompositions<'a> { } } - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { let (lower, _) = self.iter.size_hint(); (lower, None) } @@ -367,7 +367,7 @@ impl<'a> Iterator for Utf16Units<'a> { fn next(&mut self) -> Option { self.encoder.next() } #[inline] - fn size_hint(&self) -> (uint, Option) { self.encoder.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.encoder.size_hint() } } /* @@ -629,7 +629,7 @@ pub trait StrExt: Index { /// assert_eq!(v, vec![""]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn splitn(&self, count: uint, pat: P) -> SplitN

{ + fn splitn(&self, count: usize, pat: P) -> SplitN

{ core_str::StrExt::splitn(&self[], count, pat) } @@ -679,7 +679,7 @@ pub trait StrExt: Index { /// assert_eq!(v, vec!["leopard", "tiger", "lionX"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn rsplitn(&self, count: uint, pat: P) -> RSplitN

{ + fn rsplitn(&self, count: usize, pat: P) -> RSplitN

{ core_str::StrExt::rsplitn(&self[], count, pat) } @@ -694,13 +694,13 @@ pub trait StrExt: Index { /// # Example /// /// ```rust - /// let v: Vec<(uint, uint)> = "abcXXXabcYYYabc".match_indices("abc").collect(); + /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); /// assert_eq!(v, vec![(0,3), (6,9), (12,15)]); /// - /// let v: Vec<(uint, uint)> = "1abcabc2".match_indices("abc").collect(); + /// let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); /// assert_eq!(v, vec![(1,4), (4,7)]); /// - /// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect(); + /// let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); /// assert_eq!(v, vec![(0, 3)]); // only the first `aba` /// ``` #[unstable(feature = "collections", @@ -762,19 +762,19 @@ pub trait StrExt: Index { #[unstable(feature = "collections", reason = "use slice notation [a..b] instead")] #[deprecated(since = "1.0.0", reason = "use slice notation [a..b] instead")] - fn slice(&self, begin: uint, end: uint) -> &str; + fn slice(&self, begin: usize, end: usize) -> &str; /// Deprecated: use `s[a..]` instead. #[unstable(feature = "collections", reason = "use slice notation [a..b] instead")] #[deprecated(since = "1.0.0", reason = "use slice notation [a..] instead")] - fn slice_from(&self, begin: uint) -> &str; + fn slice_from(&self, begin: usize) -> &str; /// Deprecated: use `s[..a]` instead. #[unstable(feature = "collections", reason = "use slice notation [a..b] instead")] #[deprecated(since = "1.0.0", reason = "use slice notation [..a] instead")] - fn slice_to(&self, end: uint) -> &str; + fn slice_to(&self, end: usize) -> &str; /// Returns a slice of the string from the character range /// [`begin`..`end`). @@ -801,7 +801,7 @@ pub trait StrExt: Index { /// ``` #[unstable(feature = "collections", reason = "may have yet to prove its worth")] - fn slice_chars(&self, begin: uint, end: uint) -> &str { + fn slice_chars(&self, begin: usize, end: usize) -> &str { core_str::StrExt::slice_chars(&self[], begin, end) } @@ -812,7 +812,7 @@ pub trait StrExt: Index { /// Caller must check both UTF-8 character boundaries and the boundaries of /// the entire slice as well. #[stable(feature = "rust1", since = "1.0.0")] - unsafe fn slice_unchecked(&self, begin: uint, end: uint) -> &str { + unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str { core_str::StrExt::slice_unchecked(&self[], begin, end) } @@ -925,7 +925,7 @@ pub trait StrExt: Index { /// ``` #[unstable(feature = "collections", reason = "naming is uncertain with container conventions")] - fn is_char_boundary(&self, index: uint) -> bool { + fn is_char_boundary(&self, index: usize) -> bool { core_str::StrExt::is_char_boundary(&self[], index) } @@ -945,7 +945,7 @@ pub trait StrExt: Index { /// use std::str::CharRange; /// /// let s = "中华Việt Nam"; - /// let mut i = 0u; + /// let mut i = 0; /// while i < s.len() { /// let CharRange {ch, next} = s.char_range_at(i); /// println!("{}: {}", i, ch); @@ -975,7 +975,7 @@ pub trait StrExt: Index { /// /// # Return value /// - /// A record {ch: char, next: uint} containing the char value and the byte + /// A record {ch: char, next: usize} containing the char value and the byte /// index of the next Unicode character. /// /// # Panics @@ -984,7 +984,7 @@ pub trait StrExt: Index { /// If `i` is not the index of the beginning of a valid UTF-8 character. #[unstable(feature = "collections", reason = "naming is uncertain with container conventions")] - fn char_range_at(&self, start: uint) -> CharRange { + fn char_range_at(&self, start: usize) -> CharRange { core_str::StrExt::char_range_at(&self[], start) } @@ -1000,7 +1000,7 @@ pub trait StrExt: Index { /// If `i` is not an index following a valid UTF-8 character. #[unstable(feature = "collections", reason = "naming is uncertain with container conventions")] - fn char_range_at_reverse(&self, start: uint) -> CharRange { + fn char_range_at_reverse(&self, start: usize) -> CharRange { core_str::StrExt::char_range_at_reverse(&self[], start) } @@ -1021,7 +1021,7 @@ pub trait StrExt: Index { /// If `i` is not the index of the beginning of a valid UTF-8 character. #[unstable(feature = "collections", reason = "naming is uncertain with container conventions")] - fn char_at(&self, i: uint) -> char { + fn char_at(&self, i: usize) -> char { core_str::StrExt::char_at(&self[], i) } @@ -1033,7 +1033,7 @@ pub trait StrExt: Index { /// If `i` is not an index following a valid UTF-8 character. #[unstable(feature = "collections", reason = "naming is uncertain with container conventions")] - fn char_at_reverse(&self, i: uint) -> char { + fn char_at_reverse(&self, i: usize) -> char { core_str::StrExt::char_at_reverse(&self[], i) } @@ -1073,7 +1073,7 @@ pub trait StrExt: Index { /// assert_eq!(s.find(x), None); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn find(&self, pat: P) -> Option { + fn find(&self, pat: P) -> Option { core_str::StrExt::find(&self[], pat) } @@ -1101,7 +1101,7 @@ pub trait StrExt: Index { /// assert_eq!(s.rfind(x), None); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - fn rfind(&self, pat: P) -> Option { + fn rfind(&self, pat: P) -> Option { core_str::StrExt::rfind(&self[], pat) } @@ -1126,7 +1126,7 @@ pub trait StrExt: Index { /// ``` #[unstable(feature = "collections", reason = "might get removed in favor of a more generic find in the future")] - fn find_str(&self, needle: &str) -> Option { + fn find_str(&self, needle: &str) -> Option { core_str::StrExt::find_str(&self[], needle) } @@ -1170,7 +1170,7 @@ pub trait StrExt: Index { /// ``` #[unstable(feature = "collections", reason = "awaiting convention about comparability of arbitrary slices")] - fn subslice_offset(&self, inner: &str) -> uint { + fn subslice_offset(&self, inner: &str) -> usize { core_str::StrExt::subslice_offset(&self[], inner) } @@ -1202,7 +1202,7 @@ pub trait StrExt: Index { /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] - fn len(&self) -> uint { + fn len(&self) -> usize { core_str::StrExt::len(&self[]) } @@ -1264,8 +1264,8 @@ pub trait StrExt: Index { /// # Example /// /// ```rust - /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::>(); - /// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; + /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::>(); + /// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; /// assert_eq!(gr_inds.as_slice(), b); /// ``` #[unstable(feature = "collections", @@ -1301,7 +1301,7 @@ pub trait StrExt: Index { /// `is_cjk` = `false`) if the locale is unknown. #[unstable(feature = "collections", reason = "this functionality may only be provided by libunicode")] - fn width(&self, is_cjk: bool) -> uint { + fn width(&self, is_cjk: bool) -> usize { UnicodeStr::width(&self[], is_cjk) } @@ -1326,15 +1326,15 @@ pub trait StrExt: Index { #[stable(feature = "rust1", since = "1.0.0")] impl StrExt for str { - fn slice(&self, begin: uint, end: uint) -> &str { + fn slice(&self, begin: usize, end: usize) -> &str { &self[begin..end] } - fn slice_from(&self, begin: uint) -> &str { + fn slice_from(&self, begin: usize) -> &str { &self[begin..] } - fn slice_to(&self, end: uint) -> &str { + fn slice_to(&self, end: usize) -> &str { &self[..end] } } @@ -1357,51 +1357,51 @@ mod tests { #[test] fn test_len() { - assert_eq!("".len(), 0u); - assert_eq!("hello world".len(), 11u); - assert_eq!("\x63".len(), 1u); - assert_eq!("\u{a2}".len(), 2u); - assert_eq!("\u{3c0}".len(), 2u); - assert_eq!("\u{2620}".len(), 3u); - assert_eq!("\u{1d11e}".len(), 4u); - - 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); - assert_eq!("\0\0\0\0\0".width(false), 0u); - assert_eq!("\0\0\0\0\0".width(true), 0u); - assert_eq!("".width(false), 0u); - assert_eq!("".width(true), 0u); - assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4u); - assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8u); + assert_eq!("".len(), 0); + assert_eq!("hello world".len(), 11); + assert_eq!("\x63".len(), 1); + assert_eq!("\u{a2}".len(), 2); + assert_eq!("\u{3c0}".len(), 2); + assert_eq!("\u{2620}".len(), 3); + assert_eq!("\u{1d11e}".len(), 4); + + assert_eq!("".chars().count(), 0); + assert_eq!("hello world".chars().count(), 11); + assert_eq!("\x63".chars().count(), 1); + assert_eq!("\u{a2}".chars().count(), 1); + assert_eq!("\u{3c0}".chars().count(), 1); + assert_eq!("\u{2620}".chars().count(), 1); + assert_eq!("\u{1d11e}".chars().count(), 1); + assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19); + + assert_eq!("ｈｅｌｌｏ".width(false), 10); + assert_eq!("ｈｅｌｌｏ".width(true), 10); + assert_eq!("\0\0\0\0\0".width(false), 0); + assert_eq!("\0\0\0\0\0".width(true), 0); + assert_eq!("".width(false), 0); + assert_eq!("".width(true), 0); + assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4); + assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8); } #[test] fn test_find() { - assert_eq!("hello".find('l'), Some(2u)); - assert_eq!("hello".find(|c:char| c == 'o'), Some(4u)); + assert_eq!("hello".find('l'), Some(2)); + assert_eq!("hello".find(|c:char| c == 'o'), Some(4)); assert!("hello".find('x').is_none()); assert!("hello".find(|c:char| c == 'x').is_none()); - assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30u)); - assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30u)); + assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30)); + assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30)); } #[test] fn test_rfind() { - assert_eq!("hello".rfind('l'), Some(3u)); - assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4u)); + assert_eq!("hello".rfind('l'), Some(3)); + assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4)); assert!("hello".rfind('x').is_none()); assert!("hello".rfind(|c:char| c == 'x').is_none()); - assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30u)); - assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30u)); + assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30)); + assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30)); } #[test] @@ -1424,37 +1424,37 @@ mod tests { #[test] fn test_find_str() { // byte positions - assert_eq!("".find_str(""), Some(0u)); + assert_eq!("".find_str(""), Some(0)); assert!("banana".find_str("apple pie").is_none()); let data = "abcabc"; - assert_eq!(data[0u..6u].find_str("ab"), Some(0u)); - assert_eq!(data[2u..6u].find_str("ab"), Some(3u - 2u)); - assert!(data[2u..4u].find_str("ab").is_none()); + assert_eq!(data[0..6].find_str("ab"), Some(0)); + assert_eq!(data[2..6].find_str("ab"), Some(3 - 2)); + assert!(data[2..4].find_str("ab").is_none()); let string = "ประเทศไทย中华Việt Nam"; let mut data = String::from_str(string); data.push_str(string); assert!(data.find_str("ไท华").is_none()); - assert_eq!(data[0u..43u].find_str(""), Some(0u)); - assert_eq!(data[6u..43u].find_str(""), Some(6u - 6u)); + assert_eq!(data[0..43].find_str(""), Some(0)); + assert_eq!(data[6..43].find_str(""), Some(6 - 6)); - assert_eq!(data[0u..43u].find_str("ประ"), Some( 0u)); - assert_eq!(data[0u..43u].find_str("ทศไ"), Some(12u)); - assert_eq!(data[0u..43u].find_str("ย中"), Some(24u)); - assert_eq!(data[0u..43u].find_str("iệt"), Some(34u)); - assert_eq!(data[0u..43u].find_str("Nam"), Some(40u)); + assert_eq!(data[0..43].find_str("ประ"), Some( 0)); + assert_eq!(data[0..43].find_str("ทศไ"), Some(12)); + assert_eq!(data[0..43].find_str("ย中"), Some(24)); + assert_eq!(data[0..43].find_str("iệt"), Some(34)); + assert_eq!(data[0..43].find_str("Nam"), Some(40)); - assert_eq!(data[43u..86u].find_str("ประ"), Some(43u - 43u)); - assert_eq!(data[43u..86u].find_str("ทศไ"), Some(55u - 43u)); - assert_eq!(data[43u..86u].find_str("ย中"), Some(67u - 43u)); - assert_eq!(data[43u..86u].find_str("iệt"), Some(77u - 43u)); - assert_eq!(data[43u..86u].find_str("Nam"), Some(83u - 43u)); + assert_eq!(data[43..86].find_str("ประ"), Some(43 - 43)); + assert_eq!(data[43..86].find_str("ทศไ"), Some(55 - 43)); + assert_eq!(data[43..86].find_str("ย中"), Some(67 - 43)); + assert_eq!(data[43..86].find_str("iệt"), Some(77 - 43)); + assert_eq!(data[43..86].find_str("Nam"), Some(83 - 43)); } #[test] fn test_slice_chars() { - fn t(a: &str, b: &str, start: uint) { + fn t(a: &str, b: &str, start: usize) { assert_eq!(a.slice_chars(start, start + b.chars().count()), b); } t("", "", 0); @@ -1527,7 +1527,7 @@ mod tests { 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 i = 0; let mut rs = String::new(); while i < 100000 { rs.push_str("aaaaaaaaaa"); @@ -1536,7 +1536,7 @@ mod tests { rs } fn half_a_million_letter_a() -> String { - let mut i = 0u; + let mut i = 0; let mut rs = String::new(); while i < 100000 { rs.push_str("aaaaa"); @@ -1547,7 +1547,7 @@ mod tests { let letters = a_million_letter_a(); assert!(half_a_million_letter_a() == unsafe {String::from_str(letters.slice_unchecked( - 0u, + 0, 500000))}); } @@ -1644,7 +1644,7 @@ mod tests { assert_eq!("华", data.slice(30, 33)); fn a_million_letter_x() -> String { - let mut i = 0u; + let mut i = 0; let mut rs = String::new(); while i < 100000 { rs.push_str("华华华华华华华华华华"); @@ -1653,7 +1653,7 @@ mod tests { rs } fn half_a_million_letter_x() -> String { - let mut i = 0u; + let mut i = 0; let mut rs = String::new(); while i < 100000 { rs.push_str("华华华华华"); @@ -1663,23 +1663,23 @@ mod tests { } let letters = a_million_letter_x(); assert!(half_a_million_letter_x() == - String::from_str(letters.slice(0u, 3u * 500000u))); + String::from_str(letters.slice(0, 3 * 500000))); } #[test] fn test_slice_2() { let ss = "中华Việt Nam"; - assert_eq!("华", ss.slice(3u, 6u)); - assert_eq!("Việt Nam", ss.slice(6u, 16u)); + assert_eq!("华", ss.slice(3, 6)); + assert_eq!("Việt Nam", ss.slice(6, 16)); - assert_eq!("ab", "abc".slice(0u, 2u)); - assert_eq!("bc", "abc".slice(1u, 3u)); - assert_eq!("", "abc".slice(1u, 1u)); + assert_eq!("ab", "abc".slice(0, 2)); + assert_eq!("bc", "abc".slice(1, 3)); + assert_eq!("", "abc".slice(1, 1)); - assert_eq!("中", ss.slice(0u, 3u)); - assert_eq!("华V", ss.slice(3u, 7u)); - assert_eq!("", ss.slice(3u, 3u)); + assert_eq!("中", ss.slice(0, 3)); + assert_eq!("华V", ss.slice(3, 7)); + assert_eq!("", ss.slice(3, 3)); /*0: 中 3: 华 6: V @@ -1695,7 +1695,7 @@ mod tests { #[test] #[should_fail] fn test_slice_fail() { - "中华Việt Nam".slice(0u, 2u); + "中华Việt Nam".slice(0, 2); } #[test] @@ -1961,9 +1961,9 @@ mod tests { let v: Vec = s1.as_bytes().to_vec(); let s2: String = String::from_str(from_utf8(&v).unwrap()); - let mut i: uint = 0u; - let n1: uint = s1.len(); - let n2: uint = v.len(); + let mut i = 0; + let n1 = s1.len(); + let n2 = v.len(); assert_eq!(n1, n2); while i < n1 { let a: u8 = s1.as_bytes()[i]; @@ -1971,7 +1971,7 @@ mod tests { debug!("{}", a); debug!("{}", b); assert_eq!(a, b); - i += 1u; + i += 1; } } @@ -2093,7 +2093,7 @@ mod tests { let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; - let mut it = s.chars(); + let it = s.chars(); for c in it { assert_eq!(c, v[pos]); @@ -2108,7 +2108,7 @@ mod tests { let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ']; let mut pos = 0; - let mut it = s.chars().rev(); + let it = s.chars().rev(); for c in it { assert_eq!(c, v[pos]); @@ -2188,7 +2188,7 @@ mod tests { let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; - let mut it = s.char_indices(); + let it = s.char_indices(); for c in it { assert_eq!(c, (p[pos], v[pos])); @@ -2205,7 +2205,7 @@ mod tests { let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ']; let mut pos = 0; - let mut it = s.char_indices().rev(); + let it = s.char_indices().rev(); for c in it { assert_eq!(c, (p[pos], v[pos])); @@ -2725,11 +2725,11 @@ mod tests { // test the indices iterators let s = "a̐éö̲\r\n"; - let gr_inds = s.grapheme_indices(true).collect::>(); - let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; + let gr_inds = s.grapheme_indices(true).collect::>(); + let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; assert_eq!(gr_inds, b); - let gr_inds = s.grapheme_indices(true).rev().collect::>(); - let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0u, "a̐")]; + let gr_inds = s.grapheme_indices(true).rev().collect::>(); + let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0, "a̐")]; assert_eq!(gr_inds, b); let mut gr_inds_iter = s.grapheme_indices(true); { @@ -2785,7 +2785,7 @@ mod tests { #[test] fn test_str_container() { - fn sum_len(v: &[&str]) -> uint { + fn sum_len(v: &[&str]) -> usize { v.iter().map(|x| x.len()).sum() } diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index a96ab40dd708f..e3db8d04d4aba 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -80,7 +80,7 @@ impl String { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(capacity: uint) -> String { + pub fn with_capacity(capacity: usize) -> String { String { vec: Vec::with_capacity(capacity), } @@ -157,10 +157,10 @@ impl String { static TAG_CONT_U8: u8 = 128u8; static REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8 let total = v.len(); - fn unsafe_get(xs: &[u8], i: uint) -> u8 { + fn unsafe_get(xs: &[u8], i: usize) -> u8 { unsafe { *xs.get_unchecked(i) } } - fn safe_get(xs: &[u8], i: uint, total: uint) -> u8 { + fn safe_get(xs: &[u8], i: usize, total: usize) -> u8 { if i >= total { 0 } else { @@ -319,7 +319,7 @@ impl String { /// * We assume that the `Vec` contains valid UTF-8. #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub unsafe fn from_raw_parts(buf: *mut u8, length: uint, capacity: uint) -> String { + pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String { String { vec: Vec::from_raw_parts(buf, length, capacity), } @@ -375,7 +375,7 @@ impl String { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> uint { + pub fn capacity(&self) -> usize { self.vec.capacity() } @@ -385,7 +385,7 @@ impl String { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -396,7 +396,7 @@ impl String { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve(&mut self, additional: uint) { + pub fn reserve(&mut self, additional: usize) { self.vec.reserve(additional) } @@ -410,7 +410,7 @@ impl String { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -421,7 +421,7 @@ impl String { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve_exact(&mut self, additional: uint) { + pub fn reserve_exact(&mut self, additional: usize) { self.vec.reserve_exact(additional) } @@ -508,7 +508,7 @@ impl String { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn truncate(&mut self, new_len: uint) { + pub fn truncate(&mut self, new_len: usize) { assert!(self.is_char_boundary(new_len)); self.vec.truncate(new_len) } @@ -563,7 +563,7 @@ impl String { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn remove(&mut self, idx: uint) -> char { + pub fn remove(&mut self, idx: usize) -> char { let len = self.len(); assert!(idx <= len); @@ -590,7 +590,7 @@ impl String { /// this function will panic. #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(&mut self, idx: uint, ch: char) { + pub fn insert(&mut self, idx: usize, ch: char) { let len = self.len(); assert!(idx <= len); assert!(self.is_char_boundary(idx)); @@ -641,7 +641,7 @@ impl String { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { self.vec.len() } + pub fn len(&self) -> usize { self.vec.len() } /// Returns true if the string contains no bytes /// @@ -854,26 +854,26 @@ impl<'a> Add<&'a str> for String { } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::Index> for String { +impl ops::Index> for String { type Output = str; #[inline] - fn index(&self, index: &ops::Range) -> &str { + fn index(&self, index: &ops::Range) -> &str { &self[][*index] } } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::Index> for String { +impl ops::Index> for String { type Output = str; #[inline] - fn index(&self, index: &ops::RangeTo) -> &str { + fn index(&self, index: &ops::RangeTo) -> &str { &self[][*index] } } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::Index> for String { +impl ops::Index> for String { type Output = str; #[inline] - fn index(&self, index: &ops::RangeFrom) -> &str { + fn index(&self, index: &ops::RangeFrom) -> &str { &self[][*index] } } @@ -1298,7 +1298,7 @@ mod tests { fn test_simple_types() { assert_eq!(1.to_string(), "1"); assert_eq!((-1).to_string(), "-1"); - assert_eq!(200u.to_string(), "200"); + assert_eq!(200.to_string(), "200"); assert_eq!(2u8.to_string(), "2"); assert_eq!(true.to_string(), "true"); assert_eq!(false.to_string(), "false"); @@ -1307,7 +1307,7 @@ mod tests { #[test] fn test_vectors() { - let x: Vec = vec![]; + let x: Vec = vec![]; assert_eq!(format!("{:?}", x), "[]"); assert_eq!(format!("{:?}", vec![1]), "[1]"); assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]"); diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 8218469d6afb5..f14b34bc2153b 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -66,7 +66,7 @@ use core::ops; use core::ptr; use core::raw::Slice as RawSlice; use core::slice; -use core::uint; +use core::usize; /// A growable list type, written `Vec` but pronounced 'vector.' /// @@ -138,8 +138,8 @@ use core::uint; #[stable(feature = "rust1", since = "1.0.0")] pub struct Vec { ptr: NonZero<*mut T>, - len: uint, - cap: uint, + len: usize, + cap: usize, } unsafe impl Send for Vec { } @@ -196,9 +196,9 @@ impl Vec { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(capacity: uint) -> Vec { + pub fn with_capacity(capacity: usize) -> Vec { if mem::size_of::() == 0 { - Vec { ptr: unsafe { NonZero::new(EMPTY as *mut T) }, len: 0, cap: uint::MAX } + Vec { ptr: unsafe { NonZero::new(EMPTY as *mut T) }, len: 0, cap: usize::MAX } } else if capacity == 0 { Vec::new() } else { @@ -245,8 +245,8 @@ impl Vec { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub unsafe fn from_raw_parts(ptr: *mut T, length: uint, - capacity: uint) -> Vec { + pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, + capacity: usize) -> Vec { Vec { ptr: NonZero::new(ptr), len: length, cap: capacity } } @@ -258,7 +258,7 @@ impl Vec { #[inline] #[unstable(feature = "collections", reason = "may be better expressed via composition")] - pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec { + pub unsafe fn from_raw_buf(ptr: *const T, elts: usize) -> Vec { let mut dst = Vec::with_capacity(elts); dst.set_len(elts); ptr::copy_nonoverlapping_memory(dst.as_mut_ptr(), ptr, elts); @@ -276,7 +276,7 @@ impl Vec { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> uint { + pub fn capacity(&self) -> usize { self.cap } @@ -285,7 +285,7 @@ impl Vec { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -295,9 +295,9 @@ impl Vec { /// assert!(vec.capacity() >= 11); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve(&mut self, additional: uint) { + pub fn reserve(&mut self, additional: usize) { if self.cap - self.len < additional { - let err_msg = "Vec::reserve: `uint` overflow"; + let err_msg = "Vec::reserve: `usize` overflow"; let new_cap = self.len.checked_add(additional).expect(err_msg) .checked_next_power_of_two().expect(err_msg); self.grow_capacity(new_cap); @@ -314,7 +314,7 @@ impl Vec { /// /// # Panics /// - /// Panics if the new capacity overflows `uint`. + /// Panics if the new capacity overflows `usize`. /// /// # Examples /// @@ -324,10 +324,10 @@ impl Vec { /// assert!(vec.capacity() >= 11); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve_exact(&mut self, additional: uint) { + pub fn reserve_exact(&mut self, additional: usize) { if self.cap - self.len < additional { match self.len.checked_add(additional) { - None => panic!("Vec::reserve: `uint` overflow"), + None => panic!("Vec::reserve: `usize` overflow"), Some(new_cap) => self.grow_capacity(new_cap) } } @@ -401,7 +401,7 @@ impl Vec { /// assert_eq!(vec, vec![1, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn truncate(&mut self, len: uint) { + pub fn truncate(&mut self, len: usize) { unsafe { // drop any extra elements while len < self.len { @@ -455,7 +455,7 @@ impl Vec { let cap = self.cap; let begin = ptr as *const T; let end = if mem::size_of::() == 0 { - (ptr as uint + self.len()) as *const T + (ptr as usize + self.len()) as *const T } else { ptr.offset(self.len() as int) as *const T }; @@ -480,7 +480,7 @@ impl Vec { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub unsafe fn set_len(&mut self, len: uint) { + pub unsafe fn set_len(&mut self, len: usize) { self.len = len; } @@ -506,7 +506,7 @@ impl Vec { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn swap_remove(&mut self, index: uint) -> T { + pub fn swap_remove(&mut self, index: usize) -> T { let length = self.len(); self.swap(index, length - 1); self.pop().unwrap() @@ -530,7 +530,7 @@ impl Vec { /// assert_eq!(vec, vec![1, 4, 2, 3, 5]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(&mut self, index: uint, element: T) { + pub fn insert(&mut self, index: usize, element: T) { let len = self.len(); assert!(index <= len); // space for the new element @@ -566,7 +566,7 @@ impl Vec { /// assert_eq!(v, vec![1, 3]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn remove(&mut self, index: uint) -> T { + pub fn remove(&mut self, index: usize) -> T { let len = self.len(); assert!(index < len); unsafe { // infallible @@ -602,11 +602,11 @@ impl Vec { #[stable(feature = "rust1", since = "1.0.0")] pub fn retain(&mut self, mut f: F) where F: FnMut(&T) -> bool { let len = self.len(); - let mut del = 0u; + let mut del = 0; { let v = &mut **self; - for i in 0u..len { + for i in 0..len { if !f(&v[i]) { del += 1; } else if del > 0 { @@ -623,7 +623,7 @@ impl Vec { /// /// # Panics /// - /// Panics if the number of elements in the vector overflows a `uint`. + /// Panics if the number of elements in the vector overflows a `usize`. /// /// # Examples /// @@ -687,7 +687,7 @@ impl Vec { /// /// # Panics /// - /// Panics if the number of elements in the vector overflows a `uint`. + /// Panics if the number of elements in the vector overflows a `usize`. /// /// # Examples /// ```rust @@ -741,7 +741,7 @@ impl Vec { unsafe { let begin = *self.ptr as *const T; let end = if mem::size_of::() == 0 { - (*self.ptr as uint + self.len()) as *const T + (*self.ptr as usize + self.len()) as *const T } else { (*self.ptr).offset(self.len() as int) as *const T }; @@ -781,7 +781,7 @@ impl Vec { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { self.len } + pub fn len(&self) -> usize { self.len } /// Returns `true` if the vector contains no elements. /// @@ -808,7 +808,7 @@ impl Vec { /// # Examples /// /// ``` - /// let v = vec![0u, 1, 2]; + /// let v = vec![0, 1, 2]; /// let w = v.map_in_place(|i| i + 3); /// assert_eq!(w.as_slice(), [3, 4, 5].as_slice()); /// @@ -850,7 +850,7 @@ impl Vec { // After `array.offset(offset)`: 0x9. // (0x1 + 0x8 = 0x1 - 0x8) // - // 2) If the size of the elements in the vector is >1, the `uint` -> + // 2) If the size of the elements in the vector is >1, the `usize` -> // `int` conversion can't overflow. let offset = vec.len() as int; let start = vec.as_mut_ptr(); @@ -977,8 +977,8 @@ impl Vec { let u = f(t); // Forget the `U` and increment `num_u`. This increment - // cannot overflow the `uint` as we only do this for a - // number of times that fits into a `uint` (and start with + // cannot overflow the `usize` as we only do this for a + // number of times that fits into a `usize` (and start with // `0`). Again, we should not panic between these steps. mem::forget(u); pv.num_u += 1; @@ -1052,7 +1052,7 @@ impl Vec { /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification; waiting for dust to settle")] - pub fn resize(&mut self, new_len: uint, value: T) { + pub fn resize(&mut self, new_len: usize, value: T) { let len = self.len(); if new_len > len { @@ -1205,7 +1205,7 @@ impl Vec { /// /// If the capacity for `self` is already equal to or greater than the /// requested capacity, then no action is taken. - fn grow_capacity(&mut self, capacity: uint) { + fn grow_capacity(&mut self, capacity: usize) { if mem::size_of::() == 0 { return } if capacity > self.cap { @@ -1223,7 +1223,7 @@ impl Vec { // FIXME: #13996: need a way to mark the return value as `noalias` #[inline(never)] -unsafe fn alloc_or_realloc(ptr: *mut T, old_size: uint, size: uint) -> *mut T { +unsafe fn alloc_or_realloc(ptr: *mut T, old_size: usize, size: usize) -> *mut T { if old_size == 0 { allocate(size, mem::min_align_of::()) as *mut T } else { @@ -1232,7 +1232,7 @@ unsafe fn alloc_or_realloc(ptr: *mut T, old_size: uint, size: uint) -> *mut T } #[inline] -unsafe fn dealloc(ptr: *mut T, len: uint) { +unsafe fn dealloc(ptr: *mut T, len: usize) { if mem::size_of::() != 0 { deallocate(ptr as *mut u8, len * mem::size_of::(), @@ -1274,22 +1274,22 @@ impl> Hash for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl Index for Vec { +impl Index for Vec { type Output = T; #[inline] - fn index<'a>(&'a self, index: &uint) -> &'a T { + fn index<'a>(&'a self, index: &usize) -> &'a T { // NB built-in indexing via `&[T]` &(**self)[*index] } } #[stable(feature = "rust1", since = "1.0.0")] -impl IndexMut for Vec { +impl IndexMut for Vec { type Output = T; #[inline] - fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut T { + fn index_mut<'a>(&'a mut self, index: &usize) -> &'a mut T { // NB built-in indexing via `&mut [T]` &mut (**self)[*index] } @@ -1297,26 +1297,26 @@ impl IndexMut for Vec { #[stable(feature = "rust1", since = "1.0.0")] -impl ops::Index> for Vec { +impl ops::Index> for Vec { type Output = [T]; #[inline] - fn index(&self, index: &ops::Range) -> &[T] { + fn index(&self, index: &ops::Range) -> &[T] { Index::index(&**self, index) } } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::Index> for Vec { +impl ops::Index> for Vec { type Output = [T]; #[inline] - fn index(&self, index: &ops::RangeTo) -> &[T] { + fn index(&self, index: &ops::RangeTo) -> &[T] { Index::index(&**self, index) } } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::Index> for Vec { +impl ops::Index> for Vec { type Output = [T]; #[inline] - fn index(&self, index: &ops::RangeFrom) -> &[T] { + fn index(&self, index: &ops::RangeFrom) -> &[T] { Index::index(&**self, index) } } @@ -1330,26 +1330,26 @@ impl ops::Index for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::IndexMut> for Vec { +impl ops::IndexMut> for Vec { type Output = [T]; #[inline] - fn index_mut(&mut self, index: &ops::Range) -> &mut [T] { + fn index_mut(&mut self, index: &ops::Range) -> &mut [T] { IndexMut::index_mut(&mut **self, index) } } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::IndexMut> for Vec { +impl ops::IndexMut> for Vec { type Output = [T]; #[inline] - fn index_mut(&mut self, index: &ops::RangeTo) -> &mut [T] { + fn index_mut(&mut self, index: &ops::RangeTo) -> &mut [T] { IndexMut::index_mut(&mut **self, index) } } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::IndexMut> for Vec { +impl ops::IndexMut> for Vec { type Output = [T]; #[inline] - fn index_mut(&mut self, index: &ops::RangeFrom) -> &mut [T] { + fn index_mut(&mut self, index: &ops::RangeFrom) -> &mut [T] { IndexMut::index_mut(&mut **self, index) } } @@ -1609,7 +1609,7 @@ impl<'a, T> IntoCow<'a, Vec, [T]> for &'a [T] where T: Clone { #[stable(feature = "rust1", since = "1.0.0")] pub struct IntoIter { allocation: *mut T, // the block of memory allocated for the vector - cap: uint, // the capacity of the vector + cap: usize, // the capacity of the vector ptr: *const T, end: *const T } @@ -1645,7 +1645,7 @@ impl Iterator for IntoIter { // purposefully don't use 'ptr.offset' because for // vectors with 0-size elements this would return the // same pointer. - self.ptr = mem::transmute(self.ptr as uint + 1); + self.ptr = mem::transmute(self.ptr as usize + 1); // Use a non-null pointer value Some(ptr::read(mem::transmute(1u))) @@ -1660,8 +1660,8 @@ impl Iterator for IntoIter { } #[inline] - fn size_hint(&self) -> (uint, Option) { - let diff = (self.end as uint) - (self.ptr as uint); + fn size_hint(&self) -> (usize, Option) { + let diff = (self.end as usize) - (self.ptr as usize); let size = mem::size_of::(); let exact = diff / (if size == 0 {1} else {size}); (exact, Some(exact)) @@ -1678,7 +1678,7 @@ impl DoubleEndedIterator for IntoIter { } else { if mem::size_of::() == 0 { // See above for why 'ptr.offset' isn't used - self.end = mem::transmute(self.end as uint - 1); + self.end = mem::transmute(self.end as usize - 1); // Use a non-null pointer value Some(ptr::read(mem::transmute(1u))) @@ -1733,7 +1733,7 @@ impl<'a, T> Iterator for Drain<'a, T> { // purposefully don't use 'ptr.offset' because for // vectors with 0-size elements this would return the // same pointer. - self.ptr = mem::transmute(self.ptr as uint + 1); + self.ptr = mem::transmute(self.ptr as usize + 1); // Use a non-null pointer value Some(ptr::read(mem::transmute(1u))) @@ -1748,8 +1748,8 @@ impl<'a, T> Iterator for Drain<'a, T> { } #[inline] - fn size_hint(&self) -> (uint, Option) { - let diff = (self.end as uint) - (self.ptr as uint); + fn size_hint(&self) -> (usize, Option) { + let diff = (self.end as usize) - (self.ptr as usize); let size = mem::size_of::(); let exact = diff / (if size == 0 {1} else {size}); (exact, Some(exact)) @@ -1766,7 +1766,7 @@ impl<'a, T> DoubleEndedIterator for Drain<'a, T> { } else { if mem::size_of::() == 0 { // See above for why 'ptr.offset' isn't used - self.end = mem::transmute(self.end as uint - 1); + self.end = mem::transmute(self.end as usize - 1); // Use a non-null pointer value Some(ptr::read(mem::transmute(1u))) @@ -1862,8 +1862,8 @@ struct PartialVecNonZeroSized { /// When the destructor of this struct runs, all `num_t` `T`s and `num_u` `U`s /// are destructed. struct PartialVecZeroSized { - num_t: uint, - num_u: uint, + num_t: usize, + num_u: usize, marker_t: InvariantType, marker_u: InvariantType, } @@ -1920,7 +1920,7 @@ mod tests { use super::as_vec; struct DropCounter<'a> { - count: &'a mut int + count: &'a mut u32 } #[unsafe_destructor] @@ -1949,7 +1949,7 @@ mod tests { #[test] fn test_small_vec_struct() { - assert!(size_of::>() == size_of::() * 3); + assert!(size_of::>() == size_of::() * 3); } #[test] @@ -2020,7 +2020,7 @@ mod tests { #[test] fn test_slice_from_mut() { - let mut values = vec![1u8,2,3,4,5]; + let mut values = vec![1, 2, 3, 4, 5]; { let slice = &mut values[2 ..]; assert!(slice == [3, 4, 5]); @@ -2034,7 +2034,7 @@ mod tests { #[test] fn test_slice_to_mut() { - let mut values = vec![1u8,2,3,4,5]; + let mut values = vec![1, 2, 3, 4, 5]; { let slice = &mut values[.. 2]; assert!(slice == [1, 2]); @@ -2048,7 +2048,7 @@ mod tests { #[test] fn test_split_at_mut() { - let mut values = vec![1u8,2,3,4,5]; + let mut values = vec![1, 2, 3, 4, 5]; { let (left, right) = values.split_at_mut(2); { @@ -2068,12 +2068,12 @@ mod tests { } } - assert!(values == vec![2u8, 3, 5, 6, 7]); + assert!(values == vec![2, 3, 5, 6, 7]); } #[test] fn test_clone() { - let v: Vec = vec!(); + let v: Vec = vec![]; let w = vec!(1, 2, 3); assert_eq!(v, v.clone()); @@ -2108,9 +2108,9 @@ mod tests { #[test] fn test_retain() { - let mut vec = vec![1u, 2, 3, 4]; + let mut vec = vec![1, 2, 3, 4]; vec.retain(|&x| x % 2 == 0); - assert!(vec == vec![2u, 4]); + assert!(vec == vec![2, 4]); } #[test] @@ -2169,20 +2169,20 @@ mod tests { // Test on-stack copy-from-buf. let a = [1, 2, 3]; let ptr = a.as_ptr(); - let b = Vec::from_raw_buf(ptr, 3u); + let b = Vec::from_raw_buf(ptr, 3); assert_eq!(b, vec![1, 2, 3]); // Test on-heap copy-from-buf. let c = vec![1, 2, 3, 4, 5]; let ptr = c.as_ptr(); - let d = Vec::from_raw_buf(ptr, 5u); + let d = Vec::from_raw_buf(ptr, 5); assert_eq!(d, vec![1, 2, 3, 4, 5]); } } #[test] fn test_vec_truncate_drop() { - static mut drops: uint = 0; + static mut drops: u32 = 0; struct Elem(int); impl Drop for Elem { fn drop(&mut self) { @@ -2201,7 +2201,7 @@ mod tests { #[test] #[should_fail] fn test_vec_truncate_fail() { - struct BadElem(int); + struct BadElem(i32); impl Drop for BadElem { fn drop(&mut self) { let BadElem(ref mut x) = *self; @@ -2217,62 +2217,62 @@ mod tests { #[test] fn test_index() { - let vec = vec!(1, 2, 3); + let vec = vec![1, 2, 3]; assert!(vec[1] == 2); } #[test] #[should_fail] fn test_index_out_of_bounds() { - let vec = vec!(1, 2, 3); + let vec = vec![1, 2, 3]; let _ = vec[3]; } #[test] #[should_fail] fn test_slice_out_of_bounds_1() { - let x: Vec = vec![1, 2, 3, 4, 5]; + let x = vec![1, 2, 3, 4, 5]; &x[-1..]; } #[test] #[should_fail] fn test_slice_out_of_bounds_2() { - let x: Vec = vec![1, 2, 3, 4, 5]; + let x = vec![1, 2, 3, 4, 5]; &x[..6]; } #[test] #[should_fail] fn test_slice_out_of_bounds_3() { - let x: Vec = vec![1, 2, 3, 4, 5]; + let x = vec![1, 2, 3, 4, 5]; &x[-1..4]; } #[test] #[should_fail] fn test_slice_out_of_bounds_4() { - let x: Vec = vec![1, 2, 3, 4, 5]; + let x = vec![1, 2, 3, 4, 5]; &x[1..6]; } #[test] #[should_fail] fn test_slice_out_of_bounds_5() { - let x: Vec = vec![1, 2, 3, 4, 5]; + let x = vec![1, 2, 3, 4, 5]; &x[3..2]; } #[test] #[should_fail] fn test_swap_remove_empty() { - let mut vec: Vec = vec!(); + let mut vec= Vec::::new(); vec.swap_remove(0); } #[test] fn test_move_iter_unwrap() { - let mut vec: Vec = Vec::with_capacity(7); + let mut vec = Vec::with_capacity(7); vec.push(1); vec.push(2); let ptr = vec.as_ptr(); @@ -2285,14 +2285,14 @@ mod tests { #[test] #[should_fail] fn test_map_in_place_incompatible_types_fail() { - let v = vec![0u, 1, 2]; + let v = vec![0, 1, 2]; v.map_in_place(|_| ()); } #[test] fn test_map_in_place() { - let v = vec![0u, 1, 2]; - assert_eq!(v.map_in_place(|i: uint| i as int - 1), [-1, 0, 1]); + let v = vec![0, 1, 2]; + assert_eq!(v.map_in_place(|i: u32| i as i32 - 1), [-1, 0, 1]); } #[test] @@ -2318,7 +2318,7 @@ mod tests { DROP_COUNTER.fetch_add(1, Ordering::Relaxed); } } - const NUM_ELEMENTS: uint = 2; + const NUM_ELEMENTS: usize = 2; static DROP_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT; let v = repeat(Nothing).take(NUM_ELEMENTS).collect::>(); @@ -2334,7 +2334,7 @@ mod tests { #[test] fn test_move_items() { let vec = vec![1, 2, 3]; - let mut vec2 : Vec = vec![]; + let mut vec2 = vec![]; for i in vec { vec2.push(i); } @@ -2344,7 +2344,7 @@ mod tests { #[test] fn test_move_items_reverse() { let vec = vec![1, 2, 3]; - let mut vec2 : Vec = vec![]; + let mut vec2 = vec![]; for i in vec.into_iter().rev() { vec2.push(i); } @@ -2354,7 +2354,7 @@ mod tests { #[test] fn test_move_items_zero_sized() { let vec = vec![(), (), ()]; - let mut vec2 : Vec<()> = vec![]; + let mut vec2 = vec![]; for i in vec { vec2.push(i); } @@ -2364,7 +2364,7 @@ mod tests { #[test] fn test_drain_items() { let mut vec = vec![1, 2, 3]; - let mut vec2: Vec = vec![]; + let mut vec2 = vec![]; for i in vec.drain() { vec2.push(i); } @@ -2375,18 +2375,18 @@ mod tests { #[test] fn test_drain_items_reverse() { let mut vec = vec![1, 2, 3]; - let mut vec2: Vec = vec![]; + let mut vec2 = vec![]; for i in vec.drain().rev() { vec2.push(i); } assert_eq!(vec, []); - assert_eq!(vec2, [ 3, 2, 1 ]); + assert_eq!(vec2, [3, 2, 1]); } #[test] fn test_drain_items_zero_sized() { let mut vec = vec![(), (), ()]; - let mut vec2: Vec<()> = vec![]; + let mut vec2 = vec![]; for i in vec.drain() { vec2.push(i); } @@ -2396,9 +2396,9 @@ mod tests { #[test] fn test_into_boxed_slice() { - let xs = vec![1u, 2, 3]; + let xs = vec![1, 2, 3]; let ys = xs.into_boxed_slice(); - assert_eq!(ys, [1u, 2, 3]); + assert_eq!(ys, [1, 2, 3]); } #[test] @@ -2421,17 +2421,17 @@ mod tests { #[bench] fn bench_new(b: &mut Bencher) { b.iter(|| { - let v: Vec = Vec::new(); + let v: Vec = Vec::new(); assert_eq!(v.len(), 0); assert_eq!(v.capacity(), 0); }) } - fn do_bench_with_capacity(b: &mut Bencher, src_len: uint) { + fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) { b.bytes = src_len as u64; b.iter(|| { - let v: Vec = Vec::with_capacity(src_len); + let v: Vec = Vec::with_capacity(src_len); assert_eq!(v.len(), 0); assert_eq!(v.capacity(), src_len); }) @@ -2457,7 +2457,7 @@ mod tests { do_bench_with_capacity(b, 1000) } - fn do_bench_from_fn(b: &mut Bencher, src_len: uint) { + fn do_bench_from_fn(b: &mut Bencher, src_len: usize) { b.bytes = src_len as u64; b.iter(|| { @@ -2487,11 +2487,11 @@ mod tests { do_bench_from_fn(b, 1000) } - fn do_bench_from_elem(b: &mut Bencher, src_len: uint) { + fn do_bench_from_elem(b: &mut Bencher, src_len: usize) { b.bytes = src_len as u64; b.iter(|| { - let dst: Vec = repeat(5).take(src_len).collect(); + let dst: Vec = repeat(5).take(src_len).collect(); assert_eq!(dst.len(), src_len); assert!(dst.iter().all(|x| *x == 5)); }) @@ -2517,8 +2517,8 @@ mod tests { do_bench_from_elem(b, 1000) } - fn do_bench_from_slice(b: &mut Bencher, src_len: uint) { - let src: Vec = FromIterator::from_iter(0..src_len); + fn do_bench_from_slice(b: &mut Bencher, src_len: usize) { + let src: Vec<_> = FromIterator::from_iter(0..src_len); b.bytes = src_len as u64; @@ -2549,13 +2549,13 @@ mod tests { do_bench_from_slice(b, 1000) } - fn do_bench_from_iter(b: &mut Bencher, src_len: uint) { - let src: Vec = FromIterator::from_iter(0..src_len); + fn do_bench_from_iter(b: &mut Bencher, src_len: usize) { + let src: Vec<_> = FromIterator::from_iter(0..src_len); b.bytes = src_len as u64; b.iter(|| { - let dst: Vec = FromIterator::from_iter(src.clone().into_iter()); + let dst: Vec<_> = FromIterator::from_iter(src.clone().into_iter()); assert_eq!(dst.len(), src_len); assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); }); @@ -2581,9 +2581,9 @@ mod tests { do_bench_from_iter(b, 1000) } - fn do_bench_extend(b: &mut Bencher, dst_len: uint, src_len: uint) { - let dst: Vec = FromIterator::from_iter(0..dst_len); - let src: Vec = FromIterator::from_iter(dst_len..dst_len + src_len); + fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) { + let dst: Vec<_> = FromIterator::from_iter(0..dst_len); + let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); b.bytes = src_len as u64; @@ -2630,9 +2630,9 @@ mod tests { do_bench_extend(b, 1000, 1000) } - fn do_bench_push_all(b: &mut Bencher, dst_len: uint, src_len: uint) { - let dst: Vec = FromIterator::from_iter(0..dst_len); - let src: Vec = FromIterator::from_iter(dst_len..dst_len + src_len); + fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) { + let dst: Vec<_> = FromIterator::from_iter(0..dst_len); + let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); b.bytes = src_len as u64; @@ -2679,9 +2679,9 @@ mod tests { do_bench_push_all(b, 1000, 1000) } - fn do_bench_push_all_move(b: &mut Bencher, dst_len: uint, src_len: uint) { - let dst: Vec = FromIterator::from_iter(0u..dst_len); - let src: Vec = FromIterator::from_iter(dst_len..dst_len + src_len); + fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) { + let dst: Vec<_> = FromIterator::from_iter(0..dst_len); + let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); b.bytes = src_len as u64; @@ -2728,8 +2728,8 @@ mod tests { do_bench_push_all_move(b, 1000, 1000) } - fn do_bench_clone(b: &mut Bencher, src_len: uint) { - let src: Vec = FromIterator::from_iter(0..src_len); + fn do_bench_clone(b: &mut Bencher, src_len: usize) { + let src: Vec = FromIterator::from_iter(0..src_len); b.bytes = src_len as u64; @@ -2760,9 +2760,9 @@ mod tests { do_bench_clone(b, 1000) } - fn do_bench_clone_from(b: &mut Bencher, times: uint, dst_len: uint, src_len: uint) { - let dst: Vec = FromIterator::from_iter(0..src_len); - let src: Vec = FromIterator::from_iter(dst_len..dst_len + src_len); + fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) { + let dst: Vec<_> = FromIterator::from_iter(0..src_len); + let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); b.bytes = (times * src_len) as u64; diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index abcf358a1926c..08511ae3e27cf 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -29,8 +29,6 @@ use core::ops::{Index, IndexMut}; use {vec, slice}; use vec::Vec; -// FIXME(conventions): capacity management??? - /// A map optimized for small integer keys. /// /// # Examples @@ -117,7 +115,7 @@ impl> Hash for VecMap { fn hash(&self, state: &mut S) { // In order to not traverse the `VecMap` twice, count the elements // during iteration. - let mut count: uint = 0; + let mut count: usize = 0; for elt in self { elt.hash(state); count += 1; @@ -148,7 +146,7 @@ impl VecMap { /// let mut map: VecMap<&str> = VecMap::with_capacity(10); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(capacity: uint) -> VecMap { + pub fn with_capacity(capacity: usize) -> VecMap { VecMap { v: Vec::with_capacity(capacity) } } @@ -164,7 +162,7 @@ impl VecMap { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> uint { + pub fn capacity(&self) -> usize { self.v.capacity() } @@ -183,7 +181,7 @@ impl VecMap { /// assert!(map.capacity() >= 10); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve_len(&mut self, len: uint) { + pub fn reserve_len(&mut self, len: usize) { let cur_len = self.v.len(); if len >= cur_len { self.v.reserve(len - cur_len); @@ -207,7 +205,7 @@ impl VecMap { /// assert!(map.capacity() >= 10); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve_len_exact(&mut self, len: uint) { + pub fn reserve_len_exact(&mut self, len: usize) { let cur_len = self.v.len(); if len >= cur_len { self.v.reserve_exact(len - cur_len); @@ -215,11 +213,11 @@ impl VecMap { } /// Returns an iterator visiting all keys in ascending order of the keys. - /// The iterator's element type is `uint`. + /// The iterator's element type is `usize`. #[stable(feature = "rust1", since = "1.0.0")] pub fn keys<'r>(&'r self) -> Keys<'r, V> { fn first((a, _): (A, B)) -> A { a } - let first: fn((uint, &'r V)) -> uint = first; // coerce to fn pointer + let first: fn((usize, &'r V)) -> usize = first; // coerce to fn pointer Keys { iter: self.iter().map(first) } } @@ -229,13 +227,13 @@ impl VecMap { #[stable(feature = "rust1", since = "1.0.0")] pub fn values<'r>(&'r self) -> Values<'r, V> { fn second((_, b): (A, B)) -> B { b } - let second: fn((uint, &'r V)) -> &'r V = second; // coerce to fn pointer + let second: fn((usize, &'r V)) -> &'r V = second; // coerce to fn pointer Values { iter: self.iter().map(second) } } /// Returns an iterator visiting all key-value pairs in ascending order of the keys. - /// The iterator's element type is `(uint, &'r V)`. + /// The iterator's element type is `(usize, &'r V)`. /// /// # Examples /// @@ -263,7 +261,7 @@ impl VecMap { /// Returns an iterator visiting all key-value pairs in ascending order of the keys, /// with mutable references to the values. - /// The iterator's element type is `(uint, &'r mut V)`. + /// The iterator's element type is `(usize, &'r mut V)`. /// /// # Examples /// @@ -294,7 +292,7 @@ impl VecMap { /// Returns an iterator visiting all key-value pairs in ascending order of /// the keys, consuming the original `VecMap`. - /// The iterator's element type is `(uint, &'r V)`. + /// The iterator's element type is `(usize, &'r V)`. /// /// # Examples /// @@ -306,23 +304,23 @@ impl VecMap { /// map.insert(3, "c"); /// map.insert(2, "b"); /// - /// let vec: Vec<(uint, &str)> = map.into_iter().collect(); + /// let vec: Vec<(usize, &str)> = map.into_iter().collect(); /// /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn into_iter(self) -> IntoIter { - fn filter((i, v): (uint, Option)) -> Option<(uint, A)> { + fn filter((i, v): (usize, Option)) -> Option<(usize, A)> { v.map(|v| (i, v)) } - let filter: fn((uint, Option)) -> Option<(uint, V)> = filter; // coerce to fn ptr + let filter: fn((usize, Option)) -> Option<(usize, V)> = filter; // coerce to fn ptr IntoIter { iter: self.v.into_iter().enumerate().filter_map(filter) } } /// Returns an iterator visiting all key-value pairs in ascending order of /// the keys, emptying (but not consuming) the original `VecMap`. - /// The iterator's element type is `(uint, &'r V)`. Keeps the allocated memory for reuse. + /// The iterator's element type is `(usize, &'r V)`. Keeps the allocated memory for reuse. /// /// # Examples /// @@ -334,17 +332,17 @@ impl VecMap { /// map.insert(3, "c"); /// map.insert(2, "b"); /// - /// let vec: Vec<(uint, &str)> = map.drain().collect(); + /// let vec: Vec<(usize, &str)> = map.drain().collect(); /// /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] pub fn drain<'a>(&'a mut self) -> Drain<'a, V> { - fn filter((i, v): (uint, Option)) -> Option<(uint, A)> { + fn filter((i, v): (usize, Option)) -> Option<(usize, A)> { v.map(|v| (i, v)) } - let filter: fn((uint, Option)) -> Option<(uint, V)> = filter; // coerce to fn ptr + let filter: fn((usize, Option)) -> Option<(usize, V)> = filter; // coerce to fn ptr Drain { iter: self.v.drain().enumerate().filter_map(filter) } } @@ -362,7 +360,7 @@ impl VecMap { /// assert_eq!(a.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { + pub fn len(&self) -> usize { self.v.iter().filter(|elt| elt.is_some()).count() } @@ -411,7 +409,7 @@ impl VecMap { /// assert_eq!(map.get(&2), None); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get(&self, key: &uint) -> Option<&V> { + pub fn get(&self, key: &usize) -> Option<&V> { if *key < self.v.len() { match self.v[*key] { Some(ref value) => Some(value), @@ -436,7 +434,7 @@ impl VecMap { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn contains_key(&self, key: &uint) -> bool { + pub fn contains_key(&self, key: &usize) -> bool { self.get(key).is_some() } @@ -456,7 +454,7 @@ impl VecMap { /// assert_eq!(map[1], "b"); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_mut(&mut self, key: &uint) -> Option<&mut V> { + pub fn get_mut(&mut self, key: &usize) -> Option<&mut V> { if *key < self.v.len() { match *(&mut self.v[*key]) { Some(ref mut value) => Some(value), @@ -484,7 +482,7 @@ impl VecMap { /// assert_eq!(map[37], "c"); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(&mut self, key: uint, value: V) -> Option { + pub fn insert(&mut self, key: usize, value: V) -> Option { let len = self.v.len(); if len <= key { self.v.extend((0..key - len + 1).map(|_| None)); @@ -506,7 +504,7 @@ impl VecMap { /// assert_eq!(map.remove(&1), None); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn remove(&mut self, key: &uint) -> Option { + pub fn remove(&mut self, key: &usize) -> Option { if *key >= self.v.len() { return None; } @@ -669,8 +667,8 @@ impl fmt::Debug for VecMap { } #[stable(feature = "rust1", since = "1.0.0")] -impl FromIterator<(uint, V)> for VecMap { - fn from_iter>(iter: Iter) -> VecMap { +impl FromIterator<(usize, V)> for VecMap { + fn from_iter>(iter: Iter) -> VecMap { let mut map = VecMap::new(); map.extend(iter); map @@ -702,29 +700,29 @@ impl<'a, T> IntoIterator for &'a mut VecMap { } #[stable(feature = "rust1", since = "1.0.0")] -impl Extend<(uint, V)> for VecMap { - fn extend>(&mut self, iter: Iter) { +impl Extend<(usize, V)> for VecMap { + fn extend>(&mut self, iter: Iter) { for (k, v) in iter { self.insert(k, v); } } } -impl Index for VecMap { +impl Index for VecMap { type Output = V; #[inline] - fn index<'a>(&'a self, i: &uint) -> &'a V { + fn index<'a>(&'a self, i: &usize) -> &'a V { self.get(i).expect("key not present") } } #[stable(feature = "rust1", since = "1.0.0")] -impl IndexMut for VecMap { +impl IndexMut for VecMap { type Output = V; #[inline] - fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut V { + fn index_mut<'a>(&'a mut self, i: &usize) -> &'a mut V { self.get_mut(i).expect("key not present") } } @@ -757,7 +755,7 @@ macro_rules! iterator { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { (0, Some(self.back - self.front)) } } @@ -794,8 +792,8 @@ macro_rules! double_ended_iterator { /// An iterator over the key-value pairs of a map. #[stable(feature = "rust1", since = "1.0.0")] pub struct Iter<'a, V:'a> { - front: uint, - back: uint, + front: usize, + back: usize, iter: slice::Iter<'a, Option> } @@ -810,25 +808,25 @@ impl<'a, V> Clone for Iter<'a, V> { } } -iterator! { impl Iter -> (uint, &'a V), as_ref } -double_ended_iterator! { impl Iter -> (uint, &'a V), as_ref } +iterator! { impl Iter -> (usize, &'a V), as_ref } +double_ended_iterator! { impl Iter -> (usize, &'a V), as_ref } /// An iterator over the key-value pairs of a map, with the /// values being mutable. #[stable(feature = "rust1", since = "1.0.0")] pub struct IterMut<'a, V:'a> { - front: uint, - back: uint, + front: usize, + back: usize, iter: slice::IterMut<'a, Option> } -iterator! { impl IterMut -> (uint, &'a mut V), as_mut } -double_ended_iterator! { impl IterMut -> (uint, &'a mut V), as_mut } +iterator! { impl IterMut -> (usize, &'a mut V), as_mut } +double_ended_iterator! { impl IterMut -> (usize, &'a mut V), as_mut } /// An iterator over the keys of a map. #[stable(feature = "rust1", since = "1.0.0")] pub struct Keys<'a, V: 'a> { - iter: Map, fn((uint, &'a V)) -> uint> + iter: Map, fn((usize, &'a V)) -> usize> } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -843,7 +841,7 @@ impl<'a, V> Clone for Keys<'a, V> { /// An iterator over the values of a map. #[stable(feature = "rust1", since = "1.0.0")] pub struct Values<'a, V: 'a> { - iter: Map, fn((uint, &'a V)) -> &'a V> + iter: Map, fn((usize, &'a V)) -> &'a V> } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -860,39 +858,39 @@ impl<'a, V> Clone for Values<'a, V> { pub struct IntoIter { iter: FilterMap< Enumerate>>, - fn((uint, Option)) -> Option<(uint, V)>> + fn((usize, Option)) -> Option<(usize, V)>> } #[unstable(feature = "collections")] pub struct Drain<'a, V> { iter: FilterMap< Enumerate>>, - fn((uint, Option)) -> Option<(uint, V)>> + fn((usize, Option)) -> Option<(usize, V)>> } #[unstable(feature = "collections")] impl<'a, V> Iterator for Drain<'a, V> { - type Item = (uint, V); + type Item = (usize, V); - fn next(&mut self) -> Option<(uint, V)> { self.iter.next() } - fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } + fn next(&mut self) -> Option<(usize, V)> { self.iter.next() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } #[unstable(feature = "collections")] impl<'a, V> DoubleEndedIterator for Drain<'a, V> { - fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() } + fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, V> Iterator for Keys<'a, V> { - type Item = uint; + type Item = usize; - fn next(&mut self) -> Option { self.iter.next() } - fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } + fn next(&mut self) -> Option { self.iter.next() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, V> DoubleEndedIterator for Keys<'a, V> { - fn next_back(&mut self) -> Option { self.iter.next_back() } + fn next_back(&mut self) -> Option { self.iter.next_back() } } #[stable(feature = "rust1", since = "1.0.0")] @@ -900,7 +898,7 @@ impl<'a, V> Iterator for Values<'a, V> { type Item = &'a V; fn next(&mut self) -> Option<(&'a V)> { self.iter.next() } - fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl<'a, V> DoubleEndedIterator for Values<'a, V> { @@ -909,14 +907,14 @@ impl<'a, V> DoubleEndedIterator for Values<'a, V> { #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for IntoIter { - type Item = (uint, V); + type Item = (usize, V); - fn next(&mut self) -> Option<(uint, V)> { self.iter.next() } - fn size_hint(&self) -> (uint, Option) { self.iter.size_hint() } + fn next(&mut self) -> Option<(usize, V)> { self.iter.next() } + fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } #[stable(feature = "rust1", since = "1.0.0")] impl DoubleEndedIterator for IntoIter { - fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() } + fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() } } #[cfg(test)] @@ -990,7 +988,7 @@ mod test_map { map.insert(1, 'a'); map.insert(2, 'b'); map.insert(3, 'c'); - let keys = map.keys().collect::>(); + let keys: Vec<_> = map.keys().collect(); assert_eq!(keys.len(), 3); assert!(keys.contains(&1)); assert!(keys.contains(&2)); @@ -1003,7 +1001,7 @@ mod test_map { map.insert(1, 'a'); map.insert(2, 'b'); map.insert(3, 'c'); - let values = map.values().map(|&v| v).collect::>(); + let values: Vec<_> = map.values().cloned().collect(); assert_eq!(values.len(), 3); assert!(values.contains(&'a')); assert!(values.contains(&'b')); @@ -1137,7 +1135,7 @@ mod test_map { map.insert(3, "c"); map.insert(2, "b"); - let vec: Vec<(usize, &str)> = map.drain().collect(); + let vec: Vec<_> = map.drain().collect(); assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); assert_eq!(map.len(), 0); @@ -1146,7 +1144,7 @@ mod test_map { #[test] fn test_show() { let mut map = VecMap::new(); - let empty = VecMap::::new(); + let empty = VecMap::::new(); map.insert(1, 2); map.insert(3, 4); @@ -1195,7 +1193,7 @@ mod test_map { let mut b = VecMap::new(); assert!(!(a < b) && !(b < a)); - assert!(b.insert(2u, 5).is_none()); + assert!(b.insert(2, 5).is_none()); assert!(a < b); assert!(a.insert(2, 7).is_none()); assert!(!(a < b) && b < a); @@ -1213,7 +1211,7 @@ mod test_map { let mut b = VecMap::new(); assert!(a <= b && a >= b); - assert!(a.insert(1u, 1).is_none()); + assert!(a.insert(1, 1).is_none()); assert!(a > b && a >= b); assert!(b < a && b <= a); assert!(b.insert(2, 2).is_none()); @@ -1245,9 +1243,9 @@ mod test_map { #[test] fn test_from_iter() { - let xs: Vec<(uint, char)> = vec![(1u, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]; + let xs = vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]; - let map: VecMap = xs.iter().map(|&x| x).collect(); + let map: VecMap<_> = xs.iter().cloned().collect(); for &(k, v) in &xs { assert_eq!(map.get(&k), Some(&v)); @@ -1256,7 +1254,7 @@ mod test_map { #[test] fn test_index() { - let mut map: VecMap = VecMap::new(); + let mut map = VecMap::new(); map.insert(1, 2); map.insert(2, 1); @@ -1268,7 +1266,7 @@ mod test_map { #[test] #[should_fail] fn test_index_nonexistent() { - let mut map: VecMap = VecMap::new(); + let mut map = VecMap::new(); map.insert(1, 2); map.insert(2, 1); @@ -1281,7 +1279,7 @@ mod test_map { fn test_entry(){ let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; - let mut map: VecMap = xs.iter().map(|&x| x).collect(); + let mut map: VecMap<_> = xs.iter().cloned().collect(); // Existing key (insert) match map.entry(1) { @@ -1337,7 +1335,7 @@ mod bench { #[bench] pub fn insert_rand_100(b: &mut Bencher) { - let mut m : VecMap = VecMap::new(); + let mut m = VecMap::new(); insert_rand_n(100, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.remove(&i); }); @@ -1345,7 +1343,7 @@ mod bench { #[bench] pub fn insert_rand_10_000(b: &mut Bencher) { - let mut m : VecMap = VecMap::new(); + let mut m = VecMap::new(); insert_rand_n(10_000, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.remove(&i); }); @@ -1354,7 +1352,7 @@ mod bench { // Insert seq #[bench] pub fn insert_seq_100(b: &mut Bencher) { - let mut m : VecMap = VecMap::new(); + let mut m = VecMap::new(); insert_seq_n(100, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.remove(&i); }); @@ -1362,7 +1360,7 @@ mod bench { #[bench] pub fn insert_seq_10_000(b: &mut Bencher) { - let mut m : VecMap = VecMap::new(); + let mut m = VecMap::new(); insert_seq_n(10_000, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.remove(&i); }); @@ -1371,7 +1369,7 @@ mod bench { // Find rand #[bench] pub fn find_rand_100(b: &mut Bencher) { - let mut m : VecMap = VecMap::new(); + let mut m = VecMap::new(); find_rand_n(100, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.get(&i); }); @@ -1379,7 +1377,7 @@ mod bench { #[bench] pub fn find_rand_10_000(b: &mut Bencher) { - let mut m : VecMap = VecMap::new(); + let mut m = VecMap::new(); find_rand_n(10_000, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.get(&i); }); @@ -1388,7 +1386,7 @@ mod bench { // Find seq #[bench] pub fn find_seq_100(b: &mut Bencher) { - let mut m : VecMap = VecMap::new(); + let mut m = VecMap::new(); find_seq_n(100, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.get(&i); }); @@ -1396,7 +1394,7 @@ mod bench { #[bench] pub fn find_seq_10_000(b: &mut Bencher) { - let mut m : VecMap = VecMap::new(); + let mut m = VecMap::new(); find_seq_n(10_000, &mut m, b, |m, i| { m.insert(i, 1); }, |m, i| { m.get(&i); }); diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 6964a0b9db817..bacb0f3fa7176 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -1591,10 +1591,10 @@ pub fn region_existential_bound<'tcx>(r: ty::Region) -> ExistentialBounds<'tcx> } impl CLike for BuiltinBound { - fn to_uint(&self) -> uint { + fn to_usize(&self) -> uint { *self as uint } - fn from_uint(v: uint) -> BuiltinBound { + fn from_usize(v: uint) -> BuiltinBound { unsafe { mem::transmute(v) } } } diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs index be7abfe6aca3b..53d3b069467d3 100644 --- a/src/libserialize/collection_impls.rs +++ b/src/libserialize/collection_impls.rs @@ -136,7 +136,7 @@ impl< fn encode(&self, s: &mut S) -> Result<(), S::Error> { let mut bits = 0; for item in self { - bits |= item.to_uint(); + bits |= item.to_usize(); } s.emit_uint(bits) } @@ -150,7 +150,7 @@ impl< let mut set = EnumSet::new(); for bit in 0..uint::BITS { if bits & (1 << bit) != 0 { - set.insert(CLike::from_uint(1 << bit)); + set.insert(CLike::from_usize(1 << bit)); } } Ok(set) diff --git a/src/libstd/collections/hash/bench.rs b/src/libstd/collections/hash/bench.rs index ce02648b8f29d..ca506e8c36f50 100644 --- a/src/libstd/collections/hash/bench.rs +++ b/src/libstd/collections/hash/bench.rs @@ -21,7 +21,7 @@ fn new_drop(b : &mut Bencher) { use super::map::HashMap; b.iter(|| { - let m : HashMap = HashMap::new(); + let m : HashMap = HashMap::new(); assert_eq!(m.len(), 0); }) } diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index 6327061047248..e1a8c8fd7038f 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -45,9 +45,9 @@ use super::table::BucketState::{ }; use super::state::HashState; -const INITIAL_LOG2_CAP: uint = 5; +const INITIAL_LOG2_CAP: usize = 5; #[unstable(feature = "std_misc")] -pub const INITIAL_CAPACITY: uint = 1 << INITIAL_LOG2_CAP; // 2^5 +pub const INITIAL_CAPACITY: usize = 1 << INITIAL_LOG2_CAP; // 2^5 /// The default behavior of HashMap implements a load factor of 90.9%. /// This behavior is characterized by the following condition: @@ -62,7 +62,7 @@ impl DefaultResizePolicy { } #[inline] - fn min_capacity(&self, usable_size: uint) -> uint { + fn min_capacity(&self, usable_size: usize) -> usize { // Here, we are rephrasing the logic by specifying the lower limit // on capacity: // @@ -72,7 +72,7 @@ impl DefaultResizePolicy { /// An inverse of `min_capacity`, approximately. #[inline] - fn usable_capacity(&self, cap: uint) -> uint { + fn usable_capacity(&self, cap: usize) -> usize { // As the number of entries approaches usable capacity, // min_capacity(size) must be smaller than the internal capacity, // so that the map is not resized: @@ -369,7 +369,7 @@ fn pop_internal(starting_bucket: FullBucketMut) -> (K, V) { /// /// `hash`, `k`, and `v` are the elements to "robin hood" into the hashtable. fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>, - mut ib: uint, + mut ib: usize, mut hash: SafeHash, mut k: K, mut v: V) @@ -515,7 +515,7 @@ impl + Eq, V> HashMap { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(capacity: uint) -> HashMap { + pub fn with_capacity(capacity: usize) -> HashMap { HashMap::with_capacity_and_hash_state(capacity, Default::default()) } } @@ -569,7 +569,7 @@ impl HashMap /// ``` #[inline] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")] - pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S) + pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S) -> HashMap { let resize_policy = DefaultResizePolicy::new(); let min_cap = max(INITIAL_CAPACITY, resize_policy.min_capacity(capacity)); @@ -593,7 +593,7 @@ impl HashMap /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> uint { + pub fn capacity(&self) -> usize { self.resize_policy.usable_capacity(self.table.capacity()) } @@ -603,7 +603,7 @@ impl HashMap /// /// # Panics /// - /// Panics if the new allocation size overflows `uint`. + /// Panics if the new allocation size overflows `usize`. /// /// # Example /// @@ -613,7 +613,7 @@ impl HashMap /// map.reserve(10); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve(&mut self, additional: uint) { + pub fn reserve(&mut self, additional: usize) { let new_size = self.len().checked_add(additional).expect("capacity overflow"); let min_cap = self.resize_policy.min_capacity(new_size); @@ -631,7 +631,7 @@ impl HashMap /// 1) Make sure the new capacity is enough for all the elements, accounting /// for the load factor. /// 2) Ensure new_capacity is a power of two or zero. - fn resize(&mut self, new_capacity: uint) { + fn resize(&mut self, new_capacity: usize) { assert!(self.table.size() <= new_capacity); assert!(new_capacity.is_power_of_two() || new_capacity == 0); @@ -793,7 +793,7 @@ impl HashMap if (ib as int) < robin_ib { // Found a luckier bucket than me. Better steal his spot. - return robin_hood(bucket, robin_ib as uint, hash, k, v); + return robin_hood(bucket, robin_ib as usize, hash, k, v); } probe = bucket.next(); @@ -953,7 +953,7 @@ impl HashMap /// assert_eq!(a.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { self.table.size() } + pub fn len(&self) -> usize { self.table.size() } /// Returns true if the map contains no elements. /// @@ -1188,7 +1188,7 @@ fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable, hash: SafeHas return Vacant(VacantEntry { hash: hash, key: k, - elem: NeqElem(bucket, robin_ib as uint), + elem: NeqElem(bucket, robin_ib as usize), }); } @@ -1371,7 +1371,7 @@ pub enum Entry<'a, K: 'a, V: 'a> { enum VacantEntryState { /// The index is occupied, but the key to insert has precedence, /// and will kick the current one out on insertion. - NeqElem(FullBucket, uint), + NeqElem(FullBucket, usize), /// The index is genuinely vacant. NoElem(EmptyBucket), } @@ -1674,11 +1674,11 @@ mod test_map { #[derive(Hash, PartialEq, Eq)] struct Dropable { - k: uint + k: usize } impl Dropable { - fn new(k: uint) -> Dropable { + fn new(k: usize) -> Dropable { DROP_VECTOR.with(|slot| { slot.borrow_mut()[k] += 1; }); @@ -1711,24 +1711,24 @@ mod test_map { let mut m = HashMap::new(); DROP_VECTOR.with(|v| { - for i in 0u..200 { + for i in 0..200 { assert_eq!(v.borrow()[i], 0); } }); - for i in 0u..100 { + for i in 0..100 { let d1 = Dropable::new(i); let d2 = Dropable::new(i+100); m.insert(d1, d2); } DROP_VECTOR.with(|v| { - for i in 0u..200 { + for i in 0..200 { assert_eq!(v.borrow()[i], 1); } }); - for i in 0u..50 { + for i in 0..50 { let k = Dropable::new(i); let v = m.remove(&k); @@ -1741,12 +1741,12 @@ mod test_map { } DROP_VECTOR.with(|v| { - for i in 0u..50 { + for i in 0..50 { assert_eq!(v.borrow()[i], 0); assert_eq!(v.borrow()[i+100], 0); } - for i in 50u..100 { + for i in 50..100 { assert_eq!(v.borrow()[i], 1); assert_eq!(v.borrow()[i+100], 1); } @@ -1754,7 +1754,7 @@ mod test_map { } DROP_VECTOR.with(|v| { - for i in 0u..200 { + for i in 0..200 { assert_eq!(v.borrow()[i], 0); } }); @@ -1770,19 +1770,19 @@ mod test_map { let mut hm = HashMap::new(); DROP_VECTOR.with(|v| { - for i in 0u..200 { + for i in 0..200 { assert_eq!(v.borrow()[i], 0); } }); - for i in 0u..100 { + for i in 0..100 { let d1 = Dropable::new(i); let d2 = Dropable::new(i+100); hm.insert(d1, d2); } DROP_VECTOR.with(|v| { - for i in 0u..200 { + for i in 0..200 { assert_eq!(v.borrow()[i], 1); } }); @@ -1797,7 +1797,7 @@ mod test_map { let mut half = hm.into_iter().take(50); DROP_VECTOR.with(|v| { - for i in 0u..200 { + for i in 0..200 { assert_eq!(v.borrow()[i], 1); } }); @@ -1805,11 +1805,11 @@ mod test_map { for _ in half.by_ref() {} DROP_VECTOR.with(|v| { - let nk = (0u..100).filter(|&i| { + let nk = (0..100).filter(|&i| { v.borrow()[i] == 1 }).count(); - let nv = (0u..100).filter(|&i| { + let nv = (0..100).filter(|&i| { v.borrow()[i+100] == 1 }).count(); @@ -1819,7 +1819,7 @@ mod test_map { }; DROP_VECTOR.with(|v| { - for i in 0u..200 { + for i in 0..200 { assert_eq!(v.borrow()[i], 0); } }); @@ -1964,7 +1964,7 @@ mod test_map { #[test] fn test_iterate() { let mut m = HashMap::with_capacity(4); - for i in 0u..32 { + for i in 0..32 { assert!(m.insert(i, i*2).is_none()); } assert_eq!(m.len(), 32); @@ -1981,8 +1981,8 @@ mod test_map { #[test] fn test_keys() { let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; - let map = vec.into_iter().collect::>(); - let keys = map.keys().map(|&k| k).collect::>(); + let map: HashMap<_, _> = vec.into_iter().collect(); + let keys: Vec<_> = map.keys().cloned().collect(); assert_eq!(keys.len(), 3); assert!(keys.contains(&1)); assert!(keys.contains(&2)); @@ -1992,8 +1992,8 @@ mod test_map { #[test] fn test_values() { let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; - let map = vec.into_iter().collect::>(); - let values = map.values().map(|&v| v).collect::>(); + let map: HashMap<_, _> = vec.into_iter().collect(); + let values: Vec<_> = map.values().cloned().collect(); assert_eq!(values.len(), 3); assert!(values.contains(&'a')); assert!(values.contains(&'b')); @@ -2031,8 +2031,8 @@ mod test_map { #[test] fn test_show() { - let mut map: HashMap = HashMap::new(); - let empty: HashMap = HashMap::new(); + let mut map = HashMap::new(); + let empty: HashMap = HashMap::new(); map.insert(1, 2); map.insert(3, 4); @@ -2051,7 +2051,7 @@ mod test_map { assert_eq!(m.len(), 0); assert!(m.is_empty()); - let mut i = 0u; + let mut i = 0; let old_cap = m.table.capacity(); while old_cap == m.table.capacity() { m.insert(i, i); @@ -2079,7 +2079,7 @@ mod test_map { assert_eq!(cap, initial_cap * 2); - let mut i = 0u; + let mut i = 0; for _ in 0..cap * 3 / 4 { m.insert(i, i); i += 1; @@ -2121,21 +2121,21 @@ mod test_map { #[test] fn test_reserve_shrink_to_fit() { let mut m = HashMap::new(); - m.insert(0u, 0u); + m.insert(0, 0); m.remove(&0); assert!(m.capacity() >= m.len()); - for i in 0us..128 { + for i in 0..128 { m.insert(i, i); } m.reserve(256); let usable_cap = m.capacity(); - for i in 128us..128+256 { + for i in 128..(128 + 256) { m.insert(i, i); assert_eq!(m.capacity(), usable_cap); } - for i in 100us..128+256 { + for i in 100..(128 + 256) { assert_eq!(m.remove(&i), Some(i)); } m.shrink_to_fit(); @@ -2144,7 +2144,7 @@ mod test_map { assert!(!m.is_empty()); assert!(m.capacity() >= m.len()); - for i in 0us..100 { + for i in 0..100 { assert_eq!(m.remove(&i), Some(i)); } m.shrink_to_fit(); @@ -2159,7 +2159,7 @@ mod test_map { fn test_from_iter() { let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; - let map: HashMap = xs.iter().map(|&x| x).collect(); + let map: HashMap<_, _> = xs.iter().cloned().collect(); for &(k, v) in &xs { assert_eq!(map.get(&k), Some(&v)); @@ -2170,7 +2170,7 @@ mod test_map { fn test_size_hint() { let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; - let map: HashMap = xs.iter().map(|&x| x).collect(); + let map: HashMap<_, _> = xs.iter().cloned().collect(); let mut iter = map.iter(); @@ -2183,7 +2183,7 @@ mod test_map { fn test_iter_len() { let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; - let map: HashMap = xs.iter().map(|&x| x).collect(); + let map: HashMap<_, _> = xs.iter().cloned().collect(); let mut iter = map.iter(); @@ -2196,7 +2196,7 @@ mod test_map { fn test_mut_size_hint() { let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; - let mut map: HashMap = xs.iter().map(|&x| x).collect(); + let mut map: HashMap<_, _> = xs.iter().cloned().collect(); let mut iter = map.iter_mut(); @@ -2209,7 +2209,7 @@ mod test_map { fn test_iter_mut_len() { let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; - let mut map: HashMap = xs.iter().map(|&x| x).collect(); + let mut map: HashMap<_, _> = xs.iter().cloned().collect(); let mut iter = map.iter_mut(); @@ -2220,7 +2220,7 @@ mod test_map { #[test] fn test_index() { - let mut map: HashMap = HashMap::new(); + let mut map = HashMap::new(); map.insert(1, 2); map.insert(2, 1); @@ -2232,7 +2232,7 @@ mod test_map { #[test] #[should_fail] fn test_index_nonexistent() { - let mut map: HashMap = HashMap::new(); + let mut map = HashMap::new(); map.insert(1, 2); map.insert(2, 1); @@ -2245,7 +2245,7 @@ mod test_map { fn test_entry(){ let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; - let mut map: HashMap = xs.iter().map(|&x| x).collect(); + let mut map: HashMap<_, _> = xs.iter().cloned().collect(); // Existing key (insert) match map.entry(1) { @@ -2296,7 +2296,7 @@ mod test_map { #[test] fn test_entry_take_doesnt_corrupt() { // Test for #19292 - fn check(m: &HashMap) { + fn check(m: &HashMap) { for k in m.keys() { assert!(m.contains_key(k), "{} is in keys() but not in the map?", k); @@ -2307,12 +2307,12 @@ mod test_map { let mut rng = weak_rng(); // Populate the map with some items. - for _ in 0u..50 { + for _ in 0..50 { let x = rng.gen_range(-10, 10); m.insert(x, ()); } - for i in 0u..1000 { + for i in 0..1000 { let x = rng.gen_range(-10, 10); match m.entry(x) { Vacant(_) => {}, diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index f5877e1dd99d8..a4641f14e3084 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -76,7 +76,7 @@ use super::state::HashState; /// #[derive(Hash, Eq, PartialEq, Debug)] /// struct Viking<'a> { /// name: &'a str, -/// power: uint, +/// power: usize, /// } /// /// let mut vikings = HashSet::new(); @@ -123,7 +123,7 @@ impl + Eq> HashSet { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(capacity: uint) -> HashSet { + pub fn with_capacity(capacity: usize) -> HashSet { HashSet { map: HashMap::with_capacity(capacity) } } } @@ -174,7 +174,7 @@ impl HashSet /// ``` #[inline] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")] - pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S) + pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S) -> HashSet { HashSet { map: HashMap::with_capacity_and_hash_state(capacity, hash_state), @@ -192,7 +192,7 @@ impl HashSet /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> uint { + pub fn capacity(&self) -> usize { self.map.capacity() } @@ -202,7 +202,7 @@ impl HashSet /// /// # Panics /// - /// Panics if the new allocation size overflows `uint`. + /// Panics if the new allocation size overflows `usize`. /// /// # Example /// @@ -212,7 +212,7 @@ impl HashSet /// set.reserve(10); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve(&mut self, additional: uint) { + pub fn reserve(&mut self, additional: usize) { self.map.reserve(additional) } @@ -402,7 +402,7 @@ impl HashSet /// assert_eq!(v.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> uint { self.map.len() } + pub fn len(&self) -> usize { self.map.len() } /// Returns true if the set contains no elements /// @@ -456,7 +456,7 @@ impl HashSet /// ``` /// use std::collections::HashSet; /// - /// let set: HashSet = [1, 2, 3].iter().map(|&x| x).collect(); + /// let set: HashSet<_> = [1, 2, 3].iter().cloned().collect(); /// assert_eq!(set.contains(&1), true); /// assert_eq!(set.contains(&4), false); /// ``` @@ -475,8 +475,8 @@ impl HashSet /// ``` /// use std::collections::HashSet; /// - /// let a: HashSet = [1, 2, 3].iter().map(|&x| x).collect(); - /// let mut b: HashSet = HashSet::new(); + /// let a: HashSet<_> = [1, 2, 3].iter().cloned().collect(); + /// let mut b = HashSet::new(); /// /// assert_eq!(a.is_disjoint(&b), true); /// b.insert(4); @@ -496,8 +496,8 @@ impl HashSet /// ``` /// use std::collections::HashSet; /// - /// let sup: HashSet = [1, 2, 3].iter().map(|&x| x).collect(); - /// let mut set: HashSet = HashSet::new(); + /// let sup: HashSet<_> = [1, 2, 3].iter().cloned().collect(); + /// let mut set = HashSet::new(); /// /// assert_eq!(set.is_subset(&sup), true); /// set.insert(2); @@ -517,8 +517,8 @@ impl HashSet /// ``` /// use std::collections::HashSet; /// - /// let sub: HashSet = [1, 2].iter().map(|&x| x).collect(); - /// let mut set: HashSet = HashSet::new(); + /// let sub: HashSet<_> = [1, 2].iter().cloned().collect(); + /// let mut set = HashSet::new(); /// /// assert_eq!(set.is_superset(&sub), false); /// @@ -670,10 +670,10 @@ impl<'a, 'b, T, S, H> BitOr<&'b HashSet> for &'a HashSet /// ``` /// use std::collections::HashSet; /// - /// let a: HashSet = vec![1, 2, 3].into_iter().collect(); - /// let b: HashSet = vec![3, 4, 5].into_iter().collect(); + /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect(); /// - /// let set: HashSet = &a | &b; + /// let set = &a | &b; /// /// let mut i = 0; /// let expected = [1, 2, 3, 4, 5]; @@ -703,10 +703,10 @@ impl<'a, 'b, T, S, H> BitAnd<&'b HashSet> for &'a HashSet /// ``` /// use std::collections::HashSet; /// - /// let a: HashSet = vec![1, 2, 3].into_iter().collect(); - /// let b: HashSet = vec![2, 3, 4].into_iter().collect(); + /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: HashSet<_> = vec![2, 3, 4].into_iter().collect(); /// - /// let set: HashSet = &a & &b; + /// let set = &a & &b; /// /// let mut i = 0; /// let expected = [2, 3]; @@ -736,10 +736,10 @@ impl<'a, 'b, T, S, H> BitXor<&'b HashSet> for &'a HashSet /// ``` /// use std::collections::HashSet; /// - /// let a: HashSet = vec![1, 2, 3].into_iter().collect(); - /// let b: HashSet = vec![3, 4, 5].into_iter().collect(); + /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect(); /// - /// let set: HashSet = &a ^ &b; + /// let set = &a ^ &b; /// /// let mut i = 0; /// let expected = [1, 2, 4, 5]; @@ -769,10 +769,10 @@ impl<'a, 'b, T, S, H> Sub<&'b HashSet> for &'a HashSet /// ``` /// use std::collections::HashSet; /// - /// let a: HashSet = vec![1, 2, 3].into_iter().collect(); - /// let b: HashSet = vec![3, 4, 5].into_iter().collect(); + /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect(); /// - /// let set: HashSet = &a - &b; + /// let set = &a - &b; /// /// let mut i = 0; /// let expected = [1, 2]; @@ -1029,7 +1029,7 @@ mod test_set { #[test] fn test_iterate() { let mut a = HashSet::new(); - for i in 0u..32 { + for i in 0..32 { assert!(a.insert(i)); } let mut observed: u32 = 0; @@ -1152,7 +1152,7 @@ mod test_set { fn test_from_iter() { let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9]; - let set: HashSet = xs.iter().map(|&x| x).collect(); + let set: HashSet<_> = xs.iter().cloned().collect(); for x in &xs { assert!(set.contains(x)); @@ -1198,8 +1198,8 @@ mod test_set { #[test] fn test_show() { - let mut set: HashSet = HashSet::new(); - let empty: HashSet = HashSet::new(); + let mut set = HashSet::new(); + let empty = HashSet::::new(); set.insert(1); set.insert(2); @@ -1212,19 +1212,19 @@ mod test_set { #[test] fn test_trivial_drain() { - let mut s = HashSet::::new(); + let mut s = HashSet::::new(); for _ in s.drain() {} assert!(s.is_empty()); drop(s); - let mut s = HashSet::::new(); + let mut s = HashSet::::new(); drop(s.drain()); assert!(s.is_empty()); } #[test] fn test_drain() { - let mut s: HashSet = (1..100).collect(); + let mut s: HashSet<_> = (1..100).collect(); // try this a bunch of times to make sure we don't screw up internal state. for _ in 0..20 { diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index 8952b81690186..0bb6bd4cf356a 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -67,8 +67,8 @@ const EMPTY_BUCKET: u64 = 0u64; /// but in general is just a tricked out `Vec>`. #[unsafe_no_drop_flag] pub struct RawTable { - capacity: uint, - size: uint, + capacity: usize, + size: usize, hashes: *mut u64, // Because K/V do not appear directly in any of the types in the struct, // inform rustc that in fact instances of K and V are reachable from here. @@ -88,7 +88,7 @@ impl Copy for RawBucket {} pub struct Bucket { raw: RawBucket, - idx: uint, + idx: usize, table: M } @@ -96,13 +96,13 @@ impl Copy for Bucket {} pub struct EmptyBucket { raw: RawBucket, - idx: uint, + idx: usize, table: M } pub struct FullBucket { raw: RawBucket, - idx: uint, + idx: usize, table: M } @@ -190,7 +190,7 @@ impl FullBucket { self.table } /// Get the raw index. - pub fn index(&self) -> uint { + pub fn index(&self) -> usize { self.idx } } @@ -212,21 +212,21 @@ impl Bucket { self.table } /// Get the raw index. - pub fn index(&self) -> uint { + pub fn index(&self) -> usize { self.idx } } impl>> Bucket { pub fn new(table: M, hash: SafeHash) -> Bucket { - Bucket::at_index(table, hash.inspect() as uint) + Bucket::at_index(table, hash.inspect() as usize) } - pub fn at_index(table: M, ib_index: uint) -> Bucket { + pub fn at_index(table: M, ib_index: usize) -> Bucket { let ib_index = ib_index & (table.capacity() - 1); Bucket { raw: unsafe { - table.first_bucket_raw().offset(ib_index as int) + table.first_bucket_raw().offset(ib_index as isize) }, idx: ib_index, table: table @@ -276,7 +276,7 @@ impl>> Bucket { // ... and it's zero at all other times. let maybe_wraparound_dist = (self.idx ^ (self.idx + 1)) & self.table.capacity(); // Finally, we obtain the offset 1 or the offset -cap + 1. - let dist = 1 - (maybe_wraparound_dist as int); + let dist = 1 - (maybe_wraparound_dist as isize); self.idx += 1; @@ -366,11 +366,11 @@ impl>> FullBucket { /// /// In the cited blog posts above, this is called the "distance to /// initial bucket", or DIB. Also known as "probe count". - pub fn distance(&self) -> uint { + pub fn distance(&self) -> usize { // Calculates the distance one has to travel when going from // `hash mod capacity` onwards to `idx mod capacity`, wrapping around // if the destination is not reached before the end of the table. - (self.idx - self.hash().inspect() as uint) & (self.table.capacity() - 1) + (self.idx - self.hash().inspect() as usize) & (self.table.capacity() - 1) } #[inline] @@ -503,7 +503,7 @@ impl>> GapThenFull { /// # Panics /// /// Panics if `target_alignment` is not a power of two. -fn round_up_to_next(unrounded: uint, target_alignment: uint) -> uint { +fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize { assert!(target_alignment.is_power_of_two()); (unrounded + target_alignment - 1) & !(target_alignment - 1) } @@ -520,10 +520,10 @@ fn test_rounding() { // Returns a tuple of (key_offset, val_offset), // from the start of a mallocated array. -fn calculate_offsets(hashes_size: uint, - keys_size: uint, keys_align: uint, - vals_align: uint) - -> (uint, uint) { +fn calculate_offsets(hashes_size: usize, + keys_size: usize, keys_align: usize, + vals_align: usize) + -> (usize, usize) { let keys_offset = round_up_to_next(hashes_size, keys_align); let end_of_keys = keys_offset + keys_size; @@ -534,10 +534,10 @@ fn calculate_offsets(hashes_size: uint, // Returns a tuple of (minimum required malloc alignment, hash_offset, // array_size), from the start of a mallocated array. -fn calculate_allocation(hash_size: uint, hash_align: uint, - keys_size: uint, keys_align: uint, - vals_size: uint, vals_align: uint) - -> (uint, uint, uint) { +fn calculate_allocation(hash_size: usize, hash_align: usize, + keys_size: usize, keys_align: usize, + vals_size: usize, vals_align: usize) + -> (usize, usize, usize) { let hash_offset = 0; let (_, vals_offset) = calculate_offsets(hash_size, keys_size, keys_align, @@ -562,7 +562,7 @@ fn test_offset_calculation() { impl RawTable { /// Does not initialize the buckets. The caller should ensure they, /// at the very least, set every hash to EMPTY_BUCKET. - unsafe fn new_uninitialized(capacity: uint) -> RawTable { + unsafe fn new_uninitialized(capacity: usize) -> RawTable { if capacity == 0 { return RawTable { size: 0, @@ -601,7 +601,7 @@ impl RawTable { let buffer = allocate(size, malloc_alignment); if buffer.is_null() { ::alloc::oom() } - let hashes = buffer.offset(hash_offset as int) as *mut u64; + let hashes = buffer.offset(hash_offset as isize) as *mut u64; RawTable { capacity: capacity, @@ -623,15 +623,15 @@ impl RawTable { unsafe { RawBucket { hash: self.hashes, - key: buffer.offset(keys_offset as int) as *mut K, - val: buffer.offset(vals_offset as int) as *mut V + key: buffer.offset(keys_offset as isize) as *mut K, + val: buffer.offset(vals_offset as isize) as *mut V } } } /// Creates a new raw table from a given capacity. All buckets are /// initially empty. - pub fn new(capacity: uint) -> RawTable { + pub fn new(capacity: usize) -> RawTable { unsafe { let ret = RawTable::new_uninitialized(capacity); zero_memory(ret.hashes, capacity); @@ -640,13 +640,13 @@ impl RawTable { } /// The hashtable's capacity, similar to a vector's. - pub fn capacity(&self) -> uint { + pub fn capacity(&self) -> usize { self.capacity } /// The number of elements ever `put` in the hashtable, minus the number /// of elements ever `take`n. - pub fn size(&self) -> uint { + pub fn size(&self) -> usize { self.size } @@ -654,7 +654,7 @@ impl RawTable { RawBuckets { raw: self.first_bucket_raw(), hashes_end: unsafe { - self.hashes.offset(self.capacity as int) + self.hashes.offset(self.capacity as isize) }, marker: marker::ContravariantLifetime, } @@ -705,7 +705,7 @@ impl RawTable { unsafe fn rev_move_buckets(&mut self) -> RevMoveBuckets { let raw_bucket = self.first_bucket_raw(); RevMoveBuckets { - raw: raw_bucket.offset(self.capacity as int), + raw: raw_bucket.offset(self.capacity as isize), hashes_end: raw_bucket.hash, elems_left: self.size, marker: marker::ContravariantLifetime, @@ -758,7 +758,7 @@ impl<'a, K, V> Iterator for RawBuckets<'a, K, V> { struct RevMoveBuckets<'a, K, V> { raw: RawBucket, hashes_end: *mut u64, - elems_left: uint, + elems_left: usize, marker: marker::ContravariantLifetime<'a>, } @@ -791,7 +791,7 @@ impl<'a, K, V> Iterator for RevMoveBuckets<'a, K, V> { /// Iterator over shared references to entries in a table. pub struct Iter<'a, K: 'a, V: 'a> { iter: RawBuckets<'a, K, V>, - elems_left: uint, + elems_left: usize, } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -808,7 +808,7 @@ impl<'a, K, V> Clone for Iter<'a, K, V> { /// Iterator over mutable references to entries in a table. pub struct IterMut<'a, K: 'a, V: 'a> { iter: RawBuckets<'a, K, V>, - elems_left: uint, + elems_left: usize, } /// Iterator over the entries in a table, consuming the table. From 1420cebebd48a187d8639243beaf207a0dd90853 Mon Sep 17 00:00:00 2001 From: Alexis Date: Thu, 5 Feb 2015 13:48:20 -0500 Subject: [PATCH 23/35] remove unecessary lifetimes from a bunch of collections code --- src/libcollections/binary_heap.rs | 2 +- src/libcollections/ring_buf.rs | 12 +++---- src/libcollections/slice.rs | 52 +++++++++++++++---------------- src/libcollections/str.rs | 8 ++--- src/libcollections/string.rs | 8 ++--- src/libcollections/vec.rs | 18 +++++------ 6 files changed, 50 insertions(+), 50 deletions(-) diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index fe477c3495f81..3bc5b0ca053e4 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -708,7 +708,7 @@ mod tests { let iterout = vec![3, 5, 9]; let pq = BinaryHeap::from_vec(data); - let v: Vec<_> = pq.iter().rev().map(|&x| x).collect(); + let v: Vec<_> = pq.iter().rev().cloned().collect(); assert_eq!(v, iterout); } diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 85c4a64c0c172..8c219418309b8 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -529,13 +529,13 @@ impl RingBuf { /// assert_eq!(&buf.iter_mut().collect::>()[], b); /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> { + pub fn iter_mut(&mut self) -> IterMut { IterMut { tail: self.tail, head: self.head, cap: self.cap, ptr: self.ptr, - marker: marker::ContravariantLifetime::<'a>, + marker: marker::ContravariantLifetime, } } @@ -552,7 +552,7 @@ impl RingBuf { #[inline] #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] - pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) { + pub fn as_slices(&self) -> (&[T], &[T]) { unsafe { let contiguous = self.is_contiguous(); let buf = self.buffer_as_slice(); @@ -572,7 +572,7 @@ impl RingBuf { #[inline] #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] - pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) { + pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) { unsafe { let contiguous = self.is_contiguous(); let head = self.head; @@ -1584,7 +1584,7 @@ impl Index for RingBuf { type Output = A; #[inline] - fn index<'a>(&'a self, i: &usize) -> &'a A { + fn index(&self, i: &usize) -> &A { self.get(*i).expect("Out of bounds access") } } @@ -1594,7 +1594,7 @@ impl IndexMut for RingBuf { type Output = A; #[inline] - fn index_mut<'a>(&'a mut self, i: &usize) -> &'a mut A { + fn index_mut(&mut self, i: &usize) -> &mut A { self.get_mut(*i).expect("Out of bounds access") } } diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 3fe3fe04a5432..eb7e1b10c9b2d 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -812,27 +812,27 @@ impl SliceExt for [T] { } #[inline] - fn slice<'a>(&'a self, start: usize, end: usize) -> &'a [T] { + fn slice(&self, start: usize, end: usize) -> &[T] { &self[start .. end] } #[inline] - fn slice_from<'a>(&'a self, start: usize) -> &'a [T] { + fn slice_from(&self, start: usize) -> &[T] { &self[start ..] } #[inline] - fn slice_to<'a>(&'a self, end: usize) -> &'a [T] { + fn slice_to(&self, end: usize) -> &[T] { &self[.. end] } #[inline] - fn split_at<'a>(&'a self, mid: usize) -> (&'a [T], &'a [T]) { + fn split_at(&self, mid: usize) -> (&[T], &[T]) { core_slice::SliceExt::split_at(self, mid) } #[inline] - fn iter<'a>(&'a self) -> Iter<'a, T> { + fn iter(&self) -> Iter { core_slice::SliceExt::iter(self) } @@ -855,42 +855,42 @@ impl SliceExt for [T] { } #[inline] - fn windows<'a>(&'a self, size: usize) -> Windows<'a, T> { + fn windows(&self, size: usize) -> Windows { core_slice::SliceExt::windows(self, size) } #[inline] - fn chunks<'a>(&'a self, size: usize) -> Chunks<'a, T> { + fn chunks(&self, size: usize) -> Chunks { core_slice::SliceExt::chunks(self, size) } #[inline] - fn get<'a>(&'a self, index: usize) -> Option<&'a T> { + fn get(&self, index: usize) -> Option<&T> { core_slice::SliceExt::get(self, index) } #[inline] - fn first<'a>(&'a self) -> Option<&'a T> { + fn first(&self) -> Option<&T> { core_slice::SliceExt::first(self) } #[inline] - fn tail<'a>(&'a self) -> &'a [T] { + fn tail(&self) -> &[T] { core_slice::SliceExt::tail(self) } #[inline] - fn init<'a>(&'a self) -> &'a [T] { + fn init(&self) -> &[T] { core_slice::SliceExt::init(self) } #[inline] - fn last<'a>(&'a self) -> Option<&'a T> { + fn last(&self) -> Option<&T> { core_slice::SliceExt::last(self) } #[inline] - unsafe fn get_unchecked<'a>(&'a self, index: usize) -> &'a T { + unsafe fn get_unchecked(&self, index: usize) -> &T { core_slice::SliceExt::get_unchecked(self, index) } @@ -916,52 +916,52 @@ impl SliceExt for [T] { } #[inline] - fn get_mut<'a>(&'a mut self, index: usize) -> Option<&'a mut T> { + fn get_mut(&mut self, index: usize) -> Option<&mut T> { core_slice::SliceExt::get_mut(self, index) } #[inline] - fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] { + fn as_mut_slice(&mut self) -> &mut [T] { core_slice::SliceExt::as_mut_slice(self) } #[inline] - fn slice_mut<'a>(&'a mut self, start: usize, end: usize) -> &'a mut [T] { + fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] { &mut self[start .. end] } #[inline] - fn slice_from_mut<'a>(&'a mut self, start: usize) -> &'a mut [T] { + fn slice_from_mut(&mut self, start: usize) -> &mut [T] { &mut self[start ..] } #[inline] - fn slice_to_mut<'a>(&'a mut self, end: usize) -> &'a mut [T] { + fn slice_to_mut(&mut self, end: usize) -> &mut [T] { &mut self[.. end] } #[inline] - fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> { + fn iter_mut(&mut self) -> IterMut { core_slice::SliceExt::iter_mut(self) } #[inline] - fn first_mut<'a>(&'a mut self) -> Option<&'a mut T> { + fn first_mut(&mut self) -> Option<&mut T> { core_slice::SliceExt::first_mut(self) } #[inline] - fn tail_mut<'a>(&'a mut self) -> &'a mut [T] { + fn tail_mut(&mut self) -> &mut [T] { core_slice::SliceExt::tail_mut(self) } #[inline] - fn init_mut<'a>(&'a mut self) -> &'a mut [T] { + fn init_mut(&mut self) -> &mut [T] { core_slice::SliceExt::init_mut(self) } #[inline] - fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> { + fn last_mut(&mut self) -> Option<&mut T> { core_slice::SliceExt::last_mut(self) } @@ -984,7 +984,7 @@ impl SliceExt for [T] { } #[inline] - fn chunks_mut<'a>(&'a mut self, chunk_size: usize) -> ChunksMut<'a, T> { + fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut { core_slice::SliceExt::chunks_mut(self, chunk_size) } @@ -994,7 +994,7 @@ impl SliceExt for [T] { } #[inline] - fn split_at_mut<'a>(&'a mut self, mid: usize) -> (&'a mut [T], &'a mut [T]) { + fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) { core_slice::SliceExt::split_at_mut(self, mid) } @@ -1004,7 +1004,7 @@ impl SliceExt for [T] { } #[inline] - unsafe fn get_unchecked_mut<'a>(&'a mut self, index: usize) -> &'a mut T { + unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T { core_slice::SliceExt::get_unchecked_mut(self, index) } diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index e6fb3005ff38c..65c397359f4ea 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -464,7 +464,7 @@ pub trait StrExt: Index { #[inline] #[unstable(feature = "collections", reason = "this functionality may be moved to libunicode")] - fn nfd_chars<'a>(&'a self) -> Decompositions<'a> { + fn nfd_chars(&self) -> Decompositions { Decompositions { iter: self[].chars(), buffer: Vec::new(), @@ -478,7 +478,7 @@ pub trait StrExt: Index { #[inline] #[unstable(feature = "collections", reason = "this functionality may be moved to libunicode")] - fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> { + fn nfkd_chars(&self) -> Decompositions { Decompositions { iter: self[].chars(), buffer: Vec::new(), @@ -492,7 +492,7 @@ pub trait StrExt: Index { #[inline] #[unstable(feature = "collections", reason = "this functionality may be moved to libunicode")] - fn nfc_chars<'a>(&'a self) -> Recompositions<'a> { + fn nfc_chars(&self) -> Recompositions { Recompositions { iter: self.nfd_chars(), state: Composing, @@ -507,7 +507,7 @@ pub trait StrExt: Index { #[inline] #[unstable(feature = "collections", reason = "this functionality may be moved to libunicode")] - fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> { + fn nfkc_chars(&self) -> Recompositions { Recompositions { iter: self.nfkd_chars(), state: Composing, diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index e3db8d04d4aba..cf2d4415412af 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -488,7 +488,7 @@ impl String { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn as_bytes<'a>(&'a self) -> &'a [u8] { + pub fn as_bytes(&self) -> &[u8] { &self.vec } @@ -627,7 +627,7 @@ impl String { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec { + pub unsafe fn as_mut_vec(&mut self) -> &mut Vec { &mut self.vec } @@ -803,7 +803,7 @@ impl<'a, 'b> PartialEq> for &'b str { impl Str for String { #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn as_slice<'a>(&'a self) -> &'a str { + fn as_slice(&self) -> &str { unsafe { mem::transmute(&*self.vec) } } } @@ -891,7 +891,7 @@ impl ops::Deref for String { type Target = str; #[inline] - fn deref<'a>(&'a self) -> &'a str { + fn deref(&self) -> &str { unsafe { mem::transmute(&self.vec[]) } } } diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index f14b34bc2153b..071c08728cb03 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -425,7 +425,7 @@ impl Vec { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] { + pub fn as_mut_slice(&mut self) -> &mut [T] { unsafe { mem::transmute(RawSlice { data: *self.ptr, @@ -737,7 +737,7 @@ impl Vec { #[inline] #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] - pub fn drain<'a>(&'a mut self) -> Drain<'a, T> { + pub fn drain(&mut self) -> Drain { unsafe { let begin = *self.ptr as *const T; let end = if mem::size_of::() == 0 { @@ -1278,7 +1278,7 @@ impl Index for Vec { type Output = T; #[inline] - fn index<'a>(&'a self, index: &usize) -> &'a T { + fn index(&self, index: &usize) -> &T { // NB built-in indexing via `&[T]` &(**self)[*index] } @@ -1289,7 +1289,7 @@ impl IndexMut for Vec { type Output = T; #[inline] - fn index_mut<'a>(&'a mut self, index: &usize) -> &'a mut T { + fn index_mut(&mut self, index: &usize) -> &mut T { // NB built-in indexing via `&mut [T]` &mut (**self)[*index] } @@ -1366,12 +1366,12 @@ impl ops::IndexMut for Vec { impl ops::Deref for Vec { type Target = [T]; - fn deref<'a>(&'a self) -> &'a [T] { self.as_slice() } + fn deref(&self) -> &[T] { self.as_slice() } } #[stable(feature = "rust1", since = "1.0.0")] impl ops::DerefMut for Vec { - fn deref_mut<'a>(&'a mut self) -> &'a mut [T] { self.as_mut_slice() } + fn deref_mut(&mut self) -> &mut [T] { self.as_mut_slice() } } #[stable(feature = "rust1", since = "1.0.0")] @@ -1519,7 +1519,7 @@ impl AsSlice for Vec { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn as_slice<'a>(&'a self) -> &'a [T] { + fn as_slice(&self) -> &[T] { unsafe { mem::transmute(RawSlice { data: *self.ptr, @@ -1636,7 +1636,7 @@ impl Iterator for IntoIter { type Item = T; #[inline] - fn next<'a>(&'a mut self) -> Option { + fn next(&mut self) -> Option { unsafe { if self.ptr == self.end { None @@ -1671,7 +1671,7 @@ impl Iterator for IntoIter { #[stable(feature = "rust1", since = "1.0.0")] impl DoubleEndedIterator for IntoIter { #[inline] - fn next_back<'a>(&'a mut self) -> Option { + fn next_back(&mut self) -> Option { unsafe { if self.end == self.ptr { None From 15fb06d73008d868f10707f32c5caebff41b3026 Mon Sep 17 00:00:00 2001 From: Alexis Date: Thu, 5 Feb 2015 15:08:33 -0500 Subject: [PATCH 24/35] remove int_uint feature from libcollections --- src/libcollections/bit.rs | 304 ++++++++++++++++----------------- src/libcollections/lib.rs | 1 - src/libcollections/ring_buf.rs | 4 +- src/libcollections/slice.rs | 40 ++--- src/libcollections/string.rs | 12 +- src/libcollections/vec.rs | 30 ++-- 6 files changed, 195 insertions(+), 196 deletions(-) diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index 2728e08d6158c..8ba0eb9b7efe5 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -266,8 +266,8 @@ impl Bitv { /// ``` /// use std::collections::Bitv; /// - /// let mut bv = Bitv::from_elem(10u, false); - /// assert_eq!(bv.len(), 10u); + /// let mut bv = Bitv::from_elem(10, false); + /// assert_eq!(bv.len(), 10); /// for x in bv.iter() { /// assert_eq!(x, false); /// } @@ -353,7 +353,7 @@ impl Bitv { /// ``` pub fn from_fn(len: usize, mut f: F) -> Bitv where F: FnMut(usize) -> bool { let mut bitv = Bitv::from_elem(len, false); - for i in 0u..len { + for i in 0..len { bitv.set(i, f(i)); } bitv @@ -1415,7 +1415,7 @@ impl BitvSet { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn iter(&self) -> bitv_set::Iter { - SetIter {set: self, next_idx: 0u} + SetIter {set: self, next_idx: 0} } /// Iterator over each u32 stored in `self` union `other`. @@ -1443,8 +1443,8 @@ impl BitvSet { set: self, other: other, merge: or, - current_word: 0u32, - next_idx: 0u + current_word: 0, + next_idx: 0 }) } @@ -1473,7 +1473,7 @@ impl BitvSet { set: self, other: other, merge: bitand, - current_word: 0u32, + current_word: 0, next_idx: 0 }.take(min)) } @@ -1510,7 +1510,7 @@ impl BitvSet { set: self, other: other, merge: diff, - current_word: 0u32, + current_word: 0, next_idx: 0 }) } @@ -1541,7 +1541,7 @@ impl BitvSet { set: self, other: other, merge: bitxor, - current_word: 0u32, + current_word: 0, next_idx: 0 }) } @@ -1902,7 +1902,7 @@ mod tests { let zerolen = Bitv::new(); assert_eq!(format!("{:?}", zerolen), ""); - let eightbits = Bitv::from_elem(8u, false); + let eightbits = Bitv::from_elem(8, false); assert_eq!(format!("{:?}", eightbits), "00000000") } @@ -1916,10 +1916,10 @@ mod tests { #[test] fn test_1_element() { - let mut act = Bitv::from_elem(1u, false); + let mut act = Bitv::from_elem(1, false); assert!(act.eq_vec(&[false])); assert!(act.none() && !act.all()); - act = Bitv::from_elem(1u, true); + act = Bitv::from_elem(1, true); assert!(act.eq_vec(&[true])); assert!(!act.none() && act.all()); } @@ -1938,42 +1938,42 @@ mod tests { let mut act; // all 0 - act = Bitv::from_elem(10u, false); + act = Bitv::from_elem(10, false); assert!((act.eq_vec( &[false, false, false, false, false, false, false, false, false, false]))); assert!(act.none() && !act.all()); // all 1 - act = Bitv::from_elem(10u, true); + act = Bitv::from_elem(10, true); assert!((act.eq_vec(&[true, true, true, true, true, true, true, true, true, true]))); assert!(!act.none() && act.all()); // mixed - act = Bitv::from_elem(10u, false); - act.set(0u, true); - act.set(1u, true); - act.set(2u, true); - act.set(3u, true); - act.set(4u, true); + act = Bitv::from_elem(10, false); + act.set(0, true); + act.set(1, true); + act.set(2, true); + act.set(3, true); + act.set(4, true); assert!((act.eq_vec(&[true, true, true, true, true, false, false, false, false, false]))); assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(10u, false); - act.set(5u, true); - act.set(6u, true); - act.set(7u, true); - act.set(8u, true); - act.set(9u, true); + act = Bitv::from_elem(10, false); + act.set(5, true); + act.set(6, true); + act.set(7, true); + act.set(8, true); + act.set(9, true); assert!((act.eq_vec(&[false, false, false, false, false, true, true, true, true, true]))); assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(10u, false); - act.set(0u, true); - act.set(3u, true); - act.set(6u, true); - act.set(9u, true); + act = Bitv::from_elem(10, false); + act.set(0, true); + act.set(3, true); + act.set(6, true); + act.set(9, true); assert!((act.eq_vec(&[true, false, false, true, false, false, true, false, false, true]))); assert!(!act.none() && !act.all()); } @@ -1983,7 +1983,7 @@ mod tests { let mut act; // all 0 - act = Bitv::from_elem(31u, false); + act = Bitv::from_elem(31, false); assert!(act.eq_vec( &[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, @@ -1991,7 +1991,7 @@ mod tests { assert!(act.none() && !act.all()); // all 1 - act = Bitv::from_elem(31u, true); + act = Bitv::from_elem(31, true); assert!(act.eq_vec( &[true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, @@ -1999,15 +1999,15 @@ mod tests { assert!(!act.none() && act.all()); // mixed - act = Bitv::from_elem(31u, false); - act.set(0u, true); - act.set(1u, true); - act.set(2u, true); - act.set(3u, true); - act.set(4u, true); - act.set(5u, true); - act.set(6u, true); - act.set(7u, true); + act = Bitv::from_elem(31, false); + act.set(0, true); + act.set(1, true); + act.set(2, true); + act.set(3, true); + act.set(4, true); + act.set(5, true); + act.set(6, true); + act.set(7, true); assert!(act.eq_vec( &[true, true, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, @@ -2015,15 +2015,15 @@ mod tests { assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(31u, false); - act.set(16u, true); - act.set(17u, true); - act.set(18u, true); - act.set(19u, true); - act.set(20u, true); - act.set(21u, true); - act.set(22u, true); - act.set(23u, true); + act = Bitv::from_elem(31, false); + act.set(16, true); + act.set(17, true); + act.set(18, true); + act.set(19, true); + act.set(20, true); + act.set(21, true); + act.set(22, true); + act.set(23, true); assert!(act.eq_vec( &[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, true, true, true, true, true, true, @@ -2031,14 +2031,14 @@ mod tests { assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(31u, false); - act.set(24u, true); - act.set(25u, true); - act.set(26u, true); - act.set(27u, true); - act.set(28u, true); - act.set(29u, true); - act.set(30u, true); + act = Bitv::from_elem(31, false); + act.set(24, true); + act.set(25, true); + act.set(26, true); + act.set(27, true); + act.set(28, true); + act.set(29, true); + act.set(30, true); assert!(act.eq_vec( &[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, @@ -2046,10 +2046,10 @@ mod tests { assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(31u, false); - act.set(3u, true); - act.set(17u, true); - act.set(30u, true); + act = Bitv::from_elem(31, false); + act.set(3, true); + act.set(17, true); + act.set(30, true); assert!(act.eq_vec( &[false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, @@ -2062,7 +2062,7 @@ mod tests { let mut act; // all 0 - act = Bitv::from_elem(32u, false); + act = Bitv::from_elem(32, false); assert!(act.eq_vec( &[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, @@ -2070,7 +2070,7 @@ mod tests { assert!(act.none() && !act.all()); // all 1 - act = Bitv::from_elem(32u, true); + act = Bitv::from_elem(32, true); assert!(act.eq_vec( &[true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, @@ -2078,15 +2078,15 @@ mod tests { assert!(!act.none() && act.all()); // mixed - act = Bitv::from_elem(32u, false); - act.set(0u, true); - act.set(1u, true); - act.set(2u, true); - act.set(3u, true); - act.set(4u, true); - act.set(5u, true); - act.set(6u, true); - act.set(7u, true); + act = Bitv::from_elem(32, false); + act.set(0, true); + act.set(1, true); + act.set(2, true); + act.set(3, true); + act.set(4, true); + act.set(5, true); + act.set(6, true); + act.set(7, true); assert!(act.eq_vec( &[true, true, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, @@ -2094,15 +2094,15 @@ mod tests { assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(32u, false); - act.set(16u, true); - act.set(17u, true); - act.set(18u, true); - act.set(19u, true); - act.set(20u, true); - act.set(21u, true); - act.set(22u, true); - act.set(23u, true); + act = Bitv::from_elem(32, false); + act.set(16, true); + act.set(17, true); + act.set(18, true); + act.set(19, true); + act.set(20, true); + act.set(21, true); + act.set(22, true); + act.set(23, true); assert!(act.eq_vec( &[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, true, true, true, true, true, true, @@ -2110,15 +2110,15 @@ mod tests { assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(32u, false); - act.set(24u, true); - act.set(25u, true); - act.set(26u, true); - act.set(27u, true); - act.set(28u, true); - act.set(29u, true); - act.set(30u, true); - act.set(31u, true); + act = Bitv::from_elem(32, false); + act.set(24, true); + act.set(25, true); + act.set(26, true); + act.set(27, true); + act.set(28, true); + act.set(29, true); + act.set(30, true); + act.set(31, true); assert!(act.eq_vec( &[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, @@ -2126,11 +2126,11 @@ mod tests { assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(32u, false); - act.set(3u, true); - act.set(17u, true); - act.set(30u, true); - act.set(31u, true); + act = Bitv::from_elem(32, false); + act.set(3, true); + act.set(17, true); + act.set(30, true); + act.set(31, true); assert!(act.eq_vec( &[false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, @@ -2143,7 +2143,7 @@ mod tests { let mut act; // all 0 - act = Bitv::from_elem(33u, false); + act = Bitv::from_elem(33, false); assert!(act.eq_vec( &[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, @@ -2151,7 +2151,7 @@ mod tests { assert!(act.none() && !act.all()); // all 1 - act = Bitv::from_elem(33u, true); + act = Bitv::from_elem(33, true); assert!(act.eq_vec( &[true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, @@ -2159,15 +2159,15 @@ mod tests { assert!(!act.none() && act.all()); // mixed - act = Bitv::from_elem(33u, false); - act.set(0u, true); - act.set(1u, true); - act.set(2u, true); - act.set(3u, true); - act.set(4u, true); - act.set(5u, true); - act.set(6u, true); - act.set(7u, true); + act = Bitv::from_elem(33, false); + act.set(0, true); + act.set(1, true); + act.set(2, true); + act.set(3, true); + act.set(4, true); + act.set(5, true); + act.set(6, true); + act.set(7, true); assert!(act.eq_vec( &[true, true, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, @@ -2175,15 +2175,15 @@ mod tests { assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(33u, false); - act.set(16u, true); - act.set(17u, true); - act.set(18u, true); - act.set(19u, true); - act.set(20u, true); - act.set(21u, true); - act.set(22u, true); - act.set(23u, true); + act = Bitv::from_elem(33, false); + act.set(16, true); + act.set(17, true); + act.set(18, true); + act.set(19, true); + act.set(20, true); + act.set(21, true); + act.set(22, true); + act.set(23, true); assert!(act.eq_vec( &[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, true, true, true, true, true, true, @@ -2191,15 +2191,15 @@ mod tests { assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(33u, false); - act.set(24u, true); - act.set(25u, true); - act.set(26u, true); - act.set(27u, true); - act.set(28u, true); - act.set(29u, true); - act.set(30u, true); - act.set(31u, true); + act = Bitv::from_elem(33, false); + act.set(24, true); + act.set(25, true); + act.set(26, true); + act.set(27, true); + act.set(28, true); + act.set(29, true); + act.set(30, true); + act.set(31, true); assert!(act.eq_vec( &[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, @@ -2207,12 +2207,12 @@ mod tests { assert!(!act.none() && !act.all()); // mixed - act = Bitv::from_elem(33u, false); - act.set(3u, true); - act.set(17u, true); - act.set(30u, true); - act.set(31u, true); - act.set(32u, true); + act = Bitv::from_elem(33, false); + act.set(3, true); + act.set(17, true); + act.set(30, true); + act.set(31, true); + act.set(32, true); assert!(act.eq_vec( &[false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, @@ -2222,15 +2222,15 @@ mod tests { #[test] fn test_equal_differing_sizes() { - let v0 = Bitv::from_elem(10u, false); - let v1 = Bitv::from_elem(11u, false); + let v0 = Bitv::from_elem(10, false); + let v1 = Bitv::from_elem(11, false); assert!(v0 != v1); } #[test] fn test_equal_greatly_differing_sizes() { - let v0 = Bitv::from_elem(10u, false); - let v1 = Bitv::from_elem(110u, false); + let v0 = Bitv::from_elem(10, false); + let v1 = Bitv::from_elem(110, false); assert!(v0 != v1); } @@ -2248,12 +2248,12 @@ mod tests { #[test] fn test_equal_sneaky_big() { let mut a = Bitv::from_elem(100, false); - for i in 0u..100 { + for i in 0..100 { a.set(i, true); } let mut b = Bitv::from_elem(100, true); - for i in 0u..100 { + for i in 0..100 { b.set(i, true); } @@ -2350,8 +2350,8 @@ mod tests { #[test] fn test_bitv_lt() { - let mut a = Bitv::from_elem(5u, false); - let mut b = Bitv::from_elem(5u, false); + let mut a = Bitv::from_elem(5, false); + let mut b = Bitv::from_elem(5, false); assert!(!(a < b) && !(b < a)); b.set(2, true); @@ -2366,8 +2366,8 @@ mod tests { #[test] fn test_ord() { - let mut a = Bitv::from_elem(5u, false); - let mut b = Bitv::from_elem(5u, false); + let mut a = Bitv::from_elem(5, false); + let mut b = Bitv::from_elem(5, false); assert!(a <= b && a >= b); a.set(1, true); @@ -2542,7 +2542,7 @@ mod bitv_bench { let mut r = rng(); let mut bitv = 0 as usize; b.iter(|| { - for _ in 0u..100 { + for _ in 0..100 { bitv |= 1 << ((r.next_u32() as usize) % u32::BITS); } black_box(&bitv); @@ -2554,7 +2554,7 @@ mod bitv_bench { let mut r = rng(); let mut bitv = Bitv::from_elem(BENCH_BITS, false); b.iter(|| { - for _ in 0u..100 { + for _ in 0..100 { bitv.set((r.next_u32() as usize) % BENCH_BITS, true); } black_box(&bitv); @@ -2566,7 +2566,7 @@ mod bitv_bench { let mut r = rng(); let mut bitv = Bitv::from_elem(BENCH_BITS, false); b.iter(|| { - for _ in 0u..100 { + for _ in 0..100 { bitv.set((r.next_u32() as usize) % BENCH_BITS, r.gen()); } black_box(&bitv); @@ -2578,7 +2578,7 @@ mod bitv_bench { let mut r = rng(); let mut bitv = Bitv::from_elem(u32::BITS, false); b.iter(|| { - for _ in 0u..100 { + for _ in 0..100 { bitv.set((r.next_u32() as usize) % u32::BITS, true); } black_box(&bitv); @@ -2598,8 +2598,8 @@ mod bitv_bench { fn bench_bitv_small_iter(b: &mut Bencher) { let bitv = Bitv::from_elem(u32::BITS, false); b.iter(|| { - let mut sum = 0u; - for _ in 0u..10 { + let mut sum = 0; + for _ in 0..10 { for pres in &bitv { sum += pres as usize; } @@ -2612,7 +2612,7 @@ mod bitv_bench { fn bench_bitv_big_iter(b: &mut Bencher) { let bitv = Bitv::from_elem(BENCH_BITS, false); b.iter(|| { - let mut sum = 0u; + let mut sum = 0; for pres in &bitv { sum += pres as usize; } @@ -2663,7 +2663,7 @@ mod bitv_set_test { let idxs: Vec<_> = bitv.iter().collect(); assert_eq!(idxs, vec![0, 2, 3]); - let long: BitvSet = (0u..10000).filter(|&n| n % 2 == 0).collect(); + let long: BitvSet = (0..10000).filter(|&n| n % 2 == 0).collect(); let real: Vec<_> = range_step(0, 10000, 2).collect(); let idxs: Vec<_> = long.iter().collect(); @@ -2677,8 +2677,8 @@ mod bitv_set_test { for &b in &bools { for &l in &lengths { let bitset = BitvSet::from_bitv(Bitv::from_elem(l, b)); - assert_eq!(bitset.contains(&1u), b); - assert_eq!(bitset.contains(&(l-1u)), b); + assert_eq!(bitset.contains(&1), b); + assert_eq!(bitset.contains(&(l-1)), b); assert!(!bitset.contains(&l)); } } diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index f44141fe0f493..57c799785e82d 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -26,7 +26,6 @@ #![feature(box_syntax)] #![feature(core)] #![feature(hash)] -#![feature(int_uint)] #![feature(staged_api)] #![feature(unboxed_closures)] #![feature(unicode)] diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 8c219418309b8..83828940ab8bb 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -32,8 +32,8 @@ use std::cmp; use alloc::heap; -static INITIAL_CAPACITY: usize = 7u; // 2^3 - 1 -static MINIMUM_CAPACITY: usize = 1u; // 2 - 1 +static INITIAL_CAPACITY: usize = 7; // 2^3 - 1 +static MINIMUM_CAPACITY: usize = 1; // 2 - 1 /// `RingBuf` is a circular buffer, which can be used as a double-ended queue efficiently. #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index eb7e1b10c9b2d..ddbc86506b89c 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -1116,7 +1116,7 @@ pub trait SliceConcatExt { impl> SliceConcatExt> for [V] { fn concat(&self) -> Vec { - let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len()); + let size = self.iter().fold(0, |acc, v| acc + v.as_slice().len()); let mut result = Vec::with_capacity(size); for v in self { result.push_all(v.as_slice()) @@ -1125,7 +1125,7 @@ impl> SliceConcatExt> for [V] { } fn connect(&self, sep: &T) -> Vec { - let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len()); + let size = self.iter().fold(0, |acc, v| acc + v.as_slice().len()); let mut result = Vec::with_capacity(size + self.len()); let mut first = true; for v in self { @@ -1301,7 +1301,7 @@ impl Iterator for Permutations { //////////////////////////////////////////////////////////////////////////////// fn insertion_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Ordering { - let len = v.len() as int; + let len = v.len() as isize; let buf_v = v.as_mut_ptr(); // 1 <= i < len; @@ -1371,7 +1371,7 @@ fn merge_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order let mut working_space = Vec::with_capacity(2 * len); // these both are buffers of length `len`. let mut buf_dat = working_space.as_mut_ptr(); - let mut buf_tmp = unsafe {buf_dat.offset(len as int)}; + let mut buf_tmp = unsafe {buf_dat.offset(len as isize)}; // length `len`. let buf_v = v.as_ptr(); @@ -1387,17 +1387,17 @@ fn merge_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order // start <= i < len; for i in start..cmp::min(start + insertion, len) { // j satisfies: start <= j <= i; - let mut j = i as int; + let mut j = i as isize; unsafe { // `i` is in bounds. - let read_ptr = buf_v.offset(i as int); + let read_ptr = buf_v.offset(i as isize); // find where to insert, we need to do strict <, // rather than <=, to maintain stability. // start <= j - 1 < len, so .offset(j - 1) is in // bounds. - while j > start as int && + while j > start as isize && compare(&*read_ptr, &*buf_dat.offset(j - 1)) == Less { j -= 1; } @@ -1431,24 +1431,24 @@ fn merge_sort(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order // the end of the first run & start of the // second. Offset of `len` is defined, since this is // precisely one byte past the end of the object. - let right_start = buf_dat.offset(cmp::min(start + width, len) as int); + let right_start = buf_dat.offset(cmp::min(start + width, len) as isize); // end of the second. Similar reasoning to the above re safety. let right_end_idx = cmp::min(start + 2 * width, len); - let right_end = buf_dat.offset(right_end_idx as int); + let right_end = buf_dat.offset(right_end_idx as isize); // the pointers to the elements under consideration // from the two runs. // both of these are in bounds. - let mut left = buf_dat.offset(start as int); + let mut left = buf_dat.offset(start as isize); let mut right = right_start; // where we're putting the results, it is a run of // length `2*width`, so we step it once for each step // of either `left` or `right`. `buf_tmp` has length // `len`, so these are in bounds. - let mut out = buf_tmp.offset(start as int); - let out_end = buf_tmp.offset(right_end_idx as int); + let mut out = buf_tmp.offset(start as isize); + let out_end = buf_tmp.offset(right_end_idx as isize); while out < out_end { // Either the left or the right run are exhausted, @@ -2373,7 +2373,7 @@ mod tests { #[test] fn test_mut_rev_iterator() { - let mut xs = [1u, 2, 3, 4, 5]; + let mut xs = [1, 2, 3, 4, 5]; for (i,x) in xs.iter_mut().rev().enumerate() { *x += i; } @@ -2382,13 +2382,13 @@ mod tests { #[test] fn test_move_iterator() { - let xs = vec![1u,2,3,4,5]; + let xs = vec![1,2,3,4,5]; assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345); } #[test] fn test_move_rev_iterator() { - let xs = vec![1u,2,3,4,5]; + let xs = vec![1,2,3,4,5]; assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321); } @@ -2592,7 +2592,7 @@ mod tests { test_show_vec!(empty, "[]"); test_show_vec!(vec![1], "[1]"); test_show_vec!(vec![1, 2, 3], "[1, 2, 3]"); - test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]], + test_show_vec!(vec![vec![], vec![1], vec![1, 1]], "[[], [1], [1, 1]]"); let empty_mut: &mut [i32] = &mut[]; @@ -2601,7 +2601,7 @@ mod tests { test_show_vec!(v, "[1]"); let v = &mut[1, 2, 3]; test_show_vec!(v, "[1, 2, 3]"); - let v: &mut[&mut[_]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]]; + let v: &mut[&mut[_]] = &mut[&mut[], &mut[1], &mut[1, 1]]; test_show_vec!(v, "[[], [1], [1, 1]]"); } @@ -2677,7 +2677,7 @@ mod tests { fn test_iter_zero_sized() { let mut v = vec![Foo, Foo, Foo]; assert_eq!(v.len(), 3); - let mut cnt = 0u; + let mut cnt = 0; for f in &v { assert!(*f == Foo); @@ -3016,7 +3016,7 @@ mod bench { let mut rng = weak_rng(); b.iter(|| { let mut v: Vec<_> = repeat((0, 0)).take(30).collect(); - for _ in 0u..100 { + for _ in 0..100 { let l = v.len(); v.insert(rng.gen::() % (l + 1), (1, 1)); @@ -3028,7 +3028,7 @@ mod bench { let mut rng = weak_rng(); b.iter(|| { let mut v: Vec<_> = repeat((0, 0)).take(130).collect(); - for _ in 0u..100 { + for _ in 0..100 { let l = v.len(); v.remove(rng.gen::() % l); } diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index cf2d4415412af..2574cfc28da73 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -469,7 +469,7 @@ impl String { // Attempt to not use an intermediate buffer by just pushing bytes // directly onto this string. let slice = RawSlice { - data: self.vec.as_ptr().offset(cur_len as int), + data: self.vec.as_ptr().offset(cur_len as isize), len: 4, }; let used = ch.encode_utf8(mem::transmute(slice)).unwrap_or(0); @@ -569,8 +569,8 @@ impl String { let CharRange { ch, next } = self.char_range_at(idx); unsafe { - ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int), - self.vec.as_ptr().offset(next as int), + ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize), + self.vec.as_ptr().offset(next as isize), len - next); self.vec.set_len(len - (next - idx)); } @@ -599,10 +599,10 @@ impl String { let amt = ch.encode_utf8(&mut bits).unwrap(); unsafe { - ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as int), - self.vec.as_ptr().offset(idx as int), + ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as isize), + self.vec.as_ptr().offset(idx as isize), len - idx); - ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int), + ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize), bits.as_ptr(), amt); self.vec.set_len(len + amt); diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 071c08728cb03..c6c8beec87017 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -234,7 +234,7 @@ impl Vec { /// mem::forget(v); /// /// // Overwrite memory with 4, 5, 6 - /// for i in 0..len as int { + /// for i in 0..len as isize { /// ptr::write(p.offset(i), 4 + i); /// } /// @@ -457,7 +457,7 @@ impl Vec { let end = if mem::size_of::() == 0 { (ptr as usize + self.len()) as *const T } else { - ptr.offset(self.len() as int) as *const T + ptr.offset(self.len() as isize) as *const T }; mem::forget(self); IntoIter { allocation: ptr, cap: cap, ptr: begin, end: end } @@ -473,7 +473,7 @@ impl Vec { /// # Examples /// /// ``` - /// let mut v = vec![1u, 2, 3, 4]; + /// let mut v = vec![1, 2, 3, 4]; /// unsafe { /// v.set_len(1); /// } @@ -539,7 +539,7 @@ impl Vec { unsafe { // infallible // The spot to put the new value { - let p = self.as_mut_ptr().offset(index as int); + let p = self.as_mut_ptr().offset(index as isize); // Shift everything over to make space. (Duplicating the // `index`th element into two consecutive places.) ptr::copy_memory(p.offset(1), &*p, len - index); @@ -573,7 +573,7 @@ impl Vec { let ret; { // the place we are taking from. - let ptr = self.as_mut_ptr().offset(index as int); + let ptr = self.as_mut_ptr().offset(index as isize); // copy it out, unsafely having a copy of the value on // the stack and in the vector at the same time. ret = ptr::read(ptr); @@ -655,7 +655,7 @@ impl Vec { } unsafe { - let end = (*self.ptr).offset(self.len as int); + let end = (*self.ptr).offset(self.len as isize); ptr::write(&mut *end, value); self.len += 1; } @@ -743,7 +743,7 @@ impl Vec { let end = if mem::size_of::() == 0 { (*self.ptr as usize + self.len()) as *const T } else { - (*self.ptr).offset(self.len() as int) as *const T + (*self.ptr).offset(self.len() as isize) as *const T }; self.set_len(0); Drain { @@ -835,7 +835,7 @@ impl Vec { // types are passed to the allocator by `Vec`. assert!(mem::min_align_of::() == mem::min_align_of::()); - // This `as int` cast is safe, because the size of the elements of the + // This `as isize` cast is safe, because the size of the elements of the // vector is not 0, and: // // 1) If the size of the elements in the vector is 1, the `int` may @@ -852,7 +852,7 @@ impl Vec { // // 2) If the size of the elements in the vector is >1, the `usize` -> // `int` conversion can't overflow. - let offset = vec.len() as int; + let offset = vec.len() as isize; let start = vec.as_mut_ptr(); let mut pv = PartialVecNonZeroSized { @@ -1179,8 +1179,8 @@ impl Vec { let mut w = 1; while r < ln { - let p_r = p.offset(r as int); - let p_wm1 = p.offset((w - 1) as int); + let p_r = p.offset(r as isize); + let p_wm1 = p.offset((w - 1) as isize); if *p_r != *p_wm1 { if r != w { let p_w = p_wm1.offset(1); @@ -1648,7 +1648,7 @@ impl Iterator for IntoIter { self.ptr = mem::transmute(self.ptr as usize + 1); // Use a non-null pointer value - Some(ptr::read(mem::transmute(1u))) + Some(ptr::read(EMPTY as *mut T)) } else { let old = self.ptr; self.ptr = self.ptr.offset(1); @@ -1681,7 +1681,7 @@ impl DoubleEndedIterator for IntoIter { self.end = mem::transmute(self.end as usize - 1); // Use a non-null pointer value - Some(ptr::read(mem::transmute(1u))) + Some(ptr::read(EMPTY as *mut T)) } else { self.end = self.end.offset(-1); @@ -1736,7 +1736,7 @@ impl<'a, T> Iterator for Drain<'a, T> { self.ptr = mem::transmute(self.ptr as usize + 1); // Use a non-null pointer value - Some(ptr::read(mem::transmute(1u))) + Some(ptr::read(EMPTY as *mut T)) } else { let old = self.ptr; self.ptr = self.ptr.offset(1); @@ -1769,7 +1769,7 @@ impl<'a, T> DoubleEndedIterator for Drain<'a, T> { self.end = mem::transmute(self.end as usize - 1); // Use a non-null pointer value - Some(ptr::read(mem::transmute(1u))) + Some(ptr::read(EMPTY as *mut T)) } else { self.end = self.end.offset(-1); From 47c2091f265a520aceeda41b16664c204067088e Mon Sep 17 00:00:00 2001 From: Leo Testard Date: Fri, 6 Feb 2015 00:07:05 +0100 Subject: [PATCH 25/35] Fix an ICE when translating some static expressions. Creating two identical static expressions involving casts of pointers to arrays caused an assertion failure in librustc_trans. --- src/librustc_trans/trans/consts.rs | 6 ++++-- src/test/run-pass/issue-21891.rs | 16 ++++++++++++++++ 2 files changed, 20 insertions(+), 2 deletions(-) create mode 100644 src/test/run-pass/issue-21891.rs diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index 0403a2f2e3c67..43b6f2256777a 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -241,8 +241,10 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr) ty::ty_vec(unit_ty, Some(len)) => { let llunitty = type_of::type_of(cx, unit_ty); let llptr = ptrcast(llconst, llunitty.ptr_to()); - assert!(cx.const_globals().borrow_mut() - .insert(llptr as int, llconst).is_none()); + let prev_const = cx.const_globals().borrow_mut() + .insert(llptr as int, llconst); + assert!(prev_const.is_none() || + prev_const == Some(llconst)); assert_eq!(abi::FAT_PTR_ADDR, 0); assert_eq!(abi::FAT_PTR_EXTRA, 1); llconst = C_struct(cx, &[ diff --git a/src/test/run-pass/issue-21891.rs b/src/test/run-pass/issue-21891.rs new file mode 100644 index 0000000000000..d6e6f23191e24 --- /dev/null +++ b/src/test/run-pass/issue-21891.rs @@ -0,0 +1,16 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +static foo: [uint; 3] = [1, 2, 3]; + +static slice_1: &'static [uint] = &foo; +static slice_2: &'static [uint] = &foo; + +fn main() {} From ccb513e582cf032dcc220eadd31aa36ac6179a7a Mon Sep 17 00:00:00 2001 From: Steve Klabnik Date: Thu, 5 Feb 2015 19:57:28 -0500 Subject: [PATCH 26/35] Improve ptr::read docs Fixes #21491 --- src/libcore/ptr.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 9c18cd0f6d9af..ba1eae551ff2a 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -190,7 +190,7 @@ pub unsafe fn replace(dest: *mut T, mut src: T) -> T { src } -/// Reads the value from `src` without dropping it. This leaves the +/// Reads the value from `src` without moving it. This leaves the /// memory in `src` unchanged. /// /// # Safety From ef0bbaac6b7d830a4c486cb1232b06da0adc0647 Mon Sep 17 00:00:00 2001 From: Steve Klabnik Date: Thu, 5 Feb 2015 22:07:47 -0500 Subject: [PATCH 27/35] Mention the queueueue-ness of mpsc. Fixes #21915 --- src/libstd/sync/mpsc/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index 39c57a21d752a..2e60d684d6823 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! Multi-producer, single-consumer communication primitives threads +//! Multi-producer, single-consumer FIFO queue communication primitives. //! //! This module provides message-based communication over channels, concretely //! defined among three types: From 3df2fbe18e3bfd80b1313c18aaaa0546233fb9d6 Mon Sep 17 00:00:00 2001 From: Kevin Yap Date: Thu, 5 Feb 2015 20:13:08 -0800 Subject: [PATCH 28/35] Fix name of variable referenced in featureck.py --- src/etc/featureck.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/etc/featureck.py b/src/etc/featureck.py index 064cf1d40ab36..2a3f9ed04e54d 100644 --- a/src/etc/featureck.py +++ b/src/etc/featureck.py @@ -190,9 +190,9 @@ if not name in joint_features: print "error: feature '" + name + "' is both a lang and lib feature but not whitelisted" errors = True - lang_status = lang_feature_stats[name][3] + lang_status = language_feature_stats[name][3] lib_status = lib_feature_stats[name][3] - lang_stable_since = lang_feature_stats[name][4] + lang_stable_since = language_feature_stats[name][4] lib_stable_since = lib_feature_stats[name][4] if lang_status != lib_status and lib_status != "deprecated": From 73b9aeb4295aaf6c215c5981150bfa2ac9ace60a Mon Sep 17 00:00:00 2001 From: Alexis Date: Thu, 5 Feb 2015 15:08:33 -0500 Subject: [PATCH 29/35] remove int_uint feature from libcollections --- src/libcollections/btree/set.rs | 6 +++--- src/libcollections/slice.rs | 4 ++-- src/libcollections/vec.rs | 10 +++++----- src/libcollections/vec_map.rs | 4 ++-- 4 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index b02c522f86da9..eb398ff8743fc 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -890,7 +890,7 @@ mod test { fn test_from_iter() { let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9]; - let set: BTreeSet = xs.iter().map(|&x| x).collect(); + let set: BTreeSet<_> = xs.iter().cloned().collect(); for x in &xs { assert!(set.contains(x)); @@ -899,8 +899,8 @@ mod test { #[test] fn test_show() { - let mut set: BTreeSet = BTreeSet::new(); - let empty: BTreeSet = BTreeSet::new(); + let mut set = BTreeSet::new(); + let empty = BTreeSet::::new(); set.insert(1); set.insert(2); diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 64cdfd5acffcd..679754be7490e 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -1575,7 +1575,7 @@ mod tests { #[test] fn test_is_empty() { - let xs: [int; 0] = []; + let xs: [i32; 0] = []; assert!(xs.is_empty()); assert!(![0].is_empty()); } @@ -1913,7 +1913,7 @@ mod tests { #[test] fn test_permutations() { { - let v: [int; 0] = []; + let v: [i32; 0] = []; let mut it = v.permutations(); let (min_size, max_opt) = it.size_hint(); assert_eq!(min_size, 1); diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index c6c8beec87017..62640e1e25032 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -2146,10 +2146,10 @@ mod tests { #[test] fn test_partition() { - assert_eq!(vec![].into_iter().partition(|x: &int| *x < 3), (vec![], vec![])); - assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![])); - assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 2), (vec![1], vec![2, 3])); - assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3])); + assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![])); + assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![])); + assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3])); + assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3])); } #[test] @@ -2183,7 +2183,7 @@ mod tests { #[test] fn test_vec_truncate_drop() { static mut drops: u32 = 0; - struct Elem(int); + struct Elem(i32); impl Drop for Elem { fn drop(&mut self) { unsafe { drops += 1; } diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index 1bb9fcf819256..4153c2a7de335 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -1053,7 +1053,7 @@ mod test_map { assert!(m.insert(10, 11).is_none()); for (k, v) in &mut m { - *v += k as int; + *v += k as isize; } let mut it = m.iter(); @@ -1095,7 +1095,7 @@ mod test_map { assert!(m.insert(10, 11).is_none()); for (k, v) in m.iter_mut().rev() { - *v += k as int; + *v += k as isize; } let mut it = m.iter(); From f7aac937f588f43c9124639be5c20366921b49be Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Fri, 6 Feb 2015 08:05:52 +0530 Subject: [PATCH 30/35] libcollections: unit test fixes --- src/libcollections/btree/map.rs | 3 ++- src/libcollections/vec_map.rs | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index fdabec9eaf00b..79d923a34925c 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -1592,7 +1592,8 @@ mod test { use prelude::*; use std::iter::range_inclusive; - use super::{BTreeMap, Occupied, Vacant}; + use super::BTreeMap; + use super::Entry::{Occupied, Vacant}; use Bound::{self, Included, Excluded, Unbounded}; #[test] diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index 4153c2a7de335..65592d138c72c 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -915,7 +915,8 @@ mod test_map { use prelude::*; use core::hash::{hash, SipHasher}; - use super::{VecMap, Occupied, Vacant}; + use super::VecMap; + use super::Entry::{Occupied, Vacant}; #[test] fn test_get_mut() { From 40d1b23fdd4b793828b39f889d66fdd2b617f909 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Fri, 6 Feb 2015 16:19:30 +0530 Subject: [PATCH 31/35] rm unused feature --- src/librustc_typeck/lib.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index a07179b31bbd8..ccf392365cea0 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -83,7 +83,6 @@ This API is completely unstable and subject to change. #![feature(rustc_private)] #![feature(slicing_syntax, unsafe_destructor)] #![feature(staged_api)] -#![feature(std_misc)] #[macro_use] extern crate log; #[macro_use] extern crate syntax; From 1589dcf944939cf0ca5e74b737c874f43bdbdc83 Mon Sep 17 00:00:00 2001 From: Simonas Kazlauskas Date: Fri, 6 Feb 2015 16:24:13 +0200 Subject: [PATCH 32/35] Remove word syntax from obsolete syntax messages The word is repeated twice in the message like error: obsolete syntax: `:`, `&mut:`, or `&:` syntax This removes the word syntax that appears in messages after the second colon (:). --- src/libsyntax/parse/obsolete.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 60de6c909b78b..1df2e762ee748 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -63,15 +63,15 @@ impl<'a> ParserObsoleteMethods for parser::Parser<'a> { "use a `move ||` expression instead", ), ObsoleteSyntax::ClosureType => ( - "`|usize| -> bool` closure type syntax", + "`|usize| -> bool` closure type", "use unboxed closures instead, no type annotation needed" ), ObsoleteSyntax::ClosureKind => ( - "`:`, `&mut:`, or `&:` syntax", + "`:`, `&mut:`, or `&:`", "rely on inference instead" ), ObsoleteSyntax::Sized => ( - "`Sized? T` syntax for removing the `Sized` bound", + "`Sized? T` for removing the `Sized` bound", "write `T: ?Sized` instead" ), }; From e5f25244f14e9c67198226e0b6ac45f4ffdf349b Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Fri, 6 Feb 2015 23:36:02 +0530 Subject: [PATCH 33/35] More libcollections fixes --- src/libstd/collections/mod.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index 6e64542211133..a167dd65e679b 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -299,15 +299,15 @@ //! #### Counting the number of times each character in a string occurs //! //! ``` -//! use std::collections::btree_map::{BTreeMap, Occupied, Vacant}; +//! use std::collections::btree_map::{BTreeMap, Entry}; //! //! let mut count = BTreeMap::new(); //! let message = "she sells sea shells by the sea shore"; //! //! for c in message.chars() { //! match count.entry(c) { -//! Vacant(entry) => { entry.insert(1u); }, -//! Occupied(mut entry) => *entry.get_mut() += 1, +//! Entry::Vacant(entry) => { entry.insert(1u); }, +//! Entry::Occupied(mut entry) => *entry.get_mut() += 1, //! } //! } //! From 3a9b4e5f8dfc7bb8f27cc27c3f2ecf9750b87a26 Mon Sep 17 00:00:00 2001 From: Alexis Date: Fri, 6 Feb 2015 13:57:13 -0500 Subject: [PATCH 34/35] fix outdated docs Conflicts: src/libstd/collections/mod.rs --- src/libstd/collections/mod.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index a167dd65e679b..d12c8b93cca26 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -209,7 +209,7 @@ //! all the contents of the collection. //! //! ``` -//! let vec = vec![1u, 2, 3, 4]; +//! let vec = vec![1, 2, 3, 4]; //! for x in vec.iter() { //! println!("vec contained {}", x); //! } @@ -219,7 +219,7 @@ //! This is great for mutating all the contents of the collection. //! //! ``` -//! let mut vec = vec![1u, 2, 3, 4]; +//! let mut vec = vec![1, 2, 3, 4]; //! for x in vec.iter_mut() { //! *x += 1; //! } @@ -234,15 +234,15 @@ //! previous section to do this as efficiently as possible. //! //! ``` -//! let mut vec1 = vec![1u, 2, 3, 4]; -//! let vec2 = vec![10u, 20, 30, 40]; +//! let mut vec1 = vec![1, 2, 3, 4]; +//! let vec2 = vec![10, 20, 30, 40]; //! vec1.extend(vec2.into_iter()); //! ``` //! //! ``` //! use std::collections::RingBuf; //! -//! let vec = vec![1u, 2, 3, 4]; +//! let vec = vec![1, 2, 3, 4]; //! let buf: RingBuf = vec.into_iter().collect(); //! ``` //! @@ -253,7 +253,7 @@ //! iterators as the way to iterate over them in reverse order. //! //! ``` -//! let vec = vec![1u, 2, 3, 4]; +//! let vec = vec![1, 2, 3, 4]; //! for x in vec.iter().rev() { //! println!("vec contained {}", x); //! } @@ -326,7 +326,7 @@ //! #### Tracking the inebriation of customers at a bar //! //! ``` -//! use std::collections::btree_map::{BTreeMap, Occupied, Vacant}; +//! use std::collections::btree_map::{BTreeMap, Entry}; //! //! // A client of the bar. They have an id and a blood alcohol level. //! struct Person { id: u32, blood_alcohol: f32 }; @@ -341,8 +341,8 @@ //! // If this is the first time we've seen this customer, initialize them //! // with no blood alcohol. Otherwise, just retrieve them. //! let person = match blood_alcohol.entry(id) { -//! Vacant(entry) => entry.insert(Person{id: id, blood_alcohol: 0.0}), -//! Occupied(entry) => entry.into_mut(), +//! Entry::Vacant(entry) => entry.insert(Person{id: id, blood_alcohol: 0.0}), +//! Entry::Occupied(entry) => entry.into_mut(), //! }; //! //! // Reduce their blood alcohol level. It takes time to order and drink a beer! From e15538d7ac6c4a7f6ab269565d1aac8cca71e73a Mon Sep 17 00:00:00 2001 From: Alexis Date: Fri, 6 Feb 2015 13:57:13 -0500 Subject: [PATCH 35/35] fix outdated docs Conflicts: src/libstd/collections/mod.rs --- src/libcollections/binary_heap.rs | 10 +++--- src/libcollections/btree/map.rs | 56 +++++++++++++++--------------- src/libcollections/btree/set.rs | 52 +++++++++++++-------------- src/libcollections/ring_buf.rs | 2 +- src/libstd/collections/hash/map.rs | 32 ++++++++--------- src/libstd/collections/hash/set.rs | 22 ++++++------ src/libstd/collections/mod.rs | 2 +- 7 files changed, 88 insertions(+), 88 deletions(-) diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index 3bc5b0ca053e4..275fc34f81326 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -183,7 +183,7 @@ impl BinaryHeap { /// ``` /// use std::collections::BinaryHeap; /// let mut heap = BinaryHeap::new(); - /// heap.push(4u); + /// heap.push(4); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn new() -> BinaryHeap { BinaryHeap { data: vec![] } } @@ -198,7 +198,7 @@ impl BinaryHeap { /// ``` /// use std::collections::BinaryHeap; /// let mut heap = BinaryHeap::with_capacity(10); - /// heap.push(4u); + /// heap.push(4); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn with_capacity(capacity: usize) -> BinaryHeap { @@ -292,7 +292,7 @@ impl BinaryHeap { /// use std::collections::BinaryHeap; /// let mut heap = BinaryHeap::with_capacity(100); /// assert!(heap.capacity() >= 100); - /// heap.push(4u); + /// heap.push(4); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn capacity(&self) -> usize { self.data.capacity() } @@ -315,7 +315,7 @@ impl BinaryHeap { /// let mut heap = BinaryHeap::new(); /// heap.reserve_exact(100); /// assert!(heap.capacity() >= 100); - /// heap.push(4u); + /// heap.push(4); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn reserve_exact(&mut self, additional: usize) { @@ -336,7 +336,7 @@ impl BinaryHeap { /// let mut heap = BinaryHeap::new(); /// heap.reserve(100); /// assert!(heap.capacity() >= 100); - /// heap.push(4u); + /// heap.push(4); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn reserve(&mut self, additional: usize) { diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 79d923a34925c..1b6057d4c7286 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -173,7 +173,7 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut a = BTreeMap::new(); - /// a.insert(1u, "a"); + /// a.insert(1, "a"); /// a.clear(); /// assert!(a.is_empty()); /// ``` @@ -203,7 +203,7 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut map = BTreeMap::new(); - /// map.insert(1u, "a"); + /// map.insert(1, "a"); /// assert_eq!(map.get(&1), Some(&"a")); /// assert_eq!(map.get(&2), None); /// ``` @@ -235,7 +235,7 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut map = BTreeMap::new(); - /// map.insert(1u, "a"); + /// map.insert(1, "a"); /// assert_eq!(map.contains_key(&1), true); /// assert_eq!(map.contains_key(&2), false); /// ``` @@ -255,7 +255,7 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut map = BTreeMap::new(); - /// map.insert(1u, "a"); + /// map.insert(1, "a"); /// match map.get_mut(&1) { /// Some(x) => *x = "b", /// None => (), @@ -317,7 +317,7 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut map = BTreeMap::new(); - /// assert_eq!(map.insert(37u, "a"), None); + /// assert_eq!(map.insert(37, "a"), None); /// assert_eq!(map.is_empty(), false); /// /// map.insert(37, "b"); @@ -429,7 +429,7 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut map = BTreeMap::new(); - /// map.insert(1u, "a"); + /// map.insert(1, "a"); /// assert_eq!(map.remove(&1), Some("a")); /// assert_eq!(map.remove(&1), None); /// ``` @@ -1170,16 +1170,16 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut map = BTreeMap::new(); - /// map.insert(1u, "a"); - /// map.insert(2u, "b"); - /// map.insert(3u, "c"); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// map.insert(3, "c"); /// /// for (key, value) in map.iter() { /// println!("{}: {}", key, value); /// } /// /// let (first_key, first_value) = map.iter().next().unwrap(); - /// assert_eq!((*first_key, *first_value), (1u, "a")); + /// assert_eq!((*first_key, *first_value), (1, "a")); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn iter(&self) -> Iter { @@ -1203,9 +1203,9 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut map = BTreeMap::new(); - /// map.insert("a", 1u); - /// map.insert("b", 2u); - /// map.insert("c", 3u); + /// map.insert("a", 1); + /// map.insert("b", 2); + /// map.insert("c", 3); /// /// // add 10 to the value if the key isn't "a" /// for (key, value) in map.iter_mut() { @@ -1235,9 +1235,9 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut map = BTreeMap::new(); - /// map.insert(1u, "a"); - /// map.insert(2u, "b"); - /// map.insert(3u, "c"); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// map.insert(3, "c"); /// /// for (key, value) in map.into_iter() { /// println!("{}: {}", key, value); @@ -1264,11 +1264,11 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut a = BTreeMap::new(); - /// a.insert(1u, "a"); - /// a.insert(2u, "b"); + /// a.insert(1, "a"); + /// a.insert(2, "b"); /// /// let keys: Vec = a.keys().cloned().collect(); - /// assert_eq!(keys, vec![1u,2,]); + /// assert_eq!(keys, vec![1,2,]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn keys<'a>(&'a self) -> Keys<'a, K, V> { @@ -1286,8 +1286,8 @@ impl BTreeMap { /// use std::collections::BTreeMap; /// /// let mut a = BTreeMap::new(); - /// a.insert(1u, "a"); - /// a.insert(2u, "b"); + /// a.insert(1, "a"); + /// a.insert(2, "b"); /// /// let values: Vec<&str> = a.values().cloned().collect(); /// assert_eq!(values, vec!["a","b"]); @@ -1309,7 +1309,7 @@ impl BTreeMap { /// /// let mut a = BTreeMap::new(); /// assert_eq!(a.len(), 0); - /// a.insert(1u, "a"); + /// a.insert(1, "a"); /// assert_eq!(a.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -1324,7 +1324,7 @@ impl BTreeMap { /// /// let mut a = BTreeMap::new(); /// assert!(a.is_empty()); - /// a.insert(1u, "a"); + /// a.insert(1, "a"); /// assert!(!a.is_empty()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -1474,13 +1474,13 @@ impl BTreeMap { /// use std::collections::Bound::{Included, Unbounded}; /// /// let mut map = BTreeMap::new(); - /// map.insert(3u, "a"); - /// map.insert(5u, "b"); - /// map.insert(8u, "c"); + /// map.insert(3, "a"); + /// map.insert(5, "b"); + /// map.insert(8, "c"); /// for (&key, &value) in map.range(Included(&4), Included(&8)) { /// println!("{}: {}", key, value); /// } - /// assert_eq!(Some((&5u, &"b")), map.range(Included(&4), Unbounded).next()); + /// assert_eq!(Some((&5, &"b")), map.range(Included(&4), Unbounded).next()); /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] @@ -1539,7 +1539,7 @@ impl BTreeMap { /// } /// } /// - /// assert_eq!(count["a"], 3u); + /// assert_eq!(count["a"], 3); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn entry(&mut self, mut key: K) -> Entry { diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index eb398ff8743fc..c888a261f9d21 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -114,14 +114,14 @@ impl BTreeSet { /// ``` /// use std::collections::BTreeSet; /// - /// let set: BTreeSet = [1u, 2, 3, 4].iter().map(|&x| x).collect(); + /// let set: BTreeSet = [1, 2, 3, 4].iter().map(|&x| x).collect(); /// /// for x in set.iter() { /// println!("{}", x); /// } /// /// let v: Vec = set.iter().map(|&x| x).collect(); - /// assert_eq!(v, vec![1u,2,3,4]); + /// assert_eq!(v, vec![1,2,3,4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn iter(&self) -> Iter { @@ -135,10 +135,10 @@ impl BTreeSet { /// ``` /// use std::collections::BTreeSet; /// - /// let set: BTreeSet = [1u, 2, 3, 4].iter().map(|&x| x).collect(); + /// let set: BTreeSet = [1, 2, 3, 4].iter().map(|&x| x).collect(); /// /// let v: Vec = set.into_iter().collect(); - /// assert_eq!(v, vec![1u,2,3,4]); + /// assert_eq!(v, vec![1,2,3,4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn into_iter(self) -> IntoIter { @@ -162,13 +162,13 @@ impl BTreeSet { /// use std::collections::Bound::{Included, Unbounded}; /// /// let mut set = BTreeSet::new(); - /// set.insert(3u); - /// set.insert(5u); - /// set.insert(8u); + /// set.insert(3); + /// set.insert(5); + /// set.insert(8); /// for &elem in set.range(Included(&4), Included(&8)) { /// println!("{}", elem); /// } - /// assert_eq!(Some(&5u), set.range(Included(&4), Unbounded).next()); + /// assert_eq!(Some(&5), set.range(Included(&4), Unbounded).next()); /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] @@ -189,15 +189,15 @@ impl BTreeSet { /// use std::collections::BTreeSet; /// /// let mut a = BTreeSet::new(); - /// a.insert(1u); - /// a.insert(2u); + /// a.insert(1); + /// a.insert(2); /// /// let mut b = BTreeSet::new(); - /// b.insert(2u); - /// b.insert(3u); + /// b.insert(2); + /// b.insert(3); /// /// let diff: Vec = a.difference(&b).cloned().collect(); - /// assert_eq!(diff, vec![1u]); + /// assert_eq!(diff, vec![1]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn difference<'a>(&'a self, other: &'a BTreeSet) -> Difference<'a, T> { @@ -212,15 +212,15 @@ impl BTreeSet { /// use std::collections::BTreeSet; /// /// let mut a = BTreeSet::new(); - /// a.insert(1u); - /// a.insert(2u); + /// a.insert(1); + /// a.insert(2); /// /// let mut b = BTreeSet::new(); - /// b.insert(2u); - /// b.insert(3u); + /// b.insert(2); + /// b.insert(3); /// /// let sym_diff: Vec = a.symmetric_difference(&b).cloned().collect(); - /// assert_eq!(sym_diff, vec![1u,3]); + /// assert_eq!(sym_diff, vec![1,3]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet) @@ -236,15 +236,15 @@ impl BTreeSet { /// use std::collections::BTreeSet; /// /// let mut a = BTreeSet::new(); - /// a.insert(1u); - /// a.insert(2u); + /// a.insert(1); + /// a.insert(2); /// /// let mut b = BTreeSet::new(); - /// b.insert(2u); - /// b.insert(3u); + /// b.insert(2); + /// b.insert(3); /// /// let intersection: Vec = a.intersection(&b).cloned().collect(); - /// assert_eq!(intersection, vec![2u]); + /// assert_eq!(intersection, vec![2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn intersection<'a>(&'a self, other: &'a BTreeSet) @@ -260,13 +260,13 @@ impl BTreeSet { /// use std::collections::BTreeSet; /// /// let mut a = BTreeSet::new(); - /// a.insert(1u); + /// a.insert(1); /// /// let mut b = BTreeSet::new(); - /// b.insert(2u); + /// b.insert(2); /// /// let union: Vec = a.union(&b).cloned().collect(); - /// assert_eq!(union, vec![1u,2]); + /// assert_eq!(union, vec![1,2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn union<'a>(&'a self, other: &'a BTreeSet) -> Union<'a, T> { diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 83828940ab8bb..f5df7018153c4 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -388,7 +388,7 @@ impl RingBuf { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::with_capacity(15); - /// buf.extend(0u..4); + /// buf.extend(0..4); /// assert_eq!(buf.capacity(), 15); /// buf.shrink_to_fit(); /// assert!(buf.capacity() >= 4); diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index 283210ed644f5..aec9446773f2a 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -90,7 +90,7 @@ impl DefaultResizePolicy { fn test_resize_policy() { use prelude::v1::*; let rp = DefaultResizePolicy; - for n in 0u..1000 { + for n in 0..1000 { assert!(rp.min_capacity(rp.usable_capacity(n)) <= n); assert!(rp.usable_capacity(rp.min_capacity(n)) <= n); } @@ -287,9 +287,9 @@ fn test_resize_policy() { /// // Use a HashMap to store the vikings' health points. /// let mut vikings = HashMap::new(); /// -/// vikings.insert(Viking::new("Einar", "Norway"), 25u); -/// vikings.insert(Viking::new("Olaf", "Denmark"), 24u); -/// vikings.insert(Viking::new("Harald", "Iceland"), 12u); +/// vikings.insert(Viking::new("Einar", "Norway"), 25); +/// vikings.insert(Viking::new("Olaf", "Denmark"), 24); +/// vikings.insert(Viking::new("Harald", "Iceland"), 12); /// /// // Use derived implementation to print the status of the vikings. /// for (viking, health) in vikings.iter() { @@ -537,7 +537,7 @@ impl HashMap /// /// let s = RandomState::new(); /// let mut map = HashMap::with_hash_state(s); - /// map.insert(1, 2u); + /// map.insert(1, 2); /// ``` #[inline] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")] @@ -565,7 +565,7 @@ impl HashMap /// /// let s = RandomState::new(); /// let mut map = HashMap::with_capacity_and_hash_state(10, s); - /// map.insert(1, 2u); + /// map.insert(1, 2); /// ``` #[inline] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")] @@ -947,7 +947,7 @@ impl HashMap /// /// let mut a = HashMap::new(); /// assert_eq!(a.len(), 0); - /// a.insert(1u, "a"); + /// a.insert(1, "a"); /// assert_eq!(a.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -962,7 +962,7 @@ impl HashMap /// /// let mut a = HashMap::new(); /// assert!(a.is_empty()); - /// a.insert(1u, "a"); + /// a.insert(1, "a"); /// assert!(!a.is_empty()); /// ``` #[inline] @@ -978,8 +978,8 @@ impl HashMap /// use std::collections::HashMap; /// /// let mut a = HashMap::new(); - /// a.insert(1u, "a"); - /// a.insert(2u, "b"); + /// a.insert(1, "a"); + /// a.insert(2, "b"); /// /// for (k, v) in a.drain().take(1) { /// assert!(k == 1 || k == 2); @@ -1009,7 +1009,7 @@ impl HashMap /// use std::collections::HashMap; /// /// let mut a = HashMap::new(); - /// a.insert(1u, "a"); + /// a.insert(1, "a"); /// a.clear(); /// assert!(a.is_empty()); /// ``` @@ -1031,7 +1031,7 @@ impl HashMap /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// map.insert(1u, "a"); + /// map.insert(1, "a"); /// assert_eq!(map.get(&1), Some(&"a")); /// assert_eq!(map.get(&2), None); /// ``` @@ -1054,7 +1054,7 @@ impl HashMap /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// map.insert(1u, "a"); + /// map.insert(1, "a"); /// assert_eq!(map.contains_key(&1), true); /// assert_eq!(map.contains_key(&2), false); /// ``` @@ -1077,7 +1077,7 @@ impl HashMap /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// map.insert(1u, "a"); + /// map.insert(1, "a"); /// match map.get_mut(&1) { /// Some(x) => *x = "b", /// None => (), @@ -1100,7 +1100,7 @@ impl HashMap /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// assert_eq!(map.insert(37u, "a"), None); + /// assert_eq!(map.insert(37, "a"), None); /// assert_eq!(map.is_empty(), false); /// /// map.insert(37, "b"); @@ -1132,7 +1132,7 @@ impl HashMap /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// map.insert(1u, "a"); + /// map.insert(1, "a"); /// assert_eq!(map.remove(&1), Some("a")); /// assert_eq!(map.remove(&1), None); /// ``` diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index a4641f14e3084..e40f17f29e804 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -81,10 +81,10 @@ use super::state::HashState; /// /// let mut vikings = HashSet::new(); /// -/// vikings.insert(Viking { name: "Einar", power: 9u }); -/// vikings.insert(Viking { name: "Einar", power: 9u }); -/// vikings.insert(Viking { name: "Olaf", power: 4u }); -/// vikings.insert(Viking { name: "Harald", power: 8u }); +/// vikings.insert(Viking { name: "Einar", power: 9 }); +/// vikings.insert(Viking { name: "Einar", power: 9 }); +/// vikings.insert(Viking { name: "Olaf", power: 4 }); +/// vikings.insert(Viking { name: "Harald", power: 8 }); /// /// // Use derived implementation to print the vikings. /// for x in vikings.iter() { @@ -146,7 +146,7 @@ impl HashSet /// /// let s = RandomState::new(); /// let mut set = HashSet::with_hash_state(s); - /// set.insert(2u); + /// set.insert(2); /// ``` #[inline] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")] @@ -169,7 +169,7 @@ impl HashSet /// use std::collections::hash_map::RandomState; /// /// let s = RandomState::new(); - /// let mut set = HashSet::with_capacity_and_hash_state(10u, s); + /// let mut set = HashSet::with_capacity_and_hash_state(10, s); /// set.insert(1); /// ``` #[inline] @@ -398,7 +398,7 @@ impl HashSet /// /// let mut v = HashSet::new(); /// assert_eq!(v.len(), 0); - /// v.insert(1u); + /// v.insert(1); /// assert_eq!(v.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -413,7 +413,7 @@ impl HashSet /// /// let mut v = HashSet::new(); /// assert!(v.is_empty()); - /// v.insert(1u); + /// v.insert(1); /// assert!(!v.is_empty()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -438,7 +438,7 @@ impl HashSet /// use std::collections::HashSet; /// /// let mut v = HashSet::new(); - /// v.insert(1u); + /// v.insert(1); /// v.clear(); /// assert!(v.is_empty()); /// ``` @@ -545,7 +545,7 @@ impl HashSet /// /// let mut set = HashSet::new(); /// - /// assert_eq!(set.insert(2u), true); + /// assert_eq!(set.insert(2), true); /// assert_eq!(set.insert(2), false); /// assert_eq!(set.len(), 1); /// ``` @@ -566,7 +566,7 @@ impl HashSet /// /// let mut set = HashSet::new(); /// - /// set.insert(2u); + /// set.insert(2); /// assert_eq!(set.remove(&2), true); /// assert_eq!(set.remove(&2), false); /// ``` diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index d12c8b93cca26..55924bc73a8d5 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -306,7 +306,7 @@ //! //! for c in message.chars() { //! match count.entry(c) { -//! Entry::Vacant(entry) => { entry.insert(1u); }, +//! Entry::Vacant(entry) => { entry.insert(1); }, //! Entry::Occupied(mut entry) => *entry.get_mut() += 1, //! } //! }