From fccf5a00056b1d72065951a4428070326df1cfb5 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 18 Mar 2015 09:36:18 -0700 Subject: [PATCH] Register new snapshots --- src/liballoc/boxed.rs | 1 - src/liballoc/heap.rs | 4 - src/liballoc/rc.rs | 3 - src/libarena/lib.rs | 6 - src/libcollections/btree/node.rs | 3 - src/libcollections/macros.rs | 46 +- src/libcollections/slice.rs | 980 +----------- src/libcollections/str.rs | 1172 --------------- src/libcollections/string.rs | 23 +- src/libcollections/vec.rs | 13 +- src/libcollections/vec_deque.rs | 2 - src/libcore/any.rs | 1 - src/libcore/intrinsics.rs | 26 +- src/libcore/num/mod.rs | 2060 +++++++++++++------------- src/libcore/prelude.rs | 2 - src/libcore/ptr.rs | 143 +- src/libcore/slice.rs | 2 - src/libcore/str/mod.rs | 2 - src/librustc/middle/check_match.rs | 2 - src/libserialize/json.rs | 2 - src/libstd/collections/hash/map.rs | 2 - src/libstd/collections/hash/table.rs | 5 - src/libstd/dynamic_lib.rs | 13 +- src/libstd/ffi/c_str.rs | 5 - src/libstd/io/mod.rs | 8 - src/libstd/num/f32.rs | 1 - src/libstd/num/f64.rs | 1 - src/libstd/num/float_macros.rs | 11 - src/libstd/num/mod.rs | 3 - src/libstd/num/strconv.rs | 7 - src/libstd/old_io/buffered.rs | 2 - src/libstd/old_io/comm_adapters.rs | 3 - src/libstd/old_io/extensions.rs | 6 - src/libstd/old_io/fs.rs | 2 - src/libstd/old_io/mem.rs | 3 - src/libstd/old_io/mod.rs | 8 - src/libstd/old_io/net/ip.rs | 5 - src/libstd/old_io/stdio.rs | 4 - src/libstd/old_io/tempfile.rs | 2 - src/libstd/old_path/mod.rs | 4 - src/libstd/old_path/posix.rs | 6 - src/libstd/old_path/windows.rs | 8 - src/libstd/os.rs | 8 - src/libstd/path.rs | 2 - src/libstd/prelude/v1.rs | 14 - src/libstd/rand/os.rs | 6 - src/libstd/rand/reader.rs | 2 - src/libstd/rt/at_exit_imp.rs | 3 - src/libstd/sys/common/wtf8.rs | 12 - src/libstd/sys/unix/os_str.rs | 2 - src/libstd/sys/windows/process2.rs | 2 - src/libsyntax/parse/parser.rs | 8 - src/libunicode/char.rs | 408 ----- src/libunicode/u_str.rs | 9 +- src/rustbook/main.rs | 1 + src/snapshots.txt | 10 + 56 files changed, 1059 insertions(+), 4030 deletions(-) diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 50935e6404d..6bdfe2b1551 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -264,7 +264,6 @@ impl BoxAny for Box { } } -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl BoxAny for Box { #[inline] diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs index 25c6bda5f39..aaf6e76237c 100644 --- a/src/liballoc/heap.rs +++ b/src/liballoc/heap.rs @@ -8,10 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[cfg(stage0)] -#[cfg(not(test))] -use core::ptr::PtrExt; - // FIXME: #13996: mark the `allocate` and `reallocate` return value as `noalias` /// Return a pointer to `size` bytes of memory aligned to `align`. diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 3692149db44..855235e89c8 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -159,9 +159,6 @@ use core::nonzero::NonZero; use core::ops::{Deref, Drop}; use core::option::Option; use core::option::Option::{Some, None}; -#[cfg(stage0)] -use core::ptr::{self, PtrExt}; -#[cfg(not(stage0))] use core::ptr; use core::result::Result; use core::result::Result::{Ok, Err}; diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index fb858344b85..1b0356b88b0 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -43,12 +43,8 @@ extern crate alloc; use std::cell::{Cell, RefCell}; use std::cmp; use std::intrinsics; -#[cfg(stage0)] // SNAP 270a677 -use std::intrinsics::{get_tydesc, TyDesc}; use std::marker; use std::mem; -#[cfg(stage0)] -use std::num::{Int, UnsignedInt}; use std::ptr; use std::rc::Rc; use std::rt::heap::{allocate, deallocate}; @@ -190,14 +186,12 @@ fn un_bitpack_tydesc_ptr(p: usize) -> (*const TyDesc, bool) { // HACK(eddyb) TyDesc replacement using a trait object vtable. // This could be replaced in the future with a custom DST layout, // or `&'static (drop_glue, size, align)` created by a `const fn`. -#[cfg(not(stage0))] // SNAP 270a677 struct TyDesc { drop_glue: fn(*const i8), size: usize, align: usize } -#[cfg(not(stage0))] // SNAP 270a677 unsafe fn get_tydesc() -> *const TyDesc { use std::raw::TraitObject; diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 006d6bb040e..bfac3b2df5a 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -105,9 +105,6 @@ struct MutNodeSlice<'a, K: 'a, V: 'a> { /// Fails if `target_alignment` is not a power of two. #[inline] fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize { - #[cfg(stage0)] - use core::num::UnsignedInt; - assert!(target_alignment.is_power_of_two()); (unrounded + target_alignment - 1) & !(target_alignment - 1) } diff --git a/src/libcollections/macros.rs b/src/libcollections/macros.rs index 3c7326dbd8f..5f614f3649c 100644 --- a/src/libcollections/macros.rs +++ b/src/libcollections/macros.rs @@ -8,45 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[cfg(stage0)] -/// Creates a `Vec` containing the arguments. -/// -/// `vec!` allows `Vec`s to be defined with the same syntax as array expressions. -/// There are two forms of this macro: -/// -/// - Create a `Vec` containing a given list of elements: -/// -/// ``` -/// let v = vec![1, 2, 3]; -/// assert_eq!(v[0], 1); -/// assert_eq!(v[1], 2); -/// assert_eq!(v[2], 3); -/// ``` -/// -/// - Create a `Vec` from a given element and size: -/// -/// ``` -/// let v = vec![1; 3]; -/// assert_eq!(v, [1, 1, 1]); -/// ``` -/// -/// Note that unlike array expressions this syntax supports all elements -/// which implement `Clone` and the number of elements doesn't have to be -/// a constant. -#[macro_export] -#[stable(feature = "rust1", since = "1.0.0")] -macro_rules! vec { - ($elem:expr; $n:expr) => ( - $crate::vec::from_elem($elem, $n) - ); - ($($x:expr),*) => ( - <[_] as $crate::slice::SliceExt>::into_vec( - $crate::boxed::Box::new([$($x),*])) - ); - ($($x:expr,)*) => (vec![$($x),*]) -} - -#[cfg(not(stage0))] /// Creates a `Vec` containing the arguments. /// /// `vec!` allows `Vec`s to be defined with the same syntax as array expressions. @@ -84,11 +45,10 @@ macro_rules! vec { ($($x:expr,)*) => (vec![$($x),*]) } -// HACK(japaric): with cfg(test) the inherent `[T]::into_vec` method, which is required for this -// macro definition, is not available. Instead use the `slice::into_vec` function which is only -// available with cfg(test) +// HACK(japaric): with cfg(test) the inherent `[T]::into_vec` method, which is +// required for this macro definition, is not available. Instead use the +// `slice::into_vec` function which is only available with cfg(test) // NB see the slice::hack module in slice.rs for more information -#[cfg(not(stage0))] #[cfg(test)] macro_rules! vec { ($elem:expr; $n:expr) => ( diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 4993994d46b..45864153dd7 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -99,8 +99,6 @@ use core::mem; use core::num::wrapping::WrappingOps; use core::ops::FnMut; use core::option::Option::{self, Some, None}; -#[cfg(stage0)] -use core::ptr::PtrExt; use core::ptr; use core::result::Result; use core::slice as core_slice; @@ -121,984 +119,20 @@ pub use core::slice::{from_raw_buf, from_raw_mut_buf}; // Basic slice extension methods //////////////////////////////////////////////////////////////////////////////// -#[cfg(stage0)] -/// Allocating extension methods for slices. -#[stable(feature = "rust1", since = "1.0.0")] -pub trait SliceExt { - #[stable(feature = "rust1", since = "1.0.0")] - type Item; - - /// Sorts the slice, in place, using `compare` to compare - /// elements. - /// - /// This sort is `O(n log n)` worst-case and stable, but allocates - /// approximately `2 * n`, where `n` is the length of `self`. - /// - /// # Examples - /// - /// ``` - /// let mut v = [5, 4, 1, 3, 2]; - /// v.sort_by(|a, b| a.cmp(b)); - /// assert!(v == [1, 2, 3, 4, 5]); - /// - /// // reverse sorting - /// v.sort_by(|a, b| b.cmp(a)); - /// assert!(v == [5, 4, 3, 2, 1]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn sort_by(&mut self, compare: F) where F: FnMut(&Self::Item, &Self::Item) -> Ordering; - - /// Consumes `src` and moves as many elements as it can into `self` - /// from the range [start,end). - /// - /// Returns the number of elements copied (the shorter of `self.len()` - /// and `end - start`). - /// - /// # Arguments - /// - /// * src - A mutable vector of `T` - /// * start - The index into `src` to start copying from - /// * end - The index into `src` to stop copying from - /// - /// # Examples - /// - /// ``` - /// let mut a = [1, 2, 3, 4, 5]; - /// let b = vec![6, 7, 8]; - /// let num_moved = a.move_from(b, 0, 3); - /// assert_eq!(num_moved, 3); - /// assert!(a == [6, 7, 8, 4, 5]); - /// ``` - #[unstable(feature = "collections", - reason = "uncertain about this API approach")] - 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: 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: 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: usize) -> &[Self::Item]; - - /// Divides one slice into two at an index. - /// - /// The first will contain all indices from `[0, mid)` (excluding - /// the index `mid` itself) and the second will contain all - /// indices from `[mid, len)` (excluding the index `len` itself). - /// - /// Panics if `mid > len`. - /// - /// # Examples - /// - /// ``` - /// let v = [10, 40, 30, 20, 50]; - /// let (v1, v2) = v.split_at(2); - /// assert_eq!([10, 40], v1); - /// assert_eq!([30, 20, 50], v2); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn split_at(&self, mid: usize) -> (&[Self::Item], &[Self::Item]); - - /// Returns an iterator over the slice. - #[stable(feature = "rust1", since = "1.0.0")] - fn iter(&self) -> Iter; - - /// Returns an iterator over subslices separated by elements that match - /// `pred`. The matched element is not contained in the subslices. - /// - /// # Examples - /// - /// Print the slice split by numbers divisible by 3 (i.e. `[10, 40]`, - /// `[20]`, `[50]`): - /// - /// ``` - /// let v = [10, 40, 30, 20, 60, 50]; - /// for group in v.split(|num| *num % 3 == 0) { - /// println!("{:?}", group); - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn split(&self, pred: F) -> Split - where F: FnMut(&Self::Item) -> bool; - - /// Returns an iterator over subslices separated by elements that match - /// `pred`, limited to splitting at most `n` times. The matched element is - /// not contained in the subslices. - /// - /// # Examples - /// - /// Print the slice split once by numbers divisible by 3 (i.e. `[10, 40]`, - /// `[20, 60, 50]`): - /// - /// ``` - /// let v = [10, 40, 30, 20, 60, 50]; - /// for group in v.splitn(1, |num| *num % 3 == 0) { - /// println!("{:?}", group); - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn splitn(&self, n: usize, pred: F) -> SplitN - where F: FnMut(&Self::Item) -> bool; - - /// Returns an iterator over subslices separated by elements that match - /// `pred` limited to splitting at most `n` times. This starts at the end of - /// the slice and works backwards. The matched element is not contained in - /// the subslices. - /// - /// # Examples - /// - /// Print the slice split once, starting from the end, by numbers divisible - /// by 3 (i.e. `[50]`, `[10, 40, 30, 20]`): - /// - /// ``` - /// let v = [10, 40, 30, 20, 60, 50]; - /// for group in v.rsplitn(1, |num| *num % 3 == 0) { - /// println!("{:?}", group); - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn rsplitn(&self, n: usize, pred: F) -> RSplitN - where F: FnMut(&Self::Item) -> bool; - - /// Returns an iterator over all contiguous windows of length - /// `size`. The windows overlap. If the slice is shorter than - /// `size`, the iterator returns no values. - /// - /// # Panics - /// - /// Panics if `size` is 0. - /// - /// # Examples - /// - /// Print the adjacent pairs of a slice (i.e. `[1,2]`, `[2,3]`, - /// `[3,4]`): - /// - /// ``` - /// let v = &[1, 2, 3, 4]; - /// for win in v.windows(2) { - /// println!("{:?}", win); - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - 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 - /// length of the slice, then the last chunk will not have length - /// `size`. - /// - /// # Panics - /// - /// Panics if `size` is 0. - /// - /// # Examples - /// - /// Print the slice two elements at a time (i.e. `[1,2]`, - /// `[3,4]`, `[5]`): - /// - /// ``` - /// let v = &[1, 2, 3, 4, 5]; - /// for win in v.chunks(2) { - /// println!("{:?}", win); - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - 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. - /// - /// # Examples - /// - /// ``` - /// let v = [10, 40, 30]; - /// assert_eq!(Some(&40), v.get(1)); - /// assert_eq!(None, v.get(3)); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn get(&self, index: usize) -> Option<&Self::Item>; - - /// Returns the first element of a slice, or `None` if it is empty. - /// - /// # Examples - /// - /// ``` - /// let v = [10, 40, 30]; - /// assert_eq!(Some(&10), v.first()); - /// - /// let w: &[i32] = &[]; - /// assert_eq!(None, w.first()); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn first(&self) -> Option<&Self::Item>; - - /// Returns all but the first element of a slice. - #[unstable(feature = "collections", reason = "likely to be renamed")] - fn tail(&self) -> &[Self::Item]; - - /// Returns all but the last element of a slice. - #[unstable(feature = "collections", reason = "likely to be renamed")] - fn init(&self) -> &[Self::Item]; - - /// Returns the last element of a slice, or `None` if it is empty. - /// - /// # Examples - /// - /// ``` - /// let v = [10, 40, 30]; - /// assert_eq!(Some(&30), v.last()); - /// - /// let w: &[i32] = &[]; - /// assert_eq!(None, w.last()); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn last(&self) -> Option<&Self::Item>; - - /// 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: usize) -> &Self::Item; - - /// Returns an unsafe pointer to the slice's buffer - /// - /// The caller must ensure that the slice outlives the pointer this - /// function returns, or else it will end up pointing to garbage. - /// - /// Modifying the slice may cause its buffer to be reallocated, which - /// would also make any pointers to it invalid. - #[stable(feature = "rust1", since = "1.0.0")] - fn as_ptr(&self) -> *const Self::Item; - - /// Binary search a sorted slice with a comparator function. - /// - /// The comparator function should implement an order consistent - /// with the sort order of the underlying slice, returning an - /// order code that indicates whether its argument is `Less`, - /// `Equal` or `Greater` the desired target. - /// - /// If a matching value is found then returns `Ok`, containing - /// the index for the matched element; if no match is found then - /// `Err` is returned, containing the index where a matching - /// element could be inserted while maintaining sorted order. - /// - /// # Examples - /// - /// Looks up a series of four elements. The first is found, with a - /// uniquely determined position; the second and third are not - /// found; the fourth could match any position in `[1,4]`. - /// - /// ``` - /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; - /// let s = s.as_slice(); - /// - /// let seek = 13; - /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9)); - /// let seek = 4; - /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7)); - /// let seek = 100; - /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13)); - /// let seek = 1; - /// let r = s.binary_search_by(|probe| probe.cmp(&seek)); - /// assert!(match r { Ok(1...4) => true, _ => false, }); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn binary_search_by(&self, f: F) -> Result where - F: FnMut(&Self::Item) -> Ordering; - - /// Return the number of elements in the slice - /// - /// # Examples - /// - /// ``` - /// let a = [1, 2, 3]; - /// assert_eq!(a.len(), 3); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn len(&self) -> usize; - - /// Returns true if the slice has a length of 0 - /// - /// # Examples - /// - /// ``` - /// let a = [1, 2, 3]; - /// assert!(!a.is_empty()); - /// ``` - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - fn is_empty(&self) -> bool { self.len() == 0 } - /// 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: usize) -> Option<&mut Self::Item>; - - /// Work with `self` as a mut slice. - /// Primarily intended for getting a &mut [T] from a [T; N]. - #[stable(feature = "rust1", since = "1.0.0")] - fn as_mut_slice(&mut self) -> &mut [Self::Item]; - - /// Deprecated: use `&mut s[start .. end]` instead. - #[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: 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: 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: usize) -> &mut [Self::Item]; - - /// Returns an iterator that allows modifying each value - #[stable(feature = "rust1", since = "1.0.0")] - fn iter_mut(&mut self) -> IterMut; - - /// Returns a mutable pointer to the first element of a slice, or `None` if it is empty - #[stable(feature = "rust1", since = "1.0.0")] - fn first_mut(&mut self) -> Option<&mut Self::Item>; - - /// Returns all but the first element of a mutable slice - #[unstable(feature = "collections", - reason = "likely to be renamed or removed")] - fn tail_mut(&mut self) -> &mut [Self::Item]; - - /// Returns all but the last element of a mutable slice - #[unstable(feature = "collections", - reason = "likely to be renamed or removed")] - fn init_mut(&mut self) -> &mut [Self::Item]; - - /// Returns a mutable pointer to the last item in the slice. - #[stable(feature = "rust1", since = "1.0.0")] - fn last_mut(&mut self) -> Option<&mut Self::Item>; - - /// Returns an iterator over mutable subslices separated by elements that - /// match `pred`. The matched element is not contained in the subslices. - #[stable(feature = "rust1", since = "1.0.0")] - fn split_mut(&mut self, pred: F) -> SplitMut - where F: FnMut(&Self::Item) -> bool; - - /// Returns an iterator over subslices separated by elements that match - /// `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: usize, pred: F) -> SplitNMut - where F: FnMut(&Self::Item) -> bool; - - /// Returns an iterator over subslices separated by elements that match - /// `pred` limited to splitting at most `n` times. This starts at the end of - /// 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: usize, pred: F) -> RSplitNMut - where F: FnMut(&Self::Item) -> bool; - - /// Returns an iterator over `chunk_size` elements of the slice at a time. - /// The chunks are mutable and do not overlap. If `chunk_size` does - /// not divide the length of the slice, then the last chunk will not - /// have length `chunk_size`. - /// - /// # Panics - /// - /// Panics if `chunk_size` is 0. - #[stable(feature = "rust1", since = "1.0.0")] - fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut; - - /// Swaps two elements in a slice. - /// - /// # Arguments - /// - /// * a - The index of the first element - /// * b - The index of the second element - /// - /// # Panics - /// - /// Panics if `a` or `b` are out of bounds. - /// - /// # Examples - /// - /// ``` - /// let mut v = ["a", "b", "c", "d"]; - /// v.swap(1, 3); - /// assert!(v == ["a", "d", "c", "b"]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn swap(&mut self, a: usize, b: usize); - - /// Divides one `&mut` into two at an index. - /// - /// The first will contain all indices from `[0, mid)` (excluding - /// the index `mid` itself) and the second will contain all - /// indices from `[mid, len)` (excluding the index `len` itself). - /// - /// # Panics - /// - /// Panics if `mid > len`. - /// - /// # Examples - /// - /// ``` - /// let mut v = [1, 2, 3, 4, 5, 6]; - /// - /// // scoped to restrict the lifetime of the borrows - /// { - /// let (left, right) = v.split_at_mut(0); - /// assert!(left == []); - /// assert!(right == [1, 2, 3, 4, 5, 6]); - /// } - /// - /// { - /// let (left, right) = v.split_at_mut(2); - /// assert!(left == [1, 2]); - /// assert!(right == [3, 4, 5, 6]); - /// } - /// - /// { - /// let (left, right) = v.split_at_mut(6); - /// assert!(left == [1, 2, 3, 4, 5, 6]); - /// assert!(right == []); - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn split_at_mut(&mut self, mid: usize) -> (&mut [Self::Item], &mut [Self::Item]); - - /// Reverse the order of elements in a slice, in place. - /// - /// # Examples - /// - /// ``` - /// let mut v = [1, 2, 3]; - /// v.reverse(); - /// assert!(v == [3, 2, 1]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn reverse(&mut self); - - /// 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: usize) -> &mut Self::Item; - - /// Return an unsafe mutable pointer to the slice's buffer. - /// - /// The caller must ensure that the slice outlives the pointer this - /// function returns, or else it will end up pointing to garbage. - /// - /// Modifying the slice may cause its buffer to be reallocated, which - /// would also make any pointers to it invalid. - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - fn as_mut_ptr(&mut self) -> *mut Self::Item; - - /// Copies `self` into a new `Vec`. - #[stable(feature = "rust1", since = "1.0.0")] - fn to_vec(&self) -> Vec where Self::Item: Clone; - - /// Creates an iterator that yields every possible permutation of the - /// vector in succession. - /// - /// # Examples - /// - /// ``` - /// let v = [1, 2, 3]; - /// let mut perms = v.permutations(); - /// - /// for p in perms { - /// println!("{:?}", p); - /// } - /// ``` - /// - /// Iterating through permutations one by one. - /// - /// ``` - /// let v = [1, 2, 3]; - /// let mut perms = v.permutations(); - /// - /// assert_eq!(Some(vec![1, 2, 3]), perms.next()); - /// assert_eq!(Some(vec![1, 3, 2]), perms.next()); - /// assert_eq!(Some(vec![3, 1, 2]), perms.next()); - /// ``` - #[unstable(feature = "collections")] - fn permutations(&self) -> Permutations where Self::Item: Clone; - - /// Copies as many elements from `src` as it can into `self` (the - /// shorter of `self.len()` and `src.len()`). Returns the number - /// of elements copied. - /// - /// # Examples - /// - /// ``` - /// let mut dst = [0, 0, 0]; - /// let src = [1, 2]; - /// - /// assert!(dst.clone_from_slice(&src) == 2); - /// assert!(dst == [1, 2, 0]); - /// - /// let src2 = [3, 4, 5, 6]; - /// assert!(dst.clone_from_slice(&src2) == 3); - /// assert!(dst == [3, 4, 5]); - /// ``` - #[unstable(feature = "collections")] - fn clone_from_slice(&mut self, &[Self::Item]) -> usize where Self::Item: Clone; - - /// Sorts the slice, in place. - /// - /// This is equivalent to `self.sort_by(|a, b| a.cmp(b))`. - /// - /// # Examples - /// - /// ``` - /// let mut v = [-5, 4, 1, -3, 2]; - /// - /// v.sort(); - /// assert!(v == [-5, -3, 1, 2, 4]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn sort(&mut self) where Self::Item: Ord; - - /// Binary search a sorted slice for a given element. - /// - /// If the value is found then `Ok` is returned, containing the - /// index of the matching element; if the value is not found then - /// `Err` is returned, containing the index where a matching - /// element could be inserted while maintaining sorted order. - /// - /// # Examples - /// - /// Looks up a series of four elements. The first is found, with a - /// uniquely determined position; the second and third are not - /// found; the fourth could match any position in `[1,4]`. - /// - /// ``` - /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; - /// let s = s.as_slice(); - /// - /// assert_eq!(s.binary_search(&13), Ok(9)); - /// assert_eq!(s.binary_search(&4), Err(7)); - /// assert_eq!(s.binary_search(&100), Err(13)); - /// let r = s.binary_search(&1); - /// 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; - - /// 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 { - self.binary_search(x) - } - - /// Mutates the slice to the next lexicographic permutation. - /// - /// Returns `true` if successful and `false` if the slice is at the - /// last-ordered permutation. - /// - /// # Examples - /// - /// ``` - /// let v: &mut [_] = &mut [0, 1, 2]; - /// v.next_permutation(); - /// let b: &mut [_] = &mut [0, 2, 1]; - /// assert!(v == b); - /// v.next_permutation(); - /// let b: &mut [_] = &mut [1, 0, 2]; - /// assert!(v == b); - /// ``` - #[unstable(feature = "collections", - reason = "uncertain if this merits inclusion in std")] - fn next_permutation(&mut self) -> bool where Self::Item: Ord; - - /// Mutates the slice to the previous lexicographic permutation. - /// - /// Returns `true` if successful and `false` if the slice is at the - /// first-ordered permutation. - /// - /// # Examples - /// - /// ``` - /// let v: &mut [_] = &mut [1, 0, 2]; - /// v.prev_permutation(); - /// let b: &mut [_] = &mut [0, 2, 1]; - /// assert!(v == b); - /// v.prev_permutation(); - /// let b: &mut [_] = &mut [0, 1, 2]; - /// assert!(v == b); - /// ``` - #[unstable(feature = "collections", - reason = "uncertain if this merits inclusion in std")] - fn prev_permutation(&mut self) -> bool where Self::Item: Ord; - - /// Find the first index containing a matching value. - #[unstable(feature = "collections")] - 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; - - /// Returns true if the slice contains an element with the given value. - /// - /// # Examples - /// - /// ``` - /// let v = [10, 40, 30]; - /// assert!(v.contains(&30)); - /// assert!(!v.contains(&50)); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn contains(&self, x: &Self::Item) -> bool where Self::Item: PartialEq; - - /// Returns true if `needle` is a prefix of the slice. - /// - /// # Examples - /// - /// ``` - /// let v = [10, 40, 30]; - /// assert!(v.starts_with(&[10])); - /// assert!(v.starts_with(&[10, 40])); - /// assert!(!v.starts_with(&[50])); - /// assert!(!v.starts_with(&[10, 50])); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn starts_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq; - - /// Returns true if `needle` is a suffix of the slice. - /// - /// # Examples - /// - /// ``` - /// let v = [10, 40, 30]; - /// assert!(v.ends_with(&[30])); - /// assert!(v.ends_with(&[40, 30])); - /// assert!(!v.ends_with(&[50])); - /// assert!(!v.ends_with(&[50, 30])); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn ends_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq; - - /// Convert `self` into a vector without clones or allocation. - #[stable(feature = "rust1", since = "1.0.0")] - fn into_vec(self: Box) -> Vec; -} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl SliceExt for [T] { - type Item = T; - - #[inline] - fn sort_by(&mut self, compare: F) where F: FnMut(&T, &T) -> Ordering { - merge_sort(self, compare) - } - - #[inline] - 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); - } - cmp::min(self.len(), end-start) - } - - #[inline] - fn slice(&self, start: usize, end: usize) -> &[T] { - &self[start .. end] - } - - #[inline] - fn slice_from(&self, start: usize) -> &[T] { - &self[start ..] - } - - #[inline] - fn slice_to(&self, end: usize) -> &[T] { - &self[.. end] - } - - #[inline] - fn split_at(&self, mid: usize) -> (&[T], &[T]) { - core_slice::SliceExt::split_at(self, mid) - } - - #[inline] - fn iter(&self) -> Iter { - core_slice::SliceExt::iter(self) - } - - #[inline] - fn split(&self, pred: F) -> Split - where F: FnMut(&T) -> bool { - core_slice::SliceExt::split(self, pred) - } - - #[inline] - 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: usize, pred: F) -> RSplitN - where F: FnMut(&T) -> bool { - core_slice::SliceExt::rsplitn(self, n, pred) - } - - #[inline] - fn windows(&self, size: usize) -> Windows { - core_slice::SliceExt::windows(self, size) - } - - #[inline] - fn chunks(&self, size: usize) -> Chunks { - core_slice::SliceExt::chunks(self, size) - } - - #[inline] - fn get(&self, index: usize) -> Option<&T> { - core_slice::SliceExt::get(self, index) - } - - #[inline] - fn first(&self) -> Option<&T> { - core_slice::SliceExt::first(self) - } - - #[inline] - fn tail(&self) -> &[T] { - core_slice::SliceExt::tail(self) - } - - #[inline] - fn init(&self) -> &[T] { - core_slice::SliceExt::init(self) - } - - #[inline] - fn last(&self) -> Option<&T> { - core_slice::SliceExt::last(self) - } - - #[inline] - unsafe fn get_unchecked(&self, index: usize) -> &T { - core_slice::SliceExt::get_unchecked(self, index) - } - - #[inline] - fn as_ptr(&self) -> *const T { - core_slice::SliceExt::as_ptr(self) - } - - #[inline] - 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) -> usize { - core_slice::SliceExt::len(self) - } - - #[inline] - fn is_empty(&self) -> bool { - core_slice::SliceExt::is_empty(self) - } - - #[inline] - fn get_mut(&mut self, index: usize) -> Option<&mut T> { - core_slice::SliceExt::get_mut(self, index) - } - - #[inline] - fn as_mut_slice(&mut self) -> &mut [T] { - core_slice::SliceExt::as_mut_slice(self) - } - - #[inline] - fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] { - &mut self[start .. end] - } - - #[inline] - fn slice_from_mut(&mut self, start: usize) -> &mut [T] { - &mut self[start ..] - } - - #[inline] - fn slice_to_mut(&mut self, end: usize) -> &mut [T] { - &mut self[.. end] - } - - #[inline] - fn iter_mut(&mut self) -> IterMut { - core_slice::SliceExt::iter_mut(self) - } - - #[inline] - fn first_mut(&mut self) -> Option<&mut T> { - core_slice::SliceExt::first_mut(self) - } - - #[inline] - fn tail_mut(&mut self) -> &mut [T] { - core_slice::SliceExt::tail_mut(self) - } - - #[inline] - fn init_mut(&mut self) -> &mut [T] { - core_slice::SliceExt::init_mut(self) - } - - #[inline] - fn last_mut(&mut self) -> Option<&mut T> { - core_slice::SliceExt::last_mut(self) - } - - #[inline] - fn split_mut(&mut self, pred: F) -> SplitMut - where F: FnMut(&T) -> bool { - core_slice::SliceExt::split_mut(self, pred) - } - - #[inline] - 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: usize, pred: F) -> RSplitNMut - where F: FnMut(&T) -> bool { - core_slice::SliceExt::rsplitn_mut(self, n, pred) - } - - #[inline] - fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut { - core_slice::SliceExt::chunks_mut(self, chunk_size) - } - - #[inline] - fn swap(&mut self, a: usize, b: usize) { - core_slice::SliceExt::swap(self, a, b) - } - - #[inline] - fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) { - core_slice::SliceExt::split_at_mut(self, mid) - } - - #[inline] - fn reverse(&mut self) { - core_slice::SliceExt::reverse(self) - } - - #[inline] - unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T { - core_slice::SliceExt::get_unchecked_mut(self, index) - } - - #[inline] - fn as_mut_ptr(&mut self) -> *mut T { - core_slice::SliceExt::as_mut_ptr(self) - } - - /// Returns a copy of `v`. - #[inline] - fn to_vec(&self) -> Vec where T: Clone { - let mut vector = Vec::with_capacity(self.len()); - vector.push_all(self); - vector - } - - /// Returns an iterator over all permutations of a vector. - fn permutations(&self) -> Permutations where T: Clone { - Permutations{ - swaps: ElementSwaps::new(self.len()), - v: self.to_vec(), - } - } - - fn clone_from_slice(&mut self, src: &[T]) -> usize where T: Clone { - core_slice::SliceExt::clone_from_slice(self, src) - } - - #[inline] - fn sort(&mut self) where T: Ord { - self.sort_by(|a, b| a.cmp(b)) - } - - fn binary_search(&self, x: &T) -> Result where T: Ord { - core_slice::SliceExt::binary_search(self, x) - } - - fn next_permutation(&mut self) -> bool where T: Ord { - core_slice::SliceExt::next_permutation(self) - } - - fn prev_permutation(&mut self) -> bool where T: Ord { - core_slice::SliceExt::prev_permutation(self) - } - - 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 { - core_slice::SliceExt::rposition_elem(self, t) - } - - fn contains(&self, x: &T) -> bool where T: PartialEq { - core_slice::SliceExt::contains(self, x) - } - - fn starts_with(&self, needle: &[T]) -> bool where T: PartialEq { - core_slice::SliceExt::starts_with(self, needle) - } - - fn ends_with(&self, needle: &[T]) -> bool where T: PartialEq { - core_slice::SliceExt::ends_with(self, needle) - } - - fn into_vec(mut self: Box) -> Vec { - unsafe { - let xs = Vec::from_raw_parts(self.as_mut_ptr(), self.len(), self.len()); - mem::forget(self); - xs - } - } -} - // HACK(japaric) needed for the implementation of `vec!` macro during testing // NB see the hack module in this file for more details -#[cfg(not(stage0))] #[cfg(test)] pub use self::hack::into_vec; // HACK(japaric) needed for the implementation of `Vec::clone` during testing // NB see the hack module in this file for more details -#[cfg(not(stage0))] #[cfg(test)] pub use self::hack::to_vec; -// HACK(japaric): With cfg(test) `impl [T]` is not available, these three functions are actually -// methods that are in `impl [T]` but not in `core::slice::SliceExt` - we need to supply these -// functions for the `test_permutations` test -#[cfg(not(stage0))] +// HACK(japaric): With cfg(test) `impl [T]` is not available, these three +// functions are actually methods that are in `impl [T]` but not in +// `core::slice::SliceExt` - we need to supply these functions for the +// `test_permutations` test mod hack { use alloc::boxed::Box; use core::clone::Clone; @@ -1136,8 +170,9 @@ mod hack { vector } - // NB we can remove this hack if we move this test to libcollectionstest - but that can't be - // done right now because the test needs access to the private fields of Permutations + // NB we can remove this hack if we move this test to libcollectionstest - + // but that can't be done right now because the test needs access to the + // private fields of Permutations #[test] fn test_permutations() { { @@ -1192,7 +227,6 @@ mod hack { } } -#[cfg(not(stage0))] /// Allocating extension methods for slices. #[lang = "slice"] #[cfg(not(test))] diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 078d18a310a..3a289e4ef37 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -59,22 +59,14 @@ use self::DecompositionType::*; use core::clone::Clone; use core::iter::AdditiveIterator; use core::iter::{Iterator, IteratorExt, Extend}; -#[cfg(stage0)] -use core::ops::Index; -#[cfg(stage0)] -use core::ops::RangeFull; use core::option::Option::{self, Some, None}; use core::result::Result; use core::slice::AsSlice; use core::str as core_str; -#[cfg(stage0)] -use unicode::char::CharExt; use unicode::str::{UnicodeStr, Utf16Encoder}; use vec_deque::VecDeque; use borrow::{Borrow, ToOwned}; -#[cfg(stage0)] -use slice::SliceExt; use string::String; use unicode; use vec::Vec; @@ -423,1171 +415,7 @@ Section: CowString Section: Trait implementations */ -#[cfg(stage0)] -/// Any string that can be represented as a slice. -#[stable(feature = "rust1", since = "1.0.0")] -pub trait StrExt: Index { - /// Escapes each char in `s` with `char::escape_default`. - #[unstable(feature = "collections", - reason = "return type may change to be an iterator")] - fn escape_default(&self) -> String { - self.chars().flat_map(|c| c.escape_default()).collect() - } - /// Escapes each char in `s` with `char::escape_unicode`. - #[unstable(feature = "collections", - reason = "return type may change to be an iterator")] - fn escape_unicode(&self) -> String { - self.chars().flat_map(|c| c.escape_unicode()).collect() - } - - /// Replaces all occurrences of one string with another. - /// - /// `replace` takes two arguments, a sub-`&str` to find in `self`, and a second `&str` to - /// replace it with. If the original `&str` isn't found, no change occurs. - /// - /// # Examples - /// - /// ``` - /// let s = "this is old"; - /// - /// assert_eq!(s.replace("old", "new"), "this is new"); - /// ``` - /// - /// When a `&str` isn't found: - /// - /// ``` - /// let s = "this is old"; - /// assert_eq!(s.replace("cookie monster", "little lamb"), s); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn replace(&self, from: &str, to: &str) -> String { - let mut result = String::new(); - let mut last_end = 0; - for (start, end) in self.match_indices(from) { - result.push_str(unsafe { self.slice_unchecked(last_end, start) }); - result.push_str(to); - last_end = end; - } - result.push_str(unsafe { self.slice_unchecked(last_end, self.len()) }); - result - } - - /// Returns an iterator over the string in Unicode Normalization Form D - /// (canonical decomposition). - #[inline] - #[unstable(feature = "unicode", - reason = "this functionality may be replaced with a more generic \ - unicode crate on crates.io")] - fn nfd_chars(&self) -> Decompositions { - Decompositions { - iter: self[..].chars(), - buffer: Vec::new(), - sorted: false, - kind: Canonical - } - } - - /// Returns an iterator over the string in Unicode Normalization Form KD - /// (compatibility decomposition). - #[inline] - #[unstable(feature = "unicode", - reason = "this functionality may be replaced with a more generic \ - unicode crate on crates.io")] - fn nfkd_chars(&self) -> Decompositions { - Decompositions { - iter: self[..].chars(), - buffer: Vec::new(), - sorted: false, - kind: Compatible - } - } - - /// An Iterator over the string in Unicode Normalization Form C - /// (canonical decomposition followed by canonical composition). - #[inline] - #[unstable(feature = "unicode", - reason = "this functionality may be replaced with a more generic \ - unicode crate on crates.io")] - fn nfc_chars(&self) -> Recompositions { - Recompositions { - iter: self.nfd_chars(), - state: Composing, - buffer: VecDeque::new(), - composee: None, - last_ccc: None - } - } - - /// An Iterator over the string in Unicode Normalization Form KC - /// (compatibility decomposition followed by canonical composition). - #[inline] - #[unstable(feature = "unicode", - reason = "this functionality may be replaced with a more generic \ - unicode crate on crates.io")] - fn nfkc_chars(&self) -> Recompositions { - Recompositions { - iter: self.nfkd_chars(), - state: Composing, - buffer: VecDeque::new(), - composee: None, - last_ccc: None - } - } - - /// Returns `true` if `self` contains another `&str`. - /// - /// # Examples - /// - /// ``` - /// assert!("bananas".contains("nana")); - /// - /// assert!(!"bananas".contains("foobar")); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool { - core_str::StrExt::contains(&self[..], pat) - } - - /// Returns `true` if `self` contains a `char`. - /// - /// # Examples - /// - /// ``` - /// assert!("hello".contains_char('e')); - /// - /// assert!(!"hello".contains_char('z')); - /// ``` - #[unstable(feature = "collections")] - #[deprecated(since = "1.0.0", reason = "use `contains()` with a char")] - fn contains_char<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool { - core_str::StrExt::contains_char(&self[..], pat) - } - - /// An iterator over the codepoints of `self`. - /// - /// # Examples - /// - /// ``` - /// let v: Vec = "abc åäö".chars().collect(); - /// - /// assert_eq!(v, ['a', 'b', 'c', ' ', 'å', 'ä', 'ö']); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn chars(&self) -> Chars { - core_str::StrExt::chars(&self[..]) - } - - /// An iterator over the bytes of `self`. - /// - /// # Examples - /// - /// ``` - /// let v: Vec = "bors".bytes().collect(); - /// - /// assert_eq!(v, b"bors".to_vec()); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn bytes(&self) -> Bytes { - core_str::StrExt::bytes(&self[..]) - } - - /// An iterator over the characters of `self` and their byte offsets. - /// - /// # Examples - /// - /// ``` - /// let v: Vec<(usize, char)> = "abc".char_indices().collect(); - /// let b = vec![(0, 'a'), (1, 'b'), (2, 'c')]; - /// - /// assert_eq!(v, b); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn char_indices(&self) -> CharIndices { - core_str::StrExt::char_indices(&self[..]) - } - - /// An iterator over substrings of `self`, separated by characters - /// matched by a pattern. - /// - /// The pattern can be a simple `&str`, or a closure that determines - /// the split. - /// - /// # Examples - /// - /// Simple `&str` patterns: - /// - /// ``` - /// let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); - /// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); - /// - /// let v: Vec<&str> = "".split('X').collect(); - /// assert_eq!(v, [""]); - /// ``` - /// - /// More complex patterns with a lambda: - /// - /// ``` - /// let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect(); - /// assert_eq!(v, ["abc", "def", "ghi"]); - /// - /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); - /// assert_eq!(v, ["lion", "", "tiger", "leopard"]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> { - core_str::StrExt::split(&self[..], pat) - } - - /// An iterator over substrings of `self`, separated by characters matched by a pattern, - /// restricted to splitting at most `count` times. - /// - /// The pattern can be a simple `&str`, or a closure that determines - /// the split. - /// - /// # Examples - /// - /// Simple `&str` patterns: - /// - /// ``` - /// let v: Vec<&str> = "Mary had a little lambda".splitn(2, ' ').collect(); - /// assert_eq!(v, ["Mary", "had", "a little lambda"]); - /// - /// let v: Vec<&str> = "lionXXtigerXleopard".splitn(2, 'X').collect(); - /// assert_eq!(v, ["lion", "", "tigerXleopard"]); - /// - /// let v: Vec<&str> = "abcXdef".splitn(0, 'X').collect(); - /// assert_eq!(v, ["abcXdef"]); - /// - /// let v: Vec<&str> = "".splitn(1, 'X').collect(); - /// assert_eq!(v, [""]); - /// ``` - /// - /// More complex patterns with a lambda: - /// - /// ``` - /// let v: Vec<&str> = "abc1def2ghi".splitn(1, |c: char| c.is_numeric()).collect(); - /// assert_eq!(v, ["abc", "def2ghi"]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn splitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> SplitN<'a, P> { - core_str::StrExt::splitn(&self[..], count, pat) - } - - /// An iterator over substrings of `self`, separated by characters - /// matched by a pattern. - /// - /// Equivalent to `split`, except that the trailing substring is skipped if empty. - /// - /// The pattern can be a simple `&str`, or a closure that determines - /// the split. - /// - /// # Examples - /// - /// Simple `&str` patterns: - /// - /// ``` - /// let v: Vec<&str> = "A.B.".split_terminator('.').collect(); - /// assert_eq!(v, ["A", "B"]); - /// - /// let v: Vec<&str> = "A..B..".split_terminator('.').collect(); - /// assert_eq!(v, ["A", "", "B", ""]); - /// ``` - /// - /// More complex patterns with a lambda: - /// - /// ``` - /// let v: Vec<&str> = "abc1def2ghi3".split_terminator(|c: char| c.is_numeric()).collect(); - /// assert_eq!(v, ["abc", "def", "ghi"]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P> { - core_str::StrExt::split_terminator(&self[..], pat) - } - - /// An iterator over substrings of `self`, separated by characters matched by a pattern, - /// starting from the end of the string. - /// - /// Restricted to splitting at most `count` times. - /// - /// The pattern can be a simple `&str`, or a closure that determines the split. - /// - /// # Examples - /// - /// Simple `&str` patterns: - /// - /// ``` - /// let v: Vec<&str> = "Mary had a little lamb".rsplitn(2, ' ').collect(); - /// assert_eq!(v, ["lamb", "little", "Mary had a"]); - /// - /// let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(2, 'X').collect(); - /// assert_eq!(v, ["leopard", "tiger", "lionX"]); - /// ``` - /// - /// More complex patterns with a lambda: - /// - /// ``` - /// let v: Vec<&str> = "abc1def2ghi".rsplitn(1, |c: char| c.is_numeric()).collect(); - /// assert_eq!(v, ["ghi", "abc1def"]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn rsplitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> { - core_str::StrExt::rsplitn(&self[..], count, pat) - } - - /// An iterator over the start and end indices of the disjoint matches of a `&str` within - /// `self`. - /// - /// That is, each returned value `(start, end)` satisfies `self.slice(start, end) == sep`. For - /// matches of `sep` within `self` that overlap, only the indices corresponding to the first - /// match are returned. - /// - /// # Examples - /// - /// ``` - /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); - /// assert_eq!(v, [(0,3), (6,9), (12,15)]); - /// - /// let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); - /// assert_eq!(v, [(1,4), (4,7)]); - /// - /// let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); - /// assert_eq!(v, [(0, 3)]); // only the first `aba` - /// ``` - #[unstable(feature = "collections", - reason = "might have its iterator type changed")] - // NB: Right now MatchIndices yields `(usize, usize)`, - // but it would be more consistent and useful to return `(usize, &str)` - fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P> { - core_str::StrExt::match_indices(&self[..], pat) - } - - /// An iterator over the substrings of `self` separated by a `&str`. - /// - /// # Examples - /// - /// ``` - /// let v: Vec<&str> = "abcXXXabcYYYabc".split_str("abc").collect(); - /// assert_eq!(v, ["", "XXX", "YYY", ""]); - /// - /// let v: Vec<&str> = "1abcabc2".split_str("abc").collect(); - /// assert_eq!(v, ["1", "", "2"]); - /// ``` - #[unstable(feature = "collections")] - #[deprecated(since = "1.0.0", reason = "use `split()` with a `&str`")] - #[allow(deprecated) /* for SplitStr */] - fn split_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitStr<'a, P> { - core_str::StrExt::split_str(&self[..], pat) - } - - /// An iterator over the lines of a string, separated by `\n`. - /// - /// This does not include the empty string after a trailing `\n`. - /// - /// # Examples - /// - /// ``` - /// let four_lines = "foo\nbar\n\nbaz"; - /// let v: Vec<&str> = four_lines.lines().collect(); - /// - /// assert_eq!(v, ["foo", "bar", "", "baz"]); - /// ``` - /// - /// Leaving off the trailing character: - /// - /// ``` - /// let four_lines = "foo\nbar\n\nbaz\n"; - /// let v: Vec<&str> = four_lines.lines().collect(); - /// - /// assert_eq!(v, ["foo", "bar", "", "baz"]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn lines(&self) -> Lines { - core_str::StrExt::lines(&self[..]) - } - - /// An iterator over the lines of a string, separated by either `\n` or `\r\n`. - /// - /// As with `.lines()`, this does not include an empty trailing line. - /// - /// # Examples - /// - /// ``` - /// let four_lines = "foo\r\nbar\n\r\nbaz"; - /// let v: Vec<&str> = four_lines.lines_any().collect(); - /// - /// assert_eq!(v, ["foo", "bar", "", "baz"]); - /// ``` - /// - /// Leaving off the trailing character: - /// - /// ``` - /// let four_lines = "foo\r\nbar\n\r\nbaz\n"; - /// let v: Vec<&str> = four_lines.lines_any().collect(); - /// - /// assert_eq!(v, ["foo", "bar", "", "baz"]); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn lines_any(&self) -> LinesAny { - core_str::StrExt::lines_any(&self[..]) - } - - /// Deprecated: use `s[a .. b]` instead. - #[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: 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: 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: usize) -> &str; - - /// Returns a slice of the string from the character range [`begin`..`end`). - /// - /// That is, start at the `begin`-th code point of the string and continue - /// to the `end`-th code point. This does not detect or handle edge cases - /// such as leaving a combining character as the first code point of the - /// string. - /// - /// Due to the design of UTF-8, this operation is `O(end)`. See `slice`, - /// `slice_to` and `slice_from` for `O(1)` variants that use byte indices - /// rather than code point indices. - /// - /// # Panics - /// - /// Panics if `begin` > `end` or the either `begin` or `end` are beyond the - /// last character of the string. - /// - /// # Examples - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// - /// assert_eq!(s.slice_chars(0, 4), "Löwe"); - /// assert_eq!(s.slice_chars(5, 7), "老虎"); - /// ``` - #[unstable(feature = "collections", - reason = "may have yet to prove its worth")] - fn slice_chars(&self, begin: usize, end: usize) -> &str { - core_str::StrExt::slice_chars(&self[..], begin, end) - } - - /// Takes a bytewise slice from a string. - /// - /// Returns the substring from [`begin`..`end`). - /// - /// # Unsafety - /// - /// Caller must check both UTF-8 character boundaries and the boundaries of - /// the entire slice as well. - /// - /// # Examples - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// - /// unsafe { - /// assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard"); - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str { - core_str::StrExt::slice_unchecked(&self[..], begin, end) - } - - /// Returns `true` if the given `&str` is a prefix of the string. - /// - /// # Examples - /// - /// ``` - /// assert!("banana".starts_with("ba")); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool { - core_str::StrExt::starts_with(&self[..], pat) - } - - /// Returns true if the given `&str` is a suffix of the string. - /// - /// # Examples - /// - /// ``` - /// assert!("banana".ends_with("nana")); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool - where P::Searcher: ReverseSearcher<'a> - { - core_str::StrExt::ends_with(&self[..], pat) - } - - /// Returns a string with all pre- and suffixes that match a pattern repeatedly removed. - /// - /// The pattern can be any `DoubleEndedSearcher`, including a closure that determines the split. - /// - /// # Examples - /// - /// Simple `char` patterns: - /// - /// ``` - /// assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); - /// - /// let x: &[_] = &['1', '2']; - /// assert_eq!("12foo1bar12".trim_matches(x), "foo1bar"); - /// ``` - /// - /// More complex patterns with a lambda: - /// - /// ``` - /// assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar"); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn trim_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str - where P::Searcher: DoubleEndedSearcher<'a> - { - core_str::StrExt::trim_matches(&self[..], pat) - } - - /// Returns a string with all prefixes that match a pattern repeatedly removed. - /// - /// The pattern can be a simple `&str`, or a closure that determines the split. - /// - /// # Examples - /// - /// Simple `&str` patterns: - /// - /// ``` - /// assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11"); - /// - /// let x: &[_] = &['1', '2']; - /// assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12"); - /// ``` - /// - /// More complex patterns with a lambda: - /// - /// ``` - /// assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123"); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str { - core_str::StrExt::trim_left_matches(&self[..], pat) - } - - /// Returns a string with all suffixes that match a pattern repeatedly removed. - /// - /// The pattern can be a simple `&str`, or a closure that determines the split. - /// - /// # Examples - /// - /// Simple `&str` patterns: - /// - /// ``` - /// assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar"); - /// let x: &[_] = &['1', '2']; - /// assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar"); - /// ``` - /// - /// More complex patterns with a lambda: - /// - /// ``` - /// assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar"); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn trim_right_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str - where P::Searcher: ReverseSearcher<'a> - { - core_str::StrExt::trim_right_matches(&self[..], pat) - } - - /// Check that `index`-th byte lies at the start and/or end of a UTF-8 code point sequence. - /// - /// The start and end of the string (when `index == self.len()`) are considered to be - /// boundaries. - /// - /// # Panics - /// - /// Panics if `index` is greater than `self.len()`. - /// - /// # Examples - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// assert!(s.is_char_boundary(0)); - /// // start of `老` - /// assert!(s.is_char_boundary(6)); - /// assert!(s.is_char_boundary(s.len())); - /// - /// // second byte of `ö` - /// assert!(!s.is_char_boundary(2)); - /// - /// // third byte of `老` - /// assert!(!s.is_char_boundary(8)); - /// ``` - #[unstable(feature = "str_char", - reason = "it is unclear whether this method pulls its weight \ - with the existence of the char_indices iterator or \ - this method may want to be replaced with checked \ - slicing")] - fn is_char_boundary(&self, index: usize) -> bool { - core_str::StrExt::is_char_boundary(&self[..], index) - } - - /// Given a byte position, return the next char and its index. - /// - /// This can be used to iterate over the Unicode characters of a string. - /// - /// # Panics - /// - /// If `i` is greater than or equal to the length of the string. - /// If `i` is not the index of the beginning of a valid UTF-8 character. - /// - /// # Examples - /// - /// This example manually iterates through the characters of a string; this should normally be - /// done by `.chars()` or `.char_indices()`. - /// - /// ``` - /// use std::str::CharRange; - /// - /// let s = "中华Việt Nam"; - /// let mut i = 0; - /// while i < s.len() { - /// let CharRange {ch, next} = s.char_range_at(i); - /// println!("{}: {}", i, ch); - /// i = next; - /// } - /// ``` - /// - /// This outputs: - /// - /// ```text - /// 0: 中 - /// 3: 华 - /// 6: V - /// 7: i - /// 8: ệ - /// 11: t - /// 12: - /// 13: N - /// 14: a - /// 15: m - /// ``` - #[unstable(feature = "str_char", - reason = "often replaced by char_indices, this method may \ - be removed in favor of just char_at() or eventually \ - removed altogether")] - fn char_range_at(&self, start: usize) -> CharRange { - core_str::StrExt::char_range_at(&self[..], start) - } - - /// Given a byte position, return the previous `char` and its position. - /// - /// This function can be used to iterate over a Unicode string in reverse. - /// - /// Returns 0 for next index if called on start index 0. - /// - /// # Panics - /// - /// If `i` is greater than the length of the string. - /// If `i` is not an index following a valid UTF-8 character. - /// - /// # Examples - /// - /// This example manually iterates through the characters of a string; this should normally be - /// done by `.chars().rev()` or `.char_indices()`. - /// - /// ``` - /// use std::str::CharRange; - /// - /// let s = "中华Việt Nam"; - /// let mut i = s.len(); - /// while i > 0 { - /// let CharRange {ch, next} = s.char_range_at_reverse(i); - /// println!("{}: {}", i, ch); - /// i = next; - /// } - /// ``` - /// - /// This outputs: - /// - /// ```text - /// 16: m - /// 15: a - /// 14: N - /// 13: - /// 12: t - /// 11: ệ - /// 8: i - /// 7: V - /// 6: 华 - /// 3: 中 - /// ``` - #[unstable(feature = "str_char", - reason = "often replaced by char_indices, this method may \ - be removed in favor of just char_at() or eventually \ - removed altogether")] - fn char_range_at_reverse(&self, start: usize) -> CharRange { - core_str::StrExt::char_range_at_reverse(&self[..], start) - } - - /// Given a byte position, return the `char` at that position. - /// - /// # Panics - /// - /// If `i` is greater than or equal to the length of the string. - /// If `i` is not the index of the beginning of a valid UTF-8 character. - /// - /// # Examples - /// - /// ``` - /// let s = "abπc"; - /// assert_eq!(s.char_at(1), 'b'); - /// assert_eq!(s.char_at(2), 'π'); - /// ``` - #[unstable(feature = "str_char", - reason = "frequently replaced by the chars() iterator, this \ - method may be removed or possibly renamed in the \ - future; it is normally replaced by chars/char_indices \ - iterators or by getting the first char from a \ - subslice")] - fn char_at(&self, i: usize) -> char { - core_str::StrExt::char_at(&self[..], i) - } - - /// Given a byte position, return the `char` at that position, counting from the end. - /// - /// # Panics - /// - /// If `i` is greater than the length of the string. - /// If `i` is not an index following a valid UTF-8 character. - /// - /// # Examples - /// - /// ``` - /// let s = "abπc"; - /// assert_eq!(s.char_at_reverse(1), 'a'); - /// assert_eq!(s.char_at_reverse(2), 'b'); - /// ``` - #[unstable(feature = "str_char", - reason = "see char_at for more details, but reverse semantics \ - are also somewhat unclear, especially with which \ - cases generate panics")] - fn char_at_reverse(&self, i: usize) -> char { - core_str::StrExt::char_at_reverse(&self[..], i) - } - - /// Convert `self` to a byte slice. - /// - /// # Examples - /// - /// ``` - /// assert_eq!("bors".as_bytes(), b"bors"); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn as_bytes(&self) -> &[u8] { - core_str::StrExt::as_bytes(&self[..]) - } - - /// Returns the byte index of the first character of `self` that matches the pattern, if it - /// exists. - /// - /// Returns `None` if it doesn't exist. - /// - /// The pattern can be a simple `&str`, or a closure that determines the split. - /// - /// # Examples - /// - /// Simple `&str` patterns: - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// - /// assert_eq!(s.find('L'), Some(0)); - /// assert_eq!(s.find('é'), Some(14)); - /// - /// ``` - /// - /// More complex patterns with a lambda: - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// - /// assert_eq!(s.find(|c: char| c.is_whitespace()), Some(5)); - /// ``` - /// - /// Not finding the pattern: - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// let x: &[_] = &['1', '2']; - /// - /// assert_eq!(s.find(x), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option { - core_str::StrExt::find(&self[..], pat) - } - - /// Returns the byte index of the last character of `self` that matches the pattern, if it - /// exists. - /// - /// Returns `None` if it doesn't exist. - /// - /// The pattern can be a simple `&str`, or a closure that determines the split. - /// - /// # Examples - /// - /// Simple `&str` patterns: - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// - /// assert_eq!(s.rfind('L'), Some(13)); - /// assert_eq!(s.rfind('é'), Some(14)); - /// ``` - /// - /// More complex patterns with a lambda: - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// - /// assert_eq!(s.rfind(|c: char| c.is_whitespace()), Some(12)); - /// ``` - /// - /// Not finding the pattern: - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// let x: &[_] = &['1', '2']; - /// - /// assert_eq!(s.rfind(x), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn rfind<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option - where P::Searcher: ReverseSearcher<'a> - { - core_str::StrExt::rfind(&self[..], pat) - } - - /// Returns the byte index of the first matching substring if it exists. - /// - /// Returns `None` if it doesn't exist. - /// - /// The pattern can be a simple `&str`, or a closure that determines the split. - /// - /// # Examples - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// - /// assert_eq!(s.find_str("老虎 L"), Some(6)); - /// assert_eq!(s.find_str("muffin man"), None); - /// ``` - #[unstable(feature = "collections")] - #[deprecated(since = "1.0.0", reason = "use `find()` with a `&str`")] - fn find_str<'a, P: Pattern<'a>>(&'a self, needle: P) -> Option { - core_str::StrExt::find_str(&self[..], needle) - } - - /// Retrieves the first character from a `&str` and returns it. - /// - /// This does not allocate a new string; instead, it returns a slice that points one character - /// beyond the character that was shifted. - /// - /// If the slice does not contain any characters, None is returned instead. - /// - /// # Examples - /// - /// ``` - /// let s = "Löwe 老虎 Léopard"; - /// let (c, s1) = s.slice_shift_char().unwrap(); - /// - /// assert_eq!(c, 'L'); - /// assert_eq!(s1, "öwe 老虎 Léopard"); - /// - /// let (c, s2) = s1.slice_shift_char().unwrap(); - /// - /// assert_eq!(c, 'ö'); - /// assert_eq!(s2, "we 老虎 Léopard"); - /// ``` - #[unstable(feature = "str_char", - reason = "awaiting conventions about shifting and slices and \ - may not be warranted with the existence of the chars \ - and/or char_indices iterators")] - fn slice_shift_char(&self) -> Option<(char, &str)> { - core_str::StrExt::slice_shift_char(&self[..]) - } - - /// Returns the byte offset of an inner slice relative to an enclosing outer slice. - /// - /// # Panics - /// - /// Panics if `inner` is not a direct slice contained within self. - /// - /// # Examples - /// - /// ``` - /// let string = "a\nb\nc"; - /// let lines: Vec<&str> = string.lines().collect(); - /// - /// assert!(string.subslice_offset(lines[0]) == 0); // &"a" - /// assert!(string.subslice_offset(lines[1]) == 2); // &"b" - /// assert!(string.subslice_offset(lines[2]) == 4); // &"c" - /// ``` - #[unstable(feature = "collections", - reason = "awaiting convention about comparability of arbitrary slices")] - fn subslice_offset(&self, inner: &str) -> usize { - core_str::StrExt::subslice_offset(&self[..], inner) - } - - /// Return an unsafe pointer to the `&str`'s buffer. - /// - /// The caller must ensure that the string outlives this pointer, and that it is not - /// reallocated (e.g. by pushing to the string). - /// - /// # Examples - /// - /// ``` - /// let s = "Hello"; - /// let p = s.as_ptr(); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - fn as_ptr(&self) -> *const u8 { - core_str::StrExt::as_ptr(&self[..]) - } - - /// Return an iterator of `u16` over the string encoded as UTF-16. - #[unstable(feature = "collections", - reason = "this functionality may only be provided by libunicode")] - fn utf16_units(&self) -> Utf16Units { - Utf16Units { encoder: Utf16Encoder::new(self[..].chars()) } - } - - /// Returns the length of `self` in bytes. - /// - /// # Examples - /// - /// ``` - /// assert_eq!("foo".len(), 3); - /// assert_eq!("ƒoo".len(), 4); // fancy f! - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - fn len(&self) -> usize { - core_str::StrExt::len(&self[..]) - } - - /// Returns true if this slice has a length of zero bytes. - /// - /// # Examples - /// - /// ``` - /// assert!("".is_empty()); - /// ``` - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - fn is_empty(&self) -> bool { - core_str::StrExt::is_empty(&self[..]) - } - - /// Parses `self` into the specified type. - /// - /// # Failure - /// - /// Will return `Err` if it's not possible to parse `self` into the type. - /// - /// # Examples - /// - /// ``` - /// assert_eq!("4".parse::(), Ok(4)); - /// ``` - /// - /// Failing: - /// - /// ``` - /// assert!("j".parse::().is_err()); - /// ``` - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - fn parse(&self) -> Result { - core_str::StrExt::parse(&self[..]) - } - - /// Returns an iterator over the [grapheme clusters][graphemes] of `self`. - /// - /// [graphemes]: http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries - /// - /// If `is_extended` is true, the iterator is over the *extended grapheme clusters*; - /// otherwise, the iterator is over the *legacy grapheme clusters*. - /// [UAX#29](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) - /// recommends extended grapheme cluster boundaries for general processing. - /// - /// # Examples - /// - /// ``` - /// let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::>(); - /// let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"]; - /// - /// assert_eq!(gr1.as_slice(), b); - /// - /// let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::>(); - /// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; - /// - /// assert_eq!(gr2.as_slice(), b); - /// ``` - #[unstable(feature = "unicode", - reason = "this functionality may be replaced with a more generic \ - unicode crate on crates.io")] - fn graphemes(&self, is_extended: bool) -> Graphemes { - UnicodeStr::graphemes(&self[..], is_extended) - } - - /// Returns an iterator over the grapheme clusters of `self` and their byte offsets. See - /// `graphemes()` for more information. - /// - /// # Examples - /// - /// ``` - /// 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 = "unicode", - reason = "this functionality may be replaced with a more generic \ - unicode crate on crates.io")] - fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices { - UnicodeStr::grapheme_indices(&self[..], is_extended) - } - - /// An iterator over the non-empty words of `self`. - /// - /// A 'word' is a subsequence separated by any sequence of whitespace. Sequences of whitespace - /// are collapsed, so empty "words" are not included. - /// - /// # Examples - /// - /// ``` - /// let some_words = " Mary had\ta little \n\t lamb"; - /// let v: Vec<&str> = some_words.words().collect(); - /// - /// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); - /// ``` - #[unstable(feature = "str_words", - reason = "the precise algorithm to use is unclear")] - fn words(&self) -> Words { - UnicodeStr::words(&self[..]) - } - - /// Returns a string's displayed width in columns. - /// - /// Control characters have zero width. - /// - /// `is_cjk` determines behavior for characters in the Ambiguous category: - /// if `is_cjk` is `true`, these are 2 columns wide; otherwise, they are 1. - /// In CJK locales, `is_cjk` should be `true`, else it should be `false`. - /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) - /// recommends that these characters be treated as 1 column (i.e., `is_cjk = - /// false`) if the locale is unknown. - #[unstable(feature = "unicode", - reason = "this functionality may be replaced with a more generic \ - unicode crate on crates.io")] - fn width(&self, is_cjk: bool) -> usize { - UnicodeStr::width(&self[..], is_cjk) - } - - /// Returns a `&str` with leading and trailing whitespace removed. - /// - /// # Examples - /// - /// ``` - /// let s = " Hello\tworld\t"; - /// assert_eq!(s.trim(), "Hello\tworld"); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn trim(&self) -> &str { - UnicodeStr::trim(&self[..]) - } - - /// Returns a `&str` with leading whitespace removed. - /// - /// # Examples - /// - /// ``` - /// let s = " Hello\tworld\t"; - /// assert_eq!(s.trim_left(), "Hello\tworld\t"); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn trim_left(&self) -> &str { - UnicodeStr::trim_left(&self[..]) - } - - /// Returns a `&str` with trailing whitespace removed. - /// - /// # Examples - /// - /// ``` - /// let s = " Hello\tworld\t"; - /// assert_eq!(s.trim_right(), " Hello\tworld"); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn trim_right(&self) -> &str { - UnicodeStr::trim_right(&self[..]) - } - - /// Returns the lowercase equivalent of this string. - /// - /// # Examples - /// - /// let s = "HELLO"; - /// assert_eq!(s.to_lowercase(), "hello"); - #[unstable(feature = "collections")] - fn to_lowercase(&self) -> String { - let mut s = String::with_capacity(self.len()); - s.extend(self[..].chars().flat_map(|c| c.to_lowercase())); - return s; - } - - /// Returns the uppercase equivalent of this string. - /// - /// # Examples - /// - /// let s = "hello"; - /// assert_eq!(s.to_uppercase(), "HELLO"); - #[unstable(feature = "collections")] - fn to_uppercase(&self) -> String { - let mut s = String::with_capacity(self.len()); - s.extend(self[..].chars().flat_map(|c| c.to_uppercase())); - return s; - } -} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl StrExt for str { - fn slice(&self, begin: usize, end: usize) -> &str { - &self[begin..end] - } - - fn slice_from(&self, begin: usize) -> &str { - &self[begin..] - } - - fn slice_to(&self, end: usize) -> &str { - &self[..end] - } -} - -#[cfg(not(stage0))] /// Any string that can be represented as a slice. #[lang = "str"] #[cfg(not(test))] diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 2a5f8db0496..cd6f27bf65f 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -85,23 +85,6 @@ impl String { } } - #[cfg(stage0)] - /// Creates a new string buffer from the given string. - /// - /// # Examples - /// - /// ``` - /// let s = String::from_str("hello"); - /// assert_eq!(s.as_slice(), "hello"); - /// ``` - #[inline] - #[unstable(feature = "collections", - reason = "needs investigation to see if to_string() can match perf")] - pub fn from_str(string: &str) -> String { - String { vec: ::slice::SliceExt::to_vec(string.as_bytes()) } - } - - #[cfg(not(stage0))] /// Creates a new string buffer from the given string. /// /// # Examples @@ -118,9 +101,9 @@ impl String { String { vec: <[_]>::to_vec(string.as_bytes()) } } - // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is required for this - // method definition, is not available. Since we don't require this method for testing - // purposes, I'll just stub it + // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is + // required for this method definition, is not available. Since we don't + // require this method for testing purposes, I'll just stub it // NB see the slice::hack module in slice.rs for more information #[inline] #[cfg(test)] diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 404179bd484..b0e8dc7d0b6 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -59,8 +59,6 @@ use core::intrinsics::assume; use core::iter::{repeat, FromIterator, IntoIterator}; use core::marker::PhantomData; use core::mem; -#[cfg(stage0)] -use core::num::{Int, UnsignedInt}; use core::ops::{Index, IndexMut, Deref, Add}; use core::ops; use core::ptr; @@ -1283,18 +1281,13 @@ pub fn from_elem(elem: T, n: usize) -> Vec { #[unstable(feature = "collections")] impl Clone for Vec { - #[cfg(stage0)] - fn clone(&self) -> Vec { ::slice::SliceExt::to_vec(&**self) } - - #[cfg(not(stage0))] #[cfg(not(test))] fn clone(&self) -> Vec { <[T]>::to_vec(&**self) } - // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is required for this - // method definition, is not available. Instead use the `slice::to_vec` function which is only - // available with cfg(test) + // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is + // required for this method definition, is not available. Instead use the + // `slice::to_vec` function which is only available with cfg(test) // NB see the slice::hack module in slice.rs for more information - #[cfg(not(stage0))] #[cfg(test)] fn clone(&self) -> Vec { ::slice::to_vec(&**self) diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index aefcad49a58..56ca74dab1f 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -25,8 +25,6 @@ use core::default::Default; use core::fmt; use core::iter::{self, repeat, FromIterator, IntoIterator, RandomAccessIterator}; use core::mem; -#[cfg(stage0)] -use core::num::{Int, UnsignedInt}; use core::num::wrapping::WrappingOps; use core::ops::{Index, IndexMut}; use core::ptr::{self, Unique}; diff --git a/src/libcore/any.rs b/src/libcore/any.rs index 6d3fac4c68d..3938a610668 100644 --- a/src/libcore/any.rs +++ b/src/libcore/any.rs @@ -155,7 +155,6 @@ impl Any { } } -#[cfg(not(stage0))] impl Any+Send { /// Forwards to the method defined on the type `Any`. #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index ead5da92bd9..1462d07652d 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -44,26 +44,6 @@ use marker::Sized; -#[cfg(stage0)] // SNAP 270a677 -pub type GlueFn = extern "Rust" fn(*const i8); - -#[lang="ty_desc"] -#[derive(Copy)] -#[cfg(stage0)] // SNAP 270a677 -pub struct TyDesc { - // sizeof(T) - pub size: usize, - - // alignof(T) - pub align: usize, - - // Called when a value of type `T` is no longer needed - pub drop_glue: GlueFn, - - // Name corresponding to the type - pub name: &'static str, -} - extern "rust-intrinsic" { // NB: These intrinsics take unsafe pointers because they mutate aliased @@ -198,12 +178,8 @@ extern "rust-intrinsic" { pub fn min_align_of() -> usize; pub fn pref_align_of() -> usize; - /// Get a static pointer to a type descriptor. - #[cfg(stage0)] // SNAP 270a677 - pub fn get_tydesc() -> *const TyDesc; - /// Gets a static string slice containing the name of a type. - #[cfg(not(stage0))] // SNAP 270a677 + #[cfg(not(stage0))] pub fn type_name() -> &'static str; /// Gets an identifier which is globally unique to the specified type. This diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index a77f9709600..156bc2708fb 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -437,13 +437,19 @@ macro_rules! uint_impl { fn max_value() -> $T { -1 } #[inline] - fn count_ones(self) -> u32 { unsafe { $ctpop(self as $ActualT) as u32 } } + fn count_ones(self) -> u32 { + unsafe { $ctpop(self as $ActualT) as u32 } + } #[inline] - fn leading_zeros(self) -> u32 { unsafe { $ctlz(self as $ActualT) as u32 } } + fn leading_zeros(self) -> u32 { + unsafe { $ctlz(self as $ActualT) as u32 } + } #[inline] - fn trailing_zeros(self) -> u32 { unsafe { $cttz(self as $ActualT) as u32 } } + fn trailing_zeros(self) -> u32 { + unsafe { $cttz(self as $ActualT) as u32 } + } #[inline] fn rotate_left(self, n: u32) -> $T { @@ -460,7 +466,9 @@ macro_rules! uint_impl { } #[inline] - fn swap_bytes(self) -> $T { unsafe { $bswap(self as $ActualT) as $T } } + fn swap_bytes(self) -> $T { + unsafe { $bswap(self as $ActualT) as $T } + } #[inline] fn checked_add(self, other: $T) -> Option<$T> { @@ -571,19 +579,29 @@ macro_rules! int_impl { fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() } #[inline] - fn leading_zeros(self) -> u32 { (self as $UnsignedT).leading_zeros() } + fn leading_zeros(self) -> u32 { + (self as $UnsignedT).leading_zeros() + } #[inline] - fn trailing_zeros(self) -> u32 { (self as $UnsignedT).trailing_zeros() } + fn trailing_zeros(self) -> u32 { + (self as $UnsignedT).trailing_zeros() + } #[inline] - fn rotate_left(self, n: u32) -> $T { (self as $UnsignedT).rotate_left(n) as $T } + fn rotate_left(self, n: u32) -> $T { + (self as $UnsignedT).rotate_left(n) as $T + } #[inline] - fn rotate_right(self, n: u32) -> $T { (self as $UnsignedT).rotate_right(n) as $T } + fn rotate_right(self, n: u32) -> $T { + (self as $UnsignedT).rotate_right(n) as $T + } #[inline] - fn swap_bytes(self) -> $T { (self as $UnsignedT).swap_bytes() as $T } + fn swap_bytes(self) -> $T { + (self as $UnsignedT).swap_bytes() as $T + } #[inline] fn checked_add(self, other: $T) -> Option<$T> { @@ -708,1043 +726,1005 @@ signed_int_impl! { i32 } signed_int_impl! { i64 } signed_int_impl! { int } -#[cfg(stage0)] -/// A built-in unsigned integer. -#[stable(feature = "rust1", since = "1.0.0")] -pub trait UnsignedInt: Int + WrappingOps { - /// Returns `true` iff `self == 2^k` for some `k`. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - fn is_power_of_two(self) -> bool { - (self.wrapping_sub(Int::one())) & self == Int::zero() && !(self == Int::zero()) - } +// `Int` + `SignedInt` implemented for signed integers +macro_rules! int_impl { + ($T:ty = $ActualT:ty, $UnsignedT:ty, $BITS:expr, + $add_with_overflow:path, + $sub_with_overflow:path, + $mul_with_overflow:path) => { + /// Returns the `0` value of this integer type. + // FIXME (#5527): Should be an associated constant + #[unstable(feature = "core", + reason = "unsure about its place in the world")] + #[inline] + pub fn zero() -> $T { 0 } - /// Returns the smallest power of two greater than or equal to `self`. - /// Unspecified behavior on overflow. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - fn next_power_of_two(self) -> Self { - let bits = size_of::() * 8; - let one: Self = Int::one(); - one << ((bits - self.wrapping_sub(one).leading_zeros() as usize) % bits) - } + /// Returns the `1` value of this integer type. + // FIXME (#5527): Should be an associated constant + #[unstable(feature = "core", + reason = "unsure about its place in the world")] + #[inline] + pub fn one() -> $T { 1 } - /// Returns the smallest power of two greater than or equal to `n`. If the - /// next power of two is greater than the type's maximum value, `None` is - /// returned, otherwise the power of two is wrapped in `Some`. - #[stable(feature = "rust1", since = "1.0.0")] - fn checked_next_power_of_two(self) -> Option { - let npot = self.next_power_of_two(); - if npot >= self { - Some(npot) - } else { - None + /// Returns the smallest value that can be represented by this integer + /// type. + // FIXME (#5527): Should be and associated constant + #[unstable(feature = "core", + reason = "unsure about its place in the world")] + #[inline] + pub fn min_value() -> $T { (-1 as $T) << ($BITS - 1) } + + /// Returns the largest value that can be represented by this integer + /// type. + // FIXME (#5527): Should be and associated constant + #[unstable(feature = "core", + reason = "unsure about its place in the world")] + #[inline] + pub fn max_value() -> $T { let min: $T = <$T>::min_value(); !min } + + /// Returns the number of ones in the binary representation of `self`. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0b01001100u8; + /// + /// assert_eq!(n.count_ones(), 3); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() } + + /// Returns the number of zeros in the binary representation of `self`. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0b01001100u8; + /// + /// assert_eq!(n.count_zeros(), 5); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn count_zeros(self) -> u32 { + (!self).count_ones() + } + + /// Returns the number of leading zeros in the binary representation + /// of `self`. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0b0101000u16; + /// + /// assert_eq!(n.leading_zeros(), 10); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn leading_zeros(self) -> u32 { + (self as $UnsignedT).leading_zeros() + } + + /// Returns the number of trailing zeros in the binary representation + /// of `self`. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0b0101000u16; + /// + /// assert_eq!(n.trailing_zeros(), 3); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn trailing_zeros(self) -> u32 { + (self as $UnsignedT).trailing_zeros() + } + + /// Shifts the bits to the left by a specified amount amount, `n`, + /// wrapping the truncated bits to the end of the resulting integer. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0x3456789ABCDEF012u64; + /// + /// assert_eq!(n.rotate_left(12), m); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn rotate_left(self, n: u32) -> $T { + (self as $UnsignedT).rotate_left(n) as $T + } + + /// Shifts the bits to the right by a specified amount amount, `n`, + /// wrapping the truncated bits to the beginning of the resulting + /// integer. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0xDEF0123456789ABCu64; + /// + /// assert_eq!(n.rotate_right(12), m); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn rotate_right(self, n: u32) -> $T { + (self as $UnsignedT).rotate_right(n) as $T + } + + /// Reverses the byte order of the integer. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0xEFCDAB8967452301u64; + /// + /// assert_eq!(n.swap_bytes(), m); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn swap_bytes(self) -> $T { + (self as $UnsignedT).swap_bytes() as $T + } + + /// Convert an integer from big endian to the target's endianness. + /// + /// On big endian this is a no-op. On little endian the bytes are + /// swapped. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "big") { + /// assert_eq!(Int::from_be(n), n) + /// } else { + /// assert_eq!(Int::from_be(n), n.swap_bytes()) + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn from_be(x: $T) -> $T { + if cfg!(target_endian = "big") { x } else { x.swap_bytes() } + } + + /// Convert an integer from little endian to the target's endianness. + /// + /// On little endian this is a no-op. On big endian the bytes are + /// swapped. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "little") { + /// assert_eq!(Int::from_le(n), n) + /// } else { + /// assert_eq!(Int::from_le(n), n.swap_bytes()) + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn from_le(x: $T) -> $T { + if cfg!(target_endian = "little") { x } else { x.swap_bytes() } + } + + /// Convert `self` to big endian from the target's endianness. + /// + /// On big endian this is a no-op. On little endian the bytes are + /// swapped. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "big") { + /// assert_eq!(n.to_be(), n) + /// } else { + /// assert_eq!(n.to_be(), n.swap_bytes()) + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn to_be(self) -> $T { // or not to be? + if cfg!(target_endian = "big") { self } else { self.swap_bytes() } + } + + /// Convert `self` to little endian from the target's endianness. + /// + /// On little endian this is a no-op. On big endian the bytes are + /// swapped. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "little") { + /// assert_eq!(n.to_le(), n) + /// } else { + /// assert_eq!(n.to_le(), n.swap_bytes()) + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn to_le(self) -> $T { + if cfg!(target_endian = "little") { self } else { self.swap_bytes() } + } + + /// Checked integer addition. Computes `self + other`, returning `None` + /// if overflow occurred. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!(5u16.checked_add(65530), Some(65535)); + /// assert_eq!(6u16.checked_add(65530), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn checked_add(self, other: $T) -> Option<$T> { + checked_op!($T, $ActualT, $add_with_overflow, self, other) + } + + /// Checked integer subtraction. Computes `self - other`, returning + /// `None` if underflow occurred. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!((-127i8).checked_sub(1), Some(-128)); + /// assert_eq!((-128i8).checked_sub(1), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn checked_sub(self, other: $T) -> Option<$T> { + checked_op!($T, $ActualT, $sub_with_overflow, self, other) + } + + /// Checked integer multiplication. Computes `self * other`, returning + /// `None` if underflow or overflow occurred. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!(5u8.checked_mul(51), Some(255)); + /// assert_eq!(5u8.checked_mul(52), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn checked_mul(self, other: $T) -> Option<$T> { + checked_op!($T, $ActualT, $mul_with_overflow, self, other) + } + + /// Checked integer division. Computes `self / other`, returning `None` + /// if `other == 0` or the operation results in underflow or overflow. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!((-127i8).checked_div(-1), Some(127)); + /// assert_eq!((-128i8).checked_div(-1), None); + /// assert_eq!((1i8).checked_div(0), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn checked_div(self, v: $T) -> Option<$T> { + match v { + 0 => None, + -1 if self == <$T>::min_value() + => None, + v => Some(self / v), + } + } + + /// Saturating integer addition. Computes `self + other`, saturating at + /// the numeric bounds instead of overflowing. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn saturating_add(self, other: $T) -> $T { + match self.checked_add(other) { + Some(x) => x, + None if other >= <$T>::zero() => <$T>::max_value(), + None => <$T>::min_value(), + } + } + + /// Saturating integer subtraction. Computes `self - other`, saturating + /// at the numeric bounds instead of overflowing. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn saturating_sub(self, other: $T) -> $T { + match self.checked_sub(other) { + Some(x) => x, + None if other >= <$T>::zero() => <$T>::min_value(), + None => <$T>::max_value(), + } + } + + /// Raises self to the power of `exp`, using exponentiation by squaring. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!(2.pow(4), 16); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn pow(self, mut exp: u32) -> $T { + let mut base = self; + let mut acc = <$T>::one(); + + let mut prev_base = self; + let mut base_oflo = false; + while exp > 0 { + if (exp & 1) == 1 { + if base_oflo { + // ensure overflow occurs in the same manner it + // would have otherwise (i.e. signal any exception + // it would have otherwise). + acc = acc * (prev_base * prev_base); + } else { + acc = acc * base; + } + } + prev_base = base; + let (new_base, new_base_oflo) = base.overflowing_mul(base); + base = new_base; + base_oflo = new_base_oflo; + exp /= 2; + } + acc + } + + /// Computes the absolute value of `self`. `Int::min_value()` will be + /// returned if the number is `Int::min_value()`. + #[unstable(feature = "core", reason = "overflow in debug builds?")] + #[inline] + pub fn abs(self) -> $T { + if self.is_negative() { -self } else { self } + } + + /// Returns a number representing sign of `self`. + /// + /// - `0` if the number is zero + /// - `1` if the number is positive + /// - `-1` if the number is negative + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn signum(self) -> $T { + match self { + n if n > 0 => 1, + 0 => 0, + _ => -1, + } + } + + /// Returns `true` if `self` is positive and `false` if the number + /// is zero or negative. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn is_positive(self) -> bool { self > 0 } + + /// Returns `true` if `self` is negative and `false` if the number + /// is zero or positive. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn is_negative(self) -> bool { self < 0 } + } +} + +#[lang = "i8"] +impl i8 { + int_impl! { i8 = i8, u8, 8, + intrinsics::i8_add_with_overflow, + intrinsics::i8_sub_with_overflow, + intrinsics::i8_mul_with_overflow } +} + +#[lang = "i16"] +impl i16 { + int_impl! { i16 = i16, u16, 16, + intrinsics::i16_add_with_overflow, + intrinsics::i16_sub_with_overflow, + intrinsics::i16_mul_with_overflow } +} + +#[lang = "i32"] +impl i32 { + int_impl! { i32 = i32, u32, 32, + intrinsics::i32_add_with_overflow, + intrinsics::i32_sub_with_overflow, + intrinsics::i32_mul_with_overflow } +} + +#[lang = "i64"] +impl i64 { + int_impl! { i64 = i64, u64, 64, + intrinsics::i64_add_with_overflow, + intrinsics::i64_sub_with_overflow, + intrinsics::i64_mul_with_overflow } +} + +#[cfg(target_pointer_width = "32")] +#[lang = "isize"] +impl isize { + int_impl! { int = i32, u32, 32, + intrinsics::i32_add_with_overflow, + intrinsics::i32_sub_with_overflow, + intrinsics::i32_mul_with_overflow } +} + +#[cfg(target_pointer_width = "64")] +#[lang = "isize"] +impl isize { + int_impl! { int = i64, u64, 64, + intrinsics::i64_add_with_overflow, + intrinsics::i64_sub_with_overflow, + intrinsics::i64_mul_with_overflow } +} + +// `Int` + `UnsignedInt` implemented for signed integers +macro_rules! uint_impl { + ($T:ty = $ActualT:ty, $BITS:expr, + $ctpop:path, + $ctlz:path, + $cttz:path, + $bswap:path, + $add_with_overflow:path, + $sub_with_overflow:path, + $mul_with_overflow:path) => { + /// Returns the `0` value of this integer type. + // FIXME (#5527): Should be an associated constant + #[unstable(feature = "core", + reason = "unsure about its place in the world")] + #[inline] + pub fn zero() -> $T { 0 } + + /// Returns the `1` value of this integer type. + // FIXME (#5527): Should be an associated constant + #[unstable(feature = "core", + reason = "unsure about its place in the world")] + #[inline] + pub fn one() -> $T { 1 } + + /// Returns the smallest value that can be represented by this integer + /// type. + // FIXME (#5527): Should be and associated constant + #[unstable(feature = "core", + reason = "unsure about its place in the world")] + #[inline] + pub fn min_value() -> $T { 0 } + + /// Returns the largest value that can be represented by this integer + /// type. + // FIXME (#5527): Should be and associated constant + #[unstable(feature = "core", + reason = "unsure about its place in the world")] + #[inline] + pub fn max_value() -> $T { -1 } + + /// Returns the number of ones in the binary representation of `self`. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0b01001100u8; + /// + /// assert_eq!(n.count_ones(), 3); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn count_ones(self) -> u32 { + unsafe { $ctpop(self as $ActualT) as u32 } + } + + /// Returns the number of zeros in the binary representation of `self`. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0b01001100u8; + /// + /// assert_eq!(n.count_zeros(), 5); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn count_zeros(self) -> u32 { + (!self).count_ones() + } + + /// Returns the number of leading zeros in the binary representation + /// of `self`. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0b0101000u16; + /// + /// assert_eq!(n.leading_zeros(), 10); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn leading_zeros(self) -> u32 { + unsafe { $ctlz(self as $ActualT) as u32 } + } + + /// Returns the number of trailing zeros in the binary representation + /// of `self`. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0b0101000u16; + /// + /// assert_eq!(n.trailing_zeros(), 3); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn trailing_zeros(self) -> u32 { + unsafe { $cttz(self as $ActualT) as u32 } + } + + /// Shifts the bits to the left by a specified amount amount, `n`, + /// wrapping the truncated bits to the end of the resulting integer. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0x3456789ABCDEF012u64; + /// + /// assert_eq!(n.rotate_left(12), m); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn rotate_left(self, n: u32) -> $T { + // Protect against undefined behaviour for over-long bit shifts + let n = n % $BITS; + (self << n) | (self >> (($BITS - n) % $BITS)) + } + + /// Shifts the bits to the right by a specified amount amount, `n`, + /// wrapping the truncated bits to the beginning of the resulting + /// integer. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0xDEF0123456789ABCu64; + /// + /// assert_eq!(n.rotate_right(12), m); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn rotate_right(self, n: u32) -> $T { + // Protect against undefined behaviour for over-long bit shifts + let n = n % $BITS; + (self >> n) | (self << (($BITS - n) % $BITS)) + } + + /// Reverses the byte order of the integer. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// let m = 0xEFCDAB8967452301u64; + /// + /// assert_eq!(n.swap_bytes(), m); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn swap_bytes(self) -> $T { + unsafe { $bswap(self as $ActualT) as $T } + } + + /// Convert an integer from big endian to the target's endianness. + /// + /// On big endian this is a no-op. On little endian the bytes are + /// swapped. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "big") { + /// assert_eq!(Int::from_be(n), n) + /// } else { + /// assert_eq!(Int::from_be(n), n.swap_bytes()) + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn from_be(x: $T) -> $T { + if cfg!(target_endian = "big") { x } else { x.swap_bytes() } + } + + /// Convert an integer from little endian to the target's endianness. + /// + /// On little endian this is a no-op. On big endian the bytes are + /// swapped. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "little") { + /// assert_eq!(Int::from_le(n), n) + /// } else { + /// assert_eq!(Int::from_le(n), n.swap_bytes()) + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn from_le(x: $T) -> $T { + if cfg!(target_endian = "little") { x } else { x.swap_bytes() } + } + + /// Convert `self` to big endian from the target's endianness. + /// + /// On big endian this is a no-op. On little endian the bytes are + /// swapped. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "big") { + /// assert_eq!(n.to_be(), n) + /// } else { + /// assert_eq!(n.to_be(), n.swap_bytes()) + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn to_be(self) -> $T { // or not to be? + if cfg!(target_endian = "big") { self } else { self.swap_bytes() } + } + + /// Convert `self` to little endian from the target's endianness. + /// + /// On little endian this is a no-op. On big endian the bytes are + /// swapped. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// let n = 0x0123456789ABCDEFu64; + /// + /// if cfg!(target_endian = "little") { + /// assert_eq!(n.to_le(), n) + /// } else { + /// assert_eq!(n.to_le(), n.swap_bytes()) + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn to_le(self) -> $T { + if cfg!(target_endian = "little") { self } else { self.swap_bytes() } + } + + /// Checked integer addition. Computes `self + other`, returning `None` + /// if overflow occurred. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!(5u16.checked_add(65530), Some(65535)); + /// assert_eq!(6u16.checked_add(65530), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn checked_add(self, other: $T) -> Option<$T> { + checked_op!($T, $ActualT, $add_with_overflow, self, other) + } + + /// Checked integer subtraction. Computes `self - other`, returning + /// `None` if underflow occurred. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!((-127i8).checked_sub(1), Some(-128)); + /// assert_eq!((-128i8).checked_sub(1), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn checked_sub(self, other: $T) -> Option<$T> { + checked_op!($T, $ActualT, $sub_with_overflow, self, other) + } + + /// Checked integer multiplication. Computes `self * other`, returning + /// `None` if underflow or overflow occurred. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!(5u8.checked_mul(51), Some(255)); + /// assert_eq!(5u8.checked_mul(52), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn checked_mul(self, other: $T) -> Option<$T> { + checked_op!($T, $ActualT, $mul_with_overflow, self, other) + } + + /// Checked integer division. Computes `self / other`, returning `None` + /// if `other == 0` or the operation results in underflow or overflow. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!((-127i8).checked_div(-1), Some(127)); + /// assert_eq!((-128i8).checked_div(-1), None); + /// assert_eq!((1i8).checked_div(0), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn checked_div(self, v: $T) -> Option<$T> { + match v { + 0 => None, + v => Some(self / v), + } + } + + /// Saturating integer addition. Computes `self + other`, saturating at + /// the numeric bounds instead of overflowing. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn saturating_add(self, other: $T) -> $T { + match self.checked_add(other) { + Some(x) => x, + None if other >= <$T>::zero() => <$T>::max_value(), + None => <$T>::min_value(), + } + } + + /// Saturating integer subtraction. Computes `self - other`, saturating + /// at the numeric bounds instead of overflowing. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn saturating_sub(self, other: $T) -> $T { + match self.checked_sub(other) { + Some(x) => x, + None if other >= <$T>::zero() => <$T>::min_value(), + None => <$T>::max_value(), + } + } + + /// Raises self to the power of `exp`, using exponentiation by squaring. + /// + /// # Examples + /// + /// ```rust + /// use std::num::Int; + /// + /// assert_eq!(2.pow(4), 16); + /// ``` + #[unstable(feature = "core", + reason = "pending integer conventions")] + #[inline] + pub fn pow(self, mut exp: u32) -> $T { + let mut base = self; + let mut acc = <$T>::one(); + + let mut prev_base = self; + let mut base_oflo = false; + while exp > 0 { + if (exp & 1) == 1 { + if base_oflo { + // ensure overflow occurs in the same manner it + // would have otherwise (i.e. signal any exception + // it would have otherwise). + acc = acc * (prev_base * prev_base); + } else { + acc = acc * base; + } + } + prev_base = base; + let (new_base, new_base_oflo) = base.overflowing_mul(base); + base = new_base; + base_oflo = new_base_oflo; + exp /= 2; + } + acc + } + + /// Returns `true` iff `self == 2^k` for some `k`. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn is_power_of_two(self) -> bool { + (self.wrapping_sub(<$T>::one())) & self == <$T>::zero() && + !(self == <$T>::zero()) + } + + /// Returns the smallest power of two greater than or equal to `self`. + /// Unspecified behavior on overflow. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn next_power_of_two(self) -> $T { + let bits = size_of::<$T>() * 8; + let one: $T = <$T>::one(); + one << ((bits - self.wrapping_sub(one).leading_zeros() as usize) % bits) + } + + /// Returns the smallest power of two greater than or equal to `n`. If + /// the next power of two is greater than the type's maximum value, + /// `None` is returned, otherwise the power of two is wrapped in `Some`. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn checked_next_power_of_two(self) -> Option<$T> { + let npot = self.next_power_of_two(); + if npot >= self { + Some(npot) + } else { + None + } } } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl UnsignedInt for uint {} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl UnsignedInt for u8 {} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl UnsignedInt for u16 {} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl UnsignedInt for u32 {} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl UnsignedInt for u64 {} - -// NB(japaric) I added this module to avoid adding several `cfg(not(stage0))`, and avoid name -// clashes between macros. We should move all the items inside this module into the outer scope -// once the `Int` trait is removed -#[cfg(not(stage0))] -mod inherent { - use intrinsics; - use mem::size_of; - use option::Option::{self, Some, None}; - - use super::wrapping::{OverflowingOps, WrappingOps}; - - // `Int` + `SignedInt` implemented for signed integers - macro_rules! int_impl { - ($T:ty = $ActualT:ty, $UnsignedT:ty, $BITS:expr, - $add_with_overflow:path, - $sub_with_overflow:path, - $mul_with_overflow:path) => { - /// Returns the `0` value of this integer type. - // FIXME (#5527): Should be an associated constant - #[unstable(feature = "core", - reason = "unsure about its place in the world")] - #[inline] - pub fn zero() -> $T { 0 } - - /// Returns the `1` value of this integer type. - // FIXME (#5527): Should be an associated constant - #[unstable(feature = "core", - reason = "unsure about its place in the world")] - #[inline] - pub fn one() -> $T { 1 } - - /// Returns the smallest value that can be represented by this integer type. - // FIXME (#5527): Should be and associated constant - #[unstable(feature = "core", - reason = "unsure about its place in the world")] - #[inline] - pub fn min_value() -> $T { (-1 as $T) << ($BITS - 1) } - - /// Returns the largest value that can be represented by this integer type. - // FIXME (#5527): Should be and associated constant - #[unstable(feature = "core", - reason = "unsure about its place in the world")] - #[inline] - pub fn max_value() -> $T { let min: $T = <$T>::min_value(); !min } - - /// Returns the number of ones in the binary representation of `self`. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0b01001100u8; - /// - /// assert_eq!(n.count_ones(), 3); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() } - - /// Returns the number of zeros in the binary representation of `self`. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0b01001100u8; - /// - /// assert_eq!(n.count_zeros(), 5); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn count_zeros(self) -> u32 { - (!self).count_ones() - } - - /// Returns the number of leading zeros in the binary representation - /// of `self`. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0b0101000u16; - /// - /// assert_eq!(n.leading_zeros(), 10); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn leading_zeros(self) -> u32 { (self as $UnsignedT).leading_zeros() } - - /// Returns the number of trailing zeros in the binary representation - /// of `self`. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0b0101000u16; - /// - /// assert_eq!(n.trailing_zeros(), 3); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn trailing_zeros(self) -> u32 { (self as $UnsignedT).trailing_zeros() } - - /// Shifts the bits to the left by a specified amount amount, `n`, wrapping - /// the truncated bits to the end of the resulting integer. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0x3456789ABCDEF012u64; - /// - /// assert_eq!(n.rotate_left(12), m); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn rotate_left(self, n: u32) -> $T { (self as $UnsignedT).rotate_left(n) as $T } - - /// Shifts the bits to the right by a specified amount amount, `n`, wrapping - /// the truncated bits to the beginning of the resulting integer. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0xDEF0123456789ABCu64; - /// - /// assert_eq!(n.rotate_right(12), m); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn rotate_right(self, n: u32) -> $T { (self as $UnsignedT).rotate_right(n) as $T } - - /// Reverses the byte order of the integer. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0xEFCDAB8967452301u64; - /// - /// assert_eq!(n.swap_bytes(), m); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn swap_bytes(self) -> $T { (self as $UnsignedT).swap_bytes() as $T } - - /// Convert an integer from big endian to the target's endianness. - /// - /// On big endian this is a no-op. On little endian the bytes are swapped. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "big") { - /// assert_eq!(Int::from_be(n), n) - /// } else { - /// assert_eq!(Int::from_be(n), n.swap_bytes()) - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn from_be(x: $T) -> $T { - if cfg!(target_endian = "big") { x } else { x.swap_bytes() } - } - - /// Convert an integer from little endian to the target's endianness. - /// - /// On little endian this is a no-op. On big endian the bytes are swapped. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "little") { - /// assert_eq!(Int::from_le(n), n) - /// } else { - /// assert_eq!(Int::from_le(n), n.swap_bytes()) - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn from_le(x: $T) -> $T { - if cfg!(target_endian = "little") { x } else { x.swap_bytes() } - } - - /// Convert `self` to big endian from the target's endianness. - /// - /// On big endian this is a no-op. On little endian the bytes are swapped. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "big") { - /// assert_eq!(n.to_be(), n) - /// } else { - /// assert_eq!(n.to_be(), n.swap_bytes()) - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn to_be(self) -> $T { // or not to be? - if cfg!(target_endian = "big") { self } else { self.swap_bytes() } - } - - /// Convert `self` to little endian from the target's endianness. - /// - /// On little endian this is a no-op. On big endian the bytes are swapped. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "little") { - /// assert_eq!(n.to_le(), n) - /// } else { - /// assert_eq!(n.to_le(), n.swap_bytes()) - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn to_le(self) -> $T { - if cfg!(target_endian = "little") { self } else { self.swap_bytes() } - } - - /// Checked integer addition. Computes `self + other`, returning `None` if - /// overflow occurred. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!(5u16.checked_add(65530), Some(65535)); - /// assert_eq!(6u16.checked_add(65530), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn checked_add(self, other: $T) -> Option<$T> { - checked_op!($T, $ActualT, $add_with_overflow, self, other) - } - - /// Checked integer subtraction. Computes `self - other`, returning `None` - /// if underflow occurred. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!((-127i8).checked_sub(1), Some(-128)); - /// assert_eq!((-128i8).checked_sub(1), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn checked_sub(self, other: $T) -> Option<$T> { - checked_op!($T, $ActualT, $sub_with_overflow, self, other) - } - - /// Checked integer multiplication. Computes `self * other`, returning - /// `None` if underflow or overflow occurred. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!(5u8.checked_mul(51), Some(255)); - /// assert_eq!(5u8.checked_mul(52), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn checked_mul(self, other: $T) -> Option<$T> { - checked_op!($T, $ActualT, $mul_with_overflow, self, other) - } - - /// Checked integer division. Computes `self / other`, returning `None` if - /// `other == 0` or the operation results in underflow or overflow. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!((-127i8).checked_div(-1), Some(127)); - /// assert_eq!((-128i8).checked_div(-1), None); - /// assert_eq!((1i8).checked_div(0), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn checked_div(self, v: $T) -> Option<$T> { - match v { - 0 => None, - -1 if self == <$T>::min_value() - => None, - v => Some(self / v), - } - } - - /// Saturating integer addition. Computes `self + other`, saturating at - /// the numeric bounds instead of overflowing. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn saturating_add(self, other: $T) -> $T { - match self.checked_add(other) { - Some(x) => x, - None if other >= <$T>::zero() => <$T>::max_value(), - None => <$T>::min_value(), - } - } - - /// Saturating integer subtraction. Computes `self - other`, saturating at - /// the numeric bounds instead of overflowing. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn saturating_sub(self, other: $T) -> $T { - match self.checked_sub(other) { - Some(x) => x, - None if other >= <$T>::zero() => <$T>::min_value(), - None => <$T>::max_value(), - } - } - - /// Raises self to the power of `exp`, using exponentiation by squaring. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!(2.pow(4), 16); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn pow(self, mut exp: u32) -> $T { - let mut base = self; - let mut acc = <$T>::one(); - - let mut prev_base = self; - let mut base_oflo = false; - while exp > 0 { - if (exp & 1) == 1 { - if base_oflo { - // ensure overflow occurs in the same manner it - // would have otherwise (i.e. signal any exception - // it would have otherwise). - acc = acc * (prev_base * prev_base); - } else { - acc = acc * base; - } - } - prev_base = base; - let (new_base, new_base_oflo) = base.overflowing_mul(base); - base = new_base; - base_oflo = new_base_oflo; - exp /= 2; - } - acc - } - - /// Computes the absolute value of `self`. `Int::min_value()` will be - /// returned if the number is `Int::min_value()`. - #[unstable(feature = "core", reason = "overflow in debug builds?")] - #[inline] - pub fn abs(self) -> $T { - if self.is_negative() { -self } else { self } - } - - /// Returns a number representing sign of `self`. - /// - /// - `0` if the number is zero - /// - `1` if the number is positive - /// - `-1` if the number is negative - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn signum(self) -> $T { - match self { - n if n > 0 => 1, - 0 => 0, - _ => -1, - } - } - - /// Returns `true` if `self` is positive and `false` if the number - /// is zero or negative. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn is_positive(self) -> bool { self > 0 } - - /// Returns `true` if `self` is negative and `false` if the number - /// is zero or positive. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn is_negative(self) -> bool { self < 0 } - } - } - - #[lang = "i8"] - impl i8 { - int_impl! { i8 = i8, u8, 8, - intrinsics::i8_add_with_overflow, - intrinsics::i8_sub_with_overflow, - intrinsics::i8_mul_with_overflow } - } - - #[lang = "i16"] - impl i16 { - int_impl! { i16 = i16, u16, 16, - intrinsics::i16_add_with_overflow, - intrinsics::i16_sub_with_overflow, - intrinsics::i16_mul_with_overflow } - } - - #[lang = "i32"] - impl i32 { - int_impl! { i32 = i32, u32, 32, - intrinsics::i32_add_with_overflow, - intrinsics::i32_sub_with_overflow, - intrinsics::i32_mul_with_overflow } - } - - #[lang = "i64"] - impl i64 { - int_impl! { i64 = i64, u64, 64, - intrinsics::i64_add_with_overflow, - intrinsics::i64_sub_with_overflow, - intrinsics::i64_mul_with_overflow } - } - - #[cfg(target_pointer_width = "32")] - #[lang = "isize"] - impl isize { - int_impl! { int = i32, u32, 32, - intrinsics::i32_add_with_overflow, - intrinsics::i32_sub_with_overflow, - intrinsics::i32_mul_with_overflow } - } - - #[cfg(target_pointer_width = "64")] - #[lang = "isize"] - impl isize { - int_impl! { int = i64, u64, 64, - intrinsics::i64_add_with_overflow, - intrinsics::i64_sub_with_overflow, - intrinsics::i64_mul_with_overflow } - } - - // `Int` + `UnsignedInt` implemented for signed integers - macro_rules! uint_impl { - ($T:ty = $ActualT:ty, $BITS:expr, - $ctpop:path, - $ctlz:path, - $cttz:path, - $bswap:path, - $add_with_overflow:path, - $sub_with_overflow:path, - $mul_with_overflow:path) => { - /// Returns the `0` value of this integer type. - // FIXME (#5527): Should be an associated constant - #[unstable(feature = "core", - reason = "unsure about its place in the world")] - #[inline] - pub fn zero() -> $T { 0 } - - /// Returns the `1` value of this integer type. - // FIXME (#5527): Should be an associated constant - #[unstable(feature = "core", - reason = "unsure about its place in the world")] - #[inline] - pub fn one() -> $T { 1 } - - /// Returns the smallest value that can be represented by this integer type. - // FIXME (#5527): Should be and associated constant - #[unstable(feature = "core", - reason = "unsure about its place in the world")] - #[inline] - pub fn min_value() -> $T { 0 } - - /// Returns the largest value that can be represented by this integer type. - // FIXME (#5527): Should be and associated constant - #[unstable(feature = "core", - reason = "unsure about its place in the world")] - #[inline] - pub fn max_value() -> $T { -1 } - - /// Returns the number of ones in the binary representation of `self`. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0b01001100u8; - /// - /// assert_eq!(n.count_ones(), 3); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn count_ones(self) -> u32 { unsafe { $ctpop(self as $ActualT) as u32 } } - - /// Returns the number of zeros in the binary representation of `self`. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0b01001100u8; - /// - /// assert_eq!(n.count_zeros(), 5); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn count_zeros(self) -> u32 { - (!self).count_ones() - } - - /// Returns the number of leading zeros in the binary representation - /// of `self`. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0b0101000u16; - /// - /// assert_eq!(n.leading_zeros(), 10); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn leading_zeros(self) -> u32 { unsafe { $ctlz(self as $ActualT) as u32 } } - - /// Returns the number of trailing zeros in the binary representation - /// of `self`. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0b0101000u16; - /// - /// assert_eq!(n.trailing_zeros(), 3); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn trailing_zeros(self) -> u32 { unsafe { $cttz(self as $ActualT) as u32 } } - - /// Shifts the bits to the left by a specified amount amount, `n`, wrapping - /// the truncated bits to the end of the resulting integer. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0x3456789ABCDEF012u64; - /// - /// assert_eq!(n.rotate_left(12), m); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn rotate_left(self, n: u32) -> $T { - // Protect against undefined behaviour for over-long bit shifts - let n = n % $BITS; - (self << n) | (self >> (($BITS - n) % $BITS)) - } - - /// Shifts the bits to the right by a specified amount amount, `n`, wrapping - /// the truncated bits to the beginning of the resulting integer. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0xDEF0123456789ABCu64; - /// - /// assert_eq!(n.rotate_right(12), m); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn rotate_right(self, n: u32) -> $T { - // Protect against undefined behaviour for over-long bit shifts - let n = n % $BITS; - (self >> n) | (self << (($BITS - n) % $BITS)) - } - - /// Reverses the byte order of the integer. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// let m = 0xEFCDAB8967452301u64; - /// - /// assert_eq!(n.swap_bytes(), m); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn swap_bytes(self) -> $T { unsafe { $bswap(self as $ActualT) as $T } } - - /// Convert an integer from big endian to the target's endianness. - /// - /// On big endian this is a no-op. On little endian the bytes are swapped. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "big") { - /// assert_eq!(Int::from_be(n), n) - /// } else { - /// assert_eq!(Int::from_be(n), n.swap_bytes()) - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn from_be(x: $T) -> $T { - if cfg!(target_endian = "big") { x } else { x.swap_bytes() } - } - - /// Convert an integer from little endian to the target's endianness. - /// - /// On little endian this is a no-op. On big endian the bytes are swapped. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "little") { - /// assert_eq!(Int::from_le(n), n) - /// } else { - /// assert_eq!(Int::from_le(n), n.swap_bytes()) - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn from_le(x: $T) -> $T { - if cfg!(target_endian = "little") { x } else { x.swap_bytes() } - } - - /// Convert `self` to big endian from the target's endianness. - /// - /// On big endian this is a no-op. On little endian the bytes are swapped. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "big") { - /// assert_eq!(n.to_be(), n) - /// } else { - /// assert_eq!(n.to_be(), n.swap_bytes()) - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn to_be(self) -> $T { // or not to be? - if cfg!(target_endian = "big") { self } else { self.swap_bytes() } - } - - /// Convert `self` to little endian from the target's endianness. - /// - /// On little endian this is a no-op. On big endian the bytes are swapped. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// let n = 0x0123456789ABCDEFu64; - /// - /// if cfg!(target_endian = "little") { - /// assert_eq!(n.to_le(), n) - /// } else { - /// assert_eq!(n.to_le(), n.swap_bytes()) - /// } - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn to_le(self) -> $T { - if cfg!(target_endian = "little") { self } else { self.swap_bytes() } - } - - /// Checked integer addition. Computes `self + other`, returning `None` if - /// overflow occurred. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!(5u16.checked_add(65530), Some(65535)); - /// assert_eq!(6u16.checked_add(65530), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn checked_add(self, other: $T) -> Option<$T> { - checked_op!($T, $ActualT, $add_with_overflow, self, other) - } - - /// Checked integer subtraction. Computes `self - other`, returning `None` - /// if underflow occurred. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!((-127i8).checked_sub(1), Some(-128)); - /// assert_eq!((-128i8).checked_sub(1), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn checked_sub(self, other: $T) -> Option<$T> { - checked_op!($T, $ActualT, $sub_with_overflow, self, other) - } - - /// Checked integer multiplication. Computes `self * other`, returning - /// `None` if underflow or overflow occurred. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!(5u8.checked_mul(51), Some(255)); - /// assert_eq!(5u8.checked_mul(52), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn checked_mul(self, other: $T) -> Option<$T> { - checked_op!($T, $ActualT, $mul_with_overflow, self, other) - } - - /// Checked integer division. Computes `self / other`, returning `None` if - /// `other == 0` or the operation results in underflow or overflow. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!((-127i8).checked_div(-1), Some(127)); - /// assert_eq!((-128i8).checked_div(-1), None); - /// assert_eq!((1i8).checked_div(0), None); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn checked_div(self, v: $T) -> Option<$T> { - match v { - 0 => None, - v => Some(self / v), - } - } - - /// Saturating integer addition. Computes `self + other`, saturating at - /// the numeric bounds instead of overflowing. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn saturating_add(self, other: $T) -> $T { - match self.checked_add(other) { - Some(x) => x, - None if other >= <$T>::zero() => <$T>::max_value(), - None => <$T>::min_value(), - } - } - - /// Saturating integer subtraction. Computes `self - other`, saturating at - /// the numeric bounds instead of overflowing. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn saturating_sub(self, other: $T) -> $T { - match self.checked_sub(other) { - Some(x) => x, - None if other >= <$T>::zero() => <$T>::min_value(), - None => <$T>::max_value(), - } - } - - /// Raises self to the power of `exp`, using exponentiation by squaring. - /// - /// # Examples - /// - /// ```rust - /// use std::num::Int; - /// - /// assert_eq!(2.pow(4), 16); - /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] - #[inline] - pub fn pow(self, mut exp: u32) -> $T { - let mut base = self; - let mut acc = <$T>::one(); - - let mut prev_base = self; - let mut base_oflo = false; - while exp > 0 { - if (exp & 1) == 1 { - if base_oflo { - // ensure overflow occurs in the same manner it - // would have otherwise (i.e. signal any exception - // it would have otherwise). - acc = acc * (prev_base * prev_base); - } else { - acc = acc * base; - } - } - prev_base = base; - let (new_base, new_base_oflo) = base.overflowing_mul(base); - base = new_base; - base_oflo = new_base_oflo; - exp /= 2; - } - acc - } - - /// Returns `true` iff `self == 2^k` for some `k`. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn is_power_of_two(self) -> bool { - (self.wrapping_sub(<$T>::one())) & self == <$T>::zero() && !(self == <$T>::zero()) - } - - /// Returns the smallest power of two greater than or equal to `self`. - /// Unspecified behavior on overflow. - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] - pub fn next_power_of_two(self) -> $T { - let bits = size_of::<$T>() * 8; - let one: $T = <$T>::one(); - one << ((bits - self.wrapping_sub(one).leading_zeros() as usize) % bits) - } - - /// Returns the smallest power of two greater than or equal to `n`. If the - /// next power of two is greater than the type's maximum value, `None` is - /// returned, otherwise the power of two is wrapped in `Some`. - #[stable(feature = "rust1", since = "1.0.0")] - pub fn checked_next_power_of_two(self) -> Option<$T> { - let npot = self.next_power_of_two(); - if npot >= self { - Some(npot) - } else { - None - } - } - } - } - - /// Swapping a single byte is a no-op. This is marked as `unsafe` for - /// consistency with the other `bswap` intrinsics. - unsafe fn bswap8(x: u8) -> u8 { x } - - #[lang = "u8"] - impl u8 { - uint_impl! { u8 = u8, 8, - intrinsics::ctpop8, - intrinsics::ctlz8, - intrinsics::cttz8, - bswap8, - intrinsics::u8_add_with_overflow, - intrinsics::u8_sub_with_overflow, - intrinsics::u8_mul_with_overflow } - } - - #[lang = "u16"] - impl u16 { - uint_impl! { u16 = u16, 16, - intrinsics::ctpop16, - intrinsics::ctlz16, - intrinsics::cttz16, - intrinsics::bswap16, - intrinsics::u16_add_with_overflow, - intrinsics::u16_sub_with_overflow, - intrinsics::u16_mul_with_overflow } - } - - #[lang = "u32"] - impl u32 { - uint_impl! { u32 = u32, 32, - intrinsics::ctpop32, - intrinsics::ctlz32, - intrinsics::cttz32, - intrinsics::bswap32, - intrinsics::u32_add_with_overflow, - intrinsics::u32_sub_with_overflow, - intrinsics::u32_mul_with_overflow } - } - - - #[lang = "u64"] - impl u64 { - uint_impl! { u64 = u64, 64, - intrinsics::ctpop64, - intrinsics::ctlz64, - intrinsics::cttz64, - intrinsics::bswap64, - intrinsics::u64_add_with_overflow, - intrinsics::u64_sub_with_overflow, - intrinsics::u64_mul_with_overflow } - } - - #[cfg(target_pointer_width = "32")] - #[lang = "usize"] - impl usize { - uint_impl! { uint = u32, 32, - intrinsics::ctpop32, - intrinsics::ctlz32, - intrinsics::cttz32, - intrinsics::bswap32, - intrinsics::u32_add_with_overflow, - intrinsics::u32_sub_with_overflow, - intrinsics::u32_mul_with_overflow } - } - - #[cfg(target_pointer_width = "64")] - #[lang = "usize"] - impl usize { - uint_impl! { uint = u64, 64, - intrinsics::ctpop64, - intrinsics::ctlz64, - intrinsics::cttz64, - intrinsics::bswap64, - intrinsics::u64_add_with_overflow, - intrinsics::u64_sub_with_overflow, - intrinsics::u64_mul_with_overflow } - } +#[lang = "u8"] +impl u8 { + uint_impl! { u8 = u8, 8, + intrinsics::ctpop8, + intrinsics::ctlz8, + intrinsics::cttz8, + bswap8, + intrinsics::u8_add_with_overflow, + intrinsics::u8_sub_with_overflow, + intrinsics::u8_mul_with_overflow } +} + +#[lang = "u16"] +impl u16 { + uint_impl! { u16 = u16, 16, + intrinsics::ctpop16, + intrinsics::ctlz16, + intrinsics::cttz16, + intrinsics::bswap16, + intrinsics::u16_add_with_overflow, + intrinsics::u16_sub_with_overflow, + intrinsics::u16_mul_with_overflow } +} + +#[lang = "u32"] +impl u32 { + uint_impl! { u32 = u32, 32, + intrinsics::ctpop32, + intrinsics::ctlz32, + intrinsics::cttz32, + intrinsics::bswap32, + intrinsics::u32_add_with_overflow, + intrinsics::u32_sub_with_overflow, + intrinsics::u32_mul_with_overflow } +} + + +#[lang = "u64"] +impl u64 { + uint_impl! { u64 = u64, 64, + intrinsics::ctpop64, + intrinsics::ctlz64, + intrinsics::cttz64, + intrinsics::bswap64, + intrinsics::u64_add_with_overflow, + intrinsics::u64_sub_with_overflow, + intrinsics::u64_mul_with_overflow } +} + +#[cfg(target_pointer_width = "32")] +#[lang = "usize"] +impl usize { + uint_impl! { uint = u32, 32, + intrinsics::ctpop32, + intrinsics::ctlz32, + intrinsics::cttz32, + intrinsics::bswap32, + intrinsics::u32_add_with_overflow, + intrinsics::u32_sub_with_overflow, + intrinsics::u32_mul_with_overflow } +} + +#[cfg(target_pointer_width = "64")] +#[lang = "usize"] +impl usize { + uint_impl! { uint = u64, 64, + intrinsics::ctpop64, + intrinsics::ctlz64, + intrinsics::cttz64, + intrinsics::bswap64, + intrinsics::u64_add_with_overflow, + intrinsics::u64_sub_with_overflow, + intrinsics::u64_mul_with_overflow } } /// A generic trait for converting a value to a number. diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs index fb793a62390..c668fe80d14 100644 --- a/src/libcore/prelude.rs +++ b/src/libcore/prelude.rs @@ -42,8 +42,6 @@ pub use iter::{Extend, IteratorExt}; pub use iter::{Iterator, DoubleEndedIterator}; pub use iter::{ExactSizeIterator}; pub use option::Option::{self, Some, None}; -#[cfg(stage0)] -pub use ptr::{PtrExt, MutPtrExt}; pub use result::Result::{self, Ok, Err}; pub use slice::{AsSlice, SliceExt}; pub use str::{Str, StrExt}; diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index f28c26d1798..1cbea057e88 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -262,145 +262,13 @@ pub unsafe fn write(dst: *mut T, src: T) { intrinsics::move_val_init(&mut *dst, src) } -#[cfg(stage0)] -/// Methods on raw pointers -#[stable(feature = "rust1", since = "1.0.0")] -pub trait PtrExt { - /// The type which is being pointed at - type Target: ?Sized; - - /// Returns true if the pointer is null. - #[stable(feature = "rust1", since = "1.0.0")] - fn is_null(self) -> bool; - - /// Returns `None` if the pointer is null, or else returns a reference to - /// the value wrapped in `Some`. - /// - /// # Safety - /// - /// While this method and its mutable counterpart are useful for - /// null-safety, it is important to note that this is still an unsafe - /// operation because the returned value could be pointing to invalid - /// memory. - #[unstable(feature = "core", - reason = "Option is not clearly the right return type, and we may want \ - to tie the return lifetime to a borrow of the raw pointer")] - unsafe fn as_ref<'a>(&self) -> Option<&'a Self::Target>; - - /// Calculates the offset from a pointer. `count` is in units of T; e.g. a - /// `count` of 3 represents a pointer offset of `3 * sizeof::()` bytes. - /// - /// # Safety - /// - /// The offset must be in-bounds of the object, or one-byte-past-the-end. - /// Otherwise `offset` invokes Undefined Behaviour, regardless of whether - /// the pointer is used. - #[stable(feature = "rust1", since = "1.0.0")] - unsafe fn offset(self, count: isize) -> Self where Self::Target: Sized; -} - -#[cfg(stage0)] -/// Methods on mutable raw pointers -#[stable(feature = "rust1", since = "1.0.0")] -pub trait MutPtrExt { - /// The type which is being pointed at - type Target: ?Sized; - - /// Returns `None` if the pointer is null, or else returns a mutable - /// reference to the value wrapped in `Some`. - /// - /// # Safety - /// - /// As with `as_ref`, this is unsafe because it cannot verify the validity - /// of the returned pointer. - #[unstable(feature = "core", - reason = "Option is not clearly the right return type, and we may want \ - to tie the return lifetime to a borrow of the raw pointer")] - unsafe fn as_mut<'a>(&self) -> Option<&'a mut Self::Target>; -} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl PtrExt for *const T { - type Target = T; - - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - fn is_null(self) -> bool { self == 0 as *const T } - - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - unsafe fn offset(self, count: isize) -> *const T where T: Sized { - intrinsics::offset(self, count) - } - - #[inline] - #[unstable(feature = "core", - reason = "return value does not necessarily convey all possible \ - information")] - unsafe fn as_ref<'a>(&self) -> Option<&'a T> { - if self.is_null() { - None - } else { - Some(&**self) - } - } -} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl PtrExt for *mut T { - type Target = T; - - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - fn is_null(self) -> bool { self == 0 as *mut T } - - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - unsafe fn offset(self, count: isize) -> *mut T where T: Sized { - intrinsics::offset(self, count) as *mut T - } - - #[inline] - #[unstable(feature = "core", - reason = "return value does not necessarily convey all possible \ - information")] - unsafe fn as_ref<'a>(&self) -> Option<&'a T> { - if self.is_null() { - None - } else { - Some(&**self) - } - } -} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl MutPtrExt for *mut T { - type Target = T; - - #[inline] - #[unstable(feature = "core", - reason = "return value does not necessarily convey all possible \ - information")] - unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> { - if self.is_null() { - None - } else { - Some(&mut **self) - } - } -} - -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] #[lang = "const_ptr"] impl *const T { /// Returns true if the pointer is null. #[stable(feature = "rust1", since = "1.0.0")] #[inline] - pub fn is_null(self) -> bool { + pub fn is_null(self) -> bool where T: Sized { self == 0 as *const T } @@ -417,7 +285,7 @@ impl *const T { reason = "Option is not clearly the right return type, and we may want \ to tie the return lifetime to a borrow of the raw pointer")] #[inline] - pub unsafe fn as_ref<'a>(&self) -> Option<&'a T> { + pub unsafe fn as_ref<'a>(&self) -> Option<&'a T> where T: Sized { if self.is_null() { None } else { @@ -440,14 +308,13 @@ impl *const T { } } -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] #[lang = "mut_ptr"] impl *mut T { /// Returns true if the pointer is null. #[stable(feature = "rust1", since = "1.0.0")] #[inline] - pub fn is_null(self) -> bool { + pub fn is_null(self) -> bool where T: Sized { self == 0 as *mut T } @@ -464,7 +331,7 @@ impl *mut T { reason = "Option is not clearly the right return type, and we may want \ to tie the return lifetime to a borrow of the raw pointer")] #[inline] - pub unsafe fn as_ref<'a>(&self) -> Option<&'a T> { + pub unsafe fn as_ref<'a>(&self) -> Option<&'a T> where T: Sized { if self.is_null() { None } else { @@ -497,7 +364,7 @@ impl *mut T { reason = "return value does not necessarily convey all possible \ information")] #[inline] - pub unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> { + pub unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> where T: Sized { if self.is_null() { None } else { diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index b1576c0d377..907b2eba80c 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -49,8 +49,6 @@ use option::Option::{None, Some}; use result::Result; use result::Result::{Ok, Err}; use ptr; -#[cfg(stage0)] -use ptr::PtrExt; use mem; use mem::size_of; use marker::{Send, Sized, Sync, self}; diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 6b83338e1d2..e8181395b5c 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -31,8 +31,6 @@ use mem; use num::Int; use ops::{Fn, FnMut}; use option::Option::{self, None, Some}; -#[cfg(stage0)] -use ptr::PtrExt; use raw::{Repr, Slice}; use result::Result::{self, Ok, Err}; use slice::{self, SliceExt}; diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 313f034021f..496c96c7c8a 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -27,8 +27,6 @@ use middle::ty; use std::cmp::Ordering; use std::fmt; use std::iter::{range_inclusive, AdditiveIterator, FromIterator, IntoIterator, repeat}; -#[cfg(stage0)] -use std::num::Float; use std::slice; use syntax::ast::{self, DUMMY_NODE_ID, NodeId, Pat}; use syntax::ast_util; diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 366b90cfbfd..529ed8598b1 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -204,8 +204,6 @@ use std::io::prelude::*; use std::io; use std::mem::{swap}; use std::num::FpCategory as Fp; -#[cfg(stage0)] -use std::num::{Float, Int}; use std::ops::Index; use std::str::FromStr; use std::string; diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index 6f8151c2b9f..60b1738d2c9 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -23,8 +23,6 @@ use hash::{Hash, SipHasher}; use iter::{self, Iterator, ExactSizeIterator, IntoIterator, IteratorExt, FromIterator, Extend, Map}; use marker::Sized; use mem::{self, replace}; -#[cfg(stage0)] -use num::{Int, UnsignedInt}; use ops::{Deref, FnMut, Index, IndexMut}; use option::Option::{self, Some, None}; use rand::{self, Rng}; diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index cba46859f34..052bcfd7e16 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -19,15 +19,10 @@ use iter::{Iterator, IteratorExt, ExactSizeIterator, count}; use marker::{Copy, Send, Sync, Sized, self}; use mem::{min_align_of, size_of}; use mem; -#[cfg(stage0)] -use num::{Int, UnsignedInt}; use num::wrapping::{OverflowingOps, WrappingOps}; use ops::{Deref, DerefMut, Drop}; use option::Option; use option::Option::{Some, None}; -#[cfg(stage0)] -use ptr::{self, PtrExt, Unique}; -#[cfg(not(stage0))] use ptr::{self, Unique}; use rt::heap::{allocate, deallocate, EMPTY}; use collections::hash_state::HashState; diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index d06b027adf6..a42809127bf 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -272,10 +272,6 @@ mod dl { use ptr; use result::Result; use result::Result::{Ok, Err}; - #[cfg(stage0)] - use slice::SliceExt; - #[cfg(stage0)] - use str::StrExt; use str; use string::String; use vec::Vec; @@ -294,10 +290,11 @@ mod dl { let err = os::errno(); if err as libc::c_int == ERROR_CALL_NOT_IMPLEMENTED { use_thread_mode = false; - // SetThreadErrorMode not found. use fallback solution: SetErrorMode() - // Note that SetErrorMode is process-wide so this can cause race condition! - // However, since even Windows APIs do not care of such problem (#20650), - // we just assume SetErrorMode race is not a great deal. + // SetThreadErrorMode not found. use fallback solution: + // SetErrorMode() Note that SetErrorMode is process-wide so + // this can cause race condition! However, since even + // Windows APIs do not care of such problem (#20650), we + // just assume SetErrorMode race is not a great deal. prev_error_mode = SetErrorMode(new_error_mode); } } diff --git a/src/libstd/ffi/c_str.rs b/src/libstd/ffi/c_str.rs index 28f22468d22..fc4f03ff3a5 100644 --- a/src/libstd/ffi/c_str.rs +++ b/src/libstd/ffi/c_str.rs @@ -22,12 +22,7 @@ use old_io; use ops::Deref; use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; -#[cfg(stage0)] -use slice::{self, SliceExt}; -#[cfg(not(stage0))] use slice; -#[cfg(stage0)] -use str::StrExt; use string::String; use vec::Vec; diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index d9e8047104a..8691c84a462 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -20,18 +20,10 @@ use iter::Iterator; use marker::Sized; use ops::{Drop, FnOnce}; use option::Option::{self, Some, None}; -#[cfg(stage0)] -use ptr::PtrExt; use result::Result::{Ok, Err}; use result; -#[cfg(stage0)] -use slice::{self, SliceExt}; -#[cfg(not(stage0))] use slice; use string::String; -#[cfg(stage0)] -use str::{self, StrExt}; -#[cfg(not(stage0))] use str; use vec::Vec; diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index a7825c4f93a..11e2b8dca1b 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -357,7 +357,6 @@ impl Float for f32 { } } -#[cfg(not(stage0))] #[cfg(not(test))] #[lang = "f32"] #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index f3978cae485..650f642220f 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -366,7 +366,6 @@ impl Float for f64 { } } -#[cfg(not(stage0))] #[cfg(not(test))] #[lang = "f64"] #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/num/float_macros.rs b/src/libstd/num/float_macros.rs index ece7af9c152..60a548b596b 100644 --- a/src/libstd/num/float_macros.rs +++ b/src/libstd/num/float_macros.rs @@ -11,17 +11,6 @@ #![unstable(feature = "std_misc")] #![doc(hidden)] -#[cfg(stage0)] -macro_rules! assert_approx_eq { - ($a:expr, $b:expr) => ({ - use num::Float; - let (a, b) = (&$a, &$b); - assert!((*a - *b).abs() < 1.0e-6, - "{} is not approximately equal to {}", *a, *b); - }) -} - -#[cfg(not(stage0))] macro_rules! assert_approx_eq { ($a:expr, $b:expr) => ({ let (a, b) = (&$a, &$b); diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 599f3f02a8b..37f1f691776 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -23,9 +23,6 @@ use marker::Copy; use clone::Clone; use cmp::{PartialOrd, PartialEq}; -#[cfg(stage0)] -pub use core::num::{Int, SignedInt, UnsignedInt}; -#[cfg(not(stage0))] pub use core::num::{Int, SignedInt}; pub use core::num::{cast, FromPrimitive, NumCast, ToPrimitive}; pub use core::num::{from_int, from_i8, from_i16, from_i32, from_i64}; diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index ea1e05df85f..66826b359e6 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -16,17 +16,10 @@ use self::ExponentFormat::*; use self::SignificantDigits::*; use self::SignFormat::*; -#[cfg(stage0)] -use char::{self, CharExt}; -#[cfg(not(stage0))] use char; use num::{self, Int, Float, ToPrimitive}; use num::FpCategory as Fp; use ops::FnMut; -#[cfg(stage0)] -use slice::SliceExt; -#[cfg(stage0)] -use str::StrExt; use string::String; use vec::Vec; diff --git a/src/libstd/old_io/buffered.rs b/src/libstd/old_io/buffered.rs index 82a48a72499..56bc21303bb 100644 --- a/src/libstd/old_io/buffered.rs +++ b/src/libstd/old_io/buffered.rs @@ -20,8 +20,6 @@ use ops::Drop; use option::Option; use option::Option::{Some, None}; use result::Result::Ok; -#[cfg(stage0)] -use slice::{SliceExt}; use slice; use vec::Vec; diff --git a/src/libstd/old_io/comm_adapters.rs b/src/libstd/old_io/comm_adapters.rs index 33928d638e0..2dc61f409e2 100644 --- a/src/libstd/old_io/comm_adapters.rs +++ b/src/libstd/old_io/comm_adapters.rs @@ -14,9 +14,6 @@ use sync::mpsc::{Sender, Receiver}; use old_io; use option::Option::{None, Some}; use result::Result::{Ok, Err}; -#[cfg(stage0)] -use slice::{bytes, SliceExt}; -#[cfg(not(stage0))] use slice::bytes; use super::{Buffer, Reader, Writer, IoResult}; use vec::Vec; diff --git a/src/libstd/old_io/extensions.rs b/src/libstd/old_io/extensions.rs index a81275952c5..12c9970aa84 100644 --- a/src/libstd/old_io/extensions.rs +++ b/src/libstd/old_io/extensions.rs @@ -26,11 +26,7 @@ use num::Int; use ops::FnOnce; use option::Option; use option::Option::{Some, None}; -#[cfg(stage0)] -use ptr::PtrExt; use result::Result::{Ok, Err}; -#[cfg(stage0)] -use slice::SliceExt; /// An iterator that reads a single byte on each iteration, /// until `.read_byte()` returns `EndOfFile`. @@ -164,8 +160,6 @@ pub fn u64_to_be_bytes(n: u64, size: uint, f: F) -> T where /// 32-bit value is parsed. pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 { use ptr::{copy_nonoverlapping_memory}; - #[cfg(stage0)] - use slice::SliceExt; assert!(size <= 8); diff --git a/src/libstd/old_io/fs.rs b/src/libstd/old_io/fs.rs index ff3af380b7d..2df925beb36 100644 --- a/src/libstd/old_io/fs.rs +++ b/src/libstd/old_io/fs.rs @@ -64,8 +64,6 @@ use option::Option::{Some, None}; use old_path::{Path, GenericPath}; use old_path; use result::Result::{Err, Ok}; -#[cfg(stage0)] -use slice::SliceExt; use string::String; use vec::Vec; diff --git a/src/libstd/old_io/mem.rs b/src/libstd/old_io/mem.rs index 72774334c13..eb7691361d4 100644 --- a/src/libstd/old_io/mem.rs +++ b/src/libstd/old_io/mem.rs @@ -17,9 +17,6 @@ use option::Option::None; use result::Result::{Err, Ok}; use old_io; use old_io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult}; -#[cfg(stage0)] -use slice::{self, SliceExt}; -#[cfg(not(stage0))] use slice; use vec::Vec; diff --git a/src/libstd/old_io/mod.rs b/src/libstd/old_io/mod.rs index 15a80e34451..6b6c36a31ec 100644 --- a/src/libstd/old_io/mod.rs +++ b/src/libstd/old_io/mod.rs @@ -251,8 +251,6 @@ pub use self::FileMode::*; pub use self::FileAccess::*; pub use self::IoErrorKind::*; -#[cfg(stage0)] -use char::CharExt; use default::Default; use error::Error; use fmt; @@ -268,10 +266,6 @@ use boxed::Box; use result::Result; use result::Result::{Ok, Err}; use sys; -#[cfg(stage0)] -use slice::SliceExt; -#[cfg(stage0)] -use str::StrExt; use str; use string::String; use usize; @@ -935,8 +929,6 @@ impl<'a> Reader for &'a mut (Reader+'a) { // API yet. If so, it should be a method on Vec. unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec, start: uint, end: uint) -> &'a mut [T] { use slice; - #[cfg(stage0)] - use ptr::PtrExt; assert!(start <= end); assert!(end <= v.capacity()); diff --git a/src/libstd/old_io/net/ip.rs b/src/libstd/old_io/net/ip.rs index 2dda2c1277a..077a5072570 100644 --- a/src/libstd/old_io/net/ip.rs +++ b/src/libstd/old_io/net/ip.rs @@ -26,11 +26,6 @@ use ops::{FnOnce, FnMut}; use option::Option; use option::Option::{None, Some}; use result::Result::{self, Ok, Err}; -#[cfg(stage0)] -use slice::SliceExt; -#[cfg(stage0)] -use str::{FromStr, StrExt}; -#[cfg(not(stage0))] use str::FromStr; use vec::Vec; diff --git a/src/libstd/old_io/stdio.rs b/src/libstd/old_io/stdio.rs index b699b93f2b8..4ca40382375 100644 --- a/src/libstd/old_io/stdio.rs +++ b/src/libstd/old_io/stdio.rs @@ -43,10 +43,6 @@ use ops::{Deref, DerefMut, FnOnce}; use ptr; use result::Result::{Ok, Err}; use rt; -#[cfg(stage0)] -use slice::SliceExt; -#[cfg(stage0)] -use str::StrExt; use string::String; use sys::{fs, tty}; use sync::{Arc, Mutex, MutexGuard, Once, ONCE_INIT}; diff --git a/src/libstd/old_io/tempfile.rs b/src/libstd/old_io/tempfile.rs index b34804fce61..04bfd4409cf 100644 --- a/src/libstd/old_io/tempfile.rs +++ b/src/libstd/old_io/tempfile.rs @@ -21,8 +21,6 @@ use option::Option; use old_path::{Path, GenericPath}; use rand::{Rng, thread_rng}; use result::Result::{Ok, Err}; -#[cfg(stage0)] -use str::StrExt; use string::String; /// A wrapper for a path to temporary directory implementing automatic diff --git a/src/libstd/old_path/mod.rs b/src/libstd/old_path/mod.rs index 5fc34c0fe92..fd117838f2f 100644 --- a/src/libstd/old_path/mod.rs +++ b/src/libstd/old_path/mod.rs @@ -72,11 +72,7 @@ use iter::IteratorExt; use option::Option; use option::Option::{None, Some}; use str; -#[cfg(stage0)] -use str::StrExt; use string::{String, CowString}; -#[cfg(stage0)] -use slice::SliceExt; use vec::Vec; /// Typedef for POSIX file paths. diff --git a/src/libstd/old_path/posix.rs b/src/libstd/old_path/posix.rs index c42f1e6b07d..4f28e9e44f1 100644 --- a/src/libstd/old_path/posix.rs +++ b/src/libstd/old_path/posix.rs @@ -20,13 +20,7 @@ use iter::{Iterator, IteratorExt, Map}; use marker::Sized; use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; -#[cfg(stage0)] -use slice::{AsSlice, Split, SliceExt, SliceConcatExt}; -#[cfg(not(stage0))] use slice::{AsSlice, Split, SliceConcatExt}; -#[cfg(stage0)] -use str::{self, FromStr, StrExt}; -#[cfg(not(stage0))] use str::{self, FromStr}; use vec::Vec; diff --git a/src/libstd/old_path/windows.rs b/src/libstd/old_path/windows.rs index 6c5311d859c..ef873265b7b 100644 --- a/src/libstd/old_path/windows.rs +++ b/src/libstd/old_path/windows.rs @@ -15,8 +15,6 @@ use self::PathPrefix::*; use ascii::AsciiExt; -#[cfg(stage0)] -use char::CharExt; use clone::Clone; use cmp::{Ordering, Eq, Ord, PartialEq, PartialOrd}; use fmt; @@ -27,13 +25,7 @@ use iter::{Iterator, IteratorExt, Map, repeat}; use mem; use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; -#[cfg(stage0)] -use slice::{SliceExt, SliceConcatExt}; -#[cfg(not(stage0))] use slice::SliceConcatExt; -#[cfg(stage0)] -use str::{SplitTerminator, FromStr, StrExt}; -#[cfg(not(stage0))] use str::{SplitTerminator, FromStr}; use string::{String, ToString}; use vec::Vec; diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 46233a46ee5..a1a3afca7a9 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -52,18 +52,10 @@ use option::Option::{Some, None}; use option::Option; use old_path::{Path, GenericPath, BytesContainer}; use path::{self, PathBuf}; -#[cfg(stage0)] -use ptr::PtrExt; use ptr; use result::Result::{Err, Ok}; use result::Result; -#[cfg(stage0)] -use slice::{AsSlice, SliceExt}; -#[cfg(not(stage0))] use slice::AsSlice; -#[cfg(stage0)] -use str::{Str, StrExt}; -#[cfg(not(stage0))] use str::Str; use str; use string::{String, ToString}; diff --git a/src/libstd/path.rs b/src/libstd/path.rs index 2d97d651366..ddceed14cc6 100644 --- a/src/libstd/path.rs +++ b/src/libstd/path.rs @@ -159,8 +159,6 @@ mod platform { use core::prelude::*; use ascii::*; - #[cfg(stage0)] - use char::CharExt as UnicodeCharExt; use super::{os_str_as_u8_slice, u8_slice_as_os_str, Prefix}; use ffi::OsStr; diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index 4327b26260a..2aaf6e82800 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -25,9 +25,6 @@ // Reexported types and traits #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use boxed::Box; -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -#[doc(no_inline)] pub use char::CharExt; #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use clone::Clone; #[stable(feature = "rust1", since = "1.0.0")] @@ -40,21 +37,10 @@ #[doc(no_inline)] pub use iter::{Iterator, IteratorExt, Extend}; #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use option::Option::{self, Some, None}; -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -#[doc(no_inline)] pub use ptr::{PtrExt, MutPtrExt}; #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use result::Result::{self, Ok, Err}; -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -#[doc(no_inline)] pub use slice::{SliceExt, SliceConcatExt, AsSlice}; -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use slice::{SliceConcatExt, AsSlice}; -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -#[doc(no_inline)] pub use str::{Str, StrExt}; -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use str::Str; #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index 46e35e0fa8b..51b6045cf16 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -24,8 +24,6 @@ mod imp { use rand::Rng; use rand::reader::ReaderRng; use result::Result::Ok; - #[cfg(stage0)] - use slice::SliceExt; use mem; use os::errno; @@ -194,8 +192,6 @@ mod imp { use rand::Rng; use result::Result::{Ok}; use self::libc::{c_int, size_t}; - #[cfg(stage0)] - use slice::SliceExt; /// A random number generator that retrieves randomness straight from /// the operating system. Platform sources: @@ -265,8 +261,6 @@ mod imp { use result::Result::{Ok, Err}; use self::libc::{DWORD, BYTE, LPCSTR, BOOL}; use self::libc::types::os::arch::extra::{LONG_PTR}; - #[cfg(stage0)] - use slice::SliceExt; type HCRYPTPROV = LONG_PTR; diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs index 42c153af036..5231b122b9e 100644 --- a/src/libstd/rand/reader.rs +++ b/src/libstd/rand/reader.rs @@ -13,8 +13,6 @@ use old_io::Reader; use rand::Rng; use result::Result::{Ok, Err}; -#[cfg(stage0)] -use slice::SliceExt; /// An RNG that reads random bytes straight from a `Reader`. This will /// work best with an infinite reader, but this is not required. diff --git a/src/libstd/rt/at_exit_imp.rs b/src/libstd/rt/at_exit_imp.rs index f6bb87f011d..9fa12b1ef30 100644 --- a/src/libstd/rt/at_exit_imp.rs +++ b/src/libstd/rt/at_exit_imp.rs @@ -12,9 +12,6 @@ //! //! Documentation can be found on the `rt::at_exit` function. -#[cfg(stage0)] -use core::prelude::*; - use boxed; use boxed::Box; use vec::Vec; diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index dfc88571a82..3cc91bf54b4 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -172,18 +172,6 @@ impl Wtf8Buf { Wtf8Buf { bytes: string.into_bytes() } } - #[cfg(stage0)] - /// Create a WTF-8 string from an UTF-8 `&str` slice. - /// - /// This copies the content of the slice. - /// - /// Since WTF-8 is a superset of UTF-8, this always succeeds. - #[inline] - pub fn from_str(str: &str) -> Wtf8Buf { - Wtf8Buf { bytes: slice::SliceExt::to_vec(str.as_bytes()) } - } - - #[cfg(not(stage0))] /// Create a WTF-8 string from an UTF-8 `&str` slice. /// /// This copies the content of the slice. diff --git a/src/libstd/sys/unix/os_str.rs b/src/libstd/sys/unix/os_str.rs index 99591480752..3b8d18d87a0 100644 --- a/src/libstd/sys/unix/os_str.rs +++ b/src/libstd/sys/unix/os_str.rs @@ -16,8 +16,6 @@ use core::prelude::*; use borrow::Cow; use fmt::{self, Debug}; use vec::Vec; -#[cfg(stage0)] -use slice::SliceExt as StdSliceExt; use str; use string::String; use mem; diff --git a/src/libstd/sys/windows/process2.rs b/src/libstd/sys/windows/process2.rs index e3cf5da59f0..4c2777459dd 100644 --- a/src/libstd/sys/windows/process2.rs +++ b/src/libstd/sys/windows/process2.rs @@ -128,8 +128,6 @@ impl Process { use env::split_paths; use mem; use iter::IteratorExt; - #[cfg(stage0)] - use str::StrExt; // To have the spawning semantics of unix/windows stay the same, we need to // read the *child's* PATH if one is provided. See #15149 for more details. diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index bf2b2c0afe6..ad2fa3d25a8 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -78,8 +78,6 @@ use owned_slice::OwnedSlice; use std::collections::HashSet; use std::io::prelude::*; use std::mem; -#[cfg(stage0)] -use std::num::Float; use std::path::{Path, PathBuf}; use std::rc::Rc; use std::slice; @@ -5809,12 +5807,6 @@ impl<'a> Parser<'a> { None } - // HACK(eddyb) staging required for `quote_item!`. - #[cfg(stage0)] // SNAP 270a677 - pub fn parse_item_with_outer_attributes(&mut self) -> Option> { - self.parse_item() - } - pub fn parse_item(&mut self) -> Option> { let attrs = self.parse_outer_attributes(); self.parse_item_(attrs, true) diff --git a/src/libunicode/char.rs b/src/libunicode/char.rs index 56bc0389b74..5850fed980a 100644 --- a/src/libunicode/char.rs +++ b/src/libunicode/char.rs @@ -41,413 +41,6 @@ pub use normalize::{decompose_canonical, decompose_compatible, compose}; pub use tables::normalization::canonical_combining_class; pub use tables::UNICODE_VERSION; -#[cfg(stage0)] -/// Functionality for manipulating `char`. -#[stable(feature = "rust1", since = "1.0.0")] -pub trait CharExt { - /// Checks if a `char` parses as a numeric digit in the given radix. - /// - /// Compared to `is_numeric()`, this function only recognizes the characters - /// `0-9`, `a-z` and `A-Z`. - /// - /// # Return value - /// - /// Returns `true` if `c` is a valid digit under `radix`, and `false` - /// otherwise. - /// - /// # Panics - /// - /// Panics if given a radix > 36. - /// - /// # Examples - /// - /// ``` - /// let c = '1'; - /// - /// assert!(c.is_digit(10)); - /// - /// assert!('f'.is_digit(16)); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn is_digit(self, radix: u32) -> bool; - - /// Converts a character to the corresponding digit. - /// - /// # Return value - /// - /// If `c` is between '0' and '9', the corresponding value between 0 and - /// 9. If `c` is 'a' or 'A', 10. If `c` is 'b' or 'B', 11, etc. Returns - /// none if the character does not refer to a digit in the given radix. - /// - /// # Panics - /// - /// Panics if given a radix outside the range [0..36]. - /// - /// # Examples - /// - /// ``` - /// let c = '1'; - /// - /// assert_eq!(c.to_digit(10), Some(1)); - /// - /// assert_eq!('f'.to_digit(16), Some(15)); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn to_digit(self, radix: u32) -> Option; - - /// Returns an iterator that yields the hexadecimal Unicode escape of a - /// character, as `char`s. - /// - /// All characters are escaped with Rust syntax of the form `\\u{NNNN}` - /// where `NNNN` is the shortest hexadecimal representation of the code - /// point. - /// - /// # Examples - /// - /// ``` - /// for i in '❤'.escape_unicode() { - /// println!("{}", i); - /// } - /// ``` - /// - /// This prints: - /// - /// ```text - /// \ - /// u - /// { - /// 2 - /// 7 - /// 6 - /// 4 - /// } - /// ``` - /// - /// Collecting into a `String`: - /// - /// ``` - /// let heart: String = '❤'.escape_unicode().collect(); - /// - /// assert_eq!(heart, r"\u{2764}"); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn escape_unicode(self) -> EscapeUnicode; - - /// Returns an iterator that yields the 'default' ASCII and - /// C++11-like literal escape of a character, as `char`s. - /// - /// The default is chosen with a bias toward producing literals that are - /// legal in a variety of languages, including C++11 and similar C-family - /// languages. The exact rules are: - /// - /// * Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively. - /// * Single-quote, double-quote and backslash chars are backslash- - /// escaped. - /// * Any other chars in the range [0x20,0x7e] are not escaped. - /// * Any other chars are given hex Unicode escapes; see `escape_unicode`. - /// - /// # Examples - /// - /// ``` - /// for i in '"'.escape_default() { - /// println!("{}", i); - /// } - /// ``` - /// - /// This prints: - /// - /// ```text - /// \ - /// " - /// ``` - /// - /// Collecting into a `String`: - /// - /// ``` - /// let quote: String = '"'.escape_default().collect(); - /// - /// assert_eq!(quote, "\\\""); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn escape_default(self) -> EscapeDefault; - - /// Returns the number of bytes this character would need if encoded in - /// UTF-8. - /// - /// # Examples - /// - /// ``` - /// let n = 'ß'.len_utf8(); - /// - /// assert_eq!(n, 2); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn len_utf8(self) -> usize; - - /// Returns the number of 16-bit code units this character would need if - /// encoded in UTF-16. - /// - /// # Examples - /// - /// ``` - /// let n = 'ß'.len_utf16(); - /// - /// assert_eq!(n, 1); - /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - fn len_utf16(self) -> usize; - - /// Encodes this character as UTF-8 into the provided byte buffer, and then - /// returns the number of bytes written. - /// - /// If the buffer is not large enough, nothing will be written into it and a - /// `None` will be returned. A buffer of length four is large enough to - /// encode any `char`. - /// - /// # Examples - /// - /// In both of these examples, 'ß' takes two bytes to encode. - /// - /// ``` - /// let mut b = [0; 2]; - /// - /// let result = 'ß'.encode_utf8(&mut b); - /// - /// assert_eq!(result, Some(2)); - /// ``` - /// - /// A buffer that's too small: - /// - /// ``` - /// let mut b = [0; 1]; - /// - /// let result = 'ß'.encode_utf8(&mut b); - /// - /// assert_eq!(result, None); - /// ``` - #[unstable(feature = "unicode", - reason = "pending decision about Iterator/Writer/Reader")] - fn encode_utf8(self, dst: &mut [u8]) -> Option; - - /// Encodes this character as UTF-16 into the provided `u16` buffer, and - /// then returns the number of `u16`s written. - /// - /// If the buffer is not large enough, nothing will be written into it and a - /// `None` will be returned. A buffer of length 2 is large enough to encode - /// any `char`. - /// - /// # Examples - /// - /// In both of these examples, 'ß' takes one `u16` to encode. - /// - /// ``` - /// let mut b = [0; 1]; - /// - /// let result = 'ß'.encode_utf16(&mut b); - /// - /// assert_eq!(result, Some(1)); - /// ``` - /// - /// A buffer that's too small: - /// - /// ``` - /// let mut b = [0; 0]; - /// - /// let result = 'ß'.encode_utf8(&mut b); - /// - /// assert_eq!(result, None); - /// ``` - #[unstable(feature = "unicode", - reason = "pending decision about Iterator/Writer/Reader")] - fn encode_utf16(self, dst: &mut [u16]) -> Option; - - /// Returns whether the specified character is considered a Unicode - /// alphabetic code point. - #[stable(feature = "rust1", since = "1.0.0")] - fn is_alphabetic(self) -> bool; - - /// Returns whether the specified character satisfies the 'XID_Start' - /// Unicode property. - /// - /// 'XID_Start' is a Unicode Derived Property specified in - /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), - /// mostly similar to ID_Start but modified for closure under NFKx. - #[unstable(feature = "unicode", - reason = "mainly needed for compiler internals")] - fn is_xid_start(self) -> bool; - - /// Returns whether the specified `char` satisfies the 'XID_Continue' - /// Unicode property. - /// - /// 'XID_Continue' is a Unicode Derived Property specified in - /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), - /// mostly similar to 'ID_Continue' but modified for closure under NFKx. - #[unstable(feature = "unicode", - reason = "mainly needed for compiler internals")] - fn is_xid_continue(self) -> bool; - - /// Indicates whether a character is in lowercase. - /// - /// This is defined according to the terms of the Unicode Derived Core - /// Property `Lowercase`. - #[stable(feature = "rust1", since = "1.0.0")] - fn is_lowercase(self) -> bool; - - /// Indicates whether a character is in uppercase. - /// - /// This is defined according to the terms of the Unicode Derived Core - /// Property `Uppercase`. - #[stable(feature = "rust1", since = "1.0.0")] - fn is_uppercase(self) -> bool; - - /// Indicates whether a character is whitespace. - /// - /// Whitespace is defined in terms of the Unicode Property `White_Space`. - #[stable(feature = "rust1", since = "1.0.0")] - fn is_whitespace(self) -> bool; - - /// Indicates whether a character is alphanumeric. - /// - /// Alphanumericness is defined in terms of the Unicode General Categories - /// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'. - #[stable(feature = "rust1", since = "1.0.0")] - fn is_alphanumeric(self) -> bool; - - /// Indicates whether a character is a control code point. - /// - /// Control code points are defined in terms of the Unicode General - /// Category `Cc`. - #[stable(feature = "rust1", since = "1.0.0")] - fn is_control(self) -> bool; - - /// Indicates whether the character is numeric (Nd, Nl, or No). - #[stable(feature = "rust1", since = "1.0.0")] - fn is_numeric(self) -> bool; - - /// Converts a character to its lowercase equivalent. - /// - /// The case-folding performed is the common or simple mapping. See - /// `to_uppercase()` for references and more information. - /// - /// # Return value - /// - /// Returns an iterator which yields the characters corresponding to the - /// lowercase equivalent of the character. If no conversion is possible then - /// the input character is returned. - #[stable(feature = "rust1", since = "1.0.0")] - fn to_lowercase(self) -> ToLowercase; - - /// Converts a character to its uppercase equivalent. - /// - /// The case-folding performed is the common or simple mapping: it maps - /// one Unicode codepoint to its uppercase equivalent according to the - /// Unicode database [1]. The additional [`SpecialCasing.txt`] is not yet - /// considered here, but the iterator returned will soon support this form - /// of case folding. - /// - /// A full reference can be found here [2]. - /// - /// # Return value - /// - /// Returns an iterator which yields the characters corresponding to the - /// uppercase equivalent of the character. If no conversion is possible then - /// the input character is returned. - /// - /// [1]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt - /// - /// [`SpecialCasing`.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt - /// - /// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992 - #[stable(feature = "rust1", since = "1.0.0")] - fn to_uppercase(self) -> ToUppercase; - - /// Returns this character's displayed width in columns, or `None` if it is a - /// control character other than `'\x00'`. - /// - /// `is_cjk` determines behavior for characters in the Ambiguous category: - /// if `is_cjk` is `true`, these are 2 columns wide; otherwise, they are 1. - /// In CJK contexts, `is_cjk` should be `true`, else it should be `false`. - /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) - /// recommends that these characters be treated as 1 column (i.e., - /// `is_cjk` = `false`) if the context cannot be reliably determined. - #[unstable(feature = "unicode", - reason = "needs expert opinion. is_cjk flag stands out as ugly")] - fn width(self, is_cjk: bool) -> Option; -} - -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl CharExt for char { - fn is_digit(self, radix: u32) -> bool { C::is_digit(self, radix) } - fn to_digit(self, radix: u32) -> Option { C::to_digit(self, radix) } - fn escape_unicode(self) -> EscapeUnicode { C::escape_unicode(self) } - fn escape_default(self) -> EscapeDefault { C::escape_default(self) } - fn len_utf8(self) -> usize { C::len_utf8(self) } - fn len_utf16(self) -> usize { C::len_utf16(self) } - fn encode_utf8(self, dst: &mut [u8]) -> Option { C::encode_utf8(self, dst) } - fn encode_utf16(self, dst: &mut [u16]) -> Option { C::encode_utf16(self, dst) } - - fn is_alphabetic(self) -> bool { - match self { - 'a' ... 'z' | 'A' ... 'Z' => true, - c if c > '\x7f' => derived_property::Alphabetic(c), - _ => false - } - } - - fn is_xid_start(self) -> bool { derived_property::XID_Start(self) } - - fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) } - - fn is_lowercase(self) -> bool { - match self { - 'a' ... 'z' => true, - c if c > '\x7f' => derived_property::Lowercase(c), - _ => false - } - } - - fn is_uppercase(self) -> bool { - match self { - 'A' ... 'Z' => true, - c if c > '\x7f' => derived_property::Uppercase(c), - _ => false - } - } - - fn is_whitespace(self) -> bool { - match self { - ' ' | '\x09' ... '\x0d' => true, - c if c > '\x7f' => property::White_Space(c), - _ => false - } - } - - fn is_alphanumeric(self) -> bool { - self.is_alphabetic() || self.is_numeric() - } - - fn is_control(self) -> bool { general_category::Cc(self) } - - fn is_numeric(self) -> bool { - match self { - '0' ... '9' => true, - c if c > '\x7f' => general_category::N(c), - _ => false - } - } - - fn to_lowercase(self) -> ToLowercase { - ToLowercase(Some(conversions::to_lower(self))) - } - - fn to_uppercase(self) -> ToUppercase { - ToUppercase(Some(conversions::to_upper(self))) - } - - fn width(self, is_cjk: bool) -> Option { charwidth::width(self, is_cjk) } -} - /// An iterator over the lowercase mapping of a given character, returned from /// the `lowercase` method on characters. #[stable(feature = "rust1", since = "1.0.0")] @@ -470,7 +63,6 @@ impl Iterator for ToUppercase { fn next(&mut self) -> Option { self.0.take() } } -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] #[lang = "char"] impl char { diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs index 0fbc98ea73c..485065685f1 100644 --- a/src/libunicode/u_str.rs +++ b/src/libunicode/u_str.rs @@ -26,8 +26,6 @@ use core::num::Int; use core::slice; use core::str::Split; -#[cfg(stage0)] -use char::CharExt as UCharExt; // conflicts with core::prelude::CharExt use tables::grapheme::GraphemeCat; /// An iterator over the words of a string, separated by a sequence of whitespace @@ -244,7 +242,7 @@ impl<'a> Iterator for Graphemes<'a> { } self.cat = if take_curr { - idx = idx + len_utf8(self.string.char_at(idx)); + idx = idx + self.string.char_at(idx).len_utf8(); None } else { Some(cat) @@ -256,11 +254,6 @@ impl<'a> Iterator for Graphemes<'a> { } } -#[cfg(stage0)] -fn len_utf8(c: char) -> usize { UCharExt::len_utf8(c) } -#[cfg(not(stage0))] -fn len_utf8(c: char) -> usize { c.len_utf8() } - impl<'a> DoubleEndedIterator for Graphemes<'a> { #[inline] fn next_back(&mut self) -> Option<&'a str> { diff --git a/src/rustbook/main.rs b/src/rustbook/main.rs index 84d510294ef..09fcd518c1e 100644 --- a/src/rustbook/main.rs +++ b/src/rustbook/main.rs @@ -14,6 +14,7 @@ #![feature(exit_status)] #![feature(rustdoc)] #![feature(rustc_private)] +#![feature(path_relative_from)] extern crate rustdoc; extern crate rustc_back; diff --git a/src/snapshots.txt b/src/snapshots.txt index a84067539e9..3bdf32b53fa 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,3 +1,13 @@ +S 2015-03-17 c64d671 + bitrig-x86_64 4b2f11a96b1b5b3782d74bda707aca33bc179880 + freebsd-x86_64 14ced24e1339a4dd8baa9db69995daa52a948d54 + linux-i386 200450ad3cc56bc715ca105b9acae35204bf7351 + linux-x86_64 a54f50fee722ba6bc7281dec3e4d5121af7c15e3 + macos-i386 e33fd692f3808a0265e7b02fbc40e403080cdd4f + macos-x86_64 9a89ed364ae71aeb9d659ad223eae5f5986fc03f + winnt-i386 8911a28581e490d413b56467a6184545633ca04a + winnt-x86_64 38ce4556b19472c23ccce28685e3a2ebefb9bfbc + S 2015-03-07 270a677 bitrig-x86_64 4b2f11a96b1b5b3782d74bda707aca33bc179880 freebsd-x86_64 3c147d8e4cfdcb02c2569f5aca689a1d8920d17b