diff options
145 files changed, 2259 insertions, 1773 deletions
diff --git a/mk/crates.mk b/mk/crates.mk index 7494a9c5f98..f594a6a19f1 100644 --- a/mk/crates.mk +++ b/mk/crates.mk @@ -125,13 +125,18 @@ ONLY_RLIB_rustc_bitflags := 1 # On channels where the only usable crate is std, only build documentation for # std. This keeps distributions small and doesn't clutter up the API docs with # confusing internal details from the crates behind the facade. +# +# (Disabled while cmr figures out how to change rustdoc to make reexports work +# slightly nicer. Otherwise, all cross-crate links to Vec will go to +# libcollections, breaking them, and [src] links for anything reexported will +# not work.) -ifeq ($(CFG_RELEASE_CHANNEL),stable) -DOC_CRATES := std -else -ifeq ($(CFG_RELEASE_CHANNEL),beta) -DOC_CRATES := std -else +#ifeq ($(CFG_RELEASE_CHANNEL),stable) +#DOC_CRATES := std +#else +#ifeq ($(CFG_RELEASE_CHANNEL),beta) +#DOC_CRATES := std +#else DOC_CRATES := $(filter-out rustc, \ $(filter-out rustc_trans, \ $(filter-out rustc_typeck, \ @@ -143,8 +148,8 @@ DOC_CRATES := $(filter-out rustc, \ $(filter-out log, \ $(filter-out getopts, \ $(filter-out syntax, $(CRATES)))))))))))) -endif -endif +#endif +#endif COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_resolve \ rustc_typeck rustc_driver syntax rustc_privacy \ rustc_lint diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index f0aacc1460b..7fd09f9e1f5 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -18,7 +18,6 @@ #![feature(std_misc)] #![feature(test)] #![feature(path_ext)] -#![feature(convert)] #![feature(str_char)] #![deny(warnings)] diff --git a/src/doc/reference.md b/src/doc/reference.md index 4da7d6db444..0bc4414999d 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -1188,12 +1188,15 @@ the guarantee that these issues are never caused by safe code. * Data races * Dereferencing a null/dangling raw pointer -* Mutating an immutable value/reference without `UnsafeCell` * Reads of [undef](http://llvm.org/docs/LangRef.html#undefined-values) (uninitialized) memory * Breaking the [pointer aliasing rules](http://llvm.org/docs/LangRef.html#pointer-aliasing-rules) with raw pointers (a subset of the rules used by C) +* `&mut` and `&` follow LLVM’s scoped [noalias] model, except if the `&T` + contains an `UnsafeCell<U>`. Unsafe code must not violate these aliasing + guarantees. +* Mutating an immutable value/reference without `UnsafeCell<U>` * Invoking undefined behavior via compiler intrinsics: * Indexing outside of the bounds of an object with `std::ptr::offset` (`offset` intrinsic), with @@ -1210,6 +1213,8 @@ the guarantee that these issues are never caused by safe code. code. Rust's failure system is not compatible with exception handling in other languages. Unwinding must be caught and handled at FFI boundaries. +[noalias]: http://llvm.org/docs/LangRef.html#noalias + ##### Behaviour not considered unsafe This is a list of behaviour not considered *unsafe* in Rust terms, but that may diff --git a/src/doc/trpl/method-syntax.md b/src/doc/trpl/method-syntax.md index c8309a1e440..18542e58bbf 100644 --- a/src/doc/trpl/method-syntax.md +++ b/src/doc/trpl/method-syntax.md @@ -50,9 +50,9 @@ parameter, of which there are three variants: `self`, `&self`, and `&mut self`. You can think of this first parameter as being the `x` in `x.foo()`. The three variants correspond to the three kinds of thing `x` could be: `self` if it's just a value on the stack, `&self` if it's a reference, and `&mut self` if it's -a mutable reference. We should default to using `&self`, as it's the most -common, as Rustaceans prefer borrowing over taking ownership, and references -over mutable references. Here's an example of all three variants: +a mutable reference. We should default to using `&self`, as you should prefer +borrowing over taking ownership, as well as taking immutable references +over mutable ones. Here's an example of all three variants: ```rust struct Circle { @@ -181,17 +181,23 @@ impl Circle { } struct CircleBuilder { - coordinate: f64, + x: f64, + y: f64, radius: f64, } impl CircleBuilder { fn new() -> CircleBuilder { - CircleBuilder { coordinate: 0.0, radius: 0.0, } + CircleBuilder { x: 0.0, y: 0.0, radius: 0.0, } + } + + fn x(&mut self, coordinate: f64) -> &mut CircleBuilder { + self.x = coordinate; + self } - fn coordinate(&mut self, coordinate: f64) -> &mut CircleBuilder { - self.coordinate = coordinate; + fn y(&mut self, coordinate: f64) -> &mut CircleBuilder { + self.x = coordinate; self } @@ -201,18 +207,20 @@ impl CircleBuilder { } fn finalize(&self) -> Circle { - Circle { x: self.coordinate, y: self.coordinate, radius: self.radius } + Circle { x: self.x, y: self.y, radius: self.radius } } } fn main() { let c = CircleBuilder::new() - .coordinate(10.0) - .radius(5.0) + .x(1.0) + .y(2.0) + .radius(2.0) .finalize(); - println!("area: {}", c.area()); + println!("x: {}", c.x); + println!("y: {}", c.y); } ``` diff --git a/src/doc/trpl/ownership.md b/src/doc/trpl/ownership.md index b851f19d22d..f4b5495ba63 100644 --- a/src/doc/trpl/ownership.md +++ b/src/doc/trpl/ownership.md @@ -472,10 +472,15 @@ thread-safe counterpart of `Rc<T>`. ## Lifetime Elision -Earlier, we mentioned *lifetime elision*, a feature of Rust which allows you to -not write lifetime annotations in certain circumstances. All references have a -lifetime, and so if you elide a lifetime (like `&T` instead of `&'a T`), Rust -will do three things to determine what those lifetimes should be. +Rust supports powerful local type inference in function bodies, but it’s +forbidden in item signatures to allow reasoning about the types just based in +the item signature alone. However, for ergonomic reasons a very restricted +secondary inference algorithm called “lifetime elision” applies in function +signatures. It infers only based on the signature components themselves and not +based on the body of the function, only infers lifetime paramters, and does +this with only three easily memorizable and unambiguous rules. This makes +lifetime elision a shorthand for writing an item signature, while not hiding +away the actual types involved as full local inference would if applied to it. When talking about lifetime elision, we use the term *input lifetime* and *output lifetime*. An *input lifetime* is a lifetime associated with a parameter diff --git a/src/doc/trpl/testing.md b/src/doc/trpl/testing.md index 8fb08e1c6cf..8b2c14526cb 100644 --- a/src/doc/trpl/testing.md +++ b/src/doc/trpl/testing.md @@ -231,7 +231,7 @@ pub fn add_two(a: i32) -> i32 { } #[cfg(test)] -mod tests { +mod test { use super::add_two; #[test] @@ -241,7 +241,7 @@ mod tests { } ``` -There's a few changes here. The first is the introduction of a `mod tests` with +There's a few changes here. The first is the introduction of a `mod test` with a `cfg` attribute. The module allows us to group all of our tests together, and to also define helper functions if needed, that don't become a part of the rest of our crate. The `cfg` attribute only compiles our test code if we're @@ -260,7 +260,7 @@ pub fn add_two(a: i32) -> i32 { } #[cfg(test)] -mod tests { +mod test { use super::*; #[test] diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 9b37ddc7ab5..855c86f08e7 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -110,7 +110,7 @@ use heap::deallocate; /// let child_numbers = shared_numbers.clone(); /// /// thread::spawn(move || { -/// let local_numbers = child_numbers.as_slice(); +/// let local_numbers = &child_numbers[..]; /// /// // Work with the local numbers /// }); diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 94a497dfe85..f3c0dd0c3dc 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -233,24 +233,10 @@ impl<T: ?Sized + Hash> Hash for Box<T> { } } -/// Extension methods for an owning `Any` trait object. -#[unstable(feature = "alloc", - reason = "this trait will likely disappear once compiler bugs blocking \ - a direct impl on `Box<Any>` have been fixed ")] -// FIXME(#18737): this should be a direct impl on `Box<Any>`. If you're -// removing this please make sure that you can downcase on -// `Box<Any + Send>` as well as `Box<Any>` -pub trait BoxAny { - /// Returns the boxed value if it is of type `T`, or - /// `Err(Self)` if it isn't. - #[stable(feature = "rust1", since = "1.0.0")] - fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>>; -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl BoxAny for Box<Any> { +impl Box<Any> { #[inline] - fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> { + #[stable(feature = "rust1", since = "1.0.0")] + pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> { if self.is::<T>() { unsafe { // Get the raw representation of the trait object @@ -267,10 +253,10 @@ impl BoxAny for Box<Any> { } } -#[stable(feature = "rust1", since = "1.0.0")] -impl BoxAny for Box<Any+Send> { +impl Box<Any+Send> { #[inline] - fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> { + #[stable(feature = "rust1", since = "1.0.0")] + pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> { <Box<Any>>::downcast(self) } } diff --git a/src/liballoc/boxed_test.rs b/src/liballoc/boxed_test.rs index bb1ff9428a7..682d5f407c4 100644 --- a/src/liballoc/boxed_test.rs +++ b/src/liballoc/boxed_test.rs @@ -17,7 +17,6 @@ use core::clone::Clone; use std::boxed; use std::boxed::Box; -use std::boxed::BoxAny; #[test] fn test_owned_clone() { diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs index 3733350412e..57baa811b9d 100644 --- a/src/liballoc/heap.rs +++ b/src/liballoc/heap.rs @@ -189,7 +189,6 @@ mod imp { use core::option::Option; use core::option::Option::None; use core::ptr::{null_mut, null}; - use core::num::Int; use libc::{c_char, c_int, c_void, size_t}; use super::MIN_ALIGN; @@ -301,7 +300,7 @@ mod imp { libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8 } else { let new_ptr = allocate(size, align); - ptr::copy(new_ptr, ptr, cmp::min(size, old_size)); + ptr::copy(ptr, new_ptr, cmp::min(size, old_size)); deallocate(ptr, old_size, align); new_ptr } diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index fcf8c815694..3ed8ca2bea9 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -91,7 +91,6 @@ use core::hash; use core::iter::RandomAccessIterator; use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned}; use core::iter::{self, FromIterator, IntoIterator}; -use core::num::Int; use core::ops::Index; use core::slice; use core::{u8, u32, usize}; diff --git a/src/libcollections/borrow.rs b/src/libcollections/borrow.rs index 88d59f699d1..63f5c838baf 100644 --- a/src/libcollections/borrow.rs +++ b/src/libcollections/borrow.rs @@ -40,6 +40,24 @@ use self::Cow::*; #[stable(feature = "rust1", since = "1.0.0")] pub trait Borrow<Borrowed: ?Sized> { /// Immutably borrow from an owned value. + /// + /// # Examples + /// + /// ``` + /// use std::borrow::Borrow; + /// + /// fn check<T: Borrow<str>>(s: T) { + /// assert_eq!("Hello", s.borrow()); + /// } + /// + /// let s = "Hello".to_string(); + /// + /// check(s); + /// + /// let s = "Hello"; + /// + /// check(s); + /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn borrow(&self) -> &Borrowed; } @@ -50,6 +68,20 @@ pub trait Borrow<Borrowed: ?Sized> { #[stable(feature = "rust1", since = "1.0.0")] pub trait BorrowMut<Borrowed: ?Sized> : Borrow<Borrowed> { /// Mutably borrow from an owned value. + /// + /// # Examples + /// + /// ``` + /// use std::borrow::BorrowMut; + /// + /// fn check<T: BorrowMut<[i32]>>(mut v: T) { + /// assert_eq!(&mut [1, 2, 3], v.borrow_mut()); + /// } + /// + /// let v = vec![1, 2, 3]; + /// + /// check(v); + /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn borrow_mut(&mut self) -> &mut Borrowed; } @@ -171,6 +203,18 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned { /// Acquire a mutable reference to the owned form of the data. /// /// Copies the data if it is not already owned. + /// + /// # Examples + /// + /// ``` + /// use std::borrow::Cow; + /// + /// let mut cow: Cow<[_]> = Cow::Owned(vec![1, 2, 3]); + /// + /// let hello = cow.to_mut(); + /// + /// assert_eq!(&[1, 2, 3], hello); + /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned { match *self { @@ -185,6 +229,18 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned { /// Extract the owned data. /// /// Copies the data if it is not already owned. + /// + /// # Examples + /// + /// ``` + /// use std::borrow::Cow; + /// + /// let cow: Cow<[_]> = Cow::Owned(vec![1, 2, 3]); + /// + /// let hello = cow.into_owned(); + /// + /// assert_eq!(vec![1, 2, 3], hello); + /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn into_owned(self) -> <B as ToOwned>::Owned { match self { diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 956d4d143d2..847ee7c19ce 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -1133,13 +1133,13 @@ impl<K, V> Node<K, V> { #[inline] unsafe fn insert_kv(&mut self, index: usize, key: K, val: V) -> &mut V { ptr::copy( - self.keys_mut().as_mut_ptr().offset(index as isize + 1), self.keys().as_ptr().offset(index as isize), + self.keys_mut().as_mut_ptr().offset(index as isize + 1), self.len() - index ); ptr::copy( - self.vals_mut().as_mut_ptr().offset(index as isize + 1), self.vals().as_ptr().offset(index as isize), + self.vals_mut().as_mut_ptr().offset(index as isize + 1), self.len() - index ); @@ -1155,8 +1155,8 @@ impl<K, V> Node<K, V> { #[inline] unsafe fn insert_edge(&mut self, index: usize, edge: Node<K, V>) { ptr::copy( - self.edges_mut().as_mut_ptr().offset(index as isize + 1), self.edges().as_ptr().offset(index as isize), + self.edges_mut().as_mut_ptr().offset(index as isize + 1), self.len() - index ); ptr::write(self.edges_mut().get_unchecked_mut(index), edge); @@ -1188,13 +1188,13 @@ impl<K, V> Node<K, V> { let val = ptr::read(self.vals().get_unchecked(index)); ptr::copy( - self.keys_mut().as_mut_ptr().offset(index as isize), self.keys().as_ptr().offset(index as isize + 1), + self.keys_mut().as_mut_ptr().offset(index as isize), self.len() - index - 1 ); ptr::copy( - self.vals_mut().as_mut_ptr().offset(index as isize), self.vals().as_ptr().offset(index as isize + 1), + self.vals_mut().as_mut_ptr().offset(index as isize), self.len() - index - 1 ); @@ -1209,8 +1209,8 @@ impl<K, V> Node<K, V> { let edge = ptr::read(self.edges().get_unchecked(index)); ptr::copy( - self.edges_mut().as_mut_ptr().offset(index as isize), self.edges().as_ptr().offset(index as isize + 1), + self.edges_mut().as_mut_ptr().offset(index as isize), // index can be == len+1, so do the +1 first to avoid underflow. (self.len() + 1) - index ); @@ -1237,19 +1237,19 @@ impl<K, V> Node<K, V> { right._len = self.len() / 2; let right_offset = self.len() - right.len(); ptr::copy_nonoverlapping( - right.keys_mut().as_mut_ptr(), self.keys().as_ptr().offset(right_offset as isize), + right.keys_mut().as_mut_ptr(), right.len() ); ptr::copy_nonoverlapping( - right.vals_mut().as_mut_ptr(), self.vals().as_ptr().offset(right_offset as isize), + right.vals_mut().as_mut_ptr(), right.len() ); if !self.is_leaf() { ptr::copy_nonoverlapping( - right.edges_mut().as_mut_ptr(), self.edges().as_ptr().offset(right_offset as isize), + right.edges_mut().as_mut_ptr(), right.len() + 1 ); } @@ -1278,19 +1278,19 @@ impl<K, V> Node<K, V> { ptr::write(self.vals_mut().get_unchecked_mut(old_len), val); ptr::copy_nonoverlapping( - self.keys_mut().as_mut_ptr().offset(old_len as isize + 1), right.keys().as_ptr(), + self.keys_mut().as_mut_ptr().offset(old_len as isize + 1), right.len() ); ptr::copy_nonoverlapping( - self.vals_mut().as_mut_ptr().offset(old_len as isize + 1), right.vals().as_ptr(), + self.vals_mut().as_mut_ptr().offset(old_len as isize + 1), right.len() ); if !self.is_leaf() { ptr::copy_nonoverlapping( - self.edges_mut().as_mut_ptr().offset(old_len as isize + 1), right.edges().as_ptr(), + self.edges_mut().as_mut_ptr().offset(old_len as isize + 1), right.len() + 1 ); } diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index fe2efc7164d..474b4de8123 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -16,7 +16,6 @@ use core::prelude::*; use core::marker; use core::fmt; -use core::num::Int; use core::iter::{FromIterator, IntoIterator}; use core::ops::{Sub, BitOr, BitAnd, BitXor}; diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index c769b3df37f..367a7b41207 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -38,7 +38,6 @@ #![feature(unsafe_no_drop_flag, filling_drop)] #![feature(step_by)] #![feature(str_char)] -#![feature(convert)] #![feature(slice_patterns)] #![feature(debug_builders)] #![cfg_attr(test, feature(rand, rustc_private, test, hash, collections))] diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 14dcd52fe80..84613c28d72 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -89,7 +89,6 @@ use core::iter::MultiplicativeIterator; use core::marker::Sized; use core::mem::size_of; use core::mem; -use core::num::wrapping::WrappingOps; use core::ops::FnMut; use core::option::Option::{self, Some, None}; use core::ptr; @@ -556,7 +555,6 @@ impl<T> [T] { /// ```rust /// # #![feature(core)] /// 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)); @@ -923,7 +921,6 @@ impl<T> [T] { /// ```rust /// # #![feature(core)] /// 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)); @@ -1320,10 +1317,10 @@ fn insertion_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> O if i != j { let tmp = ptr::read(read_ptr); - ptr::copy(buf_v.offset(j + 1), - &*buf_v.offset(j), + ptr::copy(&*buf_v.offset(j), + buf_v.offset(j + 1), (i - j) as usize); - ptr::copy_nonoverlapping(buf_v.offset(j), &tmp, 1); + ptr::copy_nonoverlapping(&tmp, buf_v.offset(j), 1); mem::forget(tmp); } } @@ -1396,10 +1393,10 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order // j + 1 could be `len` (for the last `i`), but in // that case, `i == j` so we don't copy. The // `.offset(j)` is always in bounds. - ptr::copy(buf_dat.offset(j + 1), - &*buf_dat.offset(j), + ptr::copy(&*buf_dat.offset(j), + buf_dat.offset(j + 1), i - j as usize); - ptr::copy_nonoverlapping(buf_dat.offset(j), read_ptr, 1); + ptr::copy_nonoverlapping(read_ptr, buf_dat.offset(j), 1); } } } @@ -1447,11 +1444,11 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order if left == right_start { // the number remaining in this run. let elems = (right_end as usize - right as usize) / mem::size_of::<T>(); - ptr::copy_nonoverlapping(out, &*right, elems); + ptr::copy_nonoverlapping(&*right, out, elems); break; } else if right == right_end { let elems = (right_start as usize - left as usize) / mem::size_of::<T>(); - ptr::copy_nonoverlapping(out, &*left, elems); + ptr::copy_nonoverlapping(&*left, out, elems); break; } @@ -1465,7 +1462,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order } else { step(&mut left) }; - ptr::copy_nonoverlapping(out, &*to_copy, 1); + ptr::copy_nonoverlapping(&*to_copy, out, 1); step(&mut out); } } @@ -1479,7 +1476,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order // write the result to `v` in one go, so that there are never two copies // of the same object in `v`. unsafe { - ptr::copy_nonoverlapping(v.as_mut_ptr(), &*buf_dat, len); + ptr::copy_nonoverlapping(&*buf_dat, v.as_mut_ptr(), len); } // increment the pointer, returning the old pointer. diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 0665abc9e95..f517ce7d535 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -18,9 +18,6 @@ //! (see below). It is not possible to move out of borrowed strings because they //! are owned elsewhere. //! -//! Basic operations are implemented directly by the compiler, but more advanced -//! operations are defined as methods on the `str` type. -//! //! # Examples //! //! Here's some code that uses a `&str`: @@ -1473,12 +1470,12 @@ impl str { /// let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>(); /// let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"]; /// - /// assert_eq!(gr1.as_slice(), b); + /// assert_eq!(&gr1[..], b); /// /// let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>(); /// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; /// - /// assert_eq!(gr2.as_slice(), b); + /// assert_eq!(&gr2[..], b); /// ``` #[unstable(feature = "unicode", reason = "this functionality may only be provided by libunicode")] @@ -1496,7 +1493,7 @@ impl str { /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>(); /// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; /// - /// assert_eq!(gr_inds.as_slice(), b); + /// assert_eq!(&gr_inds[..], b); /// ``` #[unstable(feature = "unicode", reason = "this functionality may only be provided by libunicode")] diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 7131c1cd881..aa78db684af 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -93,7 +93,7 @@ impl String { /// ``` /// # #![feature(collections, core)] /// let s = String::from_str("hello"); - /// assert_eq!(s.as_slice(), "hello"); + /// assert_eq!(&s[..], "hello"); /// ``` #[inline] #[unstable(feature = "collections", @@ -364,6 +364,14 @@ impl String { self.vec } + /// Extract a string slice containing the entire string. + #[inline] + #[unstable(feature = "convert", + reason = "waiting on RFC revision")] + pub fn as_str(&self) -> &str { + self + } + /// Pushes the given string onto this string buffer. /// /// # Examples @@ -592,8 +600,8 @@ impl String { let ch = self.char_at(idx); let next = idx + ch.len_utf8(); unsafe { - ptr::copy(self.vec.as_mut_ptr().offset(idx as isize), - self.vec.as_ptr().offset(next as isize), + ptr::copy(self.vec.as_ptr().offset(next as isize), + self.vec.as_mut_ptr().offset(idx as isize), len - next); self.vec.set_len(len - (next - idx)); } @@ -622,11 +630,11 @@ impl String { let amt = ch.encode_utf8(&mut bits).unwrap(); unsafe { - ptr::copy(self.vec.as_mut_ptr().offset((idx + amt) as isize), - self.vec.as_ptr().offset(idx as isize), + ptr::copy(self.vec.as_ptr().offset(idx as isize), + self.vec.as_mut_ptr().offset((idx + amt) as isize), len - idx); - ptr::copy(self.vec.as_mut_ptr().offset(idx as isize), - bits.as_ptr(), + ptr::copy(bits.as_ptr(), + self.vec.as_mut_ptr().offset(idx as isize), amt); self.vec.set_len(len + amt); } @@ -848,7 +856,6 @@ impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str { #[allow(deprecated)] impl Str for String { #[inline] - #[stable(feature = "rust1", since = "1.0.0")] fn as_slice(&self) -> &str { unsafe { mem::transmute(&*self.vec) } } @@ -1019,19 +1026,36 @@ impl AsRef<str> for String { #[stable(feature = "rust1", since = "1.0.0")] impl<'a> From<&'a str> for String { + #[inline] fn from(s: &'a str) -> String { s.to_string() } } #[stable(feature = "rust1", since = "1.0.0")] +impl<'a> From<&'a str> for Cow<'a, str> { + #[inline] + fn from(s: &'a str) -> Cow<'a, str> { + Cow::Borrowed(s) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a> From<String> for Cow<'a, str> { + #[inline] + fn from(s: String) -> Cow<'a, str> { + Cow::Owned(s) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] impl Into<Vec<u8>> for String { fn into(self) -> Vec<u8> { self.into_bytes() } } -#[stable(feature = "rust1", since = "1.0.0")] +#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`")] impl IntoCow<'static, str> for String { #[inline] fn into_cow(self) -> Cow<'static, str> { @@ -1039,7 +1063,7 @@ impl IntoCow<'static, str> for String { } } -#[stable(feature = "rust1", since = "1.0.0")] +#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`")] impl<'a> IntoCow<'a, str> for &'a str { #[inline] fn into_cow(self) -> Cow<'a, str> { diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 14bc7f65e09..ba25fb1a681 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -260,16 +260,17 @@ impl<T> Vec<T> { /// Creates a vector by copying the elements from a raw pointer. /// - /// This function will copy `elts` contiguous elements starting at `ptr` into a new allocation - /// owned by the returned `Vec<T>`. The elements of the buffer are copied into the vector - /// without cloning, as if `ptr::read()` were called on them. + /// This function will copy `elts` contiguous elements starting at `ptr` + /// into a new allocation owned by the returned `Vec<T>`. The elements of + /// the buffer are copied into the vector without cloning, as if + /// `ptr::read()` were called on them. #[inline] #[unstable(feature = "collections", reason = "may be better expressed via composition")] pub unsafe fn from_raw_buf(ptr: *const T, elts: usize) -> Vec<T> { let mut dst = Vec::with_capacity(elts); dst.set_len(elts); - ptr::copy_nonoverlapping(dst.as_mut_ptr(), ptr, elts); + ptr::copy_nonoverlapping(ptr, dst.as_mut_ptr(), elts); dst } @@ -288,8 +289,9 @@ impl<T> Vec<T> { self.cap } - /// Reserves capacity for at least `additional` more elements to be inserted in the given - /// `Vec<T>`. The collection may reserve more space to avoid frequent reallocations. + /// Reserves capacity for at least `additional` more elements to be inserted + /// in the given `Vec<T>`. The collection may reserve more space to avoid + /// frequent reallocations. /// /// # Panics /// @@ -423,11 +425,18 @@ impl<T> Vec<T> { } } + /// Extract a slice containing the entire vector. + #[inline] + #[unstable(feature = "convert", + reason = "waiting on RFC revision")] + pub fn as_slice(&self) -> &[T] { + self + } + /// Deprecated: use `&mut s[..]` instead. #[inline] - #[unstable(feature = "collections", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")] + #[unstable(feature = "convert", + reason = "waiting on RFC revision")] pub fn as_mut_slice(&mut self) -> &mut [T] { &mut self[..] } @@ -541,7 +550,7 @@ impl<T> Vec<T> { let p = self.as_mut_ptr().offset(index as isize); // Shift everything over to make space. (Duplicating the // `index`th element into two consecutive places.) - ptr::copy(p.offset(1), &*p, len - index); + ptr::copy(&*p, p.offset(1), len - index); // Write it in, overwriting the first copy of the `index`th // element. ptr::write(&mut *p, element); @@ -579,7 +588,7 @@ impl<T> Vec<T> { ret = ptr::read(ptr); // Shift everything down to fill in that spot. - ptr::copy(ptr, &*ptr.offset(1), len - index - 1); + ptr::copy(&*ptr.offset(1), ptr, len - index - 1); } self.set_len(len - 1); ret @@ -721,8 +730,8 @@ impl<T> Vec<T> { let len = self.len(); unsafe { ptr::copy_nonoverlapping( - self.get_unchecked_mut(len), other.as_ptr(), + self.get_unchecked_mut(len), other.len()); } @@ -821,13 +830,13 @@ impl<T> Vec<T> { /// # #![feature(collections, core)] /// let v = vec![0, 1, 2]; /// let w = v.map_in_place(|i| i + 3); - /// assert_eq!(w.as_slice(), [3, 4, 5].as_slice()); + /// assert_eq!(&w[..], &[3, 4, 5]); /// /// #[derive(PartialEq, Debug)] /// struct Newtype(u8); /// let bytes = vec![0x11, 0x22]; /// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x)); - /// assert_eq!(newtyped_bytes.as_slice(), [Newtype(0x11), Newtype(0x22)].as_slice()); + /// assert_eq!(&newtyped_bytes[..], &[Newtype(0x11), Newtype(0x22)]); /// ``` #[unstable(feature = "collections", reason = "API may change to provide stronger guarantees")] @@ -1042,8 +1051,8 @@ impl<T> Vec<T> { other.set_len(other_len); ptr::copy_nonoverlapping( - other.as_mut_ptr(), self.as_ptr().offset(at as isize), + other.as_mut_ptr(), other.len()); } other @@ -1641,13 +1650,6 @@ impl<T> AsRef<Vec<T>> for Vec<T> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<T> Into<Vec<T>> for Vec<T> { - fn into(self) -> Vec<T> { - self - } -} - -#[stable(feature = "rust1", since = "1.0.0")] impl<T> AsRef<[T]> for Vec<T> { fn as_ref(&self) -> &[T] { self diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index 8f3f4e6b890..09735e585dd 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -25,7 +25,6 @@ use core::default::Default; use core::fmt; use core::iter::{self, repeat, FromIterator, IntoIterator, RandomAccessIterator}; use core::mem; -use core::num::wrapping::WrappingOps; use core::ops::{Index, IndexMut}; use core::ptr::{self, Unique}; use core::slice; @@ -142,8 +141,8 @@ impl<T> VecDeque<T> { debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len, self.cap); ptr::copy( - self.ptr.offset(dst as isize), self.ptr.offset(src as isize), + self.ptr.offset(dst as isize), len); } @@ -155,8 +154,8 @@ impl<T> VecDeque<T> { debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len, self.cap); ptr::copy_nonoverlapping( - self.ptr.offset(dst as isize), self.ptr.offset(src as isize), + self.ptr.offset(dst as isize), len); } } @@ -526,7 +525,8 @@ impl<T> VecDeque<T> { /// buf.push_back(3); /// buf.push_back(4); /// let b: &[_] = &[&5, &3, &4]; - /// assert_eq!(buf.iter().collect::<Vec<&i32>>().as_slice(), b); + /// let c: Vec<&i32> = buf.iter().collect(); + /// assert_eq!(&c[..], b); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn iter(&self) -> Iter<T> { @@ -1361,21 +1361,21 @@ impl<T> VecDeque<T> { // `at` lies in the first half. let amount_in_first = first_len - at; - ptr::copy_nonoverlapping(*other.ptr, - first_half.as_ptr().offset(at as isize), + ptr::copy_nonoverlapping(first_half.as_ptr().offset(at as isize), + *other.ptr, amount_in_first); // just take all of the second half. - ptr::copy_nonoverlapping(other.ptr.offset(amount_in_first as isize), - second_half.as_ptr(), + ptr::copy_nonoverlapping(second_half.as_ptr(), + other.ptr.offset(amount_in_first as isize), second_len); } else { // `at` lies in the second half, need to factor in the elements we skipped // in the first half. let offset = at - first_len; let amount_in_second = second_len - offset; - ptr::copy_nonoverlapping(*other.ptr, - second_half.as_ptr().offset(offset as isize), + ptr::copy_nonoverlapping(second_half.as_ptr().offset(offset as isize), + *other.ptr, amount_in_second); } } diff --git a/src/libcollectionstest/fmt.rs b/src/libcollectionstest/fmt.rs index 9a9aa71b58b..abd1262dbf1 100644 --- a/src/libcollectionstest/fmt.rs +++ b/src/libcollectionstest/fmt.rs @@ -13,5 +13,5 @@ use std::fmt; #[test] fn test_format() { let s = fmt::format(format_args!("Hello, {}!", "world")); - assert_eq!(s.as_slice(), "Hello, world!"); + assert_eq!(&s[..], "Hello, world!"); } diff --git a/src/libcollectionstest/lib.rs b/src/libcollectionstest/lib.rs index f03a073e274..a6340a3d7f9 100644 --- a/src/libcollectionstest/lib.rs +++ b/src/libcollectionstest/lib.rs @@ -21,6 +21,7 @@ #![feature(unicode)] #![feature(unsafe_destructor)] #![feature(into_cow)] +#![feature(convert)] #![cfg_attr(test, feature(str_char))] #[macro_use] extern crate log; diff --git a/src/libcollectionstest/slice.rs b/src/libcollectionstest/slice.rs index 4168fe88a4b..24cafa9f1c6 100644 --- a/src/libcollectionstest/slice.rs +++ b/src/libcollectionstest/slice.rs @@ -59,7 +59,7 @@ fn test_from_elem() { // Test on-heap from_elem. v = vec![20; 6]; { - let v = v.as_slice(); + let v = &v[..]; assert_eq!(v[0], 20); assert_eq!(v[1], 20); assert_eq!(v[2], 20); diff --git a/src/libcollectionstest/str.rs b/src/libcollectionstest/str.rs index 5cfa8009054..5b390befebe 100644 --- a/src/libcollectionstest/str.rs +++ b/src/libcollectionstest/str.rs @@ -1470,9 +1470,9 @@ fn test_split_strator() { fn test_str_default() { use std::default::Default; - fn t<S: Default + Str>() { + fn t<S: Default + AsRef<str>>() { let s: S = Default::default(); - assert_eq!(s.as_slice(), ""); + assert_eq!(s.as_ref(), ""); } t::<&str>(); diff --git a/src/libcore/any.rs b/src/libcore/any.rs index d3bc07b173a..0ffc4a229b5 100644 --- a/src/libcore/any.rs +++ b/src/libcore/any.rs @@ -202,8 +202,7 @@ pub struct TypeId { impl TypeId { /// Returns the `TypeId` of the type this generic function has been /// instantiated with - #[unstable(feature = "core", - reason = "may grow a `Reflect` bound soon via marker traits")] + #[stable(feature = "rust1", since = "1.0.0")] pub fn of<T: ?Sized + Any>() -> TypeId { TypeId { t: unsafe { intrinsics::type_id::<T>() }, diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 9ab8ab8672d..49dd108b89c 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -20,8 +20,6 @@ //! //! ``` //! # #![feature(core)] -//! use std::num::SignedInt; -//! //! struct FuzzyNum { //! num: i32, //! } @@ -362,6 +360,8 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> { /// Compare and return the minimum of two values. /// +/// Returns the first argument if the comparison determines them to be equal. +/// /// # Examples /// /// ``` @@ -373,11 +373,13 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn min<T: Ord>(v1: T, v2: T) -> T { - if v1 < v2 { v1 } else { v2 } + if v1 <= v2 { v1 } else { v2 } } /// Compare and return the maximum of two values. /// +/// Returns the second argument if the comparison determines them to be equal. +/// /// # Examples /// /// ``` @@ -389,7 +391,7 @@ pub fn min<T: Ord>(v1: T, v2: T) -> T { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn max<T: Ord>(v1: T, v2: T) -> T { - if v1 > v2 { v1 } else { v2 } + if v2 >= v1 { v2 } else { v1 } } /// Compare and return the minimum of two values if there is one. @@ -427,7 +429,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> { /// Compare and return the maximum of two values if there is one. /// -/// Returns the first argument if the comparison determines them to be equal. +/// Returns the second argument if the comparison determines them to be equal. /// /// # Examples /// @@ -452,8 +454,8 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> { #[unstable(feature = "core")] pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> { match v1.partial_cmp(&v2) { - Some(Less) => Some(v2), - Some(Equal) | Some(Greater) => Some(v1), + Some(Equal) | Some(Less) => Some(v2), + Some(Greater) => Some(v1), None => None } } diff --git a/src/libcore/convert.rs b/src/libcore/convert.rs index 3680daa2d5e..62ca8c47ab6 100644 --- a/src/libcore/convert.rs +++ b/src/libcore/convert.rs @@ -14,33 +14,40 @@ //! conversions from one type to another. They follow the standard //! Rust conventions of `as`/`to`/`into`/`from`. -#![unstable(feature = "convert", - reason = "recently added, experimental traits")] +#![stable(feature = "rust1", since = "1.0.0")] use marker::Sized; /// A cheap, reference-to-reference conversion. +#[stable(feature = "rust1", since = "1.0.0")] pub trait AsRef<T: ?Sized> { /// Perform the conversion. + #[stable(feature = "rust1", since = "1.0.0")] fn as_ref(&self) -> &T; } /// A cheap, mutable reference-to-mutable reference conversion. +#[stable(feature = "rust1", since = "1.0.0")] pub trait AsMut<T: ?Sized> { /// Perform the conversion. + #[stable(feature = "rust1", since = "1.0.0")] fn as_mut(&mut self) -> &mut T; } /// A conversion that consumes `self`, which may or may not be /// expensive. +#[stable(feature = "rust1", since = "1.0.0")] pub trait Into<T>: Sized { /// Perform the conversion. + #[stable(feature = "rust1", since = "1.0.0")] fn into(self) -> T; } /// Construct `Self` via a conversion. +#[stable(feature = "rust1", since = "1.0.0")] pub trait From<T> { /// Perform the conversion. + #[stable(feature = "rust1", since = "1.0.0")] fn from(T) -> Self; } @@ -48,14 +55,8 @@ pub trait From<T> { // GENERIC IMPLS //////////////////////////////////////////////////////////////////////////////// -// As implies Into -impl<'a, T: ?Sized, U: ?Sized> Into<&'a U> for &'a T where T: AsRef<U> { - fn into(self) -> &'a U { - self.as_ref() - } -} - // As lifts over & +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ?Sized, U: ?Sized> AsRef<U> for &'a T where T: AsRef<U> { fn as_ref(&self) -> &U { <T as AsRef<U>>::as_ref(*self) @@ -63,6 +64,7 @@ impl<'a, T: ?Sized, U: ?Sized> AsRef<U> for &'a T where T: AsRef<U> { } // As lifts over &mut +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ?Sized, U: ?Sized> AsRef<U> for &'a mut T where T: AsRef<U> { fn as_ref(&self) -> &U { <T as AsRef<U>>::as_ref(*self) @@ -77,14 +79,8 @@ impl<'a, T: ?Sized, U: ?Sized> AsRef<U> for &'a mut T where T: AsRef<U> { // } // } -// AsMut implies Into -impl<'a, T: ?Sized, U: ?Sized> Into<&'a mut U> for &'a mut T where T: AsMut<U> { - fn into(self) -> &'a mut U { - (*self).as_mut() - } -} - // AsMut lifts over &mut +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ?Sized, U: ?Sized> AsMut<U> for &'a mut T where T: AsMut<U> { fn as_mut(&mut self) -> &mut U { (*self).as_mut() @@ -107,28 +103,38 @@ impl<T> From<T> for T { } // From implies Into +#[stable(feature = "rust1", since = "1.0.0")] impl<T, U> Into<U> for T where U: From<T> { fn into(self) -> U { U::from(self) } } +// From (and thus Into) is reflexive +#[stable(feature = "rust1", since = "1.0.0")] +impl<T> From<T> for T { + fn from(t: T) -> T { t } +} + //////////////////////////////////////////////////////////////////////////////// // CONCRETE IMPLS //////////////////////////////////////////////////////////////////////////////// +#[stable(feature = "rust1", since = "1.0.0")] impl<T> AsRef<[T]> for [T] { fn as_ref(&self) -> &[T] { self } } +#[stable(feature = "rust1", since = "1.0.0")] impl<T> AsMut<[T]> for [T] { fn as_mut(&mut self) -> &mut [T] { self } } +#[stable(feature = "rust1", since = "1.0.0")] impl AsRef<str> for str { fn as_ref(&self) -> &str { self diff --git a/src/libcore/error.rs b/src/libcore/error.rs index 73ec19f1a14..24035b7d9a8 100644 --- a/src/libcore/error.rs +++ b/src/libcore/error.rs @@ -33,41 +33,6 @@ //! high-level module to provide its own errors that do not commit to any //! particular implementation, but also reveal some of its implementation for //! debugging via `cause` chains. -//! -//! For example, -//! -//! ``` -//! # #![feature(os, old_io, old_path)] -//! use std::error::FromError; -//! use std::old_io::{File, IoError}; -//! use std::os::{MemoryMap, MapError}; -//! use std::old_path::Path; -//! -//! enum MyError { -//! Io(IoError), -//! Map(MapError) -//! } -//! -//! impl From<IoError> for MyError { -//! fn from(err: IoError) -> MyError { -//! MyError::Io(err) -//! } -//! } -//! -//! impl From<MapError> for MyError { -//! fn from(err: MapError) -> MyError { -//! MyError::Map(err) -//! } -//! } -//! -//! #[allow(unused_variables)] -//! fn open_and_map() -> Result<(), MyError> { -//! let f = try!(File::open(&Path::new("foo.txt"))); -//! let m = try!(MemoryMap::new(0, &[])); -//! // do something interesting here... -//! Ok(()) -//! } -//! ``` #![stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index 6e82b18abc6..6a5943265ca 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -316,8 +316,8 @@ pub fn float_to_str_bytes_common<T: Float, U, F>( impl<'a> fmt::Write for Filler<'a> { fn write_str(&mut self, s: &str) -> fmt::Result { - slice::bytes::copy_memory(&mut self.buf[(*self.end)..], - s.as_bytes()); + slice::bytes::copy_memory(s.as_bytes(), + &mut self.buf[(*self.end)..]); *self.end += s.len(); Ok(()) } diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 974252a92af..f3f5a0b70cb 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -33,6 +33,7 @@ trait GenericRadix { fn digit(&self, x: u8) -> u8; /// Format an integer using the radix using a formatter. + #[allow(deprecated)] // Int fn fmt_int<T: Int>(&self, mut x: T, f: &mut fmt::Formatter) -> fmt::Result { // The radix can be as low as 2, so we need a buffer of at least 64 // characters for a base 2 number. diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index bd1516e0cfc..e65fbac926b 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -12,9 +12,10 @@ //! An implementation of SipHash 2-4. +#![allow(deprecated)] // until the next snapshot for inherent wrapping ops + use prelude::*; use default::Default; -use num::wrapping::WrappingOps; use super::Hasher; /// An implementation of SipHash 2-4. @@ -71,7 +72,7 @@ macro_rules! u8to64_le { macro_rules! rotl { ($x:expr, $b:expr) => - (($x << $b) | ($x >> (64.wrapping_sub($b)))) + (($x << $b) | ($x >> (64_i32.wrapping_sub($b)))) } macro_rules! compress { diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 1b3c83ecf15..0e91eafce18 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -197,7 +197,6 @@ extern "rust-intrinsic" { /// Rust moves to non-zeroing dynamic drop (and thus removes the /// embedded drop flags that are being established by this /// intrinsic). - #[cfg(not(stage0))] pub fn init_dropped<T>() -> T; /// Create a value initialized to zero. @@ -293,9 +292,9 @@ extern "rust-intrinsic" { /// let mut t: T = mem::uninitialized(); /// /// // Perform the swap, `&mut` pointers never alias - /// ptr::copy_nonoverlapping(&mut t, &*x, 1); - /// ptr::copy_nonoverlapping(x, &*y, 1); - /// ptr::copy_nonoverlapping(y, &t, 1); + /// ptr::copy_nonoverlapping(x, &mut t, 1); + /// ptr::copy_nonoverlapping(y, x, 1); + /// ptr::copy_nonoverlapping(&t, y, 1); /// /// // y and t now point to the same thing, but we need to completely forget `tmp` /// // because it's no longer relevant. @@ -304,6 +303,12 @@ extern "rust-intrinsic" { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] + #[cfg(not(stage0))] + pub fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize); + + /// dox + #[stable(feature = "rust1", since = "1.0.0")] + #[cfg(stage0)] pub fn copy_nonoverlapping<T>(dst: *mut T, src: *const T, count: usize); /// Copies `count * size_of<T>` bytes from `src` to `dst`. The source @@ -329,12 +334,18 @@ extern "rust-intrinsic" { /// unsafe fn from_buf_raw<T>(ptr: *const T, elts: usize) -> Vec<T> { /// let mut dst = Vec::with_capacity(elts); /// dst.set_len(elts); - /// ptr::copy(dst.as_mut_ptr(), ptr, elts); + /// ptr::copy(ptr, dst.as_mut_ptr(), elts); /// dst /// } /// ``` /// #[stable(feature = "rust1", since = "1.0.0")] + #[cfg(not(stage0))] + pub fn copy<T>(src: *const T, dst: *mut T, count: usize); + + /// dox + #[stable(feature = "rust1", since = "1.0.0")] + #[cfg(stage0)] pub fn copy<T>(dst: *mut T, src: *const T, count: usize); /// Invokes memset on the specified pointer, setting `count * size_of::<T>()` diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 39bf97ae1ce..7e6789c3da1 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -64,8 +64,8 @@ use cmp::Ord; use default::Default; use marker; use mem; -use num::{ToPrimitive, Int}; -use ops::{Add, FnMut, RangeFrom}; +use num::{Int, Zero, One, ToPrimitive}; +use ops::{Add, Sub, FnMut, RangeFrom}; use option::Option; use option::Option::{Some, None}; use marker::Sized; @@ -624,7 +624,7 @@ pub trait Iterator { /// let a = [1, 2, 3, 4, 5]; /// let mut it = a.iter(); /// assert!(it.any(|x| *x == 3)); - /// assert_eq!(it.as_slice(), [4, 5]); + /// assert_eq!(&it[..], [4, 5]); /// /// ``` #[inline] @@ -648,7 +648,7 @@ pub trait Iterator { /// let a = [1, 2, 3, 4, 5]; /// let mut it = a.iter(); /// assert_eq!(it.find(|&x| *x == 3).unwrap(), &3); - /// assert_eq!(it.as_slice(), [4, 5]); + /// assert_eq!(&it[..], [4, 5]); #[inline] #[stable(feature = "rust1", since = "1.0.0")] fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where @@ -672,7 +672,7 @@ pub trait Iterator { /// let a = [1, 2, 3, 4, 5]; /// let mut it = a.iter(); /// assert_eq!(it.position(|x| *x == 3).unwrap(), 2); - /// assert_eq!(it.as_slice(), [4, 5]); + /// assert_eq!(&it[..], [4, 5]); #[inline] #[stable(feature = "rust1", since = "1.0.0")] fn position<P>(&mut self, mut predicate: P) -> Option<usize> where @@ -702,7 +702,7 @@ pub trait Iterator { /// let a = [1, 2, 2, 4, 5]; /// let mut it = a.iter(); /// assert_eq!(it.rposition(|x| *x == 2).unwrap(), 2); - /// assert_eq!(it.as_slice(), [1, 2]); + /// assert_eq!(&it[..], [1, 2]); #[inline] #[stable(feature = "rust1", since = "1.0.0")] fn rposition<P>(&mut self, mut predicate: P) -> Option<usize> where @@ -722,6 +722,9 @@ pub trait Iterator { /// Consumes the entire iterator to return the maximum element. /// + /// Returns the rightmost element if the comparison determines two elements + /// to be equally maximum. + /// /// # Examples /// /// ``` @@ -732,16 +735,19 @@ pub trait Iterator { #[stable(feature = "rust1", since = "1.0.0")] fn max(self) -> Option<Self::Item> where Self: Sized, Self::Item: Ord { - self.fold(None, |max, x| { + self.fold(None, |max, y| { match max { - None => Some(x), - Some(y) => Some(cmp::max(x, y)) + None => Some(y), + Some(x) => Some(cmp::max(x, y)) } }) } /// Consumes the entire iterator to return the minimum element. /// + /// Returns the leftmost element if the comparison determines two elements + /// to be equally minimum. + /// /// # Examples /// /// ``` @@ -752,10 +758,10 @@ pub trait Iterator { #[stable(feature = "rust1", since = "1.0.0")] fn min(self) -> Option<Self::Item> where Self: Sized, Self::Item: Ord { - self.fold(None, |min, x| { + self.fold(None, |min, y| { match min { - None => Some(x), - Some(y) => Some(cmp::min(x, y)) + None => Some(y), + Some(x) => Some(cmp::min(x, y)) } }) } @@ -799,7 +805,7 @@ pub trait Iterator { Some(x) => { match self.next() { None => return OneElement(x), - Some(y) => if x < y {(x, y)} else {(y,x)} + Some(y) => if x <= y {(x, y)} else {(y, x)} } } }; @@ -817,19 +823,19 @@ pub trait Iterator { None => { if first < min { min = first; - } else if first > max { + } else if first >= max { max = first; } break; } Some(x) => x }; - if first < second { - if first < min {min = first;} - if max < second {max = second;} + if first <= second { + if first < min { min = first } + if second >= max { max = second } } else { - if second < min {min = second;} - if max < first {max = first;} + if second < min { min = second } + if first >= max { max = first } } } @@ -839,13 +845,15 @@ pub trait Iterator { /// Return the element that gives the maximum value from the /// specified function. /// + /// Returns the rightmost element if the comparison determines two elements + /// to be equally maximum. + /// /// # Examples /// /// ``` /// # #![feature(core)] - /// use std::num::SignedInt; /// - /// let a = [-3, 0, 1, 5, -10]; + /// let a = [-3_i32, 0, 1, 5, -10]; /// assert_eq!(*a.iter().max_by(|x| x.abs()).unwrap(), -10); /// ``` #[inline] @@ -855,14 +863,14 @@ pub trait Iterator { Self: Sized, F: FnMut(&Self::Item) -> B, { - self.fold(None, |max: Option<(Self::Item, B)>, x| { - let x_val = f(&x); + self.fold(None, |max: Option<(Self::Item, B)>, y| { + let y_val = f(&y); match max { - None => Some((x, x_val)), - Some((y, y_val)) => if x_val > y_val { - Some((x, x_val)) - } else { + None => Some((y, y_val)), + Some((x, x_val)) => if y_val >= x_val { Some((y, y_val)) + } else { + Some((x, x_val)) } } }).map(|(x, _)| x) @@ -871,13 +879,15 @@ pub trait Iterator { /// Return the element that gives the minimum value from the /// specified function. /// + /// Returns the leftmost element if the comparison determines two elements + /// to be equally minimum. + /// /// # Examples /// /// ``` /// # #![feature(core)] - /// use std::num::SignedInt; /// - /// let a = [-3, 0, 1, 5, -10]; + /// let a = [-3_i32, 0, 1, 5, -10]; /// assert_eq!(*a.iter().min_by(|x| x.abs()).unwrap(), 0); /// ``` #[inline] @@ -887,11 +897,11 @@ pub trait Iterator { Self: Sized, F: FnMut(&Self::Item) -> B, { - self.fold(None, |min: Option<(Self::Item, B)>, x| { - let x_val = f(&x); + self.fold(None, |min: Option<(Self::Item, B)>, y| { + let y_val = f(&y); match min { - None => Some((x, x_val)), - Some((y, y_val)) => if x_val < y_val { + None => Some((y, y_val)), + Some((x, x_val)) => if x_val <= y_val { Some((x, x_val)) } else { Some((y, y_val)) @@ -2417,6 +2427,67 @@ impl<A, St, F> Iterator for Unfold<St, F> where F: FnMut(&mut St) -> Option<A> { } } +/// Objects that can be stepped over in both directions. +/// +/// The `steps_between` function provides a way to efficiently compare +/// two `Step` objects. +#[unstable(feature = "step_trait", + reason = "likely to be replaced by finer-grained traits")] +pub trait Step: Ord { + /// Steps `self` if possible. + fn step(&self, by: &Self) -> Option<Self>; + + /// The number of steps between two step objects. + /// + /// `start` should always be less than `end`, so the result should never + /// be negative. + /// + /// Return `None` if it is not possible to calculate steps_between + /// without overflow. + fn steps_between(start: &Self, end: &Self, by: &Self) -> Option<usize>; +} + +macro_rules! step_impl { + ($($t:ty)*) => ($( + impl Step for $t { + #[inline] + fn step(&self, by: &$t) -> Option<$t> { + (*self).checked_add(*by) + } + #[inline] + #[allow(trivial_numeric_casts)] + fn steps_between(start: &$t, end: &$t, by: &$t) -> Option<usize> { + if *start <= *end { + Some(((*end - *start) / *by) as usize) + } else { + Some(0) + } + } + } + )*) +} + +macro_rules! step_impl_no_between { + ($($t:ty)*) => ($( + impl Step for $t { + #[inline] + fn step(&self, by: &$t) -> Option<$t> { + (*self).checked_add(*by) + } + #[inline] + fn steps_between(_a: &$t, _b: &$t, _by: &$t) -> Option<usize> { + None + } + } + )*) +} + +step_impl!(usize u8 u16 u32 isize i8 i16 i32); +#[cfg(target_pointer_width = "64")] +step_impl!(u64 i64); +#[cfg(target_pointer_width = "32")] +step_impl_no_between!(u64 i64); + /// An adapter for stepping range iterators by a custom amount. /// /// The resulting iterator handles overflow by stopping. The `A` @@ -2429,7 +2500,7 @@ pub struct StepBy<A, R> { range: R, } -impl<A: Add> RangeFrom<A> { +impl<A: Step> RangeFrom<A> { /// Creates an iterator starting at the same point, but stepping by /// the given amount at each iteration. /// @@ -2451,7 +2522,8 @@ impl<A: Add> RangeFrom<A> { } } -impl<A: Int> ::ops::Range<A> { +#[allow(deprecated)] +impl<A: Step> ::ops::Range<A> { /// Creates an iterator with the same range, but stepping by the /// given amount at each iteration. /// @@ -2505,14 +2577,17 @@ pub fn count<A>(start: A, step: A) -> Counter<A> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<A: Add<Output=A> + Clone> Iterator for StepBy<A, RangeFrom<A>> { +impl<A> Iterator for StepBy<A, RangeFrom<A>> where + A: Clone, + for<'a> &'a A: Add<&'a A, Output = A> +{ type Item = A; #[inline] fn next(&mut self) -> Option<A> { - let result = self.range.start.clone(); - self.range.start = result.clone() + self.step_by.clone(); - Some(result) + let mut n = &self.range.start + &self.step_by; + mem::swap(&mut n, &mut self.range.start); + Some(n) } #[inline] @@ -2715,19 +2790,27 @@ pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<A: Int> Iterator for StepBy<A, ::ops::Range<A>> { +#[allow(deprecated)] +impl<A: Step + Zero + Clone> Iterator for StepBy<A, ::ops::Range<A>> { type Item = A; #[inline] fn next(&mut self) -> Option<A> { - let rev = self.step_by < Int::zero(); - let start = self.range.start; - if (rev && start > self.range.end) || (!rev && start < self.range.end) { - match start.checked_add(self.step_by) { - Some(x) => self.range.start = x, - None => self.range.start = self.range.end.clone() + let rev = self.step_by < A::zero(); + if (rev && self.range.start > self.range.end) || + (!rev && self.range.start < self.range.end) + { + match self.range.start.step(&self.step_by) { + Some(mut n) => { + mem::swap(&mut self.range.start, &mut n); + Some(n) + }, + None => { + let mut n = self.range.end.clone(); + mem::swap(&mut self.range.start, &mut n); + Some(n) + } } - Some(start) } else { None } @@ -2774,6 +2857,7 @@ pub struct RangeStepInclusive<A> { #[inline] #[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] +#[allow(deprecated)] pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> { let rev = step < Int::zero(); RangeStepInclusive { @@ -2787,6 +2871,7 @@ pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepIncl #[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] +#[allow(deprecated)] impl<A: Int> Iterator for RangeStepInclusive<A> { type Item = A; @@ -2814,15 +2899,25 @@ macro_rules! range_exact_iter_impl { } #[stable(feature = "rust1", since = "1.0.0")] -impl<A: Int> Iterator for ::ops::Range<A> { +#[allow(deprecated)] +impl<A: Step + One + Clone> Iterator for ::ops::Range<A> { type Item = A; #[inline] fn next(&mut self) -> Option<A> { if self.start < self.end { - let result = self.start; - self.start = self.start + Int::one(); - Some(result) + match self.start.step(&A::one()) { + Some(mut n) => { + mem::swap(&mut n, &mut self.start); + Some(n) + }, + None => { + let mut n = self.end.clone(); + mem::swap(&mut n, &mut self.start); + Some(n) + + } + } } else { None } @@ -2830,11 +2925,10 @@ impl<A: Int> Iterator for ::ops::Range<A> { #[inline] fn size_hint(&self) -> (usize, Option<usize>) { - if self.start >= self.end { - (0, Some(0)) + if let Some(hint) = Step::steps_between(&self.start, &self.end, &A::one()) { + (hint, Some(hint)) } else { - let length = (self.end - self.start).to_usize(); - (length.unwrap_or(0), length) + (0, None) } } } @@ -2844,12 +2938,15 @@ impl<A: Int> Iterator for ::ops::Range<A> { range_exact_iter_impl!(usize u8 u16 u32 isize i8 i16 i32); #[stable(feature = "rust1", since = "1.0.0")] -impl<A: Int> DoubleEndedIterator for ::ops::Range<A> { +#[allow(deprecated)] +impl<A: Step + One + Clone> DoubleEndedIterator for ::ops::Range<A> where + for<'a> &'a A: Sub<&'a A, Output = A> +{ #[inline] fn next_back(&mut self) -> Option<A> { if self.start < self.end { - self.end = self.end - Int::one(); - Some(self.end) + self.end = &self.end - &A::one(); + Some(self.end.clone()) } else { None } @@ -2857,15 +2954,16 @@ impl<A: Int> DoubleEndedIterator for ::ops::Range<A> { } #[stable(feature = "rust1", since = "1.0.0")] -impl<A: Int> Iterator for ::ops::RangeFrom<A> { +#[allow(deprecated)] +impl<A: Step + One> Iterator for ::ops::RangeFrom<A> { type Item = A; #[inline] fn next(&mut self) -> Option<A> { - let result = self.start; - self.start = self.start + Int::one(); - debug_assert!(result < self.start); - Some(result) + self.start.step(&A::one()).map(|mut n| { + mem::swap(&mut n, &mut self.start); + n + }) } } diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 3f4b39da4b3..277b98f0523 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -487,9 +487,5 @@ pub struct InvariantType<T>; pub trait Reflect : MarkerTrait { } -#[cfg(stage0)] -impl<T> Reflect for T { } - -#[cfg(not(stage0))] impl Reflect for .. { } diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 434a5d17a92..249beb6295c 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -173,11 +173,6 @@ pub unsafe fn zeroed<T>() -> T { #[inline] #[unstable(feature = "filling_drop")] pub unsafe fn dropped<T>() -> T { - #[cfg(stage0)] - #[inline(always)] - unsafe fn dropped_impl<T>() -> T { zeroed() } - - #[cfg(not(stage0))] #[inline(always)] unsafe fn dropped_impl<T>() -> T { intrinsics::init_dropped() } @@ -229,9 +224,9 @@ pub fn swap<T>(x: &mut T, y: &mut T) { let mut t: T = uninitialized(); // Perform the swap, `&mut` pointers never alias - ptr::copy_nonoverlapping(&mut t, &*x, 1); - ptr::copy_nonoverlapping(x, &*y, 1); - ptr::copy_nonoverlapping(y, &t, 1); + ptr::copy_nonoverlapping(&*x, &mut t, 1); + ptr::copy_nonoverlapping(&*y, x, 1); + ptr::copy_nonoverlapping(&t, y, 1); // y and t now point to the same thing, but we need to completely forget `t` // because it's no longer relevant. @@ -337,38 +332,32 @@ macro_rules! repeat_u8_as_u64 { // But having the sign bit set is a pain, so 0x1d is probably better. // // And of course, 0x00 brings back the old world of zero'ing on drop. -#[cfg(not(stage0))] #[unstable(feature = "filling_drop")] +#[unstable(feature = "filling_drop")] pub const POST_DROP_U8: u8 = 0x1d; -#[cfg(not(stage0))] #[unstable(feature = "filling_drop")] +#[unstable(feature = "filling_drop")] pub const POST_DROP_U32: u32 = repeat_u8_as_u32!(POST_DROP_U8); -#[cfg(not(stage0))] #[unstable(feature = "filling_drop")] +#[unstable(feature = "filling_drop")] pub const POST_DROP_U64: u64 = repeat_u8_as_u64!(POST_DROP_U8); #[cfg(target_pointer_width = "32")] -#[cfg(not(stage0))] #[unstable(feature = "filling_drop")] +#[unstable(feature = "filling_drop")] pub const POST_DROP_USIZE: usize = POST_DROP_U32 as usize; #[cfg(target_pointer_width = "64")] -#[cfg(not(stage0))] #[unstable(feature = "filling_drop")] +#[unstable(feature = "filling_drop")] pub const POST_DROP_USIZE: usize = POST_DROP_U64 as usize; -#[cfg(stage0)] #[unstable(feature = "filling_drop")] -pub const POST_DROP_U8: u8 = 0; -#[cfg(stage0)] #[unstable(feature = "filling_drop")] -pub const POST_DROP_U32: u32 = 0; -#[cfg(stage0)] #[unstable(feature = "filling_drop")] -pub const POST_DROP_U64: u64 = 0; -#[cfg(stage0)] #[unstable(feature = "filling_drop")] -pub const POST_DROP_USIZE: usize = 0; - -/// Interprets `src` as `&U`, and then reads `src` without moving the contained value. -/// -/// This function will unsafely assume the pointer `src` is valid for `sizeof(U)` bytes by -/// transmuting `&T` to `&U` and then reading the `&U`. It will also unsafely create a copy of the -/// contained value instead of moving out of `src`. -/// -/// It is not a compile-time error if `T` and `U` have different sizes, but it is highly encouraged -/// to only invoke this function where `T` and `U` have the same size. This function triggers -/// undefined behavior if `U` is larger than `T`. +/// Interprets `src` as `&U`, and then reads `src` without moving the contained +/// value. +/// +/// This function will unsafely assume the pointer `src` is valid for +/// `sizeof(U)` bytes by transmuting `&T` to `&U` and then reading the `&U`. It +/// will also unsafely create a copy of the contained value instead of moving +/// out of `src`. +/// +/// It is not a compile-time error if `T` and `U` have different sizes, but it +/// is highly encouraged to only invoke this function where `T` and `U` have the +/// same size. This function triggers undefined behavior if `U` is larger than +/// `T`. /// /// # Examples /// diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index 5b660970b86..12b45a766b6 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -22,12 +22,12 @@ use num::Float; use num::FpCategory as Fp; use option::Option; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const RADIX: u32 = 2; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const MANTISSA_DIGITS: u32 = 24; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const DIGITS: u32 = 6; #[stable(feature = "rust1", since = "1.0.0")] @@ -56,14 +56,14 @@ pub const MIN_POSITIVE: f32 = 1.17549435e-38_f32; #[stable(feature = "rust1", since = "1.0.0")] pub const MAX: f32 = 3.40282347e+38_f32; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const MIN_EXP: i32 = -125; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const MAX_EXP: i32 = 128; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const MIN_10_EXP: i32 = -37; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const MAX_10_EXP: i32 = 38; #[stable(feature = "rust1", since = "1.0.0")] @@ -73,61 +73,89 @@ pub const INFINITY: f32 = 1.0_f32/0.0_f32; #[stable(feature = "rust1", since = "1.0.0")] pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32; -/// Various useful constants. -#[unstable(feature = "core", - reason = "naming scheme needs to be revisited")] +/// Basic mathematial constants. +#[stable(feature = "rust1", since = "1.0.0")] pub mod consts { // FIXME: replace with mathematical constants from cmath. /// Archimedes' constant + #[stable(feature = "rust1", since = "1.0.0")] pub const PI: f32 = 3.14159265358979323846264338327950288_f32; /// pi * 2.0 + #[unstable(feature = "core", reason = "unclear naming convention/usefulness")] pub const PI_2: f32 = 6.28318530717958647692528676655900576_f32; /// pi/2.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_2: f32 = 1.57079632679489661923132169163975144_f32; /// pi/3.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_3: f32 = 1.04719755119659774615421446109316763_f32; /// pi/4.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_4: f32 = 0.785398163397448309615660845819875721_f32; /// pi/6.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_6: f32 = 0.52359877559829887307710723054658381_f32; /// pi/8.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_8: f32 = 0.39269908169872415480783042290993786_f32; /// 1.0/pi + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_1_PI: f32 = 0.318309886183790671537767526745028724_f32; /// 2.0/pi + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_2_PI: f32 = 0.636619772367581343075535053490057448_f32; /// 2.0/sqrt(pi) + #[stable(feature = "rust1", since = "1.0.0")] + pub const FRAC_2_SQRT_PI: f32 = 1.12837916709551257389615890312154517_f32; + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to FRAC_2_SQRT_PI")] pub const FRAC_2_SQRTPI: f32 = 1.12837916709551257389615890312154517_f32; /// sqrt(2.0) + #[stable(feature = "rust1", since = "1.0.0")] + pub const SQRT_2: f32 = 1.41421356237309504880168872420969808_f32; + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to SQRT_2")] pub const SQRT2: f32 = 1.41421356237309504880168872420969808_f32; /// 1.0/sqrt(2.0) + #[stable(feature = "rust1", since = "1.0.0")] + pub const FRAC_1_SQRT_2: f32 = 0.707106781186547524400844362104849039_f32; + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to FRAC_1_SQRT_2")] pub const FRAC_1_SQRT2: f32 = 0.707106781186547524400844362104849039_f32; /// Euler's number + #[stable(feature = "rust1", since = "1.0.0")] pub const E: f32 = 2.71828182845904523536028747135266250_f32; /// log2(e) + #[stable(feature = "rust1", since = "1.0.0")] pub const LOG2_E: f32 = 1.44269504088896340735992468100189214_f32; /// log10(e) + #[stable(feature = "rust1", since = "1.0.0")] pub const LOG10_E: f32 = 0.434294481903251827651128918916605082_f32; /// ln(2.0) + #[stable(feature = "rust1", since = "1.0.0")] pub const LN_2: f32 = 0.693147180559945309417232121458176568_f32; /// ln(10.0) + #[stable(feature = "rust1", since = "1.0.0")] pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32; } diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index 729b9422d5c..058acedd9c9 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -22,15 +22,12 @@ use num::Float; use num::FpCategory as Fp; use option::Option; -// FIXME(#5527): These constants should be deprecated once associated -// constants are implemented in favour of referencing the respective -// members of `Bounded` and `Float`. - -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const RADIX: u32 = 2; +#[stable(feature = "rust1", since = "1.0.0")] pub const MANTISSA_DIGITS: u32 = 53; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const DIGITS: u32 = 15; #[stable(feature = "rust1", since = "1.0.0")] @@ -59,14 +56,14 @@ pub const MIN_POSITIVE: f64 = 2.2250738585072014e-308_f64; #[stable(feature = "rust1", since = "1.0.0")] pub const MAX: f64 = 1.7976931348623157e+308_f64; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const MIN_EXP: i32 = -1021; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const MAX_EXP: i32 = 1024; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const MIN_10_EXP: i32 = -307; -#[unstable(feature = "core", reason = "pending integer conventions")] +#[stable(feature = "rust1", since = "1.0.0")] pub const MAX_10_EXP: i32 = 308; #[stable(feature = "rust1", since = "1.0.0")] @@ -76,65 +73,89 @@ pub const INFINITY: f64 = 1.0_f64/0.0_f64; #[stable(feature = "rust1", since = "1.0.0")] pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64; -/// Various useful constants. -#[unstable(feature = "core", - reason = "naming scheme needs to be revisited")] +/// Basic mathematial constants. +#[stable(feature = "rust1", since = "1.0.0")] pub mod consts { // FIXME: replace with mathematical constants from cmath. - // FIXME(#5527): These constants should be deprecated once associated - // constants are implemented in favour of referencing the respective members - // of `Float`. - /// Archimedes' constant + #[stable(feature = "rust1", since = "1.0.0")] pub const PI: f64 = 3.14159265358979323846264338327950288_f64; /// pi * 2.0 + #[unstable(feature = "core", reason = "unclear naming convention/usefulness")] pub const PI_2: f64 = 6.28318530717958647692528676655900576_f64; /// pi/2.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_2: f64 = 1.57079632679489661923132169163975144_f64; /// pi/3.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_3: f64 = 1.04719755119659774615421446109316763_f64; /// pi/4.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_4: f64 = 0.785398163397448309615660845819875721_f64; /// pi/6.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_6: f64 = 0.52359877559829887307710723054658381_f64; /// pi/8.0 + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_PI_8: f64 = 0.39269908169872415480783042290993786_f64; /// 1.0/pi + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_1_PI: f64 = 0.318309886183790671537767526745028724_f64; /// 2.0/pi + #[stable(feature = "rust1", since = "1.0.0")] pub const FRAC_2_PI: f64 = 0.636619772367581343075535053490057448_f64; /// 2.0/sqrt(pi) + #[stable(feature = "rust1", since = "1.0.0")] + pub const FRAC_2_SQRT_PI: f64 = 1.12837916709551257389615890312154517_f64; + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to FRAC_2_SQRT_PI")] pub const FRAC_2_SQRTPI: f64 = 1.12837916709551257389615890312154517_f64; /// sqrt(2.0) + #[stable(feature = "rust1", since = "1.0.0")] + pub const SQRT_2: f64 = 1.41421356237309504880168872420969808_f64; + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to SQRT_2")] pub const SQRT2: f64 = 1.41421356237309504880168872420969808_f64; /// 1.0/sqrt(2.0) + #[stable(feature = "rust1", since = "1.0.0")] + pub const FRAC_1_SQRT_2: f64 = 0.707106781186547524400844362104849039_f64; + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to FRAC_1_SQRT_2")] pub const FRAC_1_SQRT2: f64 = 0.707106781186547524400844362104849039_f64; /// Euler's number + #[stable(feature = "rust1", since = "1.0.0")] pub const E: f64 = 2.71828182845904523536028747135266250_f64; /// log2(e) + #[stable(feature = "rust1", since = "1.0.0")] pub const LOG2_E: f64 = 1.44269504088896340735992468100189214_f64; /// log10(e) + #[stable(feature = "rust1", since = "1.0.0")] pub const LOG10_E: f64 = 0.434294481903251827651128918916605082_f64; /// ln(2.0) + #[stable(feature = "rust1", since = "1.0.0")] pub const LN_2: f64 = 0.693147180559945309417232121458176568_f64; /// ln(10.0) + #[stable(feature = "rust1", since = "1.0.0")] pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64; } diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index dc98bb8e603..64f8e7055a5 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -32,11 +32,66 @@ use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; use str::{FromStr, StrExt}; +/// Provides intentionally-wrapped arithmetic on `T`. +/// +/// Operations like `+` on `u32` values is intended to never overflow, +/// and in some debug configurations overflow is detected and results +/// in a panic. While most arithmetic falls into this category, some +/// code explicitly expects and relies upon modular arithmetic (e.g., +/// hashing). +/// +/// Wrapping arithmetic can be achieved either through methods like +/// `wrapping_add`, or through the `Wrapping<T>` type, which says that +/// all standard arithmetic operations on the underlying value are +/// intended to have wrapping semantics. +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)] +pub struct Wrapping<T>(pub T); + #[unstable(feature = "core", reason = "may be removed or relocated")] pub mod wrapping; +/// Types that have a "zero" value. +/// +/// This trait is intended for use in conjunction with `Add`, as an identity: +/// `x + T::zero() == x`. +#[unstable(feature = "zero_one", + reason = "unsure of placement, wants to use associated constants")] +pub trait Zero { + /// The "zero" (usually, additive identity) for this type. + fn zero() -> Self; +} + +/// Types that have a "one" value. +/// +/// This trait is intended for use in conjunction with `Mul`, as an identity: +/// `x * T::one() == x`. +#[unstable(feature = "zero_one", + reason = "unsure of placement, wants to use associated constants")] +pub trait One { + /// The "one" (usually, multiplicative identity) for this type. + fn one() -> Self; +} + +macro_rules! zero_one_impl { + ($($t:ty)*) => ($( + impl Zero for $t { + #[inline] + fn zero() -> $t { 0 } + } + impl One for $t { + #[inline] + fn one() -> $t { 1 } + } + )*) +} +zero_one_impl! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize } + /// A built-in signed or unsigned integer. #[stable(feature = "rust1", since = "1.0.0")] +#[deprecated(since = "1.0.0", + reason = "replaced by inherent methods; for generics, use rust-lang/num")] +#[allow(deprecated)] pub trait Int : Copy + Clone + NumCast @@ -450,6 +505,7 @@ macro_rules! uint_impl { $sub_with_overflow:path, $mul_with_overflow:path) => { #[stable(feature = "rust1", since = "1.0.0")] + #[allow(deprecated)] impl Int for $T { #[inline] fn zero() -> $T { 0 } @@ -589,6 +645,7 @@ macro_rules! int_impl { $sub_with_overflow:path, $mul_with_overflow:path) => { #[stable(feature = "rust1", since = "1.0.0")] + #[allow(deprecated)] impl Int for $T { #[inline] fn zero() -> $T { 0 } @@ -692,6 +749,9 @@ int_impl! { isize = i64, u64, 64, /// A built-in two's complement integer. #[stable(feature = "rust1", since = "1.0.0")] +#[deprecated(since = "1.0.0", + reason = "replaced by inherent methods; for generics, use rust-lang/num")] +#[allow(deprecated)] pub trait SignedInt : Int + Neg<Output=Self> @@ -723,6 +783,7 @@ pub trait SignedInt macro_rules! signed_int_impl { ($T:ty) => { #[stable(feature = "rust1", since = "1.0.0")] + #[allow(deprecated)] impl SignedInt for $T { #[inline] fn abs(self) -> $T { @@ -759,35 +820,25 @@ macro_rules! int_impl { $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 } + /// Convert a string slice in a given base to an integer. + /// + /// Leading and trailing whitespace represent an error. + /// + /// # Arguments + /// + /// * src - A string slice + /// * radix - The base to use. Must lie in the range [2 .. 36] + /// + /// # Return value + /// + /// `None` if the string did not represent a valid number. + /// Otherwise, `Some(n)` where `n` is the integer represented + /// by `src`. + #[stable(feature = "rust1", since = "1.0.0")] + #[allow(deprecated)] + pub fn from_str_radix(src: &str, radix: u32) -> Result<$T, ParseIntError> { + <Self as FromStrRadix>::from_str_radix(src, radix) + } /// Returns the number of ones in the binary representation of `self`. /// @@ -801,8 +852,7 @@ macro_rules! int_impl { /// /// assert_eq!(n.count_ones(), 3); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() } @@ -818,8 +868,7 @@ macro_rules! int_impl { /// /// assert_eq!(n.count_zeros(), 5); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn count_zeros(self) -> u32 { (!self).count_ones() @@ -838,8 +887,7 @@ macro_rules! int_impl { /// /// assert_eq!(n.leading_zeros(), 10); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn leading_zeros(self) -> u32 { (self as $UnsignedT).leading_zeros() @@ -858,8 +906,7 @@ macro_rules! int_impl { /// /// assert_eq!(n.trailing_zeros(), 3); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn trailing_zeros(self) -> u32 { (self as $UnsignedT).trailing_zeros() @@ -879,8 +926,7 @@ macro_rules! int_impl { /// /// assert_eq!(n.rotate_left(12), m); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn rotate_left(self, n: u32) -> $T { (self as $UnsignedT).rotate_left(n) as $T @@ -901,8 +947,7 @@ macro_rules! int_impl { /// /// assert_eq!(n.rotate_right(12), m); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn rotate_right(self, n: u32) -> $T { (self as $UnsignedT).rotate_right(n) as $T @@ -1103,8 +1148,8 @@ macro_rules! int_impl { 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(), + None if other >= <$T as Zero>::zero() => <$T>::max_value(), + None => <$T>::min_value(), } } @@ -1115,8 +1160,38 @@ macro_rules! int_impl { 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(), + None if other >= <$T as Zero>::zero() => <$T>::min_value(), + None => <$T>::max_value(), + } + } + + /// Wrapping (modular) addition. Computes `self + other`, + /// wrapping around at the boundary of the type. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn wrapping_add(self, rhs: $T) -> $T { + unsafe { + intrinsics::overflowing_add(self, rhs) + } + } + + /// Wrapping (modular) subtraction. Computes `self - other`, + /// wrapping around at the boundary of the type. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn wrapping_sub(self, rhs: $T) -> $T { + unsafe { + intrinsics::overflowing_sub(self, rhs) + } + } + + /// Wrapping (modular) multiplication. Computes `self * + /// other`, wrapping around at the boundary of the type. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn wrapping_mul(self, rhs: $T) -> $T { + unsafe { + intrinsics::overflowing_mul(self, rhs) } } @@ -1130,12 +1205,11 @@ macro_rules! int_impl { /// /// assert_eq!(2.pow(4), 16); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn pow(self, mut exp: u32) -> $T { let mut base = self; - let mut acc = <$T>::one(); + let mut acc = <$T as One>::one(); let mut prev_base = self; let mut base_oflo = false; @@ -1161,7 +1235,7 @@ macro_rules! int_impl { /// 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?")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn abs(self) -> $T { if self.is_negative() { -self } else { self } @@ -1256,35 +1330,25 @@ macro_rules! uint_impl { $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 } + /// Convert a string slice in a given base to an integer. + /// + /// Leading and trailing whitespace represent an error. + /// + /// # Arguments + /// + /// * src - A string slice + /// * radix - The base to use. Must lie in the range [2 .. 36] + /// + /// # Return value + /// + /// `None` if the string did not represent a valid number. + /// Otherwise, `Some(n)` where `n` is the integer represented + /// by `src`. + #[stable(feature = "rust1", since = "1.0.0")] + #[allow(deprecated)] + pub fn from_str_radix(src: &str, radix: u32) -> Result<$T, ParseIntError> { + <Self as FromStrRadix>::from_str_radix(src, radix) + } /// Returns the number of ones in the binary representation of `self`. /// @@ -1298,8 +1362,7 @@ macro_rules! uint_impl { /// /// assert_eq!(n.count_ones(), 3); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn count_ones(self) -> u32 { unsafe { $ctpop(self as $ActualT) as u32 } @@ -1317,8 +1380,7 @@ macro_rules! uint_impl { /// /// assert_eq!(n.count_zeros(), 5); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn count_zeros(self) -> u32 { (!self).count_ones() @@ -1337,8 +1399,7 @@ macro_rules! uint_impl { /// /// assert_eq!(n.leading_zeros(), 10); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn leading_zeros(self) -> u32 { unsafe { $ctlz(self as $ActualT) as u32 } @@ -1357,8 +1418,7 @@ macro_rules! uint_impl { /// /// assert_eq!(n.trailing_zeros(), 3); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn trailing_zeros(self) -> u32 { unsafe { $cttz(self as $ActualT) as u32 } @@ -1378,8 +1438,7 @@ macro_rules! uint_impl { /// /// assert_eq!(n.rotate_left(12), m); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn rotate_left(self, n: u32) -> $T { // Protect against undefined behaviour for over-long bit shifts @@ -1402,8 +1461,7 @@ macro_rules! uint_impl { /// /// assert_eq!(n.rotate_right(12), m); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn rotate_right(self, n: u32) -> $T { // Protect against undefined behaviour for over-long bit shifts @@ -1604,8 +1662,8 @@ macro_rules! uint_impl { 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(), + None if other >= <$T as Zero>::zero() => <$T>::max_value(), + None => <$T>::min_value(), } } @@ -1616,8 +1674,38 @@ macro_rules! uint_impl { 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(), + None if other >= <$T as Zero>::zero() => <$T>::min_value(), + None => <$T>::max_value(), + } + } + + /// Wrapping (modular) addition. Computes `self + other`, + /// wrapping around at the boundary of the type. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn wrapping_add(self, rhs: $T) -> $T { + unsafe { + intrinsics::overflowing_add(self, rhs) + } + } + + /// Wrapping (modular) subtraction. Computes `self - other`, + /// wrapping around at the boundary of the type. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn wrapping_sub(self, rhs: $T) -> $T { + unsafe { + intrinsics::overflowing_sub(self, rhs) + } + } + + /// Wrapping (modular) multiplication. Computes `self * + /// other`, wrapping around at the boundary of the type. + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn wrapping_mul(self, rhs: $T) -> $T { + unsafe { + intrinsics::overflowing_mul(self, rhs) } } @@ -1631,12 +1719,11 @@ macro_rules! uint_impl { /// /// assert_eq!(2.pow(4), 16); /// ``` - #[unstable(feature = "core", - reason = "pending integer conventions")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn pow(self, mut exp: u32) -> $T { let mut base = self; - let mut acc = <$T>::one(); + let mut acc = <$T as One>::one(); let mut prev_base = self; let mut base_oflo = false; @@ -1664,8 +1751,8 @@ macro_rules! uint_impl { #[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()) + (self.wrapping_sub(<$T as One>::one())) & self == <$T as Zero>::zero() && + !(self == <$T as Zero>::zero()) } /// Returns the smallest power of two greater than or equal to `self`. @@ -1674,7 +1761,7 @@ macro_rules! uint_impl { #[inline] pub fn next_power_of_two(self) -> $T { let bits = size_of::<$T>() * 8; - let one: $T = <$T>::one(); + let one: $T = <$T as One>::one(); one << ((bits - self.wrapping_sub(one).leading_zeros() as usize) % bits) } @@ -2339,17 +2426,26 @@ impl_num_cast! { f64, to_f64 } /// Used for representing the classification of floating point numbers #[derive(Copy, PartialEq, Debug)] -#[unstable(feature = "core", reason = "may be renamed")] +#[stable(feature = "rust1", since = "1.0.0")] pub enum FpCategory { /// "Not a Number", often obtained by dividing by zero + #[stable(feature = "rust1", since = "1.0.0")] Nan, + /// Positive or negative infinity + #[stable(feature = "rust1", since = "1.0.0")] Infinite , + /// Positive or negative zero + #[stable(feature = "rust1", since = "1.0.0")] Zero, + /// De-normalized floating point representation (less precise than `Normal`) + #[stable(feature = "rust1", since = "1.0.0")] Subnormal, + /// A regular floating point number + #[stable(feature = "rust1", since = "1.0.0")] Normal, } @@ -2526,13 +2622,24 @@ pub trait Float /// A generic trait for converting a string with a radix (base) to a value #[unstable(feature = "core", reason = "needs reevaluation")] +#[deprecated(since = "1.0.0", + reason = "moved to inherent methods; use e.g. i32::from_str_radix")] pub trait FromStrRadix { + #[unstable(feature = "core", reason = "needs reevaluation")] + #[deprecated(since = "1.0.0", reason = "moved to inherent methods")] type Err; + + #[unstable(feature = "core", reason = "needs reevaluation")] + #[deprecated(since = "1.0.0", + reason = "moved to inherent methods; use e.g. i32::from_str_radix")] + #[allow(deprecated)] fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::Err>; } /// A utility function that just calls `FromStrRadix::from_str_radix`. #[unstable(feature = "core", reason = "needs reevaluation")] +#[deprecated(since = "1.0.0", reason = "use e.g. i32::from_str_radix")] +#[allow(deprecated)] pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: u32) -> Result<T, T::Err> { FromStrRadix::from_str_radix(str, radix) @@ -2570,12 +2677,14 @@ macro_rules! from_str_radix_float_impl { /// `None` if the string did not represent a valid number. Otherwise, /// `Some(n)` where `n` is the floating-point number represented by `src`. #[inline] + #[allow(deprecated)] fn from_str(src: &str) -> Result<$T, ParseFloatError> { from_str_radix(src, 10) } } #[stable(feature = "rust1", since = "1.0.0")] + #[allow(deprecated)] impl FromStrRadix for $T { type Err = ParseFloatError; @@ -2746,6 +2855,7 @@ from_str_radix_float_impl! { f64 } macro_rules! from_str_radix_int_impl { ($T:ty) => { #[stable(feature = "rust1", since = "1.0.0")] + #[allow(deprecated)] impl FromStr for $T { type Err = ParseIntError; #[inline] @@ -2755,6 +2865,7 @@ macro_rules! from_str_radix_int_impl { } #[stable(feature = "rust1", since = "1.0.0")] + #[allow(deprecated)] impl FromStrRadix for $T { type Err = ParseIntError; fn from_str_radix(src: &str, radix: u32) diff --git a/src/libcore/num/wrapping.rs b/src/libcore/num/wrapping.rs index 9ecc063403c..bda05a3d9e8 100644 --- a/src/libcore/num/wrapping.rs +++ b/src/libcore/num/wrapping.rs @@ -7,7 +7,11 @@ // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. + #![allow(missing_docs)] +#![allow(deprecated)] + +use super::Wrapping; use ops::*; @@ -26,6 +30,8 @@ use intrinsics::{i16_mul_with_overflow, u16_mul_with_overflow}; use intrinsics::{i32_mul_with_overflow, u32_mul_with_overflow}; use intrinsics::{i64_mul_with_overflow, u64_mul_with_overflow}; +#[unstable(feature = "core", reason = "may be removed, renamed, or relocated")] +#[deprecated(since = "1.0.0", reason = "moved to inherent methods")] pub trait WrappingOps { fn wrapping_add(self, rhs: Self) -> Self; fn wrapping_sub(self, rhs: Self) -> Self; @@ -39,6 +45,49 @@ pub trait OverflowingOps { fn overflowing_mul(self, rhs: Self) -> (Self, bool); } +macro_rules! sh_impl { + ($t:ty, $f:ty) => ( + #[stable(feature = "rust1", since = "1.0.0")] + impl Shl<$f> for Wrapping<$t> { + type Output = Wrapping<$t>; + + #[inline(always)] + fn shl(self, other: $f) -> Wrapping<$t> { + Wrapping(self.0 << other) + } + } + + #[stable(feature = "rust1", since = "1.0.0")] + impl Shr<$f> for Wrapping<$t> { + type Output = Wrapping<$t>; + + #[inline(always)] + fn shr(self, other: $f) -> Wrapping<$t> { + Wrapping(self.0 >> other) + } + } + ) +} + +// FIXME (#23545): uncomment the remaining impls +macro_rules! sh_impl_all { + ($($t:ty)*) => ($( + // sh_impl! { $t, u8 } + // sh_impl! { $t, u16 } + // sh_impl! { $t, u32 } + // sh_impl! { $t, u64 } + sh_impl! { $t, usize } + + // sh_impl! { $t, i8 } + // sh_impl! { $t, i16 } + // sh_impl! { $t, i32 } + // sh_impl! { $t, i64 } + // sh_impl! { $t, isize } + )*) +} + +sh_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize } + macro_rules! wrapping_impl { ($($t:ty)*) => ($( impl WrappingOps for $t { @@ -61,94 +110,79 @@ macro_rules! wrapping_impl { } } } - )*) -} - -wrapping_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 } - -#[unstable(feature = "core", reason = "may be removed, renamed, or relocated")] -#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)] -pub struct Wrapping<T>(pub T); - -impl<T:WrappingOps> Add for Wrapping<T> { - type Output = Wrapping<T>; - #[inline(always)] - fn add(self, other: Wrapping<T>) -> Wrapping<T> { - Wrapping(self.0.wrapping_add(other.0)) - } -} + #[stable(feature = "rust1", since = "1.0.0")] + impl Add for Wrapping<$t> { + type Output = Wrapping<$t>; -impl<T:WrappingOps> Sub for Wrapping<T> { - type Output = Wrapping<T>; - - #[inline(always)] - fn sub(self, other: Wrapping<T>) -> Wrapping<T> { - Wrapping(self.0.wrapping_sub(other.0)) - } -} + #[inline(always)] + fn add(self, other: Wrapping<$t>) -> Wrapping<$t> { + Wrapping(self.0.wrapping_add(other.0)) + } + } -impl<T:WrappingOps> Mul for Wrapping<T> { - type Output = Wrapping<T>; + #[stable(feature = "rust1", since = "1.0.0")] + impl Sub for Wrapping<$t> { + type Output = Wrapping<$t>; - #[inline(always)] - fn mul(self, other: Wrapping<T>) -> Wrapping<T> { - Wrapping(self.0.wrapping_mul(other.0)) - } -} + #[inline(always)] + fn sub(self, other: Wrapping<$t>) -> Wrapping<$t> { + Wrapping(self.0.wrapping_sub(other.0)) + } + } -impl<T:WrappingOps+Not<Output=T>> Not for Wrapping<T> { - type Output = Wrapping<T>; + #[stable(feature = "rust1", since = "1.0.0")] + impl Mul for Wrapping<$t> { + type Output = Wrapping<$t>; - fn not(self) -> Wrapping<T> { - Wrapping(!self.0) - } -} + #[inline(always)] + fn mul(self, other: Wrapping<$t>) -> Wrapping<$t> { + Wrapping(self.0.wrapping_mul(other.0)) + } + } -impl<T:WrappingOps+BitXor<Output=T>> BitXor for Wrapping<T> { - type Output = Wrapping<T>; + #[stable(feature = "rust1", since = "1.0.0")] + impl Not for Wrapping<$t> { + type Output = Wrapping<$t>; - #[inline(always)] - fn bitxor(self, other: Wrapping<T>) -> Wrapping<T> { - Wrapping(self.0 ^ other.0) - } -} + fn not(self) -> Wrapping<$t> { + Wrapping(!self.0) + } + } -impl<T:WrappingOps+BitOr<Output=T>> BitOr for Wrapping<T> { - type Output = Wrapping<T>; + #[stable(feature = "rust1", since = "1.0.0")] + impl BitXor for Wrapping<$t> { + type Output = Wrapping<$t>; - #[inline(always)] - fn bitor(self, other: Wrapping<T>) -> Wrapping<T> { - Wrapping(self.0 | other.0) - } -} + #[inline(always)] + fn bitxor(self, other: Wrapping<$t>) -> Wrapping<$t> { + Wrapping(self.0 ^ other.0) + } + } -impl<T:WrappingOps+BitAnd<Output=T>> BitAnd for Wrapping<T> { - type Output = Wrapping<T>; + #[stable(feature = "rust1", since = "1.0.0")] + impl BitOr for Wrapping<$t> { + type Output = Wrapping<$t>; - #[inline(always)] - fn bitand(self, other: Wrapping<T>) -> Wrapping<T> { - Wrapping(self.0 & other.0) - } -} + #[inline(always)] + fn bitor(self, other: Wrapping<$t>) -> Wrapping<$t> { + Wrapping(self.0 | other.0) + } + } -impl<T:WrappingOps+Shl<usize,Output=T>> Shl<usize> for Wrapping<T> { - type Output = Wrapping<T>; + #[stable(feature = "rust1", since = "1.0.0")] + impl BitAnd for Wrapping<$t> { + type Output = Wrapping<$t>; - #[inline(always)] - fn shl(self, other: usize) -> Wrapping<T> { - Wrapping(self.0 << other) - } + #[inline(always)] + fn bitand(self, other: Wrapping<$t>) -> Wrapping<$t> { + Wrapping(self.0 & other.0) + } + } + )*) } -impl<T:WrappingOps+Shr<usize,Output=T>> Shr<usize> for Wrapping<T> { - type Output = Wrapping<T>; - - #[inline(always)] - fn shr(self, other: usize) -> Wrapping<T> { - Wrapping(self.0 >> other) - } -} +wrapping_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 } macro_rules! overflowing_impl { ($($t:ident)*) => ($( diff --git a/src/libcore/option.rs b/src/libcore/option.rs index cd82936b0b3..c5102ede29f 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -333,7 +333,7 @@ impl<T> Option<T> { } } - /// Moves the value `v` out of the `Option<T>` if the content of the `Option<T>` is a `Some(v)`. + /// Moves the value `v` out of the `Option<T>` if it is `Some(v)`. /// /// # Panics /// diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 07d018dea92..41a70ef708f 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -104,11 +104,28 @@ use cmp::Ordering::{self, Less, Equal, Greater}; // FIXME #19649: intrinsic docs don't render, so these have no docs :( #[stable(feature = "rust1", since = "1.0.0")] +#[cfg(not(stage0))] pub use intrinsics::copy_nonoverlapping; +/// dox +#[cfg(stage0)] #[stable(feature = "rust1", since = "1.0.0")] +pub unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize) { + intrinsics::copy_nonoverlapping(dst, src, count) +} + +#[stable(feature = "rust1", since = "1.0.0")] +#[cfg(not(stage0))] pub use intrinsics::copy; +/// dox +#[cfg(stage0)] +#[stable(feature = "rust1", since = "1.0.0")] +pub unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) { + intrinsics::copy(dst, src, count) +} + + #[stable(feature = "rust1", since = "1.0.0")] pub use intrinsics::write_bytes; @@ -167,12 +184,11 @@ pub unsafe fn zero_memory<T>(dst: *mut T, count: usize) { pub unsafe fn swap<T>(x: *mut T, y: *mut T) { // Give ourselves some scratch space to work with let mut tmp: T = mem::uninitialized(); - let t: *mut T = &mut tmp; // Perform the swap - copy_nonoverlapping(t, &*x, 1); - copy(x, &*y, 1); // `x` and `y` may overlap - copy_nonoverlapping(y, &*t, 1); + copy_nonoverlapping(x, &mut tmp, 1); + copy(y, x, 1); // `x` and `y` may overlap + copy_nonoverlapping(&tmp, y, 1); // y and t now point to the same thing, but we need to completely forget `tmp` // because it's no longer relevant. @@ -208,7 +224,7 @@ pub unsafe fn replace<T>(dest: *mut T, mut src: T) -> T { #[stable(feature = "rust1", since = "1.0.0")] pub unsafe fn read<T>(src: *const T) -> T { let mut tmp: T = mem::uninitialized(); - copy_nonoverlapping(&mut tmp, src, 1); + copy_nonoverlapping(src, &mut tmp, 1); tmp } diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 12cfdbf5306..223a0bdae36 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -1577,14 +1577,14 @@ pub mod bytes { /// /// Panics if the length of `dst` is less than the length of `src`. #[inline] - pub fn copy_memory(dst: &mut [u8], src: &[u8]) { + pub fn copy_memory(src: &[u8], dst: &mut [u8]) { let len_src = src.len(); assert!(dst.len() >= len_src); // `dst` is unaliasable, so we know statically it doesn't overlap // with `src`. unsafe { - ptr::copy_nonoverlapping(dst.as_mut_ptr(), - src.as_ptr(), + ptr::copy_nonoverlapping(src.as_ptr(), + dst.as_mut_ptr(), len_src); } } diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 189cf3d3498..f9e2b47d9b6 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -945,9 +945,9 @@ impl TwoWaySearcher { // critical factorization (u, v) and p = period(v) #[inline] #[allow(dead_code)] + #[allow(deprecated)] fn maximal_suffix(arr: &[u8], reversed: bool) -> (usize, usize) { - use num::wrapping::WrappingOps; - let mut left = -1; // Corresponds to i in the paper + let mut left: usize = -1; // Corresponds to i in the paper let mut right = 0; // Corresponds to j in the paper let mut offset = 1; // Corresponds to k in the paper let mut period = 1; // Corresponds to p in the paper diff --git a/src/libcoretest/ptr.rs b/src/libcoretest/ptr.rs index bdb56c9f867..8f1017c50a3 100644 --- a/src/libcoretest/ptr.rs +++ b/src/libcoretest/ptr.rs @@ -35,18 +35,15 @@ fn test() { let v0 = vec![32000u16, 32001u16, 32002u16]; let mut v1 = vec![0u16, 0u16, 0u16]; - copy(v1.as_mut_ptr().offset(1), - v0.as_ptr().offset(1), 1); + copy(v0.as_ptr().offset(1), v1.as_mut_ptr().offset(1), 1); assert!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16)); - copy(v1.as_mut_ptr(), - v0.as_ptr().offset(2), 1); + copy(v0.as_ptr().offset(2), v1.as_mut_ptr(), 1); assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 0u16)); - copy(v1.as_mut_ptr().offset(2), - v0.as_ptr(), 1); + copy(v0.as_ptr(), v1.as_mut_ptr().offset(2), 1); assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 32000u16)); diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index b3a3f266a5e..74be96235d2 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -84,7 +84,7 @@ //! //! fn edges(&'a self) -> dot::Edges<'a,Ed> { //! let &Edges(ref edges) = self; -//! edges.as_slice().into_cow() +//! (&edges[..]).into_cow() //! } //! //! fn source(&self, e: &Ed) -> Nd { let &(s,_) = e; s } diff --git a/src/librand/chacha.rs b/src/librand/chacha.rs index 91abb548d2e..44187a4fc99 100644 --- a/src/librand/chacha.rs +++ b/src/librand/chacha.rs @@ -198,7 +198,7 @@ impl Rand for ChaChaRng { for word in &mut key { *word = other.gen(); } - SeedableRng::from_seed(key.as_slice()) + SeedableRng::from_seed(&key[..]) } } diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index 7ea62b7fd3f..a7f7889783f 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -14,8 +14,8 @@ use core::prelude::*; use core::slice; -use core::iter::{range_step, repeat}; -use core::num::wrapping::Wrapping as w; +use core::iter::repeat; +use core::num::Wrapping as w; use {Rng, SeedableRng, Rand}; @@ -95,7 +95,7 @@ impl IsaacRng { if use_rsl { macro_rules! memloop { ($arr:expr) => {{ - for i in range_step(0, RAND_SIZE_USIZE, 8) { + for i in (0..RAND_SIZE_USIZE).step_by(8) { a=a+$arr[i ]; b=b+$arr[i+1]; c=c+$arr[i+2]; d=d+$arr[i+3]; e=e+$arr[i+4]; f=f+$arr[i+5]; @@ -112,7 +112,7 @@ impl IsaacRng { memloop!(self.rsl); memloop!(self.mem); } else { - for i in range_step(0, RAND_SIZE_USIZE, 8) { + for i in (0..RAND_SIZE_USIZE).step_by(8) { mix!(); self.mem[i ]=a; self.mem[i+1]=b; self.mem[i+2]=c; self.mem[i+3]=d; @@ -136,7 +136,7 @@ impl IsaacRng { const MIDPOINT: usize = RAND_SIZE_USIZE / 2; macro_rules! ind { - ($x:expr) => ( self.mem[($x >> 2).0 as usize & (RAND_SIZE_USIZE - 1)] ) + ($x:expr) => (self.mem[($x >> 2).0 as usize & (RAND_SIZE_USIZE - 1)] ) } let r = [(0, MIDPOINT), (MIDPOINT, 0)]; @@ -172,7 +172,7 @@ impl IsaacRng { }} } - for i in range_step(0, MIDPOINT, 4) { + for i in (0..MIDPOINT).step_by(4) { rngstepp!(i + 0, 13); rngstepn!(i + 1, 6); rngstepp!(i + 2, 2); diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 97106908cde..15d3d981eb5 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -30,6 +30,7 @@ #![feature(staged_api)] #![staged_api] #![feature(core)] +#![feature(step_by)] #![deprecated(reason = "use the crates.io `rand` library instead", since = "1.0.0-alpha")] @@ -153,7 +154,7 @@ pub trait Rng : Sized { /// /// let mut v = [0; 13579]; /// thread_rng().fill_bytes(&mut v); - /// println!("{:?}", v.as_slice()); + /// println!("{:?}", &v[..]); /// ``` fn fill_bytes(&mut self, dest: &mut [u8]) { // this could, in theory, be done by transmuting dest to a @@ -309,9 +310,9 @@ pub trait Rng : Sized { /// let mut rng = thread_rng(); /// let mut y = [1, 2, 3]; /// rng.shuffle(&mut y); - /// println!("{:?}", y.as_slice()); + /// println!("{:?}", y); /// rng.shuffle(&mut y); - /// println!("{:?}", y.as_slice()); + /// println!("{:?}", y); /// ``` fn shuffle<T>(&mut self, values: &mut [T]) { let mut i = values.len(); diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index 234b8cf5eb5..092cd780ec7 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -241,7 +241,6 @@ pub mod reader { use std::isize; use std::mem::transmute; - use std::num::Int; use std::slice::bytes; use serialize; @@ -346,7 +345,7 @@ pub mod reader { unsafe { let ptr = data.as_ptr().offset(start as isize) as *const u32; - let val = Int::from_be(*ptr); + let val = u32::from_be(*ptr); let i = (val >> 28) as usize; let (shift, mask) = SHIFT_MASK_TABLE[i]; @@ -449,21 +448,21 @@ pub mod reader { pub fn doc_as_u16(d: Doc) -> u16 { assert_eq!(d.end, d.start + 2); let mut b = [0; 2]; - bytes::copy_memory(&mut b, &d.data[d.start..d.end]); + bytes::copy_memory(&d.data[d.start..d.end], &mut b); unsafe { (*(b.as_ptr() as *const u16)).to_be() } } pub fn doc_as_u32(d: Doc) -> u32 { assert_eq!(d.end, d.start + 4); let mut b = [0; 4]; - bytes::copy_memory(&mut b, &d.data[d.start..d.end]); + bytes::copy_memory(&d.data[d.start..d.end], &mut b); unsafe { (*(b.as_ptr() as *const u32)).to_be() } } pub fn doc_as_u64(d: Doc) -> u64 { assert_eq!(d.end, d.start + 8); let mut b = [0; 8]; - bytes::copy_memory(&mut b, &d.data[d.start..d.end]); + bytes::copy_memory(&d.data[d.start..d.end], &mut b); unsafe { (*(b.as_ptr() as *const u64)).to_be() } } @@ -835,7 +834,6 @@ pub mod reader { pub mod writer { use std::mem; - use std::num::Int; use std::io::prelude::*; use std::io::{self, SeekFrom, Cursor}; use std::slice::bytes; @@ -938,7 +936,7 @@ pub mod writer { { let last_size_pos = last_size_pos as usize; let data = &self.writer.get_ref()[last_size_pos+4..cur_pos as usize]; - bytes::copy_memory(&mut buf, data); + bytes::copy_memory(data, &mut buf); } // overwrite the size and data and continue diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index f31f8e8d4ce..6215f823142 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -41,7 +41,6 @@ #![feature(path_ext)] #![feature(str_words)] #![feature(str_char)] -#![feature(convert)] #![feature(into_cow)] #![feature(slice_patterns)] #![cfg_attr(test, feature(test))] diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index fc0b8543ea6..92810b407f0 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -35,7 +35,7 @@ use std::collections::HashMap; use std::hash::{self, Hash, SipHasher}; use std::io::prelude::*; use std::io; -use std::num::{FromPrimitive, Int}; +use std::num::FromPrimitive; use std::rc::Rc; use std::slice::bytes; use std::str; @@ -62,7 +62,7 @@ pub type Cmd<'a> = &'a crate_metadata; fn u32_from_be_bytes(bytes: &[u8]) -> u32 { let mut b = [0; 4]; - bytes::copy_memory(&mut b, &bytes[..4]); + bytes::copy_memory(&bytes[..4], &mut b); unsafe { (*(b.as_ptr() as *const u32)).to_be() } } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 36c9e582b41..e98b438d370 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -885,6 +885,11 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { } } + // When this returns true, it means that the expression *is* a + // method-call (i.e. via the operator-overload). This true result + // also implies that walk_overloaded_operator already took care of + // recursively processing the input arguments, and thus the caller + // should not do so. fn walk_overloaded_operator(&mut self, expr: &ast::Expr, receiver: &ast::Expr, diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 2d9bb2af1b2..3738e38f687 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -71,6 +71,8 @@ pub use self::Note::*; pub use self::deref_kind::*; pub use self::categorization::*; +use self::Aliasability::*; + use middle::check_const; use middle::def; use middle::region; @@ -295,23 +297,29 @@ pub trait Typer<'tcx> : ty::ClosureTyper<'tcx> { impl MutabilityCategory { pub fn from_mutbl(m: ast::Mutability) -> MutabilityCategory { - match m { + let ret = match m { MutImmutable => McImmutable, MutMutable => McDeclared - } + }; + debug!("MutabilityCategory::{}({:?}) => {:?}", + "from_mutbl", m, ret); + ret } pub fn from_borrow_kind(borrow_kind: ty::BorrowKind) -> MutabilityCategory { - match borrow_kind { + let ret = match borrow_kind { ty::ImmBorrow => McImmutable, ty::UniqueImmBorrow => McImmutable, ty::MutBorrow => McDeclared, - } + }; + debug!("MutabilityCategory::{}({:?}) => {:?}", + "from_borrow_kind", borrow_kind, ret); + ret } - pub fn from_pointer_kind(base_mutbl: MutabilityCategory, - ptr: PointerKind) -> MutabilityCategory { - match ptr { + fn from_pointer_kind(base_mutbl: MutabilityCategory, + ptr: PointerKind) -> MutabilityCategory { + let ret = match ptr { Unique => { base_mutbl.inherit() } @@ -321,11 +329,14 @@ impl MutabilityCategory { UnsafePtr(m) => { MutabilityCategory::from_mutbl(m) } - } + }; + debug!("MutabilityCategory::{}({:?}, {:?}) => {:?}", + "from_pointer_kind", base_mutbl, ptr, ret); + ret } fn from_local(tcx: &ty::ctxt, id: ast::NodeId) -> MutabilityCategory { - match tcx.map.get(id) { + let ret = match tcx.map.get(id) { ast_map::NodeLocal(p) | ast_map::NodeArg(p) => match p.node { ast::PatIdent(bind_mode, _, _) => { if bind_mode == ast::BindByValue(ast::MutMutable) { @@ -337,30 +348,39 @@ impl MutabilityCategory { _ => tcx.sess.span_bug(p.span, "expected identifier pattern") }, _ => tcx.sess.span_bug(tcx.map.span(id), "expected identifier pattern") - } + }; + debug!("MutabilityCategory::{}(tcx, id={:?}) => {:?}", + "from_local", id, ret); + ret } pub fn inherit(&self) -> MutabilityCategory { - match *self { + let ret = match *self { McImmutable => McImmutable, McDeclared => McInherited, McInherited => McInherited, - } + }; + debug!("{:?}.inherit() => {:?}", self, ret); + ret } pub fn is_mutable(&self) -> bool { - match *self { + let ret = match *self { McImmutable => false, McInherited => true, McDeclared => true, - } + }; + debug!("{:?}.is_mutable() => {:?}", self, ret); + ret } pub fn is_immutable(&self) -> bool { - match *self { + let ret = match *self { McImmutable => true, McDeclared | McInherited => false - } + }; + debug!("{:?}.is_immutable() => {:?}", self, ret); + ret } pub fn to_user_str(&self) -> &'static str { @@ -733,7 +753,9 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { } }; - Ok(Rc::new(cmt_result)) + let ret = Rc::new(cmt_result); + debug!("cat_upvar ret={}", ret.repr(self.tcx())); + Ok(ret) } fn env_deref(&self, @@ -794,14 +816,18 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { McDeclared | McInherited => { } } - cmt_ { + let ret = cmt_ { id: id, span: span, cat: cat_deref(Rc::new(cmt_result), 0, env_ptr), mutbl: deref_mutbl, ty: var_ty, note: NoteClosureEnv(upvar_id) - } + }; + + debug!("env_deref ret {}", ret.repr(self.tcx())); + + ret } pub fn cat_rvalue_node(&self, @@ -831,7 +857,9 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { } } }; - self.cat_rvalue(id, span, re, expr_ty) + let ret = self.cat_rvalue(id, span, re, expr_ty); + debug!("cat_rvalue_node ret {}", ret.repr(self.tcx())); + ret } pub fn cat_rvalue(&self, @@ -839,14 +867,16 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { span: Span, temp_scope: ty::Region, expr_ty: Ty<'tcx>) -> cmt<'tcx> { - Rc::new(cmt_ { + let ret = Rc::new(cmt_ { id:cmt_id, span:span, cat:cat_rvalue(temp_scope), mutbl:McDeclared, ty:expr_ty, note: NoteNone - }) + }); + debug!("cat_rvalue ret {}", ret.repr(self.tcx())); + ret } pub fn cat_field<N:ast_node>(&self, @@ -855,14 +885,16 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { f_name: ast::Name, f_ty: Ty<'tcx>) -> cmt<'tcx> { - Rc::new(cmt_ { + let ret = Rc::new(cmt_ { id: node.id(), span: node.span(), mutbl: base_cmt.mutbl.inherit(), cat: cat_interior(base_cmt, InteriorField(NamedField(f_name))), ty: f_ty, note: NoteNone - }) + }); + debug!("cat_field ret {}", ret.repr(self.tcx())); + ret } pub fn cat_tup_field<N:ast_node>(&self, @@ -871,14 +903,16 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { f_idx: usize, f_ty: Ty<'tcx>) -> cmt<'tcx> { - Rc::new(cmt_ { + let ret = Rc::new(cmt_ { id: node.id(), span: node.span(), mutbl: base_cmt.mutbl.inherit(), cat: cat_interior(base_cmt, InteriorField(PositionalField(f_idx))), ty: f_ty, note: NoteNone - }) + }); + debug!("cat_tup_field ret {}", ret.repr(self.tcx())); + ret } fn cat_deref<N:ast_node>(&self, @@ -913,10 +947,14 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { }; let base_cmt_ty = base_cmt.ty; match ty::deref(base_cmt_ty, true) { - Some(mt) => self.cat_deref_common(node, base_cmt, deref_cnt, + Some(mt) => { + let ret = self.cat_deref_common(node, base_cmt, deref_cnt, mt.ty, deref_context, - /* implicit: */ false), + /* implicit: */ false); + debug!("cat_deref ret {}", ret.repr(self.tcx())); + ret + } None => { debug!("Explicit deref of non-derefable type: {}", base_cmt_ty.repr(self.tcx())); @@ -954,14 +992,16 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { (base_cmt.mutbl.inherit(), cat_interior(base_cmt, interior)) } }; - Ok(Rc::new(cmt_ { + let ret = Rc::new(cmt_ { id: node.id(), span: node.span(), cat: cat, mutbl: m, ty: deref_ty, note: NoteNone - })) + }); + debug!("cat_deref_common ret {}", ret.repr(self.tcx())); + Ok(ret) } pub fn cat_index<N:ast_node>(&self, @@ -1009,8 +1049,10 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { }; let m = base_cmt.mutbl.inherit(); - return Ok(interior(elt, base_cmt.clone(), base_cmt.ty, - m, context, element_ty)); + let ret = interior(elt, base_cmt.clone(), base_cmt.ty, + m, context, element_ty); + debug!("cat_index ret {}", ret.repr(self.tcx())); + return Ok(ret); fn interior<'tcx, N: ast_node>(elt: &N, of_cmt: cmt<'tcx>, @@ -1039,14 +1081,14 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { context: InteriorOffsetKind) -> McResult<cmt<'tcx>> { - match try!(deref_kind(base_cmt.ty, Some(context))) { + let ret = match try!(deref_kind(base_cmt.ty, Some(context))) { deref_ptr(ptr) => { // for unique ptrs, we inherit mutability from the // owning reference. let m = MutabilityCategory::from_pointer_kind(base_cmt.mutbl, ptr); // the deref is explicit in the resulting cmt - Ok(Rc::new(cmt_ { + Rc::new(cmt_ { id:elt.id(), span:elt.span(), cat:cat_deref(base_cmt.clone(), 0, ptr), @@ -1056,13 +1098,15 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { None => self.tcx().sess.bug("Found non-derefable type") }, note: NoteNone - })) + }) } deref_interior(_) => { - Ok(base_cmt) + base_cmt } - } + }; + debug!("deref_vec ret {}", ret.repr(self.tcx())); + Ok(ret) } /// Given a pattern P like: `[_, ..Q, _]`, where `vec_cmt` is the cmt for `P`, `slice_pat` is @@ -1112,14 +1156,16 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { interior_ty: Ty<'tcx>, interior: InteriorKind) -> cmt<'tcx> { - Rc::new(cmt_ { + let ret = Rc::new(cmt_ { id: node.id(), span: node.span(), mutbl: base_cmt.mutbl.inherit(), cat: cat_interior(base_cmt, interior), ty: interior_ty, note: NoteNone - }) + }); + debug!("cat_imm_interior ret={}", ret.repr(self.tcx())); + ret } pub fn cat_downcast<N:ast_node>(&self, @@ -1128,14 +1174,16 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { downcast_ty: Ty<'tcx>, variant_did: ast::DefId) -> cmt<'tcx> { - Rc::new(cmt_ { + let ret = Rc::new(cmt_ { id: node.id(), span: node.span(), mutbl: base_cmt.mutbl.inherit(), cat: cat_downcast(base_cmt, variant_did), ty: downcast_ty, note: NoteNone - }) + }); + debug!("cat_downcast ret={}", ret.repr(self.tcx())); + ret } pub fn cat_pattern<F>(&self, cmt: cmt<'tcx>, pat: &ast::Pat, mut op: F) -> McResult<()> @@ -1341,17 +1389,25 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { } } -#[derive(Copy)] +#[derive(Copy, Clone, Debug)] pub enum InteriorSafety { InteriorUnsafe, InteriorSafe } -#[derive(Copy)] +#[derive(Clone, Debug)] +pub enum Aliasability { + FreelyAliasable(AliasableReason), + NonAliasable, + ImmutableUnique(Box<Aliasability>), +} + +#[derive(Copy, Clone, Debug)] pub enum AliasableReason { AliasableBorrowed, AliasableClosure(ast::NodeId), // Aliasable due to capture Fn closure env AliasableOther, + UnaliasableImmutable, // Created as needed upon seeing ImmutableUnique AliasableStatic(InteriorSafety), AliasableStaticMut(InteriorSafety), } @@ -1380,9 +1436,9 @@ impl<'tcx> cmt_<'tcx> { } } - /// Returns `Some(_)` if this lvalue represents a freely aliasable pointer type. + /// Returns `FreelyAliasable(_)` if this lvalue represents a freely aliasable pointer type. pub fn freely_aliasable(&self, ctxt: &ty::ctxt<'tcx>) - -> Option<AliasableReason> { + -> Aliasability { // Maybe non-obvious: copied upvars can only be considered // non-aliasable in once closures, since any other kind can be // aliased and eventually recused. @@ -1393,17 +1449,27 @@ impl<'tcx> cmt_<'tcx> { cat_deref(ref b, _, BorrowedPtr(ty::UniqueImmBorrow, _)) | cat_deref(ref b, _, Implicit(ty::UniqueImmBorrow, _)) | cat_downcast(ref b, _) | - cat_deref(ref b, _, Unique) | cat_interior(ref b, _) => { // Aliasability depends on base cmt b.freely_aliasable(ctxt) } + cat_deref(ref b, _, Unique) => { + let sub = b.freely_aliasable(ctxt); + if b.mutbl.is_mutable() { + // Aliasability depends on base cmt alone + sub + } else { + // Do not allow mutation through an immutable box. + ImmutableUnique(Box::new(sub)) + } + } + cat_rvalue(..) | cat_local(..) | cat_upvar(..) | cat_deref(_, _, UnsafePtr(..)) => { // yes, it's aliasable, but... - None + NonAliasable } cat_static_item(..) => { @@ -1414,17 +1480,18 @@ impl<'tcx> cmt_<'tcx> { }; if self.mutbl.is_mutable() { - Some(AliasableStaticMut(int_safe)) + FreelyAliasable(AliasableStaticMut(int_safe)) } else { - Some(AliasableStatic(int_safe)) + FreelyAliasable(AliasableStatic(int_safe)) } } cat_deref(ref base, _, BorrowedPtr(ty::ImmBorrow, _)) | cat_deref(ref base, _, Implicit(ty::ImmBorrow, _)) => { match base.cat { - cat_upvar(Upvar{ id, .. }) => Some(AliasableClosure(id.closure_expr_id)), - _ => Some(AliasableBorrowed) + cat_upvar(Upvar{ id, .. }) => + FreelyAliasable(AliasableClosure(id.closure_expr_id)), + _ => FreelyAliasable(AliasableBorrowed) } } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index a788386d242..1090ba984ee 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -73,6 +73,7 @@ use std::cmp; use std::fmt; use std::hash::{Hash, SipHasher, Hasher}; use std::mem; +use std::num::ToPrimitive; use std::ops; use std::rc::Rc; use std::vec::IntoIter; @@ -5491,7 +5492,6 @@ pub fn type_is_empty(cx: &ctxt, ty: Ty) -> bool { pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) -> Rc<Vec<Rc<VariantInfo<'tcx>>>> { - use std::num::Int; // For checked_add memoized(&cx.enum_var_cache, id, |id: ast::DefId| { if ast::LOCAL_CRATE != id.krate { Rc::new(csearch::get_enum_variants(cx, id)) diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs index fe457841e91..5d7457da7e0 100644 --- a/src/librustc_back/lib.rs +++ b/src/librustc_back/lib.rs @@ -46,7 +46,6 @@ #![feature(path_ext)] #![feature(std_misc)] #![feature(step_by)] -#![feature(convert)] #![cfg_attr(test, feature(test, rand))] extern crate syntax; diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs index c7049f750fc..8f0387059e4 100644 --- a/src/librustc_back/sha2.rs +++ b/src/librustc_back/sha2.rs @@ -64,7 +64,7 @@ impl ToBits for u64 { fn add_bytes_to_bits<T: Int + ToBits>(bits: T, bytes: T) -> T { let (new_high_bits, new_low_bits) = bytes.to_bits(); - if new_high_bits > Int::zero() { + if new_high_bits > T::zero() { panic!("numeric overflow occurred.") } @@ -139,15 +139,15 @@ impl FixedBuffer for FixedBuffer64 { let buffer_remaining = size - self.buffer_idx; if input.len() >= buffer_remaining { copy_memory( - &mut self.buffer[self.buffer_idx..size], - &input[..buffer_remaining]); + &input[..buffer_remaining], + &mut self.buffer[self.buffer_idx..size]); self.buffer_idx = 0; func(&self.buffer); i += buffer_remaining; } else { copy_memory( - &mut self.buffer[self.buffer_idx..self.buffer_idx + input.len()], - input); + input, + &mut self.buffer[self.buffer_idx..self.buffer_idx + input.len()]); self.buffer_idx += input.len(); return; } @@ -165,8 +165,8 @@ impl FixedBuffer for FixedBuffer64 { // be empty. let input_remaining = input.len() - i; copy_memory( - &mut self.buffer[..input_remaining], - &input[i..]); + &input[i..], + &mut self.buffer[..input_remaining]); self.buffer_idx += input_remaining; } @@ -537,7 +537,7 @@ mod tests { use self::rand::isaac::IsaacRng; use serialize::hex::FromHex; use std::iter::repeat; - use std::num::Int; + use std::u64; use super::{Digest, Sha256, FixedBuffer}; // A normal addition - no overflow occurs @@ -550,7 +550,7 @@ mod tests { #[test] #[should_panic] fn test_add_bytes_to_bits_overflow() { - super::add_bytes_to_bits::<u64>(Int::max_value(), 1); + super::add_bytes_to_bits::<u64>(u64::MAX, 1); } struct Test { diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index f268a957fe8..ce7b492c51a 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -943,13 +943,20 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { cmt: mc::cmt<'tcx>) -> bool { match cmt.freely_aliasable(this.tcx()) { - None => { + mc::Aliasability::NonAliasable => { return true; } - Some(mc::AliasableStaticMut(..)) => { + mc::Aliasability::FreelyAliasable(mc::AliasableStaticMut(..)) => { return true; } - Some(cause) => { + mc::Aliasability::ImmutableUnique(_) => { + this.bccx.report_aliasability_violation( + span, + MutabilityViolation, + mc::AliasableReason::UnaliasableImmutable); + return false; + } + mc::Aliasability::FreelyAliasable(cause) => { this.bccx.report_aliasability_violation( span, MutabilityViolation, diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs index bbdec402bdc..733d486d2d2 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs @@ -151,10 +151,11 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> { assignee_cmt: mc::cmt<'tcx>, mode: euv::MutateMode) { - debug!("mutate(assignment_id={}, assignee_cmt={})", - assignment_id, assignee_cmt.repr(self.tcx())); + let opt_lp = opt_loan_path(&assignee_cmt); + debug!("mutate(assignment_id={}, assignee_cmt={}) opt_lp={:?}", + assignment_id, assignee_cmt.repr(self.tcx()), opt_lp); - match opt_loan_path(&assignee_cmt) { + match opt_lp { Some(lp) => { gather_moves::gather_assignment(self.bccx, &self.move_data, assignment_id, assignment_span, @@ -181,12 +182,16 @@ fn check_aliasability<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, req_kind: ty::BorrowKind) -> Result<(),()> { - match (cmt.freely_aliasable(bccx.tcx), req_kind) { - (None, _) => { + let aliasability = cmt.freely_aliasable(bccx.tcx); + debug!("check_aliasability aliasability={:?} req_kind={:?}", + aliasability, req_kind); + + match (aliasability, req_kind) { + (mc::Aliasability::NonAliasable, _) => { /* Uniquely accessible path -- OK for `&` and `&mut` */ Ok(()) } - (Some(mc::AliasableStatic(safety)), ty::ImmBorrow) => { + (mc::Aliasability::FreelyAliasable(mc::AliasableStatic(safety)), ty::ImmBorrow) => { // Borrow of an immutable static item: match safety { mc::InteriorUnsafe => { @@ -202,13 +207,20 @@ fn check_aliasability<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, } } } - (Some(mc::AliasableStaticMut(..)), _) => { + (mc::Aliasability::FreelyAliasable(mc::AliasableStaticMut(..)), _) => { // Even touching a static mut is considered unsafe. We assume the // user knows what they're doing in these cases. Ok(()) } - (Some(alias_cause), ty::UniqueImmBorrow) | - (Some(alias_cause), ty::MutBorrow) => { + (mc::Aliasability::ImmutableUnique(_), ty::MutBorrow) => { + bccx.report_aliasability_violation( + borrow_span, + BorrowViolation(loan_cause), + mc::AliasableReason::UnaliasableImmutable); + Err(()) + } + (mc::Aliasability::FreelyAliasable(alias_cause), ty::UniqueImmBorrow) | + (mc::Aliasability::FreelyAliasable(alias_cause), ty::MutBorrow) => { bccx.report_aliasability_violation( borrow_span, BorrowViolation(loan_cause), @@ -376,7 +388,8 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> { req_kind: ty::BorrowKind) -> Result<(),()> { //! Implements the M-* rules in README.md. - + debug!("check_mutability(cause={:?} cmt={} req_kind={:?}", + cause, cmt.repr(bccx.tcx), req_kind); match req_kind { ty::UniqueImmBorrow | ty::ImmBorrow => { match cmt.mutbl { diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index b5ceff6124d..268e469b7f9 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -844,6 +844,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { &format!("{} in an aliasable location", prefix)); } + mc::AliasableReason::UnaliasableImmutable => { + self.tcx.sess.span_err( + span, + &format!("{} in an immutable container", + prefix)); + } mc::AliasableClosure(id) => { self.tcx.sess.span_err(span, &format!("{} in a captured outer \ diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 456d5f7a60a..112f1502643 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -38,7 +38,6 @@ #![feature(io)] #![feature(set_stdio)] #![feature(unicode)] -#![feature(convert)] extern crate arena; extern crate flate; diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index f9ad6690f6b..e7443af3013 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -39,9 +39,8 @@ use util::ppaux::ty_to_string; use util::nodemap::{FnvHashMap, NodeSet}; use lint::{Level, Context, LintPass, LintArray, Lint}; -use std::collections::BitSet; +use std::collections::{HashSet, BitSet}; use std::collections::hash_map::Entry::{Occupied, Vacant}; -use std::num::SignedInt; use std::{cmp, slice}; use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64}; @@ -1437,6 +1436,9 @@ pub struct MissingDoc { /// Stack of whether #[doc(hidden)] is set /// at each level which has lint attributes. doc_hidden_stack: Vec<bool>, + + /// Private traits or trait items that leaked through. Don't check their methods. + private_traits: HashSet<ast::NodeId>, } impl MissingDoc { @@ -1445,6 +1447,7 @@ impl MissingDoc { struct_def_stack: vec!(), in_variant: false, doc_hidden_stack: vec!(false), + private_traits: HashSet::new(), } } @@ -1531,18 +1534,46 @@ impl LintPass for MissingDoc { ast::ItemMod(..) => "a module", ast::ItemEnum(..) => "an enum", ast::ItemStruct(..) => "a struct", - ast::ItemTrait(..) => "a trait", + ast::ItemTrait(_, _, _, ref items) => { + // Issue #11592, traits are always considered exported, even when private. + if it.vis == ast::Visibility::Inherited { + self.private_traits.insert(it.id); + for itm in items { + self.private_traits.insert(itm.id); + } + return + } + "a trait" + }, ast::ItemTy(..) => "a type alias", + ast::ItemImpl(_, _, _, Some(ref trait_ref), _, ref impl_items) => { + // If the trait is private, add the impl items to private_traits so they don't get + // reported for missing docs. + let real_trait = ty::trait_ref_to_def_id(cx.tcx, trait_ref); + match cx.tcx.map.find(real_trait.node) { + Some(ast_map::NodeItem(item)) => if item.vis == ast::Visibility::Inherited { + for itm in impl_items { + self.private_traits.insert(itm.id); + } + }, + _ => { } + } + return + }, _ => return }; + self.check_missing_docs_attrs(cx, Some(it.id), &it.attrs, it.span, desc); } fn check_trait_item(&mut self, cx: &Context, trait_item: &ast::TraitItem) { + if self.private_traits.contains(&trait_item.id) { return } + let desc = match trait_item.node { ast::MethodTraitItem(..) => "a trait method", ast::TypeTraitItem(..) => "an associated type" }; + self.check_missing_docs_attrs(cx, Some(trait_item.id), &trait_item.attrs, trait_item.span, desc); diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs index 056550f6635..4e099a4ca87 100644 --- a/src/librustc_trans/back/lto.rs +++ b/src/librustc_trans/back/lto.rs @@ -22,6 +22,7 @@ use flate; use std::ffi::CString; use std::mem; +#[allow(deprecated)] use std::num::Int; pub fn run(sess: &session::Session, llmod: ModuleRef, @@ -204,6 +205,7 @@ fn extract_compressed_bytecode_size_v1(bc: &[u8]) -> u64 { return read_from_le_bytes::<u64>(bc, link::RLIB_BYTECODE_OBJECT_V1_DATASIZE_OFFSET); } +#[allow(deprecated)] fn read_from_le_bytes<T: Int>(bytes: &[u8], position_in_bytes: usize) -> T { let byte_data = &bytes[position_in_bytes..position_in_bytes + mem::size_of::<T>()]; let data = unsafe { diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index a3ac0473bfa..b0eacd1a55d 100644 --- a/src/librustc_trans/lib.rs +++ b/src/librustc_trans/lib.rs @@ -39,7 +39,6 @@ #![feature(unicode)] #![feature(path_ext)] #![feature(fs)] -#![feature(convert)] #![feature(path_relative_from)] #![allow(trivial_casts)] diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index 963f7a0543f..e32d8e2b9cf 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -45,6 +45,7 @@ pub use self::Repr::*; +#[allow(deprecated)] use std::num::Int; use std::rc::Rc; diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 61e332f87ad..20677ab93fc 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -41,7 +41,7 @@ use middle::cfg; use middle::lang_items::{LangItem, ExchangeMallocFnLangItem, StartFnLangItem}; use middle::weak_lang_items; use middle::subst::{Subst, Substs}; -use middle::ty::{self, Ty, ClosureTyper}; +use middle::ty::{self, Ty, ClosureTyper, type_is_simd, simd_size}; use session::config::{self, NoDebugInfo}; use session::Session; use trans::_match; @@ -52,7 +52,7 @@ use trans::callee; use trans::cleanup::CleanupMethods; use trans::cleanup; use trans::closure; -use trans::common::{Block, C_bool, C_bytes_in_context, C_i32, C_integral}; +use trans::common::{Block, C_bool, C_bytes_in_context, C_i32, C_int, C_integral}; use trans::common::{C_null, C_struct_in_context, C_u64, C_u8, C_undef}; use trans::common::{CrateContext, ExternMap, FunctionContext}; use trans::common::{Result, NodeIdAndSpan}; @@ -824,6 +824,15 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>( let zero = C_integral(Type::uint_from_ty(cx.ccx(), t), 0, false); (ICmp(cx, llvm::IntEQ, rhs, zero, debug_loc), false) } + ty::ty_struct(_, _) if type_is_simd(cx.tcx(), rhs_t) => { + let mut res = C_bool(cx.ccx(), false); + for i in 0 .. simd_size(cx.tcx(), rhs_t) { + res = Or(cx, res, + IsNull(cx, + ExtractElement(cx, rhs, C_int(cx.ccx(), i as i64))), debug_loc); + } + (res, false) + } _ => { cx.sess().bug(&format!("fail-if-zero on unexpected type: {}", ty_to_string(cx.tcx(), rhs_t))); diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index cfd5b6c13d8..62a6ede4c2f 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -398,8 +398,8 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, false, false, *substs.types.get(FnSpace, 0), - llargs[0], llargs[1], + llargs[0], llargs[2], call_debug_location) } @@ -408,8 +408,8 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, true, false, *substs.types.get(FnSpace, 0), - llargs[0], llargs[1], + llargs[0], llargs[2], call_debug_location) } diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 99dc9ceacec..2e577a0bd19 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -21,6 +21,7 @@ use util::ppaux::Repr; use trans::type_::Type; +#[allow(deprecated)] use std::num::Int; use syntax::abi; use syntax::ast; diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 1f992b9c3ae..16501ec2807 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -4285,7 +4285,7 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, id: ast::NodeId, hint: attr::ReprAttr) -> Vec<Rc<ty::VariantInfo<'tcx>>> { - use std::num::Int; + #![allow(trivial_numeric_casts)] let rty = ty::node_id_to_type(ccx.tcx, id); let mut variants: Vec<Rc<ty::VariantInfo>> = Vec::new(); @@ -5080,7 +5080,21 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { mutbl: ast::MutImmutable })) } - "copy" | "copy_nonoverlapping" | + "copy" | "copy_nonoverlapping" => { + (1, + vec!( + ty::mk_ptr(tcx, ty::mt { + ty: param(ccx, 0), + mutbl: ast::MutImmutable + }), + ty::mk_ptr(tcx, ty::mt { + ty: param(ccx, 0), + mutbl: ast::MutMutable + }), + tcx.types.usize, + ), + ty::mk_nil(tcx)) + } "volatile_copy_memory" | "volatile_copy_nonoverlapping_memory" => { (1, vec!( diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 431cb4a2898..98598509cbc 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -36,7 +36,6 @@ #![feature(file_path)] #![feature(path_ext)] #![feature(path_relative_from)] -#![feature(convert)] #![feature(slice_patterns)] extern crate arena; diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 702a32be586..babbe15b17d 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -243,8 +243,9 @@ fn runtest(test: &str, cratename: &str, libs: SearchPaths, if should_panic && out.status.success() { panic!("test executable succeeded when it should have failed"); } else if !should_panic && !out.status.success() { - panic!("test executable failed:\n{:?}", - str::from_utf8(&out.stdout)); + panic!("test executable failed:\n{}\n{}", + str::from_utf8(&out.stdout).unwrap_or(""), + str::from_utf8(&out.stderr).unwrap_or("")); } } } diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index cd7f66f50c8..cdfe212bf23 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -100,7 +100,7 @@ //! let encoded = json::encode(&object).unwrap(); //! //! // Deserialize using `json::decode` -//! let decoded: TestStruct = json::decode(encoded.as_slice()).unwrap(); +//! let decoded: TestStruct = json::decode(&encoded[..]).unwrap(); //! } //! ``` //! @@ -204,6 +204,8 @@ use std::io::prelude::*; use std::io; use std::mem::swap; use std::num::FpCategory as Fp; +#[allow(deprecated)] +use std::num::wrapping::WrappingOps; use std::ops::Index; use std::str::FromStr; use std::string; @@ -1552,6 +1554,7 @@ impl<T: Iterator<Item=char>> Parser<T> { } } + #[allow(deprecated)] // possible resolve bug is mapping these to traits fn parse_u64(&mut self) -> Result<u64, ParserError> { let mut accum = 0; let last_accum = 0; // necessary to detect overflow. diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index b79323b3f96..2e86712c9bc 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -36,7 +36,6 @@ Core encoding and decoding interfaces. #![feature(std_misc)] #![feature(unicode)] #![feature(str_char)] -#![feature(convert)] #![cfg_attr(test, feature(test, old_io))] // test harness access diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index 8f659334538..aa3195cbf01 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -480,8 +480,8 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> GapThenFull<K, V, M> { pub fn shift(mut self) -> Option<GapThenFull<K, V, M>> { unsafe { *self.gap.raw.hash = mem::replace(&mut *self.full.raw.hash, EMPTY_BUCKET); - ptr::copy_nonoverlapping(self.gap.raw.key, self.full.raw.key, 1); - ptr::copy_nonoverlapping(self.gap.raw.val, self.full.raw.val, 1); + ptr::copy_nonoverlapping(self.full.raw.key, self.gap.raw.key, 1); + ptr::copy_nonoverlapping(self.full.raw.val, self.gap.raw.val, 1); } let FullBucket { raw: prev_raw, idx: prev_idx, .. } = self.full; diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index d8a95133d94..f9bb7e6cbd4 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -190,7 +190,6 @@ mod dl { use ffi::{CStr, OsStr}; use str; use libc; - use os::unix::prelude::*; use ptr; pub fn open(filename: Option<&OsStr>) -> Result<*mut u8, String> { diff --git a/src/libstd/env.rs b/src/libstd/env.rs index 71f072302fb..5abe0f7a0b6 100644 --- a/src/libstd/env.rs +++ b/src/libstd/env.rs @@ -261,7 +261,20 @@ pub fn set_var<K: ?Sized, V: ?Sized>(k: &K, v: &V) os_imp::setenv(k.as_os_str(), v.as_os_str()) } -/// Remove a variable from the environment entirely. +/// Remove an environment variable from the environment of the currently running process. +/// +/// # Examples +/// +/// ``` +/// use std::env; +/// +/// let key = "KEY"; +/// env::set_var(key, "VALUE"); +/// assert_eq!(env::var(key), Ok("VALUE".to_string())); +/// +/// env::remove_var(key); +/// assert!(env::var(key).is_err()); +/// ``` #[stable(feature = "env", since = "1.0.0")] pub fn remove_var<K: ?Sized>(k: &K) where K: AsOsStr { let _g = ENV_LOCK.lock(); @@ -327,7 +340,6 @@ pub struct JoinPathsError { /// # Examples /// /// ``` -/// # #![feature(convert)] /// use std::env; /// use std::path::PathBuf; /// @@ -398,6 +410,19 @@ pub fn home_dir() -> Option<PathBuf> { /// On Windows, returns the value of, in order, the 'TMP', 'TEMP', /// 'USERPROFILE' environment variable if any are set and not the empty /// string. Otherwise, tmpdir returns the path to the Windows directory. +/// +/// ``` +/// use std::env; +/// use std::fs::File; +/// +/// # fn foo() -> std::io::Result<()> { +/// let mut dir = env::temp_dir(); +/// dir.push("foo.txt"); +/// +/// let f = try!(File::create(dir)); +/// # Ok(()) +/// # } +/// ``` #[stable(feature = "env", since = "1.0.0")] pub fn temp_dir() -> PathBuf { os_imp::temp_dir() @@ -557,6 +582,7 @@ pub mod consts { #[stable(feature = "env", since = "1.0.0")] pub const ARCH: &'static str = super::arch::ARCH; + /// The family of the operating system. In this case, `unix`. #[stable(feature = "env", since = "1.0.0")] pub const FAMILY: &'static str = super::os::FAMILY; diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs index 49dbac4585b..30e96ec465f 100644 --- a/src/libstd/ffi/os_str.rs +++ b/src/libstd/ffi/os_str.rs @@ -35,6 +35,7 @@ use core::prelude::*; use borrow::{Borrow, Cow, ToOwned}; +use ffi::CString; use fmt::{self, Debug}; use mem; use string::String; @@ -42,6 +43,7 @@ use ops; use cmp; use hash::{Hash, Hasher}; use old_path::{Path, GenericPath}; +use vec::Vec; use sys::os_str::{Buf, Slice}; use sys_common::{AsInner, IntoInner, FromInner}; @@ -83,6 +85,37 @@ impl OsString { OsString { inner: Buf::from_string(String::new()) } } + /// Construct an `OsString` from a byte sequence. + /// + /// # Platform behavior + /// + /// On Unix systems, any byte sequence can be successfully + /// converted into an `OsString`. + /// + /// On Windows system, only UTF-8 byte sequences will successfully + /// convert; non UTF-8 data will produce `None`. + #[unstable(feature = "convert", reason = "recently added")] + pub fn from_bytes<B>(bytes: B) -> Option<OsString> where B: Into<Vec<u8>> { + #[cfg(unix)] + fn from_bytes_inner(vec: Vec<u8>) -> Option<OsString> { + use os::unix::ffi::OsStringExt; + Some(OsString::from_vec(vec)) + } + + #[cfg(windows)] + fn from_bytes_inner(vec: Vec<u8>) -> Option<OsString> { + String::from_utf8(vec).ok().map(OsString::from) + } + + from_bytes_inner(bytes.into()) + } + + /// Convert to an `OsStr` slice. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn as_os_str(&self) -> &OsStr { + self + } + /// Convert the `OsString` into a `String` if it contains valid Unicode data. /// /// On failure, ownership of the original `OsString` is returned. @@ -211,8 +244,16 @@ impl Hash for OsString { } impl OsStr { + /// Coerce into an `OsStr` slice. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &OsStr { + s.as_ref() + } + /// Coerce directly from a `&str` slice to a `&OsStr` slice. #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", + reason = "use `OsStr::new` instead")] pub fn from_str(s: &str) -> &OsStr { unsafe { mem::transmute(Slice::from_str(s)) } } @@ -239,6 +280,36 @@ impl OsStr { OsString { inner: self.inner.to_owned() } } + /// Yield this `OsStr` as a byte slice. + /// + /// # Platform behavior + /// + /// On Unix systems, this is a no-op. + /// + /// On Windows systems, this returns `None` unless the `OsStr` is + /// valid unicode, in which case it produces UTF-8-encoded + /// data. This may entail checking validity. + #[unstable(feature = "convert", reason = "recently added")] + pub fn to_bytes(&self) -> Option<&[u8]> { + if cfg!(windows) { + self.to_str().map(|s| s.as_bytes()) + } else { + Some(self.bytes()) + } + } + + /// Create a `CString` containing this `OsStr` data. + /// + /// Fails if the `OsStr` contains interior nulls. + /// + /// This is a convenience for creating a `CString` from + /// `self.to_bytes()`, and inherits the platform behavior of the + /// `to_bytes` method. + #[unstable(feature = "convert", reason = "recently added")] + pub fn to_cstring(&self) -> Option<CString> { + self.to_bytes().and_then(|b| CString::new(b).ok()) + } + /// Get the underlying byte representation. /// /// Note: it is *crucial* that this API is private, to avoid @@ -258,14 +329,14 @@ impl PartialEq for OsStr { #[stable(feature = "rust1", since = "1.0.0")] impl PartialEq<str> for OsStr { fn eq(&self, other: &str) -> bool { - *self == *OsStr::from_str(other) + *self == *OsStr::new(other) } } #[stable(feature = "rust1", since = "1.0.0")] impl PartialEq<OsStr> for str { fn eq(&self, other: &OsStr) -> bool { - *other == *OsStr::from_str(self) + *other == *OsStr::new(self) } } @@ -292,7 +363,7 @@ impl PartialOrd for OsStr { impl PartialOrd<str> for OsStr { #[inline] fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> { - self.partial_cmp(OsStr::from_str(other)) + self.partial_cmp(OsStr::new(other)) } } @@ -359,7 +430,7 @@ impl AsOsStr for OsString { #[deprecated(since = "1.0.0", reason = "trait is deprecated")] impl AsOsStr for str { fn as_os_str(&self) -> &OsStr { - OsStr::from_str(self) + unsafe { mem::transmute(Slice::from_str(self)) } } } @@ -367,7 +438,7 @@ impl AsOsStr for str { #[deprecated(since = "1.0.0", reason = "trait is deprecated")] impl AsOsStr for String { fn as_os_str(&self) -> &OsStr { - OsStr::from_str(&self[..]) + unsafe { mem::transmute(Slice::from_str(self)) } } } @@ -388,14 +459,14 @@ impl AsRef<OsStr> for OsString { #[stable(feature = "rust1", since = "1.0.0")] impl AsRef<OsStr> for str { fn as_ref(&self) -> &OsStr { - OsStr::from_str(self) + unsafe { mem::transmute(Slice::from_str(self)) } } } #[stable(feature = "rust1", since = "1.0.0")] impl AsRef<OsStr> for String { fn as_ref(&self) -> &OsStr { - OsStr::from_str(&self[..]) + unsafe { mem::transmute(Slice::from_str(self)) } } } diff --git a/src/libstd/fs/mod.rs b/src/libstd/fs/mod.rs index a3128ef0f8d..2f57d82e6f7 100644 --- a/src/libstd/fs/mod.rs +++ b/src/libstd/fs/mod.rs @@ -56,7 +56,7 @@ mod tempdir; #[stable(feature = "rust1", since = "1.0.0")] pub struct File { inner: fs_imp::File, - path: PathBuf, + path: Option<PathBuf>, } /// Metadata information about a file. @@ -171,7 +171,7 @@ impl File { reason = "this abstraction is imposed by this library instead \ of the underlying OS and may be removed")] pub fn path(&self) -> Option<&Path> { - Some(&self.path) + self.path.as_ref().map(|p| &**p) } /// Attempt to sync all OS-internal metadata to disk. @@ -273,6 +273,12 @@ impl File { impl AsInner<fs_imp::File> for File { fn as_inner(&self) -> &fs_imp::File { &self.inner } } +impl FromInner<fs_imp::File> for File { + fn from_inner(f: fs_imp::File) -> File { + File { inner: f, path: None } + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl Read for File { fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { @@ -381,7 +387,7 @@ impl OpenOptions { pub fn open<P: AsRef<Path>>(&self, path: P) -> io::Result<File> { let path = path.as_ref(); let inner = try!(fs_imp::File::open(path, &self.0)); - Ok(File { path: path.to_path_buf(), inner: inner }) + Ok(File { path: Some(path.to_path_buf()), inner: inner }) } } @@ -1327,7 +1333,7 @@ mod tests { check!(fs::copy(&input, &out)); let mut v = Vec::new(); check!(check!(File::open(&out)).read_to_end(&mut v)); - assert_eq!(v.as_slice(), b"hello"); + assert_eq!(&v[..], b"hello"); assert_eq!(check!(input.metadata()).permissions(), check!(out.metadata()).permissions()); @@ -1622,7 +1628,7 @@ mod tests { check!(check!(File::create(&tmpdir.join("test"))).write(&bytes)); let mut v = Vec::new(); check!(check!(File::open(&tmpdir.join("test"))).read_to_end(&mut v)); - assert!(v == bytes.as_slice()); + assert!(v == &bytes[..]); } #[test] diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index f03ed7a3dde..628ad839c16 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -177,8 +177,8 @@ impl<W: Write> BufWriter<W> { if written > 0 { // NB: would be better expressed as .remove(0..n) if it existed unsafe { - ptr::copy(self.buf.as_mut_ptr(), - self.buf.as_ptr().offset(written as isize), + ptr::copy(self.buf.as_ptr().offset(written as isize), + self.buf.as_mut_ptr(), len - written); } } diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs index 79f0af670b4..da2cfdf7681 100644 --- a/src/libstd/io/cursor.rs +++ b/src/libstd/io/cursor.rs @@ -14,7 +14,6 @@ use io::prelude::*; use cmp; use io::{self, SeekFrom, Error, ErrorKind}; use iter::repeat; -use num::Int; use slice; /// A `Cursor` is a type which wraps a non-I/O object to provide a `Seek` @@ -151,7 +150,7 @@ impl Write for Cursor<Vec<u8>> { // there (left), and what will be appended on the end (right) let space = self.inner.len() - pos as usize; let (left, right) = buf.split_at(cmp::min(space, buf.len())); - slice::bytes::copy_memory(&mut self.inner[(pos as usize)..], left); + slice::bytes::copy_memory(left, &mut self.inner[(pos as usize)..]); self.inner.push_all(right); // Bump us forward @@ -282,19 +281,19 @@ mod tests { #[test] fn test_slice_reader() { let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; - let mut reader = &mut in_buf.as_slice(); + let mut reader = &mut &in_buf[..]; let mut buf = []; assert_eq!(reader.read(&mut buf), Ok(0)); let mut buf = [0]; assert_eq!(reader.read(&mut buf), Ok(1)); assert_eq!(reader.len(), 7); let b: &[_] = &[0]; - assert_eq!(buf.as_slice(), b); + assert_eq!(buf, b); let mut buf = [0; 4]; assert_eq!(reader.read(&mut buf), Ok(4)); assert_eq!(reader.len(), 3); let b: &[_] = &[1, 2, 3, 4]; - assert_eq!(buf.as_slice(), b); + assert_eq!(buf, b); assert_eq!(reader.read(&mut buf), Ok(3)); let b: &[_] = &[5, 6, 7]; assert_eq!(&buf[..3], b); @@ -304,7 +303,7 @@ mod tests { #[test] fn test_buf_reader() { let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; - let mut reader = Cursor::new(in_buf.as_slice()); + let mut reader = Cursor::new(&in_buf[..]); let mut buf = []; assert_eq!(reader.read(&mut buf), Ok(0)); assert_eq!(reader.position(), 0); diff --git a/src/libstd/io/impls.rs b/src/libstd/io/impls.rs index ce03e26866b..52daba36213 100644 --- a/src/libstd/io/impls.rs +++ b/src/libstd/io/impls.rs @@ -149,7 +149,7 @@ impl<'a> Read for &'a [u8] { fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { let amt = cmp::min(buf.len(), self.len()); let (a, b) = self.split_at(amt); - slice::bytes::copy_memory(buf, a); + slice::bytes::copy_memory(a, buf); *self = b; Ok(amt) } @@ -170,7 +170,7 @@ impl<'a> Write for &'a mut [u8] { fn write(&mut self, data: &[u8]) -> io::Result<usize> { let amt = cmp::min(data.len(), self.len()); let (a, b) = mem::replace(self, &mut []).split_at_mut(amt); - slice::bytes::copy_memory(a, &data[..amt]); + slice::bytes::copy_memory(&data[..amt], a); *self = b; Ok(amt) } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index b7cb8f9ed50..6b21dbc2f09 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -44,7 +44,7 @@ //! lives in the [`vec`](vec/index.html) module. Contiguous, unsized regions //! of memory, `[T]`, commonly called "slices", and their borrowed versions, //! `&[T]`, commonly called "borrowed slices", are built-in types for which the -//! for which the [`slice`](slice/index.html) module defines many methods. +//! [`slice`](slice/index.html) module defines many methods. //! //! `&str`, a UTF-8 string, is a built-in type, and the standard library //! defines methods for it on a variety of traits in the @@ -122,12 +122,11 @@ #![feature(unsafe_no_drop_flag, filling_drop)] #![feature(macro_reexport)] #![feature(unique)] -#![feature(convert)] #![feature(allow_internal_unstable)] #![feature(str_char)] #![feature(into_cow)] -#![feature(slice_patterns)] #![feature(std_misc)] +#![feature(slice_patterns)] #![feature(debug_builders)] #![cfg_attr(test, feature(test, rustc_private, std_misc))] diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 88106811093..b3d1adb4421 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -64,6 +64,10 @@ macro_rules! panic { /// /// Equivalent to the `println!` macro except that a newline is not printed at /// the end of the message. +/// +/// Note that stdout is frequently line-buffered by default so it may be +/// necessary to use `io::stdout().flush()` to ensure the output is emitted +/// immediately. #[macro_export] #[stable(feature = "rust1", since = "1.0.0")] #[allow_internal_unstable] diff --git a/src/libstd/net/mod.rs b/src/libstd/net/mod.rs index 68f3098d993..ee57300765e 100644 --- a/src/libstd/net/mod.rs +++ b/src/libstd/net/mod.rs @@ -18,6 +18,7 @@ use prelude::v1::*; use io::{self, Error, ErrorKind}; +#[allow(deprecated)] // Int use num::Int; use sys_common::net2 as net_imp; @@ -54,7 +55,9 @@ pub enum Shutdown { Both, } +#[allow(deprecated)] // Int fn hton<I: Int>(i: I) -> I { i.to_be() } +#[allow(deprecated)] // Int fn ntoh<I: Int>(i: I) -> I { Int::from_be(i) } fn each_addr<A: ToSocketAddrs, F, T>(addr: A, mut f: F) -> io::Result<T> diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs index 869faa795f9..9ed08d05e8b 100644 --- a/src/libstd/net/tcp.rs +++ b/src/libstd/net/tcp.rs @@ -17,7 +17,7 @@ use io::prelude::*; use io; use net::{ToSocketAddrs, SocketAddr, Shutdown}; use sys_common::net2 as net_imp; -use sys_common::AsInner; +use sys_common::{AsInner, FromInner}; /// A structure which represents a TCP stream between a local socket and a /// remote socket. @@ -172,6 +172,10 @@ impl AsInner<net_imp::TcpStream> for TcpStream { fn as_inner(&self) -> &net_imp::TcpStream { &self.0 } } +impl FromInner<net_imp::TcpStream> for TcpStream { + fn from_inner(inner: net_imp::TcpStream) -> TcpStream { TcpStream(inner) } +} + impl TcpListener { /// Creates a new `TcpListener` which will be bound to the specified /// address. @@ -245,6 +249,12 @@ impl AsInner<net_imp::TcpListener> for TcpListener { fn as_inner(&self) -> &net_imp::TcpListener { &self.0 } } +impl FromInner<net_imp::TcpListener> for TcpListener { + fn from_inner(inner: net_imp::TcpListener) -> TcpListener { + TcpListener(inner) + } +} + #[cfg(test)] mod tests { use prelude::v1::*; diff --git a/src/libstd/net/udp.rs b/src/libstd/net/udp.rs index 81151114962..4aeb3d7c7c8 100644 --- a/src/libstd/net/udp.rs +++ b/src/libstd/net/udp.rs @@ -16,7 +16,7 @@ use prelude::v1::*; use io::{self, Error, ErrorKind}; use net::{ToSocketAddrs, SocketAddr, IpAddr}; use sys_common::net2 as net_imp; -use sys_common::AsInner; +use sys_common::{AsInner, FromInner}; /// A User Datagram Protocol socket. /// @@ -140,6 +140,10 @@ impl AsInner<net_imp::UdpSocket> for UdpSocket { fn as_inner(&self) -> &net_imp::UdpSocket { &self.0 } } +impl FromInner<net_imp::UdpSocket> for UdpSocket { + fn from_inner(inner: net_imp::UdpSocket) -> UdpSocket { UdpSocket(inner) } +} + #[cfg(test)] mod tests { use prelude::v1::*; diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index dc1d53b8a39..0ae4d3c5bd6 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -75,6 +75,7 @@ mod cmath { } #[stable(feature = "rust1", since = "1.0.0")] +#[allow(deprecated)] impl Float for f32 { #[inline] fn nan() -> f32 { num::Float::nan() } @@ -361,227 +362,18 @@ impl Float for f32 { #[lang = "f32"] #[stable(feature = "rust1", since = "1.0.0")] impl f32 { - // inlined methods from `num::Float` - /// Returns the `NaN` value. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let nan: f32 = Float::nan(); - /// - /// assert!(nan.is_nan()); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn nan() -> f32 { num::Float::nan() } - - /// Returns the infinite value. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f32; - /// - /// let infinity: f32 = Float::infinity(); - /// - /// assert!(infinity.is_infinite()); - /// assert!(!infinity.is_finite()); - /// assert!(infinity > f32::MAX); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn infinity() -> f32 { num::Float::infinity() } - - /// Returns the negative infinite value. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f32; - /// - /// let neg_infinity: f32 = Float::neg_infinity(); - /// - /// assert!(neg_infinity.is_infinite()); - /// assert!(!neg_infinity.is_finite()); - /// assert!(neg_infinity < f32::MIN); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn neg_infinity() -> f32 { num::Float::neg_infinity() } - - /// Returns `0.0`. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let inf: f32 = Float::infinity(); - /// let zero: f32 = Float::zero(); - /// let neg_zero: f32 = Float::neg_zero(); - /// - /// assert_eq!(zero, neg_zero); - /// assert_eq!(7.0f32/inf, zero); - /// assert_eq!(zero * 10.0, zero); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn zero() -> f32 { num::Float::zero() } - - /// Returns `-0.0`. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let inf: f32 = Float::infinity(); - /// let zero: f32 = Float::zero(); - /// let neg_zero: f32 = Float::neg_zero(); - /// - /// assert_eq!(zero, neg_zero); - /// assert_eq!(7.0f32/inf, zero); - /// assert_eq!(zero * 10.0, zero); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn neg_zero() -> f32 { num::Float::neg_zero() } - - /// Returns `1.0`. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let one: f32 = Float::one(); - /// - /// assert_eq!(one, 1.0f32); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn one() -> f32 { num::Float::one() } - - // FIXME (#5527): These should be associated constants - - /// Deprecated: use `std::f32::MANTISSA_DIGITS` or `std::f64::MANTISSA_DIGITS` - /// instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MANTISSA_DIGITS` or \ - `std::f64::MANTISSA_DIGITS` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn mantissa_digits(unused_self: Option<f32>) -> usize { - num::Float::mantissa_digits(unused_self) - } - - /// Deprecated: use `std::f32::DIGITS` or `std::f64::DIGITS` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::DIGITS` or `std::f64::DIGITS` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn digits(unused_self: Option<f32>) -> usize { num::Float::digits(unused_self) } - - /// Deprecated: use `std::f32::EPSILON` or `std::f64::EPSILON` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::EPSILON` or `std::f64::EPSILON` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn epsilon() -> f32 { num::Float::epsilon() } - - /// Deprecated: use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn min_exp(unused_self: Option<f32>) -> isize { num::Float::min_exp(unused_self) } - - /// Deprecated: use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn max_exp(unused_self: Option<f32>) -> isize { num::Float::max_exp(unused_self) } - - /// Deprecated: use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn min_10_exp(unused_self: Option<f32>) -> isize { num::Float::min_10_exp(unused_self) } - - /// Deprecated: use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn max_10_exp(unused_self: Option<f32>) -> isize { num::Float::max_10_exp(unused_self) } - - /// Returns the smallest finite value that this type can represent. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f64; - /// - /// let x: f64 = Float::min_value(); - /// - /// assert_eq!(x, f64::MIN); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - #[allow(deprecated)] - pub fn min_value() -> f32 { num::Float::min_value() } - - /// Returns the smallest normalized positive number that this type can represent. - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - #[allow(deprecated)] - pub fn min_pos_value(unused_self: Option<f32>) -> f32 { num::Float::min_pos_value(unused_self) } - - /// Returns the largest finite value that this type can represent. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f64; - /// - /// let x: f64 = Float::max_value(); - /// assert_eq!(x, f64::MAX); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - #[allow(deprecated)] - pub fn max_value() -> f32 { num::Float::max_value() } - /// Returns `true` if this value is `NaN` and false otherwise. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let nan = f64::NAN; - /// let f = 7.0; + /// let nan = f32::NAN; + /// let f = 7.0_f32; /// /// assert!(nan.is_nan()); /// assert!(!f.is_nan()); /// ``` - #[unstable(feature = "std_misc", reason = "position is undecided")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn is_nan(self) -> bool { num::Float::is_nan(self) } @@ -589,14 +381,12 @@ impl f32 { /// false otherwise. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; /// use std::f32; /// /// let f = 7.0f32; - /// let inf: f32 = Float::infinity(); - /// let neg_inf: f32 = Float::neg_infinity(); - /// let nan: f32 = f32::NAN; + /// let inf = f32::INFINITY; + /// let neg_inf = f32::NEG_INFINITY; + /// let nan = f32::NAN; /// /// assert!(!f.is_infinite()); /// assert!(!nan.is_infinite()); @@ -604,21 +394,19 @@ impl f32 { /// assert!(inf.is_infinite()); /// assert!(neg_inf.is_infinite()); /// ``` - #[unstable(feature = "std_misc", reason = "position is undecided")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn is_infinite(self) -> bool { num::Float::is_infinite(self) } /// Returns `true` if this number is neither infinite nor `NaN`. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; /// use std::f32; /// /// let f = 7.0f32; - /// let inf: f32 = Float::infinity(); - /// let neg_inf: f32 = Float::neg_infinity(); - /// let nan: f32 = f32::NAN; + /// let inf = f32::INFINITY; + /// let neg_inf = f32::NEG_INFINITY; + /// let nan = f32::NAN; /// /// assert!(f.is_finite()); /// @@ -626,7 +414,7 @@ impl f32 { /// assert!(!inf.is_finite()); /// assert!(!neg_inf.is_finite()); /// ``` - #[unstable(feature = "std_misc", reason = "position is undecided")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn is_finite(self) -> bool { num::Float::is_finite(self) } @@ -635,13 +423,12 @@ impl f32 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; /// use std::f32; /// /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32 /// let max = f32::MAX; /// let lower_than_min = 1.0e-40_f32; - /// let zero = 0.0f32; + /// let zero = 0.0_f32; /// /// assert!(min.is_normal()); /// assert!(max.is_normal()); @@ -653,7 +440,7 @@ impl f32 { /// assert!(!lower_than_min.is_normal()); /// ``` /// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number - #[unstable(feature = "std_misc", reason = "position is undecided")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn is_normal(self) -> bool { num::Float::is_normal(self) } @@ -662,11 +449,10 @@ impl f32 { /// predicate instead. /// /// ``` - /// # #![feature(core)] - /// use std::num::{Float, FpCategory}; + /// use std::num::FpCategory; /// use std::f32; /// - /// let num = 12.4f32; + /// let num = 12.4_f32; /// let inf = f32::INFINITY; /// /// assert_eq!(num.classify(), FpCategory::Normal); @@ -682,7 +468,7 @@ impl f32 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f32; /// /// let num = 2.0f32; /// @@ -695,7 +481,7 @@ impl f32 { /// // 1 * 8388608 * 2^(-22) == 2 /// let abs_difference = (sign_f * mantissa_f * exponent_f - num).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` /// [floating-point]: ../../../../../reference.html#machine-types #[unstable(feature = "std_misc", reason = "signature is undecided")] @@ -705,10 +491,8 @@ impl f32 { /// Returns the largest integer less than or equal to a number. /// /// ``` - /// use std::num::Float; - /// - /// let f = 3.99; - /// let g = 3.0; + /// let f = 3.99_f32; + /// let g = 3.0_f32; /// /// assert_eq!(f.floor(), 3.0); /// assert_eq!(g.floor(), 3.0); @@ -720,10 +504,8 @@ impl f32 { /// Returns the smallest integer greater than or equal to a number. /// /// ``` - /// use std::num::Float; - /// - /// let f = 3.01; - /// let g = 4.0; + /// let f = 3.01_f32; + /// let g = 4.0_f32; /// /// assert_eq!(f.ceil(), 4.0); /// assert_eq!(g.ceil(), 4.0); @@ -736,10 +518,8 @@ impl f32 { /// `0.0`. /// /// ``` - /// use std::num::Float; - /// - /// let f = 3.3; - /// let g = -3.3; + /// let f = 3.3_f32; + /// let g = -3.3_f32; /// /// assert_eq!(f.round(), 3.0); /// assert_eq!(g.round(), -3.0); @@ -751,10 +531,8 @@ impl f32 { /// Return the integer part of a number. /// /// ``` - /// use std::num::Float; - /// - /// let f = 3.3; - /// let g = -3.7; + /// let f = 3.3_f32; + /// let g = -3.7_f32; /// /// assert_eq!(f.trunc(), 3.0); /// assert_eq!(g.trunc(), -3.0); @@ -766,38 +544,36 @@ impl f32 { /// Returns the fractional part of a number. /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let x = 3.5; - /// let y = -3.5; + /// let x = 3.5_f32; + /// let y = -3.5_f32; /// let abs_difference_x = (x.fract() - 0.5).abs(); /// let abs_difference_y = (y.fract() - (-0.5)).abs(); /// - /// assert!(abs_difference_x < 1e-10); - /// assert!(abs_difference_y < 1e-10); + /// assert!(abs_difference_x <= f32::EPSILON); + /// assert!(abs_difference_y <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn fract(self) -> f32 { num::Float::fract(self) } - /// Computes the absolute value of `self`. Returns `Float::nan()` if the - /// number is `Float::nan()`. + /// Computes the absolute value of `self`. Returns `NAN` if the + /// number is `NAN`. /// /// ``` - /// # #![feature(core, std_misc)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let x = 3.5; - /// let y = -3.5; + /// let x = 3.5_f32; + /// let y = -3.5_f32; /// /// let abs_difference_x = (x.abs() - x).abs(); /// let abs_difference_y = (y.abs() - (-y)).abs(); /// - /// assert!(abs_difference_x < 1e-10); - /// assert!(abs_difference_y < 1e-10); + /// assert!(abs_difference_x <= f32::EPSILON); + /// assert!(abs_difference_y <= f32::EPSILON); /// - /// assert!(f64::NAN.abs().is_nan()); + /// assert!(f32::NAN.abs().is_nan()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -805,66 +581,70 @@ impl f32 { /// Returns a number that represents the sign of `self`. /// - /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()` - /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()` - /// - `Float::nan()` if the number is `Float::nan()` + /// - `1.0` if the number is positive, `+0.0` or `INFINITY` + /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` + /// - `NAN` if the number is `NAN` /// /// ``` - /// # #![feature(core, std_misc)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let f = 3.5; + /// let f = 3.5_f32; /// /// assert_eq!(f.signum(), 1.0); - /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0); + /// assert_eq!(f32::NEG_INFINITY.signum(), -1.0); /// - /// assert!(f64::NAN.signum().is_nan()); + /// assert!(f32::NAN.signum().is_nan()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn signum(self) -> f32 { num::Float::signum(self) } - /// Returns `true` if `self` is positive, including `+0.0` and - /// `Float::infinity()`. + /// Returns `true` if `self`'s sign bit is positive, including + /// `+0.0` and `INFINITY`. /// /// ``` - /// use std::num::Float; - /// use std::f64; - /// - /// let nan: f64 = f64::NAN; + /// use std::f32; /// - /// let f = 7.0; - /// let g = -7.0; + /// let nan = f32::NAN; + /// let f = 7.0_f32; + /// let g = -7.0_f32; /// - /// assert!(f.is_positive()); - /// assert!(!g.is_positive()); + /// assert!(f.is_sign_positive()); + /// assert!(!g.is_sign_positive()); /// // Requires both tests to determine if is `NaN` - /// assert!(!nan.is_positive() && !nan.is_negative()); + /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] + pub fn is_sign_positive(self) -> bool { num::Float::is_positive(self) } + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to is_sign_positive")] + #[inline] pub fn is_positive(self) -> bool { num::Float::is_positive(self) } - /// Returns `true` if `self` is negative, including `-0.0` and - /// `Float::neg_infinity()`. + /// Returns `true` if `self`'s sign is negative, including `-0.0` + /// and `NEG_INFINITY`. /// /// ``` - /// use std::num::Float; - /// use std::f64; - /// - /// let nan = f64::NAN; + /// use std::f32; /// - /// let f = 7.0; - /// let g = -7.0; + /// let nan = f32::NAN; + /// let f = 7.0f32; + /// let g = -7.0f32; /// - /// assert!(!f.is_negative()); - /// assert!(g.is_negative()); + /// assert!(!f.is_sign_negative()); + /// assert!(g.is_sign_negative()); /// // Requires both tests to determine if is `NaN`. - /// assert!(!nan.is_positive() && !nan.is_negative()); + /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] + pub fn is_sign_negative(self) -> bool { num::Float::is_negative(self) } + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to is_sign_negative")] + #[inline] pub fn is_negative(self) -> bool { num::Float::is_negative(self) } /// Fused multiply-add. Computes `(self * a) + b` with only one rounding @@ -872,36 +652,32 @@ impl f32 { /// a separate multiplication operation followed by an add. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f32; /// - /// let m = 10.0; - /// let x = 4.0; - /// let b = 60.0; + /// let m = 10.0_f32; + /// let x = 4.0_f32; + /// let b = 60.0_f32; /// /// // 100.0 /// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn mul_add(self, a: f32, b: f32) -> f32 { num::Float::mul_add(self, a, b) } /// Take the reciprocal (inverse) of a number, `1/x`. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f32; /// - /// let x = 2.0; + /// let x = 2.0_f32; /// let abs_difference = (x.recip() - (1.0/x)).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn recip(self) -> f32 { num::Float::recip(self) } @@ -910,12 +686,12 @@ impl f32 { /// Using this function is generally faster than using `powf` /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let x = 2.0; + /// let x = 2.0_f32; /// let abs_difference = (x.powi(2) - x*x).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -924,12 +700,12 @@ impl f32 { /// Raise a number to a floating point power. /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let x = 2.0; + /// let x = 2.0_f32; /// let abs_difference = (x.powf(2.0) - x*x).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -940,52 +716,51 @@ impl f32 { /// Returns NaN if `self` is a negative number. /// /// ``` - /// # #![feature(core, std_misc)] - /// use std::num::Float; + /// use std::f32; /// - /// let positive = 4.0; - /// let negative = -4.0; + /// let positive = 4.0_f32; + /// let negative = -4.0_f32; /// /// let abs_difference = (positive.sqrt() - 2.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// assert!(negative.sqrt().is_nan()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn sqrt(self) -> f32 { num::Float::sqrt(self) } - /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`. /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f32; /// - /// let f = 4.0; + /// let f = 4.0f32; /// /// let abs_difference = (f.rsqrt() - 0.5).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[unstable(feature = "std_misc", reason = "unsure about its place in the world")] + #[deprecated(since = "1.0.0", reason = "use self.sqrt().recip() instead")] #[inline] pub fn rsqrt(self) -> f32 { num::Float::rsqrt(self) } /// Returns `e^(self)`, (the exponential function). /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let one = 1.0; + /// let one = 1.0f32; /// // e^1 /// let e = one.exp(); /// /// // ln(e) - 1 == 0 /// let abs_difference = (e.ln() - 1.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -994,14 +769,14 @@ impl f32 { /// Returns `2^(self)`. /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let f = 2.0; + /// let f = 2.0f32; /// /// // 2^2 - 4 == 0 /// let abs_difference = (f.exp2() - 4.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1010,16 +785,16 @@ impl f32 { /// Returns the natural logarithm of the number. /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let one = 1.0; + /// let one = 1.0f32; /// // e^1 /// let e = one.exp(); /// /// // ln(e) - 1 == 0 /// let abs_difference = (e.ln() - 1.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1028,10 +803,10 @@ impl f32 { /// Returns the logarithm of the number with respect to an arbitrary base. /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let ten = 10.0; - /// let two = 2.0; + /// let ten = 10.0f32; + /// let two = 2.0f32; /// /// // log10(10) - 1 == 0 /// let abs_difference_10 = (ten.log(10.0) - 1.0).abs(); @@ -1039,8 +814,8 @@ impl f32 { /// // log2(2) - 1 == 0 /// let abs_difference_2 = (two.log(2.0) - 1.0).abs(); /// - /// assert!(abs_difference_10 < 1e-10); - /// assert!(abs_difference_2 < 1e-10); + /// assert!(abs_difference_10 <= f32::EPSILON); + /// assert!(abs_difference_2 <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1049,14 +824,14 @@ impl f32 { /// Returns the base 2 logarithm of the number. /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let two = 2.0; + /// let two = 2.0f32; /// /// // log2(2) - 1 == 0 /// let abs_difference = (two.log2() - 1.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1065,14 +840,14 @@ impl f32 { /// Returns the base 10 logarithm of the number. /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let ten = 10.0; + /// let ten = 10.0f32; /// /// // log10(10) - 1 == 0 /// let abs_difference = (ten.log10() - 1.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1082,14 +857,13 @@ impl f32 { /// /// ``` /// # #![feature(std_misc, core)] - /// use std::num::Float; - /// use std::f64::consts; + /// use std::f32::{self, consts}; /// /// let angle = consts::PI; /// /// let abs_difference = (angle.to_degrees() - 180.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[unstable(feature = "std_misc", reason = "desirability is unclear")] #[inline] @@ -1098,15 +872,14 @@ impl f32 { /// Convert degrees to radians. /// /// ``` - /// # #![feature(std_misc, core)] - /// use std::num::Float; - /// use std::f64::consts; + /// # #![feature(std_misc)] + /// use std::f32::{self, consts}; /// - /// let angle = 180.0; + /// let angle = 180.0f32; /// /// let abs_difference = (angle.to_radians() - consts::PI).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[unstable(feature = "std_misc", reason = "desirability is unclear")] #[inline] @@ -1116,12 +889,11 @@ impl f32 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; - /// + /// use std::f32; /// // 3*2^2 - 12 == 0 - /// let abs_difference = (Float::ldexp(3.0, 2) - 12.0).abs(); + /// let abs_difference = (f32::ldexp(3.0, 2) - 12.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[unstable(feature = "std_misc", reason = "pending integer conventions")] @@ -1138,17 +910,17 @@ impl f32 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f32; /// - /// let x = 4.0; + /// let x = 4.0f32; /// /// // (1/2)*2^3 -> 1 * 8/2 -> 4.0 /// let f = x.frexp(); /// let abs_difference_0 = (f.0 - 0.5).abs(); - /// let abs_difference_1 = (f.1 as f64 - 3.0).abs(); + /// let abs_difference_1 = (f.1 as f32 - 3.0).abs(); /// - /// assert!(abs_difference_0 < 1e-10); - /// assert!(abs_difference_1 < 1e-10); + /// assert!(abs_difference_0 <= f32::EPSILON); + /// assert!(abs_difference_1 <= f32::EPSILON); /// ``` #[unstable(feature = "std_misc", reason = "pending integer conventions")] @@ -1166,13 +938,13 @@ impl f32 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f32; /// /// let x = 1.0f32; /// /// let abs_diff = (x.next_after(2.0) - 1.00000011920928955078125_f32).abs(); /// - /// assert!(abs_diff < 1e-10); + /// assert!(abs_diff <= f32::EPSILON); /// ``` #[unstable(feature = "std_misc", reason = "unsure about its place in the world")] @@ -1184,10 +956,8 @@ impl f32 { /// Returns the maximum of the two numbers. /// /// ``` - /// use std::num::Float; - /// - /// let x = 1.0; - /// let y = 2.0; + /// let x = 1.0f32; + /// let y = 2.0f32; /// /// assert_eq!(x.max(y), y); /// ``` @@ -1200,10 +970,8 @@ impl f32 { /// Returns the minimum of the two numbers. /// /// ``` - /// use std::num::Float; - /// - /// let x = 1.0; - /// let y = 2.0; + /// let x = 1.0f32; + /// let y = 2.0f32; /// /// assert_eq!(x.min(y), x); /// ``` @@ -1220,18 +988,18 @@ impl f32 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f32; /// - /// let x = 3.0; - /// let y = -3.0; + /// let x = 3.0f32; + /// let y = -3.0f32; /// /// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs(); /// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs(); /// - /// assert!(abs_difference_x < 1e-10); - /// assert!(abs_difference_y < 1e-10); + /// assert!(abs_difference_x <= f32::EPSILON); + /// assert!(abs_difference_y <= f32::EPSILON); /// ``` - #[unstable(feature = "std_misc", reason = "may be renamed")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn abs_sub(self, other: f32) -> f32 { unsafe { cmath::fdimf(self, other) } @@ -1241,16 +1009,16 @@ impl f32 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f32; /// - /// let x = 8.0; + /// let x = 8.0f32; /// /// // x^(1/3) - 2 == 0 /// let abs_difference = (x.cbrt() - 2.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` - #[unstable(feature = "std_misc", reason = "may be renamed")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn cbrt(self) -> f32 { unsafe { cmath::cbrtf(self) } @@ -1260,19 +1028,17 @@ impl f32 { /// legs of length `x` and `y`. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f32; /// - /// let x = 2.0; - /// let y = 3.0; + /// let x = 2.0f32; + /// let y = 3.0f32; /// /// // sqrt(x^2 + y^2) /// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn hypot(self, other: f32) -> f32 { unsafe { cmath::hypotf(self, other) } @@ -1281,15 +1047,13 @@ impl f32 { /// Computes the sine of a number (in radians). /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let x = f64::consts::PI/2.0; + /// let x = f32::consts::PI/2.0; /// /// let abs_difference = (x.sin() - 1.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1300,15 +1064,13 @@ impl f32 { /// Computes the cosine of a number (in radians). /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let x = 2.0*f64::consts::PI; + /// let x = 2.0*f32::consts::PI; /// /// let abs_difference = (x.cos() - 1.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1319,14 +1081,12 @@ impl f32 { /// Computes the tangent of a number (in radians). /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let x = f64::consts::PI/4.0; /// let abs_difference = (x.tan() - 1.0).abs(); /// - /// assert!(abs_difference < 1e-14); + /// assert!(abs_difference < 1e-10); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1339,16 +1099,14 @@ impl f32 { /// [-1, 1]. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let f = f64::consts::PI / 2.0; + /// let f = f32::consts::PI / 2.0; /// /// // asin(sin(pi/2)) - /// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs(); + /// let abs_difference = f.sin().asin().abs_sub(f32::consts::PI / 2.0); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1361,16 +1119,14 @@ impl f32 { /// [-1, 1]. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let f = f64::consts::PI / 4.0; + /// let f = f32::consts::PI / 4.0; /// /// // acos(cos(pi/4)) - /// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs(); + /// let abs_difference = f.cos().acos().abs_sub(f32::consts::PI / 4.0); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1382,14 +1138,14 @@ impl f32 { /// range [-pi/2, pi/2]; /// /// ``` - /// use std::num::Float; + /// use std::f32; /// - /// let f = 1.0; + /// let f = 1.0f32; /// /// // atan(tan(1)) - /// let abs_difference = (f.tan().atan() - 1.0).abs(); + /// let abs_difference = f.tan().atan().abs_sub(1.0); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1405,25 +1161,23 @@ impl f32 { /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)` /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let pi = f64::consts::PI; + /// let pi = f32::consts::PI; /// // All angles from horizontal right (+x) /// // 45 deg counter-clockwise - /// let x1 = 3.0; - /// let y1 = -3.0; + /// let x1 = 3.0f32; + /// let y1 = -3.0f32; /// /// // 135 deg clockwise - /// let x2 = -3.0; - /// let y2 = 3.0; + /// let x2 = -3.0f32; + /// let y2 = 3.0f32; /// /// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs(); /// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs(); /// - /// assert!(abs_difference_1 < 1e-10); - /// assert!(abs_difference_2 < 1e-10); + /// assert!(abs_difference_1 <= f32::EPSILON); + /// assert!(abs_difference_2 <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1435,18 +1189,16 @@ impl f32 { /// `(sin(x), cos(x))`. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let x = f64::consts::PI/4.0; + /// let x = f32::consts::PI/4.0; /// let f = x.sin_cos(); /// /// let abs_difference_0 = (f.0 - x.sin()).abs(); /// let abs_difference_1 = (f.1 - x.cos()).abs(); /// - /// assert!(abs_difference_0 < 1e-10); - /// assert!(abs_difference_0 < 1e-10); + /// assert!(abs_difference_0 <= f32::EPSILON); + /// assert!(abs_difference_0 <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1458,17 +1210,16 @@ impl f32 { /// number is close to zero. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; + /// use std::f64; /// - /// let x = 7.0; + /// let x = 7.0f64; /// /// // e^(ln(7)) - 1 - /// let abs_difference = (x.ln().exp_m1() - 6.0).abs(); + /// let abs_difference = x.ln().exp_m1().abs_sub(6.0); /// /// assert!(abs_difference < 1e-10); /// ``` - #[unstable(feature = "std_misc", reason = "may be renamed")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn exp_m1(self) -> f32 { unsafe { cmath::expm1f(self) } @@ -1478,18 +1229,16 @@ impl f32 { /// the operations were performed separately. /// /// ``` - /// # #![feature(std_misc, core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let x = f64::consts::E - 1.0; + /// let x = f32::consts::E - 1.0; /// /// // ln(1 + (e - 1)) == ln(e) == 1 /// let abs_difference = (x.ln_1p() - 1.0).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` - #[unstable(feature = "std_misc", reason = "may be renamed")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn ln_1p(self) -> f32 { unsafe { cmath::log1pf(self) } @@ -1498,19 +1247,17 @@ impl f32 { /// Hyperbolic sine function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let e = f64::consts::E; - /// let x = 1.0; + /// let e = f32::consts::E; + /// let x = 1.0f32; /// /// let f = x.sinh(); /// // Solving sinh() at 1 gives `(e^2-1)/(2e)` /// let g = (e*e - 1.0)/(2.0*e); /// let abs_difference = (f - g).abs(); /// - /// assert!(abs_difference < 1e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1521,19 +1268,17 @@ impl f32 { /// Hyperbolic cosine function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let e = f64::consts::E; - /// let x = 1.0; + /// let e = f32::consts::E; + /// let x = 1.0f32; /// let f = x.cosh(); /// // Solving cosh() at 1 gives this result /// let g = (e*e + 1.0)/(2.0*e); - /// let abs_difference = (f - g).abs(); + /// let abs_difference = f.abs_sub(g); /// /// // Same result - /// assert!(abs_difference < 1.0e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1544,19 +1289,17 @@ impl f32 { /// Hyperbolic tangent function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let e = f64::consts::E; - /// let x = 1.0; + /// let e = f32::consts::E; + /// let x = 1.0f32; /// /// let f = x.tanh(); /// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))` /// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2)); /// let abs_difference = (f - g).abs(); /// - /// assert!(abs_difference < 1.0e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1567,15 +1310,14 @@ impl f32 { /// Inverse hyperbolic sine function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; + /// use std::f32; /// - /// let x = 1.0; + /// let x = 1.0f32; /// let f = x.sinh().asinh(); /// /// let abs_difference = (f - x).abs(); /// - /// assert!(abs_difference < 1.0e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1589,15 +1331,14 @@ impl f32 { /// Inverse hyperbolic cosine function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; + /// use std::f32; /// - /// let x = 1.0; + /// let x = 1.0f32; /// let f = x.cosh().acosh(); /// /// let abs_difference = (f - x).abs(); /// - /// assert!(abs_difference < 1.0e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1611,16 +1352,14 @@ impl f32 { /// Inverse hyperbolic tangent function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; - /// use std::f64; + /// use std::f32; /// - /// let e = f64::consts::E; + /// let e = f32::consts::E; /// let f = e.tanh().atanh(); /// - /// let abs_difference = (f - e).abs(); + /// let abs_difference = f.abs_sub(e); /// - /// assert!(abs_difference < 1.0e-10); + /// assert!(abs_difference <= f32::EPSILON); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -1640,6 +1379,7 @@ impl f32 { /// * num - The float value #[inline] #[unstable(feature = "std_misc", reason = "may be removed or relocated")] +#[deprecated(since = "1.0.0", reason = "use the ToString trait instead")] pub fn to_string(num: f32) -> String { let (r, _) = strconv::float_to_str_common( num, 10, true, SignNeg, DigAll, ExpNone, false); @@ -1653,6 +1393,7 @@ pub fn to_string(num: f32) -> String { /// * num - The float value #[inline] #[unstable(feature = "std_misc", reason = "may be removed or relocated")] +#[deprecated(since = "1.0.0", reason = "use format! instead")] pub fn to_str_hex(num: f32) -> String { let (r, _) = strconv::float_to_str_common( num, 16, true, SignNeg, DigAll, ExpNone, false); @@ -1668,6 +1409,7 @@ pub fn to_str_hex(num: f32) -> String { /// * radix - The base to use #[inline] #[unstable(feature = "std_misc", reason = "may be removed or relocated")] +#[deprecated(since = "1.0.0", reason = "use format! instead")] pub fn to_str_radix_special(num: f32, rdx: u32) -> (String, bool) { strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false) } @@ -1764,8 +1506,8 @@ mod tests { assert!(!nan.is_infinite()); assert!(!nan.is_finite()); assert!(!nan.is_normal()); - assert!(!nan.is_positive()); - assert!(!nan.is_negative()); + assert!(!nan.is_sign_positive()); + assert!(!nan.is_sign_negative()); assert_eq!(Fp::Nan, nan.classify()); } @@ -1774,8 +1516,8 @@ mod tests { let inf: f32 = Float::infinity(); assert!(inf.is_infinite()); assert!(!inf.is_finite()); - assert!(inf.is_positive()); - assert!(!inf.is_negative()); + assert!(inf.is_sign_positive()); + assert!(!inf.is_sign_negative()); assert!(!inf.is_nan()); assert!(!inf.is_normal()); assert_eq!(Fp::Infinite, inf.classify()); @@ -1786,8 +1528,8 @@ mod tests { let neg_inf: f32 = Float::neg_infinity(); assert!(neg_inf.is_infinite()); assert!(!neg_inf.is_finite()); - assert!(!neg_inf.is_positive()); - assert!(neg_inf.is_negative()); + assert!(!neg_inf.is_sign_positive()); + assert!(neg_inf.is_sign_negative()); assert!(!neg_inf.is_nan()); assert!(!neg_inf.is_normal()); assert_eq!(Fp::Infinite, neg_inf.classify()); @@ -1799,8 +1541,8 @@ mod tests { assert_eq!(0.0, zero); assert!(!zero.is_infinite()); assert!(zero.is_finite()); - assert!(zero.is_positive()); - assert!(!zero.is_negative()); + assert!(zero.is_sign_positive()); + assert!(!zero.is_sign_negative()); assert!(!zero.is_nan()); assert!(!zero.is_normal()); assert_eq!(Fp::Zero, zero.classify()); @@ -1812,8 +1554,8 @@ mod tests { assert_eq!(0.0, neg_zero); assert!(!neg_zero.is_infinite()); assert!(neg_zero.is_finite()); - assert!(!neg_zero.is_positive()); - assert!(neg_zero.is_negative()); + assert!(!neg_zero.is_sign_positive()); + assert!(neg_zero.is_sign_negative()); assert!(!neg_zero.is_nan()); assert!(!neg_zero.is_normal()); assert_eq!(Fp::Zero, neg_zero.classify()); @@ -1825,8 +1567,8 @@ mod tests { assert_eq!(1.0, one); assert!(!one.is_infinite()); assert!(one.is_finite()); - assert!(one.is_positive()); - assert!(!one.is_negative()); + assert!(one.is_sign_positive()); + assert!(!one.is_sign_negative()); assert!(!one.is_nan()); assert!(one.is_normal()); assert_eq!(Fp::Normal, one.classify()); @@ -2012,27 +1754,27 @@ mod tests { } #[test] - fn test_is_positive() { - assert!(INFINITY.is_positive()); - assert!(1f32.is_positive()); - assert!(0f32.is_positive()); - assert!(!(-0f32).is_positive()); - assert!(!(-1f32).is_positive()); - assert!(!NEG_INFINITY.is_positive()); - assert!(!(1f32/NEG_INFINITY).is_positive()); - assert!(!NAN.is_positive()); + fn test_is_sign_positive() { + assert!(INFINITY.is_sign_positive()); + assert!(1f32.is_sign_positive()); + assert!(0f32.is_sign_positive()); + assert!(!(-0f32).is_sign_positive()); + assert!(!(-1f32).is_sign_positive()); + assert!(!NEG_INFINITY.is_sign_positive()); + assert!(!(1f32/NEG_INFINITY).is_sign_positive()); + assert!(!NAN.is_sign_positive()); } #[test] - fn test_is_negative() { - assert!(!INFINITY.is_negative()); - assert!(!1f32.is_negative()); - assert!(!0f32.is_negative()); - assert!((-0f32).is_negative()); - assert!((-1f32).is_negative()); - assert!(NEG_INFINITY.is_negative()); - assert!((1f32/NEG_INFINITY).is_negative()); - assert!(!NAN.is_negative()); + fn test_is_sign_negative() { + assert!(!INFINITY.is_sign_negative()); + assert!(!1f32.is_sign_negative()); + assert!(!0f32.is_sign_negative()); + assert!((-0f32).is_sign_negative()); + assert!((-1f32).is_sign_negative()); + assert!(NEG_INFINITY.is_sign_negative()); + assert!((1f32/NEG_INFINITY).is_sign_negative()); + assert!(!NAN.is_sign_negative()); } #[test] diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 41ce9a2598c..794853f6f70 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -83,6 +83,7 @@ mod cmath { } #[stable(feature = "rust1", since = "1.0.0")] +#[allow(deprecated)] impl Float for f64 { // inlined methods from `num::Float` #[inline] @@ -370,227 +371,18 @@ impl Float for f64 { #[lang = "f64"] #[stable(feature = "rust1", since = "1.0.0")] impl f64 { - // inlined methods from `num::Float` - /// Returns the `NaN` value. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let nan: f32 = Float::nan(); - /// - /// assert!(nan.is_nan()); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn nan() -> f64 { num::Float::nan() } - - /// Returns the infinite value. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f32; - /// - /// let infinity: f32 = Float::infinity(); - /// - /// assert!(infinity.is_infinite()); - /// assert!(!infinity.is_finite()); - /// assert!(infinity > f32::MAX); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn infinity() -> f64 { num::Float::infinity() } - - /// Returns the negative infinite value. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f32; - /// - /// let neg_infinity: f32 = Float::neg_infinity(); - /// - /// assert!(neg_infinity.is_infinite()); - /// assert!(!neg_infinity.is_finite()); - /// assert!(neg_infinity < f32::MIN); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn neg_infinity() -> f64 { num::Float::neg_infinity() } - - /// Returns `0.0`. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let inf: f32 = Float::infinity(); - /// let zero: f32 = Float::zero(); - /// let neg_zero: f32 = Float::neg_zero(); - /// - /// assert_eq!(zero, neg_zero); - /// assert_eq!(7.0f32/inf, zero); - /// assert_eq!(zero * 10.0, zero); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn zero() -> f64 { num::Float::zero() } - - /// Returns `-0.0`. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let inf: f32 = Float::infinity(); - /// let zero: f32 = Float::zero(); - /// let neg_zero: f32 = Float::neg_zero(); - /// - /// assert_eq!(zero, neg_zero); - /// assert_eq!(7.0f32/inf, zero); - /// assert_eq!(zero * 10.0, zero); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn neg_zero() -> f64 { num::Float::neg_zero() } - - /// Returns `1.0`. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let one: f32 = Float::one(); - /// - /// assert_eq!(one, 1.0f32); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - pub fn one() -> f64 { num::Float::one() } - - // FIXME (#5527): These should be associated constants - - /// Deprecated: use `std::f32::MANTISSA_DIGITS` or `std::f64::MANTISSA_DIGITS` - /// instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MANTISSA_DIGITS` or \ - `std::f64::MANTISSA_DIGITS` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn mantissa_digits(unused_self: Option<f64>) -> usize { - num::Float::mantissa_digits(unused_self) - } - - /// Deprecated: use `std::f32::DIGITS` or `std::f64::DIGITS` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::DIGITS` or `std::f64::DIGITS` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn digits(unused_self: Option<f64>) -> usize { num::Float::digits(unused_self) } - - /// Deprecated: use `std::f32::EPSILON` or `std::f64::EPSILON` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::EPSILON` or `std::f64::EPSILON` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn epsilon() -> f64 { num::Float::epsilon() } - - /// Deprecated: use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn min_exp(unused_self: Option<f64>) -> isize { num::Float::min_exp(unused_self) } - - /// Deprecated: use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn max_exp(unused_self: Option<f64>) -> isize { num::Float::max_exp(unused_self) } - - /// Deprecated: use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn min_10_exp(unused_self: Option<f64>) -> isize { num::Float::min_10_exp(unused_self) } - - /// Deprecated: use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` instead. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` as appropriate")] - #[allow(deprecated)] - #[inline] - pub fn max_10_exp(unused_self: Option<f64>) -> isize { num::Float::max_10_exp(unused_self) } - - /// Returns the smallest finite value that this type can represent. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f64; - /// - /// let x: f64 = Float::min_value(); - /// - /// assert_eq!(x, f64::MIN); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - #[allow(deprecated)] - pub fn min_value() -> f64 { num::Float::min_value() } - - /// Returns the smallest normalized positive number that this type can represent. - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - #[allow(deprecated)] - pub fn min_pos_value(unused_self: Option<f64>) -> f64 { num::Float::min_pos_value(unused_self) } - - /// Returns the largest finite value that this type can represent. - /// - /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f64; - /// - /// let x: f64 = Float::max_value(); - /// assert_eq!(x, f64::MAX); - /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] - #[inline] - #[allow(deprecated)] - pub fn max_value() -> f64 { num::Float::max_value() } - /// Returns `true` if this value is `NaN` and false otherwise. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; /// use std::f64; /// /// let nan = f64::NAN; - /// let f = 7.0; + /// let f = 7.0_f64; /// /// assert!(nan.is_nan()); /// assert!(!f.is_nan()); /// ``` - #[unstable(feature = "std_misc", reason = "position is undecided")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn is_nan(self) -> bool { num::Float::is_nan(self) } @@ -598,14 +390,12 @@ impl f64 { /// false otherwise. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f32; + /// use std::f64; /// - /// let f = 7.0f32; - /// let inf: f32 = Float::infinity(); - /// let neg_inf: f32 = Float::neg_infinity(); - /// let nan: f32 = f32::NAN; + /// let f = 7.0f64; + /// let inf = f64::INFINITY; + /// let neg_inf = f64::NEG_INFINITY; + /// let nan = f64::NAN; /// /// assert!(!f.is_infinite()); /// assert!(!nan.is_infinite()); @@ -613,21 +403,19 @@ impl f64 { /// assert!(inf.is_infinite()); /// assert!(neg_inf.is_infinite()); /// ``` - #[unstable(feature = "std_misc", reason = "position is undecided")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn is_infinite(self) -> bool { num::Float::is_infinite(self) } /// Returns `true` if this number is neither infinite nor `NaN`. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// use std::f32; + /// use std::f64; /// - /// let f = 7.0f32; - /// let inf: f32 = Float::infinity(); - /// let neg_inf: f32 = Float::neg_infinity(); - /// let nan: f32 = f32::NAN; + /// let f = 7.0f64; + /// let inf: f64 = f64::INFINITY; + /// let neg_inf: f64 = f64::NEG_INFINITY; + /// let nan: f64 = f64::NAN; /// /// assert!(f.is_finite()); /// @@ -635,7 +423,7 @@ impl f64 { /// assert!(!inf.is_finite()); /// assert!(!neg_inf.is_finite()); /// ``` - #[unstable(feature = "std_misc", reason = "position is undecided")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn is_finite(self) -> bool { num::Float::is_finite(self) } @@ -643,11 +431,9 @@ impl f64 { /// [subnormal][subnormal], or `NaN`. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; /// use std::f32; /// - /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32 + /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f64 /// let max = f32::MAX; /// let lower_than_min = 1.0e-40_f32; /// let zero = 0.0f32; @@ -662,7 +448,7 @@ impl f64 { /// assert!(!lower_than_min.is_normal()); /// ``` /// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number - #[unstable(feature = "std_misc", reason = "position is undecided")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn is_normal(self) -> bool { num::Float::is_normal(self) } @@ -671,12 +457,11 @@ impl f64 { /// predicate instead. /// /// ``` - /// # #![feature(core)] - /// use std::num::{Float, FpCategory}; - /// use std::f32; + /// use std::num::FpCategory; + /// use std::f64; /// - /// let num = 12.4f32; - /// let inf = f32::INFINITY; + /// let num = 12.4_f64; + /// let inf = f64::INFINITY; /// /// assert_eq!(num.classify(), FpCategory::Normal); /// assert_eq!(inf.classify(), FpCategory::Infinite); @@ -691,15 +476,13 @@ impl f64 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let num = 2.0f32; + /// let num = 2.0f64; /// /// // (8388608, -22, 1) /// let (mantissa, exponent, sign) = num.integer_decode(); - /// let sign_f = sign as f32; - /// let mantissa_f = mantissa as f32; - /// let exponent_f = num.powf(exponent as f32); + /// let sign_f = sign as f64; + /// let mantissa_f = mantissa as f64; + /// let exponent_f = num.powf(exponent as f64); /// /// // 1 * 8388608 * 2^(-22) == 2 /// let abs_difference = (sign_f * mantissa_f * exponent_f - num).abs(); @@ -714,10 +497,8 @@ impl f64 { /// Returns the largest integer less than or equal to a number. /// /// ``` - /// use std::num::Float; - /// - /// let f = 3.99; - /// let g = 3.0; + /// let f = 3.99_f64; + /// let g = 3.0_f64; /// /// assert_eq!(f.floor(), 3.0); /// assert_eq!(g.floor(), 3.0); @@ -729,10 +510,8 @@ impl f64 { /// Returns the smallest integer greater than or equal to a number. /// /// ``` - /// use std::num::Float; - /// - /// let f = 3.01; - /// let g = 4.0; + /// let f = 3.01_f64; + /// let g = 4.0_f64; /// /// assert_eq!(f.ceil(), 4.0); /// assert_eq!(g.ceil(), 4.0); @@ -745,10 +524,8 @@ impl f64 { /// `0.0`. /// /// ``` - /// use std::num::Float; - /// - /// let f = 3.3; - /// let g = -3.3; + /// let f = 3.3_f64; + /// let g = -3.3_f64; /// /// assert_eq!(f.round(), 3.0); /// assert_eq!(g.round(), -3.0); @@ -760,10 +537,8 @@ impl f64 { /// Return the integer part of a number. /// /// ``` - /// use std::num::Float; - /// - /// let f = 3.3; - /// let g = -3.7; + /// let f = 3.3_f64; + /// let g = -3.7_f64; /// /// assert_eq!(f.trunc(), 3.0); /// assert_eq!(g.trunc(), -3.0); @@ -775,10 +550,8 @@ impl f64 { /// Returns the fractional part of a number. /// /// ``` - /// use std::num::Float; - /// - /// let x = 3.5; - /// let y = -3.5; + /// let x = 3.5_f64; + /// let y = -3.5_f64; /// let abs_difference_x = (x.fract() - 0.5).abs(); /// let abs_difference_y = (y.fract() - (-0.5)).abs(); /// @@ -789,16 +562,14 @@ impl f64 { #[inline] pub fn fract(self) -> f64 { num::Float::fract(self) } - /// Computes the absolute value of `self`. Returns `Float::nan()` if the - /// number is `Float::nan()`. + /// Computes the absolute value of `self`. Returns `NAN` if the + /// number is `NAN`. /// /// ``` - /// # #![feature(core, std_misc)] - /// use std::num::Float; /// use std::f64; /// - /// let x = 3.5; - /// let y = -3.5; + /// let x = 3.5_f64; + /// let y = -3.5_f64; /// /// let abs_difference_x = (x.abs() - x).abs(); /// let abs_difference_y = (y.abs() - (-y)).abs(); @@ -814,16 +585,14 @@ impl f64 { /// Returns a number that represents the sign of `self`. /// - /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()` - /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()` - /// - `Float::nan()` if the number is `Float::nan()` + /// - `1.0` if the number is positive, `+0.0` or `INFINITY` + /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY` + /// - `NAN` if the number is `NAN` /// /// ``` - /// # #![feature(core, std_misc)] - /// use std::num::Float; /// use std::f64; /// - /// let f = 3.5; + /// let f = 3.5_f64; /// /// assert_eq!(f.signum(), 1.0); /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0); @@ -834,46 +603,54 @@ impl f64 { #[inline] pub fn signum(self) -> f64 { num::Float::signum(self) } - /// Returns `true` if `self` is positive, including `+0.0` and - /// `Float::infinity()`. + /// Returns `true` if `self`'s sign bit is positive, including + /// `+0.0` and `INFINITY`. /// /// ``` - /// use std::num::Float; /// use std::f64; /// /// let nan: f64 = f64::NAN; /// - /// let f = 7.0; - /// let g = -7.0; + /// let f = 7.0_f64; + /// let g = -7.0_f64; /// - /// assert!(f.is_positive()); - /// assert!(!g.is_positive()); + /// assert!(f.is_sign_positive()); + /// assert!(!g.is_sign_positive()); /// // Requires both tests to determine if is `NaN` - /// assert!(!nan.is_positive() && !nan.is_negative()); + /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] + pub fn is_sign_positive(self) -> bool { num::Float::is_positive(self) } + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to is_sign_positive")] + #[inline] pub fn is_positive(self) -> bool { num::Float::is_positive(self) } - /// Returns `true` if `self` is negative, including `-0.0` and - /// `Float::neg_infinity()`. + /// Returns `true` if `self`'s sign is negative, including `-0.0` + /// and `NEG_INFINITY`. /// /// ``` - /// use std::num::Float; /// use std::f64; /// /// let nan = f64::NAN; /// - /// let f = 7.0; - /// let g = -7.0; + /// let f = 7.0_f64; + /// let g = -7.0_f64; /// - /// assert!(!f.is_negative()); - /// assert!(g.is_negative()); + /// assert!(!f.is_sign_negative()); + /// assert!(g.is_sign_negative()); /// // Requires both tests to determine if is `NaN`. - /// assert!(!nan.is_positive() && !nan.is_negative()); + /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] + pub fn is_sign_negative(self) -> bool { num::Float::is_negative(self) } + + #[stable(feature = "rust1", since = "1.0.0")] + #[deprecated(since = "1.0.0", reason = "renamed to is_sign_negative")] + #[inline] pub fn is_negative(self) -> bool { num::Float::is_negative(self) } /// Fused multiply-add. Computes `(self * a) + b` with only one rounding @@ -881,36 +658,28 @@ impl f64 { /// a separate multiplication operation followed by an add. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let m = 10.0; - /// let x = 4.0; - /// let b = 60.0; + /// let m = 10.0_f64; + /// let x = 4.0_f64; + /// let b = 60.0_f64; /// /// // 100.0 /// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs(); /// /// assert!(abs_difference < 1e-10); /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn mul_add(self, a: f64, b: f64) -> f64 { num::Float::mul_add(self, a, b) } /// Take the reciprocal (inverse) of a number, `1/x`. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let x = 2.0; + /// let x = 2.0_f64; /// let abs_difference = (x.recip() - (1.0/x)).abs(); /// /// assert!(abs_difference < 1e-10); /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn recip(self) -> f64 { num::Float::recip(self) } @@ -919,9 +688,7 @@ impl f64 { /// Using this function is generally faster than using `powf` /// /// ``` - /// use std::num::Float; - /// - /// let x = 2.0; + /// let x = 2.0_f64; /// let abs_difference = (x.powi(2) - x*x).abs(); /// /// assert!(abs_difference < 1e-10); @@ -933,9 +700,7 @@ impl f64 { /// Raise a number to a floating point power. /// /// ``` - /// use std::num::Float; - /// - /// let x = 2.0; + /// let x = 2.0_f64; /// let abs_difference = (x.powf(2.0) - x*x).abs(); /// /// assert!(abs_difference < 1e-10); @@ -949,11 +714,8 @@ impl f64 { /// Returns NaN if `self` is a negative number. /// /// ``` - /// # #![feature(core, std_misc)] - /// use std::num::Float; - /// - /// let positive = 4.0; - /// let negative = -4.0; + /// let positive = 4.0_f64; + /// let negative = -4.0_f64; /// /// let abs_difference = (positive.sqrt() - 2.0).abs(); /// @@ -968,9 +730,7 @@ impl f64 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let f = 4.0; + /// let f = 4.0_f64; /// /// let abs_difference = (f.rsqrt() - 0.5).abs(); /// @@ -978,15 +738,14 @@ impl f64 { /// ``` #[unstable(feature = "std_misc", reason = "unsure about its place in the world")] + #[deprecated(since = "1.0.0", reason = "use self.sqrt().recip() instead")] #[inline] pub fn rsqrt(self) -> f64 { num::Float::rsqrt(self) } /// Returns `e^(self)`, (the exponential function). /// /// ``` - /// use std::num::Float; - /// - /// let one = 1.0; + /// let one = 1.0_f64; /// // e^1 /// let e = one.exp(); /// @@ -1002,9 +761,7 @@ impl f64 { /// Returns `2^(self)`. /// /// ``` - /// use std::num::Float; - /// - /// let f = 2.0; + /// let f = 2.0_f64; /// /// // 2^2 - 4 == 0 /// let abs_difference = (f.exp2() - 4.0).abs(); @@ -1018,9 +775,7 @@ impl f64 { /// Returns the natural logarithm of the number. /// /// ``` - /// use std::num::Float; - /// - /// let one = 1.0; + /// let one = 1.0_f64; /// // e^1 /// let e = one.exp(); /// @@ -1036,10 +791,8 @@ impl f64 { /// Returns the logarithm of the number with respect to an arbitrary base. /// /// ``` - /// use std::num::Float; - /// - /// let ten = 10.0; - /// let two = 2.0; + /// let ten = 10.0_f64; + /// let two = 2.0_f64; /// /// // log10(10) - 1 == 0 /// let abs_difference_10 = (ten.log(10.0) - 1.0).abs(); @@ -1057,9 +810,7 @@ impl f64 { /// Returns the base 2 logarithm of the number. /// /// ``` - /// use std::num::Float; - /// - /// let two = 2.0; + /// let two = 2.0_f64; /// /// // log2(2) - 1 == 0 /// let abs_difference = (two.log2() - 1.0).abs(); @@ -1073,9 +824,7 @@ impl f64 { /// Returns the base 10 logarithm of the number. /// /// ``` - /// use std::num::Float; - /// - /// let ten = 10.0; + /// let ten = 10.0_f64; /// /// // log10(10) - 1 == 0 /// let abs_difference = (ten.log10() - 1.0).abs(); @@ -1089,8 +838,6 @@ impl f64 { /// Convert radians to degrees. /// /// ``` - /// # #![feature(std_misc, core)] - /// use std::num::Float; /// use std::f64::consts; /// /// let angle = consts::PI; @@ -1099,24 +846,22 @@ impl f64 { /// /// assert!(abs_difference < 1e-10); /// ``` - #[unstable(feature = "std_misc", reason = "desirability is unclear")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn to_degrees(self) -> f64 { num::Float::to_degrees(self) } /// Convert degrees to radians. /// /// ``` - /// # #![feature(std_misc, core)] - /// use std::num::Float; /// use std::f64::consts; /// - /// let angle = 180.0; + /// let angle = 180.0_f64; /// /// let abs_difference = (angle.to_radians() - consts::PI).abs(); /// /// assert!(abs_difference < 1e-10); /// ``` - #[unstable(feature = "std_misc", reason = "desirability is unclear")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn to_radians(self) -> f64 { num::Float::to_radians(self) } @@ -1124,10 +869,8 @@ impl f64 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; - /// /// // 3*2^2 - 12 == 0 - /// let abs_difference = (Float::ldexp(3.0, 2) - 12.0).abs(); + /// let abs_difference = (f64::ldexp(3.0, 2) - 12.0).abs(); /// /// assert!(abs_difference < 1e-10); /// ``` @@ -1146,9 +889,7 @@ impl f64 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let x = 4.0; + /// let x = 4.0_f64; /// /// // (1/2)*2^3 -> 1 * 8/2 -> 4.0 /// let f = x.frexp(); @@ -1174,7 +915,6 @@ impl f64 { /// /// ``` /// # #![feature(std_misc)] - /// use std::num::Float; /// /// let x = 1.0f32; /// @@ -1192,10 +932,8 @@ impl f64 { /// Returns the maximum of the two numbers. /// /// ``` - /// use std::num::Float; - /// - /// let x = 1.0; - /// let y = 2.0; + /// let x = 1.0_f64; + /// let y = 2.0_f64; /// /// assert_eq!(x.max(y), y); /// ``` @@ -1208,10 +946,8 @@ impl f64 { /// Returns the minimum of the two numbers. /// /// ``` - /// use std::num::Float; - /// - /// let x = 1.0; - /// let y = 2.0; + /// let x = 1.0_f64; + /// let y = 2.0_f64; /// /// assert_eq!(x.min(y), x); /// ``` @@ -1227,11 +963,8 @@ impl f64 { /// * Else: `self - other` /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let x = 3.0; - /// let y = -3.0; + /// let x = 3.0_f64; + /// let y = -3.0_f64; /// /// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs(); /// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs(); @@ -1239,7 +972,7 @@ impl f64 { /// assert!(abs_difference_x < 1e-10); /// assert!(abs_difference_y < 1e-10); /// ``` - #[unstable(feature = "std_misc", reason = "may be renamed")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn abs_sub(self, other: f64) -> f64 { unsafe { cmath::fdim(self, other) } @@ -1248,17 +981,14 @@ impl f64 { /// Take the cubic root of a number. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let x = 8.0; + /// let x = 8.0_f64; /// /// // x^(1/3) - 2 == 0 /// let abs_difference = (x.cbrt() - 2.0).abs(); /// /// assert!(abs_difference < 1e-10); /// ``` - #[unstable(feature = "std_misc", reason = "may be renamed")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn cbrt(self) -> f64 { unsafe { cmath::cbrt(self) } @@ -1268,19 +998,15 @@ impl f64 { /// legs of length `x` and `y`. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let x = 2.0; - /// let y = 3.0; + /// let x = 2.0_f64; + /// let y = 3.0_f64; /// /// // sqrt(x^2 + y^2) /// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs(); /// /// assert!(abs_difference < 1e-10); /// ``` - #[unstable(feature = "std_misc", - reason = "unsure about its place in the world")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn hypot(self, other: f64) -> f64 { unsafe { cmath::hypot(self, other) } @@ -1289,8 +1015,6 @@ impl f64 { /// Computes the sine of a number (in radians). /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let x = f64::consts::PI/2.0; @@ -1308,8 +1032,6 @@ impl f64 { /// Computes the cosine of a number (in radians). /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let x = 2.0*f64::consts::PI; @@ -1327,8 +1049,6 @@ impl f64 { /// Computes the tangent of a number (in radians). /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let x = f64::consts::PI/4.0; @@ -1347,8 +1067,6 @@ impl f64 { /// [-1, 1]. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let f = f64::consts::PI / 2.0; @@ -1369,8 +1087,6 @@ impl f64 { /// [-1, 1]. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let f = f64::consts::PI / 4.0; @@ -1390,9 +1106,7 @@ impl f64 { /// range [-pi/2, pi/2]; /// /// ``` - /// use std::num::Float; - /// - /// let f = 1.0; + /// let f = 1.0_f64; /// /// // atan(tan(1)) /// let abs_difference = (f.tan().atan() - 1.0).abs(); @@ -1413,19 +1127,17 @@ impl f64 { /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)` /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let pi = f64::consts::PI; /// // All angles from horizontal right (+x) /// // 45 deg counter-clockwise - /// let x1 = 3.0; - /// let y1 = -3.0; + /// let x1 = 3.0_f64; + /// let y1 = -3.0_f64; /// /// // 135 deg clockwise - /// let x2 = -3.0; - /// let y2 = 3.0; + /// let x2 = -3.0_f64; + /// let y2 = 3.0_f64; /// /// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs(); /// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs(); @@ -1443,8 +1155,6 @@ impl f64 { /// `(sin(x), cos(x))`. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let x = f64::consts::PI/4.0; @@ -1466,17 +1176,14 @@ impl f64 { /// number is close to zero. /// /// ``` - /// # #![feature(std_misc)] - /// use std::num::Float; - /// - /// let x = 7.0; + /// let x = 7.0_f64; /// /// // e^(ln(7)) - 1 /// let abs_difference = (x.ln().exp_m1() - 6.0).abs(); /// /// assert!(abs_difference < 1e-10); /// ``` - #[unstable(feature = "std_misc", reason = "may be renamed")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn exp_m1(self) -> f64 { unsafe { cmath::expm1(self) } @@ -1486,8 +1193,6 @@ impl f64 { /// the operations were performed separately. /// /// ``` - /// # #![feature(std_misc, core)] - /// use std::num::Float; /// use std::f64; /// /// let x = f64::consts::E - 1.0; @@ -1497,7 +1202,7 @@ impl f64 { /// /// assert!(abs_difference < 1e-10); /// ``` - #[unstable(feature = "std_misc", reason = "may be renamed")] + #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn ln_1p(self) -> f64 { unsafe { cmath::log1p(self) } @@ -1506,12 +1211,10 @@ impl f64 { /// Hyperbolic sine function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let e = f64::consts::E; - /// let x = 1.0; + /// let x = 1.0_f64; /// /// let f = x.sinh(); /// // Solving sinh() at 1 gives `(e^2-1)/(2e)` @@ -1529,12 +1232,10 @@ impl f64 { /// Hyperbolic cosine function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let e = f64::consts::E; - /// let x = 1.0; + /// let x = 1.0_f64; /// let f = x.cosh(); /// // Solving cosh() at 1 gives this result /// let g = (e*e + 1.0)/(2.0*e); @@ -1552,12 +1253,10 @@ impl f64 { /// Hyperbolic tangent function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let e = f64::consts::E; - /// let x = 1.0; + /// let x = 1.0_f64; /// /// let f = x.tanh(); /// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))` @@ -1575,9 +1274,7 @@ impl f64 { /// Inverse hyperbolic sine function. /// /// ``` - /// use std::num::Float; - /// - /// let x = 1.0; + /// let x = 1.0_f64; /// let f = x.sinh().asinh(); /// /// let abs_difference = (f - x).abs(); @@ -1596,9 +1293,7 @@ impl f64 { /// Inverse hyperbolic cosine function. /// /// ``` - /// use std::num::Float; - /// - /// let x = 1.0; + /// let x = 1.0_f64; /// let f = x.cosh().acosh(); /// /// let abs_difference = (f - x).abs(); @@ -1617,8 +1312,6 @@ impl f64 { /// Inverse hyperbolic tangent function. /// /// ``` - /// # #![feature(core)] - /// use std::num::Float; /// use std::f64; /// /// let e = f64::consts::E; @@ -1646,6 +1339,7 @@ impl f64 { /// * num - The float value #[inline] #[unstable(feature = "std_misc", reason = "may be removed or relocated")] +#[deprecated(since = "1.0.0", reason = "use the ToString trait instead")] pub fn to_string(num: f64) -> String { let (r, _) = strconv::float_to_str_common( num, 10, true, SignNeg, DigAll, ExpNone, false); @@ -1659,6 +1353,7 @@ pub fn to_string(num: f64) -> String { /// * num - The float value #[inline] #[unstable(feature = "std_misc", reason = "may be removed or relocated")] +#[deprecated(since = "1.0.0", reason = "use format! instead")] pub fn to_str_hex(num: f64) -> String { let (r, _) = strconv::float_to_str_common( num, 16, true, SignNeg, DigAll, ExpNone, false); @@ -1674,6 +1369,7 @@ pub fn to_str_hex(num: f64) -> String { /// * radix - The base to use #[inline] #[unstable(feature = "std_misc", reason = "may be removed or relocated")] +#[deprecated(since = "1.0.0", reason = "use format! instead")] pub fn to_str_radix_special(num: f64, rdx: u32) -> (String, bool) { strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false) } @@ -1770,8 +1466,8 @@ mod tests { assert!(!nan.is_infinite()); assert!(!nan.is_finite()); assert!(!nan.is_normal()); - assert!(!nan.is_positive()); - assert!(!nan.is_negative()); + assert!(!nan.is_sign_positive()); + assert!(!nan.is_sign_negative()); assert_eq!(Fp::Nan, nan.classify()); } @@ -1780,8 +1476,8 @@ mod tests { let inf: f64 = Float::infinity(); assert!(inf.is_infinite()); assert!(!inf.is_finite()); - assert!(inf.is_positive()); - assert!(!inf.is_negative()); + assert!(inf.is_sign_positive()); + assert!(!inf.is_sign_negative()); assert!(!inf.is_nan()); assert!(!inf.is_normal()); assert_eq!(Fp::Infinite, inf.classify()); @@ -1792,8 +1488,8 @@ mod tests { let neg_inf: f64 = Float::neg_infinity(); assert!(neg_inf.is_infinite()); assert!(!neg_inf.is_finite()); - assert!(!neg_inf.is_positive()); - assert!(neg_inf.is_negative()); + assert!(!neg_inf.is_sign_positive()); + assert!(neg_inf.is_sign_negative()); assert!(!neg_inf.is_nan()); assert!(!neg_inf.is_normal()); assert_eq!(Fp::Infinite, neg_inf.classify()); @@ -1805,8 +1501,8 @@ mod tests { assert_eq!(0.0, zero); assert!(!zero.is_infinite()); assert!(zero.is_finite()); - assert!(zero.is_positive()); - assert!(!zero.is_negative()); + assert!(zero.is_sign_positive()); + assert!(!zero.is_sign_negative()); assert!(!zero.is_nan()); assert!(!zero.is_normal()); assert_eq!(Fp::Zero, zero.classify()); @@ -1818,8 +1514,8 @@ mod tests { assert_eq!(0.0, neg_zero); assert!(!neg_zero.is_infinite()); assert!(neg_zero.is_finite()); - assert!(!neg_zero.is_positive()); - assert!(neg_zero.is_negative()); + assert!(!neg_zero.is_sign_positive()); + assert!(neg_zero.is_sign_negative()); assert!(!neg_zero.is_nan()); assert!(!neg_zero.is_normal()); assert_eq!(Fp::Zero, neg_zero.classify()); @@ -1831,8 +1527,8 @@ mod tests { assert_eq!(1.0, one); assert!(!one.is_infinite()); assert!(one.is_finite()); - assert!(one.is_positive()); - assert!(!one.is_negative()); + assert!(one.is_sign_positive()); + assert!(!one.is_sign_negative()); assert!(!one.is_nan()); assert!(one.is_normal()); assert_eq!(Fp::Normal, one.classify()); @@ -2017,27 +1713,27 @@ mod tests { } #[test] - fn test_is_positive() { - assert!(INFINITY.is_positive()); - assert!(1f64.is_positive()); - assert!(0f64.is_positive()); - assert!(!(-0f64).is_positive()); - assert!(!(-1f64).is_positive()); - assert!(!NEG_INFINITY.is_positive()); - assert!(!(1f64/NEG_INFINITY).is_positive()); - assert!(!NAN.is_positive()); + fn test_is_sign_positive() { + assert!(INFINITY.is_sign_positive()); + assert!(1f64.is_sign_positive()); + assert!(0f64.is_sign_positive()); + assert!(!(-0f64).is_sign_positive()); + assert!(!(-1f64).is_sign_positive()); + assert!(!NEG_INFINITY.is_sign_positive()); + assert!(!(1f64/NEG_INFINITY).is_sign_positive()); + assert!(!NAN.is_sign_positive()); } #[test] - fn test_is_negative() { - assert!(!INFINITY.is_negative()); - assert!(!1f64.is_negative()); - assert!(!0f64.is_negative()); - assert!((-0f64).is_negative()); - assert!((-1f64).is_negative()); - assert!(NEG_INFINITY.is_negative()); - assert!((1f64/NEG_INFINITY).is_negative()); - assert!(!NAN.is_negative()); + fn test_is_sign_negative() { + assert!(!INFINITY.is_sign_negative()); + assert!(!1f64.is_sign_negative()); + assert!(!0f64.is_sign_negative()); + assert!((-0f64).is_sign_negative()); + assert!((-1f64).is_sign_negative()); + assert!(NEG_INFINITY.is_sign_negative()); + assert!((1f64/NEG_INFINITY).is_sign_negative()); + assert!(!NAN.is_sign_negative()); } #[test] diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index b9e9433e3ee..2de03e2e72d 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -15,6 +15,7 @@ #![stable(feature = "rust1", since = "1.0.0")] #![allow(missing_docs)] +#![allow(deprecated)] #[cfg(test)] use fmt::Debug; use ops::{Add, Sub, Mul, Div, Rem, Neg}; @@ -23,22 +24,24 @@ use marker::Copy; use clone::Clone; use cmp::{PartialOrd, PartialEq}; -pub use core::num::{Int, SignedInt}; +pub use core::num::{Int, SignedInt, Zero, One}; pub use core::num::{cast, FromPrimitive, NumCast, ToPrimitive}; pub use core::num::{from_int, from_i8, from_i16, from_i32, from_i64}; pub use core::num::{from_uint, from_u8, from_u16, from_u32, from_u64}; pub use core::num::{from_f32, from_f64}; pub use core::num::{FromStrRadix, from_str_radix}; pub use core::num::{FpCategory, ParseIntError, ParseFloatError}; -pub use core::num::wrapping; +pub use core::num::{wrapping, Wrapping}; use option::Option; -#[unstable(feature = "std_misc", reason = "may be removed or relocated")] +#[unstable(feature = "std_misc", reason = "likely to be removed")] pub mod strconv; /// Mathematical operations on primitive floating point numbers. #[stable(feature = "rust1", since = "1.0.0")] +#[deprecated(since = "1.0.0", + reason = "replaced by inherent methods; use rust-lang/num for generics")] pub trait Float : Copy + Clone + NumCast @@ -272,6 +275,7 @@ pub trait Float /// ``` #[unstable(feature = "std_misc", reason = "position is undecided")] fn is_finite(self) -> bool; + /// Returns `true` if the number is neither zero, infinite, /// [subnormal][subnormal], or `NaN`. /// @@ -1148,7 +1152,7 @@ pub fn test_num<T>(ten: T, two: T) where #[cfg(test)] mod tests { - use prelude::v1::*; + use core::prelude::*; use super::*; use i8; use i16; @@ -1160,6 +1164,7 @@ mod tests { use u32; use u64; use usize; + use string::ToString; macro_rules! test_cast_20 { ($_20:expr) => ({ diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index 1c1aaeb6d53..fe55f40390e 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -11,6 +11,7 @@ // ignore-lexer-test FIXME #15679 #![allow(missing_docs)] +#![allow(deprecated)] use self::ExponentFormat::*; use self::SignificantDigits::*; diff --git a/src/libstd/old_io/buffered.rs b/src/libstd/old_io/buffered.rs index b8b7df75003..ad6cac62173 100644 --- a/src/libstd/old_io/buffered.rs +++ b/src/libstd/old_io/buffered.rs @@ -118,7 +118,7 @@ impl<R: Reader> Reader for BufferedReader<R> { let nread = { let available = try!(self.fill_buf()); let nread = cmp::min(available.len(), buf.len()); - slice::bytes::copy_memory(buf, &available[..nread]); + slice::bytes::copy_memory(&available[..nread], buf); nread }; self.pos += nread; @@ -225,7 +225,7 @@ impl<W: Writer> Writer for BufferedWriter<W> { self.inner.as_mut().unwrap().write_all(buf) } else { let dst = &mut self.buf[self.pos..]; - slice::bytes::copy_memory(dst, buf); + slice::bytes::copy_memory(buf, dst); self.pos += buf.len(); Ok(()) } diff --git a/src/libstd/old_io/comm_adapters.rs b/src/libstd/old_io/comm_adapters.rs index 35bc58fecd2..5ebf931e95c 100644 --- a/src/libstd/old_io/comm_adapters.rs +++ b/src/libstd/old_io/comm_adapters.rs @@ -91,7 +91,7 @@ impl Reader for ChanReader { Some(src) => { let dst = &mut buf[num_read..]; let count = cmp::min(src.len(), dst.len()); - bytes::copy_memory(dst, &src[..count]); + bytes::copy_memory(&src[..count], dst); count }, None => 0, diff --git a/src/libstd/old_io/extensions.rs b/src/libstd/old_io/extensions.rs index 441f0a7536e..0e5dd3aa4aa 100644 --- a/src/libstd/old_io/extensions.rs +++ b/src/libstd/old_io/extensions.rs @@ -171,7 +171,7 @@ pub fn u64_from_be_bytes(data: &[u8], start: usize, size: usize) -> u64 { unsafe { let ptr = data.as_ptr().offset(start as isize); let out = buf.as_mut_ptr(); - copy_nonoverlapping(out.offset((8 - size) as isize), ptr, size); + copy_nonoverlapping(ptr, out.offset((8 - size) as isize), size); (*(out as *const u64)).to_be() } } diff --git a/src/libstd/old_io/fs.rs b/src/libstd/old_io/fs.rs index 6aa63c395c6..c5fd10a9e85 100644 --- a/src/libstd/old_io/fs.rs +++ b/src/libstd/old_io/fs.rs @@ -1639,7 +1639,7 @@ mod test { check!(File::create(&tmpdir.join("test")).write(&bytes)); let actual = check!(File::open(&tmpdir.join("test")).read_to_end()); - assert!(actual == bytes.as_slice()); + assert!(actual == &bytes[..]); } #[test] diff --git a/src/libstd/old_io/mem.rs b/src/libstd/old_io/mem.rs index 5f20c383bb7..c28ad651f80 100644 --- a/src/libstd/old_io/mem.rs +++ b/src/libstd/old_io/mem.rs @@ -168,7 +168,7 @@ impl Reader for MemReader { let input = &self.buf[self.pos.. self.pos + write_len]; let output = &mut buf[..write_len]; assert_eq!(input.len(), output.len()); - slice::bytes::copy_memory(output, input); + slice::bytes::copy_memory(input, output); } self.pos += write_len; assert!(self.pos <= self.buf.len()); @@ -212,7 +212,7 @@ impl<'a> Reader for &'a [u8] { { let input = &self[..write_len]; let output = &mut buf[.. write_len]; - slice::bytes::copy_memory(output, input); + slice::bytes::copy_memory(input, output); } *self = &self[write_len..]; @@ -287,13 +287,13 @@ impl<'a> Writer for BufWriter<'a> { let src_len = src.len(); if dst_len >= src_len { - slice::bytes::copy_memory(dst, src); + slice::bytes::copy_memory(src, dst); self.pos += src_len; Ok(()) } else { - slice::bytes::copy_memory(dst, &src[..dst_len]); + slice::bytes::copy_memory(&src[..dst_len], dst); self.pos += dst_len; @@ -360,7 +360,7 @@ impl<'a> Reader for BufReader<'a> { let input = &self.buf[self.pos.. self.pos + write_len]; let output = &mut buf[..write_len]; assert_eq!(input.len(), output.len()); - slice::bytes::copy_memory(output, input); + slice::bytes::copy_memory(input, output); } self.pos += write_len; assert!(self.pos <= self.buf.len()); @@ -744,7 +744,7 @@ mod test { wr.write(&[5; 10]).unwrap(); } } - assert_eq!(buf.as_slice(), [5; 100].as_slice()); + assert_eq!(&buf[..], &[5; 100][..]); }); } diff --git a/src/libstd/old_io/net/ip.rs b/src/libstd/old_io/net/ip.rs index 26e1bb6550b..099fe657f26 100644 --- a/src/libstd/old_io/net/ip.rs +++ b/src/libstd/old_io/net/ip.rs @@ -414,7 +414,7 @@ pub struct ParseError; /// Some examples: /// /// ```rust,no_run -/// # #![feature(old_io, core)] +/// # #![feature(old_io, core, convert)] /// # #![allow(unused_must_use)] /// /// use std::old_io::{TcpStream, TcpListener}; @@ -435,7 +435,7 @@ pub struct ParseError; /// let tcp_l = TcpListener::bind("localhost:12345"); /// /// let mut udp_s = UdpSocket::bind(("127.0.0.1", 23451)).unwrap(); -/// udp_s.send_to([7, 7, 7].as_slice(), (Ipv4Addr(127, 0, 0, 1), 23451)); +/// udp_s.send_to([7, 7, 7].as_ref(), (Ipv4Addr(127, 0, 0, 1), 23451)); /// } /// ``` pub trait ToSocketAddr { diff --git a/src/libstd/old_io/process.rs b/src/libstd/old_io/process.rs index 06940bf6860..84d8fa31ba8 100644 --- a/src/libstd/old_io/process.rs +++ b/src/libstd/old_io/process.rs @@ -367,7 +367,7 @@ impl Command { /// # Examples /// /// ``` - /// # #![feature(old_io, core)] + /// # #![feature(old_io, core, convert)] /// use std::old_io::Command; /// /// let output = match Command::new("cat").arg("foot.txt").output() { @@ -376,8 +376,8 @@ impl Command { /// }; /// /// println!("status: {}", output.status); - /// println!("stdout: {}", String::from_utf8_lossy(output.output.as_slice())); - /// println!("stderr: {}", String::from_utf8_lossy(output.error.as_slice())); + /// println!("stdout: {}", String::from_utf8_lossy(output.output.as_ref())); + /// println!("stderr: {}", String::from_utf8_lossy(output.error.as_ref())); /// ``` pub fn output(&self) -> IoResult<ProcessOutput> { self.spawn().and_then(|p| p.wait_with_output()) diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 9aebdbe9eec..4ae3ad29c73 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -311,7 +311,7 @@ pub fn split_paths<T: BytesContainer>(unparsed: T) -> Vec<Path> { /// let key = "PATH"; /// let mut paths = os::getenv_as_bytes(key).map_or(Vec::new(), os::split_paths); /// paths.push(Path::new("/home/xyz/bin")); -/// os::setenv(key, os::join_paths(paths.as_slice()).unwrap()); +/// os::setenv(key, os::join_paths(&paths[..]).unwrap()); /// ``` #[unstable(feature = "os")] pub fn join_paths<T: BytesContainer>(paths: &[T]) -> Result<Vec<u8>, &'static str> { diff --git a/src/libstd/path.rs b/src/libstd/path.rs index 58d3ae9f7cf..36a5d1465f0 100644 --- a/src/libstd/path.rs +++ b/src/libstd/path.rs @@ -35,7 +35,6 @@ //! To build or modify paths, use `PathBuf`: //! //! ```rust -//! # #![feature(convert)] //! use std::path::PathBuf; //! //! let mut path = PathBuf::from("c:\\"); @@ -521,9 +520,9 @@ impl<'a> Component<'a> { pub fn as_os_str(self) -> &'a OsStr { match self { Component::Prefix(p) => p.as_os_str(), - Component::RootDir => OsStr::from_str(MAIN_SEP_STR), - Component::CurDir => OsStr::from_str("."), - Component::ParentDir => OsStr::from_str(".."), + Component::RootDir => OsStr::new(MAIN_SEP_STR), + Component::CurDir => OsStr::new("."), + Component::ParentDir => OsStr::new(".."), Component::Normal(path) => path, } } @@ -893,7 +892,6 @@ impl<'a> cmp::Ord for Components<'a> { /// # Examples /// /// ``` -/// # #![feature(convert)] /// use std::path::PathBuf; /// /// let mut path = PathBuf::from("c:\\"); @@ -918,6 +916,12 @@ impl PathBuf { PathBuf { inner: OsString::new() } } + /// Coerce to a `Path` slice. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn as_path(&self) -> &Path { + self + } + /// Extend `self` with `path`. /// /// If `path` is absolute, it replaces the current path. @@ -985,7 +989,6 @@ impl PathBuf { /// # Examples /// /// ``` - /// # #![feature(convert)] /// use std::path::PathBuf; /// /// let mut buf = PathBuf::from("/"); diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index 611dd85a71b..297eccb9f76 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -51,6 +51,3 @@ #[doc(no_inline)] pub use string::{String, ToString}; #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use vec::Vec; - -// FIXME(#23454) should these be here? -#[doc(no_inline)] pub use num::wrapping::{Wrapping, WrappingOps}; diff --git a/src/libstd/process.rs b/src/libstd/process.rs index b4bd513e8f0..7033ab5f09f 100644 --- a/src/libstd/process.rs +++ b/src/libstd/process.rs @@ -678,7 +678,7 @@ mod tests { fn test_process_output_output() { let Output {status, stdout, stderr} = Command::new("echo").arg("hello").output().unwrap(); - let output_str = str::from_utf8(stdout.as_slice()).unwrap(); + let output_str = str::from_utf8(&stdout[..]).unwrap(); assert!(status.success()); assert_eq!(output_str.trim().to_string(), "hello"); @@ -720,7 +720,7 @@ mod tests { let prog = Command::new("echo").arg("hello").stdout(Stdio::piped()) .spawn().unwrap(); let Output {status, stdout, stderr} = prog.wait_with_output().unwrap(); - let output_str = str::from_utf8(stdout.as_slice()).unwrap(); + let output_str = str::from_utf8(&stdout[..]).unwrap(); assert!(status.success()); assert_eq!(output_str.trim().to_string(), "hello"); @@ -855,7 +855,7 @@ mod tests { cmd.env("PATH", &p); } let result = cmd.output().unwrap(); - let output = String::from_utf8_lossy(result.stdout.as_slice()).to_string(); + let output = String::from_utf8_lossy(&result.stdout[..]).to_string(); assert!(output.contains("RUN_TEST_NEW_ENV=123"), "didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output); @@ -864,7 +864,7 @@ mod tests { #[test] fn test_add_to_env() { let result = env_cmd().env("RUN_TEST_NEW_ENV", "123").output().unwrap(); - let output = String::from_utf8_lossy(result.stdout.as_slice()).to_string(); + let output = String::from_utf8_lossy(&result.stdout[..]).to_string(); assert!(output.contains("RUN_TEST_NEW_ENV=123"), "didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output); diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index b2b87bb6c44..e14f32865fa 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -114,7 +114,7 @@ //! ``` //! //! Reading from a channel with a timeout requires to use a Timer together -//! with the channel. You can use the select! macro to select either and +//! with the channel. You can use the `select!` macro to select either and //! handle the timeout case. This first example will break out of the loop //! after 10 seconds no matter what: //! diff --git a/src/libstd/sys/common/mod.rs b/src/libstd/sys/common/mod.rs index a8769ba99e8..d2e2f1044d6 100644 --- a/src/libstd/sys/common/mod.rs +++ b/src/libstd/sys/common/mod.rs @@ -14,6 +14,7 @@ use old_io::{self, IoError, IoResult}; use prelude::v1::*; use sys::{last_error, retry}; use ffi::CString; +#[allow(deprecated)] // Int use num::Int; #[allow(deprecated)] diff --git a/src/libstd/sys/common/net2.rs b/src/libstd/sys/common/net2.rs index a8ee40639e3..e787442052d 100644 --- a/src/libstd/sys/common/net2.rs +++ b/src/libstd/sys/common/net2.rs @@ -259,6 +259,12 @@ impl TcpStream { } } +impl FromInner<Socket> for TcpStream { + fn from_inner(socket: Socket) -> TcpStream { + TcpStream { inner: socket } + } +} + //////////////////////////////////////////////////////////////////////////////// // TCP listeners //////////////////////////////////////////////////////////////////////////////// @@ -312,6 +318,12 @@ impl TcpListener { } } +impl FromInner<Socket> for TcpListener { + fn from_inner(socket: Socket) -> TcpListener { + TcpListener { inner: socket } + } +} + //////////////////////////////////////////////////////////////////////////////// // UDP //////////////////////////////////////////////////////////////////////////////// @@ -424,3 +436,9 @@ impl UdpSocket { self.inner.duplicate().map(|s| UdpSocket { inner: s }) } } + +impl FromInner<Socket> for UdpSocket { + fn from_inner(socket: Socket) -> UdpSocket { + UdpSocket { inner: socket } + } +} diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index 315df411179..987a12293da 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -37,6 +37,7 @@ use fmt; use hash::{Hash, Hasher}; use iter::{FromIterator, IntoIterator}; use mem; +#[allow(deprecated)] // Int use num::Int; use ops; use slice; @@ -344,8 +345,8 @@ impl Wtf8Buf { Some((surrogate_pos, _)) => { pos = surrogate_pos + 3; slice::bytes::copy_memory( + UTF8_REPLACEMENT_CHARACTER, &mut self.bytes[surrogate_pos .. pos], - UTF8_REPLACEMENT_CHARACTER ); }, None => return unsafe { String::from_utf8_unchecked(self.bytes) } diff --git a/src/libstd/sys/unix/ext.rs b/src/libstd/sys/unix/ext.rs index 0805949d560..fbfbb40701f 100644 --- a/src/libstd/sys/unix/ext.rs +++ b/src/libstd/sys/unix/ext.rs @@ -32,102 +32,171 @@ #![stable(feature = "rust1", since = "1.0.0")] /// Unix-specific extensions to general I/O primitives -#[unstable(feature = "io_ext", - reason = "may want a slightly different organization or a more \ - general file descriptor primitive")] +#[stable(feature = "rust1", since = "1.0.0")] pub mod io { #[allow(deprecated)] use old_io; use fs; use libc; use net; - use sys_common::AsInner; + use sys_common::{net2, AsInner, FromInner}; + use sys; /// Raw file descriptors. - pub type Fd = libc::c_int; - - /// Extract raw file descriptor + #[stable(feature = "rust1", since = "1.0.0")] + pub type RawFd = libc::c_int; + + /// A trait to extract the raw unix file descriptor from an underlying + /// object. + /// + /// This is only available on unix platforms and must be imported in order + /// to call the method. Windows platforms have a corresponding `AsRawHandle` + /// and `AsRawSocket` set of traits. + #[stable(feature = "rust1", since = "1.0.0")] pub trait AsRawFd { - /// Extract the raw file descriptor, without taking any ownership. - fn as_raw_fd(&self) -> Fd; + /// Extract the raw file descriptor. + /// + /// This method does **not** pass ownership of the raw file descriptor + /// to the caller. The descriptor is only guarantee to be valid while + /// the original object has not yet been destroyed. + #[stable(feature = "rust1", since = "1.0.0")] + fn as_raw_fd(&self) -> RawFd; + } + + /// A trait to express the ability to construct an object from a raw file + /// descriptor. + #[unstable(feature = "from_raw_os", + reason = "recent addition to std::os::unix::io")] + pub trait FromRawFd { + /// Constructs a new instances of `Self` from the given raw file + /// descriptor. + /// + /// This function **consumes ownership** of the specified file + /// descriptor. The returned object will take responsibility for closing + /// it when the object goes out of scope. + /// + /// Callers should normally only pass in a valid file descriptor to this + /// method or otherwise methods will return errors. + fn from_raw_fd(fd: RawFd) -> Self; } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for old_io::fs::File { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd() } } + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for fs::File { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd().raw() } } + #[unstable(feature = "from_raw_os", reason = "trait is unstable")] + impl FromRawFd for fs::File { + fn from_raw_fd(fd: RawFd) -> fs::File { + fs::File::from_inner(sys::fs2::File::from_inner(fd)) + } + } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for old_io::pipe::PipeStream { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for old_io::net::pipe::UnixStream { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for old_io::net::pipe::UnixListener { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for old_io::net::pipe::UnixAcceptor { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd() } } + #[stable(feature = "rust1", since = "1.0.0")] #[allow(deprecated)] impl AsRawFd for old_io::net::tcp::TcpStream { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd() } } + #[stable(feature = "rust1", since = "1.0.0")] #[allow(deprecated)] impl AsRawFd for old_io::net::tcp::TcpListener { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd() } } + #[stable(feature = "rust1", since = "1.0.0")] #[allow(deprecated)] impl AsRawFd for old_io::net::tcp::TcpAcceptor { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for old_io::net::udp::UdpSocket { - fn as_raw_fd(&self) -> Fd { + fn as_raw_fd(&self) -> RawFd { self.as_inner().fd() } } + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for net::TcpStream { - fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } + fn as_raw_fd(&self) -> RawFd { *self.as_inner().socket().as_inner() } } + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for net::TcpListener { - fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } + fn as_raw_fd(&self) -> RawFd { *self.as_inner().socket().as_inner() } } + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawFd for net::UdpSocket { - fn as_raw_fd(&self) -> Fd { *self.as_inner().socket().as_inner() } + fn as_raw_fd(&self) -> RawFd { *self.as_inner().socket().as_inner() } + } + + #[unstable(feature = "from_raw_os", reason = "trait is unstable")] + impl FromRawFd for net::TcpStream { + fn from_raw_fd(fd: RawFd) -> net::TcpStream { + let socket = sys::net::Socket::from_inner(fd); + net::TcpStream::from_inner(net2::TcpStream::from_inner(socket)) + } + } + #[unstable(feature = "from_raw_os", reason = "trait is unstable")] + impl FromRawFd for net::TcpListener { + fn from_raw_fd(fd: RawFd) -> net::TcpListener { + let socket = sys::net::Socket::from_inner(fd); + net::TcpListener::from_inner(net2::TcpListener::from_inner(socket)) + } + } + #[unstable(feature = "from_raw_os", reason = "trait is unstable")] + impl FromRawFd for net::UdpSocket { + fn from_raw_fd(fd: RawFd) -> net::UdpSocket { + let socket = sys::net::Socket::from_inner(fd); + net::UdpSocket::from_inner(net2::UdpSocket::from_inner(socket)) + } } } @@ -138,7 +207,7 @@ pub mod io { /// Unix-specific extension to the primitives in the `std::ffi` module #[stable(feature = "rust1", since = "1.0.0")] pub mod ffi { - use ffi::{CString, NulError, OsStr, OsString}; + use ffi::{OsStr, OsString}; use mem; use prelude::v1::*; use sys::os_str::Buf; @@ -175,10 +244,6 @@ pub mod ffi { /// Get the underlying byte view of the `OsStr` slice. #[stable(feature = "rust1", since = "1.0.0")] fn as_bytes(&self) -> &[u8]; - - /// Convert the `OsStr` slice into a `CString`. - #[stable(feature = "rust1", since = "1.0.0")] - fn to_cstring(&self) -> Result<CString, NulError>; } #[stable(feature = "rust1", since = "1.0.0")] @@ -189,9 +254,6 @@ pub mod ffi { fn as_bytes(&self) -> &[u8] { &self.as_inner().inner } - fn to_cstring(&self) -> Result<CString, NulError> { - CString::new(self.as_bytes()) - } } } @@ -302,7 +364,7 @@ pub mod process { #[stable(feature = "rust1", since = "1.0.0")] pub mod prelude { #[doc(no_inline)] - pub use super::io::{Fd, AsRawFd}; + pub use super::io::{RawFd, AsRawFd}; #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::ffi::{OsStrExt, OsStringExt}; #[doc(no_inline)] diff --git a/src/libstd/sys/unix/fs2.rs b/src/libstd/sys/unix/fs2.rs index 202e5ddaec4..c5d3dce2634 100644 --- a/src/libstd/sys/unix/fs2.rs +++ b/src/libstd/sys/unix/fs2.rs @@ -276,8 +276,14 @@ impl File { } fn cstr(path: &Path) -> io::Result<CString> { - let cstring = try!(path.as_os_str().to_cstring()); - Ok(cstring) + path.as_os_str().to_cstring().ok_or( + io::Error::new(io::ErrorKind::InvalidInput, "path contained a null", None)) +} + +impl FromInner<c_int> for File { + fn from_inner(fd: c_int) -> File { + File(FileDesc::new(fd)) + } } pub fn mkdir(p: &Path) -> io::Result<()> { diff --git a/src/libstd/sys/unix/mod.rs b/src/libstd/sys/unix/mod.rs index 5555eec4f39..e8409bb4fd4 100644 --- a/src/libstd/sys/unix/mod.rs +++ b/src/libstd/sys/unix/mod.rs @@ -171,6 +171,7 @@ pub fn retry<T, F> (mut f: F) -> T where } } +#[allow(deprecated)] pub fn cvt<T: SignedInt>(t: T) -> io::Result<T> { let one: T = Int::one(); if t == -one { @@ -180,6 +181,7 @@ pub fn cvt<T: SignedInt>(t: T) -> io::Result<T> { } } +#[allow(deprecated)] pub fn cvt_r<T, F>(mut f: F) -> io::Result<T> where T: SignedInt, F: FnMut() -> T { diff --git a/src/libstd/sys/unix/net.rs b/src/libstd/sys/unix/net.rs index b22fa33e562..00b907ce10c 100644 --- a/src/libstd/sys/unix/net.rs +++ b/src/libstd/sys/unix/net.rs @@ -17,7 +17,7 @@ use str; use sys::c; use net::SocketAddr; use sys::fd::FileDesc; -use sys_common::AsInner; +use sys_common::{AsInner, FromInner}; pub use sys::{cvt, cvt_r}; @@ -72,3 +72,7 @@ impl Socket { impl AsInner<c_int> for Socket { fn as_inner(&self) -> &c_int { self.0.as_inner() } } + +impl FromInner<c_int> for Socket { + fn from_inner(fd: c_int) -> Socket { Socket(FileDesc::new(fd)) } +} diff --git a/src/libstd/sys/unix/process2.rs b/src/libstd/sys/unix/process2.rs index 20c409154b8..c2a8b26aef4 100644 --- a/src/libstd/sys/unix/process2.rs +++ b/src/libstd/sys/unix/process2.rs @@ -54,7 +54,7 @@ impl Command { self.args.push(arg.to_cstring().unwrap()) } pub fn args<'a, I: Iterator<Item = &'a OsStr>>(&mut self, args: I) { - self.args.extend(args.map(|s| OsStrExt::to_cstring(s).unwrap())) + self.args.extend(args.map(|s| s.to_cstring().unwrap())) } fn init_env_map(&mut self) { if self.env.is_none() { diff --git a/src/libstd/sys/windows/ext.rs b/src/libstd/sys/windows/ext.rs index 7955397892b..2dd61861bd6 100644 --- a/src/libstd/sys/windows/ext.rs +++ b/src/libstd/sys/windows/ext.rs @@ -16,112 +16,188 @@ #![stable(feature = "rust1", since = "1.0.0")] -#[unstable(feature = "io_ext", - reason = "organization may change slightly and the primitives \ - provided may be tweaked")] +#[stable(feature = "rust1", since = "1.0.0")] pub mod io { use fs; use libc; use net; - use sys_common::AsInner; + use sys_common::{net2, AsInner, FromInner}; + use sys; #[allow(deprecated)] use old_io; /// Raw HANDLEs. - pub type Handle = libc::HANDLE; + #[stable(feature = "rust1", since = "1.0.0")] + pub type RawHandle = libc::HANDLE; /// Raw SOCKETs. - pub type Socket = libc::SOCKET; + #[stable(feature = "rust1", since = "1.0.0")] + pub type RawSocket = libc::SOCKET; /// Extract raw handles. + #[stable(feature = "rust1", since = "1.0.0")] pub trait AsRawHandle { /// Extract the raw handle, without taking any ownership. - fn as_raw_handle(&self) -> Handle; + #[stable(feature = "rust1", since = "1.0.0")] + fn as_raw_handle(&self) -> RawHandle; + } + + /// Construct I/O objects from raw handles. + #[unstable(feature = "from_raw_os", + reason = "recent addition to the std::os::windows::io module")] + pub trait FromRawHandle { + /// Construct a new I/O object from the specified raw handle. + /// + /// This function will **consume ownership** of the handle given, + /// passing responsibility for closing the handle to the returned + /// object. + fn from_raw_handle(handle: RawHandle) -> Self; } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawHandle for old_io::fs::File { - fn as_raw_handle(&self) -> Handle { + fn as_raw_handle(&self) -> RawHandle { self.as_inner().handle() } } + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawHandle for fs::File { - fn as_raw_handle(&self) -> Handle { + fn as_raw_handle(&self) -> RawHandle { self.as_inner().handle().raw() } } + #[unstable(feature = "from_raw_os", reason = "trait is unstable")] + impl FromRawHandle for fs::File { + fn from_raw_handle(handle: RawHandle) -> fs::File { + fs::File::from_inner(sys::fs2::File::from_inner(handle)) + } + } + #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawHandle for old_io::pipe::PipeStream { - fn as_raw_handle(&self) -> Handle { + fn as_raw_handle(&self) -> RawHandle { self.as_inner().handle() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawHandle for old_io::net::pipe::UnixStream { - fn as_raw_handle(&self) -> Handle { + fn as_raw_handle(&self) -> RawHandle { self.as_inner().handle() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawHandle for old_io::net::pipe::UnixListener { - fn as_raw_handle(&self) -> Handle { + fn as_raw_handle(&self) -> RawHandle { self.as_inner().handle() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawHandle for old_io::net::pipe::UnixAcceptor { - fn as_raw_handle(&self) -> Handle { + fn as_raw_handle(&self) -> RawHandle { self.as_inner().handle() } } /// Extract raw sockets. + #[stable(feature = "rust1", since = "1.0.0")] pub trait AsRawSocket { - fn as_raw_socket(&self) -> Socket; + /// Extract the underlying raw socket from this object. + #[stable(feature = "rust1", since = "1.0.0")] + fn as_raw_socket(&self) -> RawSocket; + } + + /// Create I/O objects from raw sockets. + #[unstable(feature = "from_raw_os", reason = "recent addition to module")] + pub trait FromRawSocket { + /// Creates a new I/O object from the given raw socket. + /// + /// This function will **consume ownership** of the socket provided and + /// it will be closed when the returned object goes out of scope. + fn from_raw_socket(sock: RawSocket) -> Self; } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawSocket for old_io::net::tcp::TcpStream { - fn as_raw_socket(&self) -> Socket { + fn as_raw_socket(&self) -> RawSocket { self.as_inner().fd() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawSocket for old_io::net::tcp::TcpListener { - fn as_raw_socket(&self) -> Socket { + fn as_raw_socket(&self) -> RawSocket { self.as_inner().socket() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawSocket for old_io::net::tcp::TcpAcceptor { - fn as_raw_socket(&self) -> Socket { + fn as_raw_socket(&self) -> RawSocket { self.as_inner().socket() } } #[allow(deprecated)] + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawSocket for old_io::net::udp::UdpSocket { - fn as_raw_socket(&self) -> Socket { + fn as_raw_socket(&self) -> RawSocket { self.as_inner().fd() } } + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawSocket for net::TcpStream { - fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() } + fn as_raw_socket(&self) -> RawSocket { + *self.as_inner().socket().as_inner() + } } + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawSocket for net::TcpListener { - fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() } + fn as_raw_socket(&self) -> RawSocket { + *self.as_inner().socket().as_inner() + } } + #[stable(feature = "rust1", since = "1.0.0")] impl AsRawSocket for net::UdpSocket { - fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() } + fn as_raw_socket(&self) -> RawSocket { + *self.as_inner().socket().as_inner() + } + } + + #[unstable(feature = "from_raw_os", reason = "trait is unstable")] + impl FromRawSocket for net::TcpStream { + fn from_raw_socket(sock: RawSocket) -> net::TcpStream { + let sock = sys::net::Socket::from_inner(sock); + net::TcpStream::from_inner(net2::TcpStream::from_inner(sock)) + } + } + #[unstable(feature = "from_raw_os", reason = "trait is unstable")] + impl FromRawSocket for net::TcpListener { + fn from_raw_socket(sock: RawSocket) -> net::TcpListener { + let sock = sys::net::Socket::from_inner(sock); + net::TcpListener::from_inner(net2::TcpListener::from_inner(sock)) + } + } + #[unstable(feature = "from_raw_os", reason = "trait is unstable")] + impl FromRawSocket for net::UdpSocket { + fn from_raw_socket(sock: RawSocket) -> net::UdpSocket { + let sock = sys::net::Socket::from_inner(sock); + net::UdpSocket::from_inner(net2::UdpSocket::from_inner(sock)) + } } } @@ -230,7 +306,7 @@ pub mod fs { #[stable(feature = "rust1", since = "1.0.0")] pub mod prelude { #[doc(no_inline)] - pub use super::io::{Socket, Handle, AsRawSocket, AsRawHandle}; + pub use super::io::{RawSocket, RawHandle, AsRawSocket, AsRawHandle}; #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::ffi::{OsStrExt, OsStringExt}; #[doc(no_inline)] diff --git a/src/libstd/sys/windows/fs2.rs b/src/libstd/sys/windows/fs2.rs index 99835265111..d03e45649ed 100644 --- a/src/libstd/sys/windows/fs2.rs +++ b/src/libstd/sys/windows/fs2.rs @@ -20,11 +20,12 @@ use mem; use path::{Path, PathBuf}; use ptr; use sync::Arc; -use sys::handle::Handle as RawHandle; +use sys::handle::Handle; use sys::{c, cvt}; +use sys_common::FromInner; use vec::Vec; -pub struct File { handle: RawHandle } +pub struct File { handle: Handle } pub struct FileAttr { data: c::WIN32_FILE_ATTRIBUTE_DATA } pub struct ReadDir { @@ -192,7 +193,7 @@ impl File { if handle == libc::INVALID_HANDLE_VALUE { Err(Error::last_os_error()) } else { - Ok(File { handle: RawHandle::new(handle) }) + Ok(File { handle: Handle::new(handle) }) } } @@ -260,7 +261,13 @@ impl File { Ok(newpos as u64) } - pub fn handle(&self) -> &RawHandle { &self.handle } + pub fn handle(&self) -> &Handle { &self.handle } +} + +impl FromInner<libc::HANDLE> for File { + fn from_inner(handle: libc::HANDLE) -> File { + File { handle: Handle::new(handle) } + } } pub fn to_utf16(s: &Path) -> Vec<u16> { diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index b1ceac9b902..e9d5fca531f 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -18,6 +18,7 @@ use ffi::{OsStr, OsString}; use io::{self, ErrorKind}; use libc; use mem; +#[allow(deprecated)] use num::Int; use old_io::{self, IoResult, IoError}; use os::windows::ffi::{OsStrExt, OsStringExt}; @@ -315,6 +316,7 @@ pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] { } } +#[allow(deprecated)] fn cvt<I: Int>(i: I) -> io::Result<I> { if i == Int::zero() { Err(io::Error::last_os_error()) diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs index 734268c70ac..12a8ef99d76 100644 --- a/src/libstd/sys/windows/net.rs +++ b/src/libstd/sys/windows/net.rs @@ -15,11 +15,12 @@ use libc::consts::os::extra::INVALID_SOCKET; use libc::{self, c_int, c_void}; use mem; use net::SocketAddr; +#[allow(deprecated)] use num::{SignedInt, Int}; use rt; use sync::{Once, ONCE_INIT}; use sys::c; -use sys_common::AsInner; +use sys_common::{AsInner, FromInner}; pub type wrlen_t = i32; @@ -50,6 +51,7 @@ fn last_error() -> io::Error { /// function must be called before another call to the socket API is made. /// /// FIXME: generics needed? +#[allow(deprecated)] pub fn cvt<T: SignedInt>(t: T) -> io::Result<T> { let one: T = Int::one(); if t == -one { @@ -67,6 +69,7 @@ pub fn cvt_gai(err: c_int) -> io::Result<()> { } /// Provides the functionality of `cvt` for a closure. +#[allow(deprecated)] pub fn cvt_r<T: SignedInt, F>(mut f: F) -> io::Result<T> where F: FnMut() -> T { cvt(f()) } @@ -123,10 +126,14 @@ impl Socket { impl Drop for Socket { fn drop(&mut self) { - unsafe { cvt(libc::closesocket(self.0)).unwrap(); } + let _ = unsafe { libc::closesocket(self.0) }; } } impl AsInner<libc::SOCKET> for Socket { fn as_inner(&self) -> &libc::SOCKET { &self.0 } } + +impl FromInner<libc::SOCKET> for Socket { + fn from_inner(sock: libc::SOCKET) -> Socket { Socket(sock) } +} diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index 167db1e8ac2..5cd90b0902b 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -31,7 +31,7 @@ use ptr; use slice; use sys::c; use sys::fs::FileDesc; -use sys::handle::Handle as RawHandle; +use sys::handle::Handle; use libc::funcs::extra::kernel32::{ GetEnvironmentStringsW, @@ -369,7 +369,7 @@ pub fn home_dir() -> Option<PathBuf> { if c::OpenProcessToken(me, c::TOKEN_READ, &mut token) == 0 { return None } - let _handle = RawHandle::new(token); + let _handle = Handle::new(token); super::fill_utf16_buf_new(|buf, mut sz| { match c::GetUserProfileDirectoryW(token, buf, &mut sz) { 0 if libc::GetLastError() != 0 => 0, diff --git a/src/libstd/thread/mod.rs b/src/libstd/thread/mod.rs index 074030bd07b..863291ff542 100644 --- a/src/libstd/thread/mod.rs +++ b/src/libstd/thread/mod.rs @@ -810,7 +810,6 @@ mod test { use any::Any; use sync::mpsc::{channel, Sender}; - use boxed::BoxAny; use result; use std::old_io::{ChanReader, ChanWriter}; use super::{Builder}; diff --git a/src/libstd/time/duration.rs b/src/libstd/time/duration.rs index 958417d864c..9b79b483b28 100644 --- a/src/libstd/time/duration.rs +++ b/src/libstd/time/duration.rs @@ -16,6 +16,7 @@ use {fmt, i64}; use ops::{Add, Sub, Mul, Div, Neg, FnOnce}; use option::Option; use option::Option::{Some, None}; +#[allow(deprecated)] // Int use num::Int; use result::Result::Ok; diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index f815e8e7843..ce1539c62f8 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -66,6 +66,7 @@ use parse::lexer; use ptr::P; use std::fmt; +#[allow(deprecated)] use std::num::Int; use std::rc::Rc; use serialize::{Encodable, Decodable, Encoder, Decoder}; @@ -1141,6 +1142,7 @@ pub enum Sign { } impl Sign { + #[allow(deprecated)] // Int pub fn new<T:Int>(n: T) -> Sign { if n < Int::zero() { Minus diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 1b03a180720..98ffc054394 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -92,7 +92,7 @@ const KNOWN_FEATURES: &'static [(&'static str, &'static str, Status)] = &[ ("main", "1.0.0", Active), // Deprecate after snapshot - // SNAP a923278 + // SNAP 5520801 ("unsafe_destructor", "1.0.0", Active), // A temporary feature gate used to enable parser extensions needed diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index c471d9e3179..0980acd3433 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -37,7 +37,6 @@ #![feature(unicode)] #![feature(path_ext)] #![feature(str_char)] -#![feature(convert)] #![feature(into_cow)] #![feature(slice_patterns)] diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 532b632fac8..78470f00207 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -20,7 +20,6 @@ use std::borrow::{IntoCow, Cow}; use std::char; use std::fmt; use std::mem::replace; -use std::num; use std::rc::Rc; pub use ext::tt::transcribe::{TtReader, new_tt_reader, new_tt_reader_with_doc_flag}; @@ -621,9 +620,9 @@ impl<'a> StringReader<'a> { let base = 10; // find the integer representing the name - self.scan_digits(base); + self.scan_digits(base, base); let encoded_name : u32 = self.with_str_from(start_bpos, |s| { - num::from_str_radix(s, 10).unwrap_or_else(|_| { + u32::from_str_radix(s, 10).unwrap_or_else(|_| { panic!("expected digits representing a name, got {:?}, {}, range [{:?},{:?}]", s, whence, start_bpos, self.last_pos); }) @@ -639,9 +638,9 @@ impl<'a> StringReader<'a> { // find the integer representing the ctxt let start_bpos = self.last_pos; - self.scan_digits(base); + self.scan_digits(base, base); let encoded_ctxt : ast::SyntaxContext = self.with_str_from(start_bpos, |s| { - num::from_str_radix(s, 10).unwrap_or_else(|_| { + u32::from_str_radix(s, 10).unwrap_or_else(|_| { panic!("expected digits representing a ctxt, got {:?}, {}", s, whence); }) }); @@ -653,16 +652,28 @@ impl<'a> StringReader<'a> { ctxt: encoded_ctxt, } } - /// Scan through any digits (base `radix`) or underscores, and return how - /// many digits there were. - fn scan_digits(&mut self, radix: u32) -> usize { + /// Scan through any digits (base `scan_radix`) or underscores, + /// and return how many digits there were. + /// + /// `real_radix` represents the true radix of the number we're + /// interested in, and errors will be emitted for any digits + /// between `real_radix` and `scan_radix`. + fn scan_digits(&mut self, real_radix: u32, scan_radix: u32) -> usize { + assert!(real_radix <= scan_radix); let mut len = 0; loop { let c = self.curr; if c == Some('_') { debug!("skipping a _"); self.bump(); continue; } - match c.and_then(|cc| cc.to_digit(radix)) { + match c.and_then(|cc| cc.to_digit(scan_radix)) { Some(_) => { debug!("{:?} in scan_digits", c); + // check that the hypothetical digit is actually + // in range for the true radix + if c.unwrap().to_digit(real_radix).is_none() { + self.err_span_(self.last_pos, self.pos, + &format!("invalid digit for a base {} literal", + real_radix)); + } len += 1; self.bump(); } @@ -681,11 +692,11 @@ impl<'a> StringReader<'a> { if c == '0' { match self.curr.unwrap_or('\0') { - 'b' => { self.bump(); base = 2; num_digits = self.scan_digits(2); } - 'o' => { self.bump(); base = 8; num_digits = self.scan_digits(8); } - 'x' => { self.bump(); base = 16; num_digits = self.scan_digits(16); } + 'b' => { self.bump(); base = 2; num_digits = self.scan_digits(2, 10); } + 'o' => { self.bump(); base = 8; num_digits = self.scan_digits(8, 10); } + 'x' => { self.bump(); base = 16; num_digits = self.scan_digits(16, 16); } '0'...'9' | '_' | '.' => { - num_digits = self.scan_digits(10) + 1; + num_digits = self.scan_digits(10, 10) + 1; } _ => { // just a 0 @@ -693,7 +704,7 @@ impl<'a> StringReader<'a> { } } } else if c.is_digit(10) { - num_digits = self.scan_digits(10) + 1; + num_digits = self.scan_digits(10, 10) + 1; } else { num_digits = 0; } @@ -712,7 +723,7 @@ impl<'a> StringReader<'a> { // with a number self.bump(); if self.curr.unwrap_or('\0').is_digit(10) { - self.scan_digits(10); + self.scan_digits(10, 10); self.scan_float_exponent(); } let last_pos = self.last_pos; @@ -935,7 +946,7 @@ impl<'a> StringReader<'a> { if self.curr_is('-') || self.curr_is('+') { self.bump(); } - if self.scan_digits(10) == 0 { + if self.scan_digits(10, 10) == 0 { self.err_span_(self.last_pos, self.pos, "expected at least one digit in exponent") } } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index bea42a88bf5..f59e1d8214a 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -21,6 +21,7 @@ use std::cell::{Cell, RefCell}; use std::fs::File; use std::io::Read; use std::iter; +#[allow(deprecated)] // Int use std::num::Int; use std::path::{Path, PathBuf}; use std::rc::Rc; @@ -372,7 +373,7 @@ pub fn maybe_aborted<T>(result: T, p: Parser) -> T { /// well. Can take any slice prefixed by a character escape. Returns the /// character and the number of characters consumed. pub fn char_lit(lit: &str) -> (char, isize) { - use std::{num, char}; + use std::char; let mut chars = lit.chars(); let c = match (chars.next(), chars.next()) { @@ -399,7 +400,7 @@ pub fn char_lit(lit: &str) -> (char, isize) { let msg2 = &msg[..]; fn esc(len: usize, lit: &str) -> Option<(char, isize)> { - num::from_str_radix(&lit[2..len], 16).ok() + u32::from_str_radix(&lit[2..len], 16).ok() .and_then(char::from_u32) .map(|x| (x, len as isize)) } @@ -408,7 +409,7 @@ pub fn char_lit(lit: &str) -> (char, isize) { if lit.as_bytes()[2] == b'{' { let idx = lit.find('}').expect(msg2); let subslice = &lit[3..idx]; - num::from_str_radix(subslice, 16).ok() + u32::from_str_radix(subslice, 16).ok() .and_then(char::from_u32) .map(|x| (x, subslice.chars().count() as isize + 4)) } else { @@ -582,7 +583,7 @@ pub fn byte_lit(lit: &str) -> (u8, usize) { b'\'' => b'\'', b'0' => b'\0', _ => { - match ::std::num::from_str_radix::<u64>(&lit[2..4], 16).ok() { + match u64::from_str_radix(&lit[2..4], 16).ok() { Some(c) => if c > 0xFF { panic!(err(2)) @@ -733,9 +734,22 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> debug!("integer_lit: the type is {:?}, base {:?}, the new string is {:?}, the original \ string was {:?}, the original suffix was {:?}", ty, base, s, orig, suffix); - let res: u64 = match ::std::num::from_str_radix(s, base).ok() { + let res = match u64::from_str_radix(s, base).ok() { Some(r) => r, - None => { sd.span_err(sp, "int literal is too large"); 0 } + None => { + // small bases are lexed as if they were base 10, e.g, the string + // might be `0b10201`. This will cause the conversion above to fail, + // but these cases have errors in the lexer: we don't want to emit + // two errors, and we especially don't want to emit this error since + // it isn't necessarily true. + let already_errored = base < 10 && + s.chars().any(|c| c.to_digit(10).map_or(false, |d| d >= base)); + + if !already_errored { + sd.span_err(sp, "int literal is too large"); + } + 0 + } }; // adjust the sign diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs index ed2d00d6ad7..38d58f042b9 100644 --- a/src/libterm/lib.rs +++ b/src/libterm/lib.rs @@ -62,7 +62,6 @@ #![feature(std_misc)] #![feature(str_char)] #![feature(path_ext)] -#![feature(convert)] #![cfg_attr(windows, feature(libc))] #[macro_use] extern crate log; diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index ee0d190d729..a08d125c233 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -44,7 +44,6 @@ #![feature(libc)] #![feature(set_stdio)] #![feature(os)] -#![feature(convert)] #![cfg_attr(test, feature(old_io))] extern crate getopts; diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index e20e6d4f29b..94dee5ccc36 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -9,6 +9,7 @@ // except according to those terms. #![allow(missing_docs)] +#![allow(deprecated)] // Float use std::cmp::Ordering::{self, Less, Greater, Equal}; use std::mem; diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs index de3a593143e..3f9dd8ab635 100644 --- a/src/libunicode/u_str.rs +++ b/src/libunicode/u_str.rs @@ -22,7 +22,6 @@ use core::char; use core::cmp; use core::iter::{Filter, AdditiveIterator}; use core::mem; -use core::num::Int; use core::slice; use core::str::Split; diff --git a/src/rustbook/main.rs b/src/rustbook/main.rs index 4a652f846ed..09fcd518c1e 100644 --- a/src/rustbook/main.rs +++ b/src/rustbook/main.rs @@ -15,7 +15,6 @@ #![feature(rustdoc)] #![feature(rustc_private)] #![feature(path_relative_from)] -#![feature(convert)] extern crate rustdoc; extern crate rustc_back; diff --git a/src/snapshots.txt b/src/snapshots.txt index 8b05f7c8955..74d8b222c54 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,3 +1,13 @@ +S 2015-03-27 5520801 + bitrig-x86_64 41de2c7a69a1ac648d3fa3b65e96a29bdc122163 + freebsd-x86_64 0910bbad35e213f679d0433884fd51398eb3bc8d + linux-i386 1ef82402ed16f5a6d2f87a9a62eaa83170e249ec + linux-x86_64 ef2154372e97a3cb687897d027fd51c8f2c5f349 + macos-i386 0310b1a970f2da7e61770fd14dbbbdca3b518234 + macos-x86_64 5f35d9c920b8083a7420ef8cf5b00d5ef3085dfa + winnt-i386 808b7961f85872f04ec15ad0d3e9e23ae9bc0c3b + winnt-x86_64 903a99a58f57a9bd9848cc68a2445dda881f1ee8 + S 2015-03-25 a923278 bitrig-x86_64 41de2c7a69a1ac648d3fa3b65e96a29bdc122163 freebsd-x86_64 cd02c86a9218da73b2a45aff293787010d33bf3e diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs index 709b23ef9dd..7c4cc0eaab7 100644 --- a/src/test/bench/shootout-fasta-redux.rs +++ b/src/test/bench/shootout-fasta-redux.rs @@ -126,10 +126,9 @@ impl<'a, W: Writer> RepeatFasta<'a, W> { let mut buf = repeat(0).take(alu_len + LINE_LEN).collect::<Vec<_>>(); let alu: &[u8] = self.alu.as_bytes(); - copy_memory(&mut buf, alu); + copy_memory(alu, &mut buf); let buf_len = buf.len(); - copy_memory(&mut buf[alu_len..buf_len], - &alu[..LINE_LEN]); + copy_memory(&alu[..LINE_LEN], &mut buf[alu_len..buf_len]); let mut pos = 0; let mut bytes; diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs index 82ea234f6dd..cda90c08f23 100644 --- a/src/test/bench/shootout-reverse-complement.rs +++ b/src/test/bench/shootout-reverse-complement.rs @@ -181,8 +181,8 @@ fn reverse_complement(seq: &mut [u8], tables: &Tables) { let mut i = LINE_LEN; while i < len { unsafe { - copy(seq.as_mut_ptr().offset((i - off + 1) as isize), - seq.as_ptr().offset((i - off) as isize), off); + copy(seq.as_ptr().offset((i - off) as isize), + seq.as_mut_ptr().offset((i - off + 1) as isize), off); *seq.get_unchecked_mut(i - off) = b'\n'; } i += LINE_LEN + 1; diff --git a/src/test/compile-fail/borrowck-issue-14498.rs b/src/test/compile-fail/borrowck-issue-14498.rs index 8278b4fb971..64033623fe2 100644 --- a/src/test/compile-fail/borrowck-issue-14498.rs +++ b/src/test/compile-fail/borrowck-issue-14498.rs @@ -9,56 +9,116 @@ // except according to those terms. // This tests that we can't modify Box<&mut T> contents while they -// are borrowed. +// are borrowed (#14498). +// +// Also includes tests of the errors reported when the Box in question +// is immutable (#14270). #![feature(box_syntax)] struct A { a: isize } struct B<'a> { a: Box<&'a mut isize> } +fn indirect_write_to_imm_box() { + let mut x: isize = 1; + let y: Box<_> = box &mut x; + let p = &y; + ***p = 2; //~ ERROR cannot assign to data in an immutable container + drop(p); +} + fn borrow_in_var_from_var() { let mut x: isize = 1; + let mut y: Box<_> = box &mut x; + let p = &y; + let q = &***p; + **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed + drop(p); + drop(q); +} + +fn borrow_in_var_from_var_via_imm_box() { + let mut x: isize = 1; let y: Box<_> = box &mut x; let p = &y; let q = &***p; **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed + //~^ ERROR cannot assign to data in an immutable container drop(p); drop(q); } fn borrow_in_var_from_field() { let mut x = A { a: 1 }; + let mut y: Box<_> = box &mut x.a; + let p = &y; + let q = &***p; + **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed + drop(p); + drop(q); +} + +fn borrow_in_var_from_field_via_imm_box() { + let mut x = A { a: 1 }; let y: Box<_> = box &mut x.a; let p = &y; let q = &***p; **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed + //~^ ERROR cannot assign to data in an immutable container drop(p); drop(q); } fn borrow_in_field_from_var() { let mut x: isize = 1; + let mut y = B { a: box &mut x }; + let p = &y.a; + let q = &***p; + **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed + drop(p); + drop(q); +} + +fn borrow_in_field_from_var_via_imm_box() { + let mut x: isize = 1; let y = B { a: box &mut x }; let p = &y.a; let q = &***p; **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed + //~^ ERROR cannot assign to data in an immutable container drop(p); drop(q); } fn borrow_in_field_from_field() { let mut x = A { a: 1 }; + let mut y = B { a: box &mut x.a }; + let p = &y.a; + let q = &***p; + **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed + drop(p); + drop(q); +} + +fn borrow_in_field_from_field_via_imm_box() { + let mut x = A { a: 1 }; let y = B { a: box &mut x.a }; let p = &y.a; let q = &***p; **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed + //~^ ERROR cannot assign to data in an immutable container drop(p); drop(q); } fn main() { + indirect_write_to_imm_box(); borrow_in_var_from_var(); + borrow_in_var_from_var_via_imm_box(); borrow_in_var_from_field(); + borrow_in_var_from_field_via_imm_box(); borrow_in_field_from_var(); + borrow_in_field_from_var_via_imm_box(); borrow_in_field_from_field(); + borrow_in_field_from_field_via_imm_box(); } diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs index 8441fb3ade9..3a9baecb9c6 100644 --- a/src/test/compile-fail/lint-dead-code-4.rs +++ b/src/test/compile-fail/lint-dead-code-4.rs @@ -16,8 +16,6 @@ extern crate libc; -use std::num::Int; - struct Foo { x: usize, b: bool, //~ ERROR: struct field is never used diff --git a/src/test/compile-fail/range-1.rs b/src/test/compile-fail/range-1.rs index e7b34d6d1bc..3ae61722bcf 100644 --- a/src/test/compile-fail/range-1.rs +++ b/src/test/compile-fail/range-1.rs @@ -15,9 +15,10 @@ pub fn main() { let _ = 0u32..10i32; //~^ ERROR start and end of range have incompatible types - // Float => does not implement iterator. - for i in 0f32..42f32 {} - //~^ ERROR the trait `core::num::Int` is not implemented for the type `f32` + // Bool => does not implement iterator. + for i in false..true {} + //~^ ERROR the trait + //~^^ ERROR the trait // Unsized type. let arr: &[_] = &[1, 2, 3]; diff --git a/src/test/parse-fail/issue-1802-1.rs b/src/test/parse-fail/issue-1802-1.rs index 8ce99f517c4..00fb2808faa 100644 --- a/src/test/parse-fail/issue-1802-1.rs +++ b/src/test/parse-fail/issue-1802-1.rs @@ -10,5 +10,5 @@ // error-pattern:no valid digits found for number fn main() { - log(error, 0b42); + log(error, 0b); } diff --git a/src/test/parse-fail/lex-bad-binary-literal.rs b/src/test/parse-fail/lex-bad-binary-literal.rs new file mode 100644 index 00000000000..e92000c54ba --- /dev/null +++ b/src/test/parse-fail/lex-bad-binary-literal.rs @@ -0,0 +1,21 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + 0b121; //~ ERROR invalid digit for a base 2 literal + 0b10_10301; //~ ERROR invalid digit for a base 2 literal + 0b30; //~ ERROR invalid digit for a base 2 literal + 0b41; //~ ERROR invalid digit for a base 2 literal + 0b5; //~ ERROR invalid digit for a base 2 literal + 0b6; //~ ERROR invalid digit for a base 2 literal + 0b7; //~ ERROR invalid digit for a base 2 literal + 0b8; //~ ERROR invalid digit for a base 2 literal + 0b9; //~ ERROR invalid digit for a base 2 literal +} diff --git a/src/test/parse-fail/lex-bad-octal-literal.rs b/src/test/parse-fail/lex-bad-octal-literal.rs new file mode 100644 index 00000000000..bf9880cb6cf --- /dev/null +++ b/src/test/parse-fail/lex-bad-octal-literal.rs @@ -0,0 +1,14 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + 0o18; //~ ERROR invalid digit for a base 8 literal + 0o1234_9_5670; //~ ERROR invalid digit for a base 8 literal +} diff --git a/src/test/run-pass-fulldeps/compiler-calls.rs b/src/test/run-pass-fulldeps/compiler-calls.rs index 7a3c32a45f9..fdc670c6b71 100644 --- a/src/test/run-pass-fulldeps/compiler-calls.rs +++ b/src/test/run-pass-fulldeps/compiler-calls.rs @@ -77,6 +77,6 @@ fn main() { let mut tc = TestCalls { count: 1 }; // we should never get use this filename, but lets make sure they are valid args. let args = vec!["compiler-calls".to_string(), "foo.rs".to_string()]; - rustc_driver::run_compiler(args.as_slice(), &mut tc); + rustc_driver::run_compiler(&args[..], &mut tc); assert!(tc.count == 30); } diff --git a/src/test/run-pass/env-home-dir.rs b/src/test/run-pass/env-home-dir.rs index 2d0128ba89e..7fb96112125 100644 --- a/src/test/run-pass/env-home-dir.rs +++ b/src/test/run-pass/env-home-dir.rs @@ -11,7 +11,6 @@ // pretty-expanded FIXME #23616 #![feature(path)] -#![feature(convert)] use std::env::*; use std::path::PathBuf; diff --git a/src/test/run-pass/generic-extern-mangle.rs b/src/test/run-pass/generic-extern-mangle.rs index 4ea05a375d1..7a765703e23 100644 --- a/src/test/run-pass/generic-extern-mangle.rs +++ b/src/test/run-pass/generic-extern-mangle.rs @@ -12,11 +12,11 @@ #![feature(core)] -use std::num::Int; +use std::ops::Add; -extern "C" fn foo<T: WrappingOps>(a: T, b: T) -> T { a.wrapping_add(b) } +extern "C" fn foo<T: Add>(a: T, b: T) -> T::Output { a + b } fn main() { - assert_eq!(99u8, foo(255u8, 100u8)); - assert_eq!(99u16, foo(65535u16, 100u16)); + assert_eq!(100u8, foo(0u8, 100u8)); + assert_eq!(100u16, foo(0u16, 100u16)); } diff --git a/src/test/run-pass/issue-11592.rs b/src/test/run-pass/issue-11592.rs new file mode 100644 index 00000000000..432e7ff2025 --- /dev/null +++ b/src/test/run-pass/issue-11592.rs @@ -0,0 +1,20 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Ensure the private trait Bar isn't complained about. + +#![deny(missing_docs)] + +mod foo { + trait Bar { fn bar(&self) { } } + impl Bar for i8 { fn bar(&self) { } } +} + +fn main() { } diff --git a/src/test/run-pass/issue-20797.rs b/src/test/run-pass/issue-20797.rs index d0720ec593f..45d31d4a7f1 100644 --- a/src/test/run-pass/issue-20797.rs +++ b/src/test/run-pass/issue-20797.rs @@ -12,8 +12,6 @@ // pretty-expanded FIXME #23616 -#![feature(convert)] - use std::default::Default; use std::io; use std::fs; diff --git a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs index e013c5b0be7..7cc762c9348 100644 --- a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs +++ b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs @@ -26,7 +26,7 @@ trait MyWriter { impl<'a> MyWriter for &'a mut [u8] { fn my_write(&mut self, buf: &[u8]) -> IoResult<()> { - slice::bytes::copy_memory(*self, buf); + slice::bytes::copy_memory(buf, *self); let write_len = buf.len(); unsafe { diff --git a/src/test/run-pass/minmax-stability-issue-23687.rs b/src/test/run-pass/minmax-stability-issue-23687.rs new file mode 100644 index 00000000000..86dd1a04532 --- /dev/null +++ b/src/test/run-pass/minmax-stability-issue-23687.rs @@ -0,0 +1,83 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(core)] +use std::fmt::Debug; +use std::cmp::{self, PartialOrd, Ordering}; +use std::iter::MinMaxResult::MinMax; + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +struct Foo { + n: u8, + name: &'static str +} + +impl PartialOrd for Foo { + fn partial_cmp(&self, other: &Foo) -> Option<Ordering> { + Some(self.cmp(other)) + } +} + +impl Ord for Foo { + fn cmp(&self, other: &Foo) -> Ordering { + self.n.cmp(&other.n) + } +} + +fn main() { + let a = Foo { n: 4, name: "a" }; + let b = Foo { n: 4, name: "b" }; + let c = Foo { n: 8, name: "c" }; + let d = Foo { n: 8, name: "d" }; + let e = Foo { n: 22, name: "e" }; + let f = Foo { n: 22, name: "f" }; + + let data = [a, b, c, d, e, f]; + + // `min` should return the left when the values are equal + assert_eq!(data.iter().min(), Some(&a)); + assert_eq!(data.iter().min_by(|a| a.n), Some(&a)); + assert_eq!(cmp::min(a, b), a); + assert_eq!(cmp::min(b, a), b); + assert_eq!(cmp::partial_min(a, b), Some(a)); + assert_eq!(cmp::partial_min(b, a), Some(b)); + + // `max` should return the right when the values are equal + assert_eq!(data.iter().max(), Some(&f)); + assert_eq!(data.iter().max_by(|a| a.n), Some(&f)); + assert_eq!(cmp::max(e, f), f); + assert_eq!(cmp::max(f, e), e); + assert_eq!(cmp::partial_max(e, f), Some(f)); + assert_eq!(cmp::partial_max(f, e), Some(e)); + + // Similar for `min_max` + assert_eq!(data.iter().min_max(), MinMax(&a, &f)); + assert_eq!(data[1..5].iter().min_max(), MinMax(&b, &e)); + assert_eq!(data[2..4].iter().min_max(), MinMax(&c, &d)); + + let mut presorted = data.to_vec(); + presorted.sort(); + assert_stable(&presorted); + + let mut presorted = data.to_vec(); + presorted.sort_by(|a, b| a.cmp(b)); + assert_stable(&presorted); + + // Assert that sorted and min/max are the same + fn assert_stable<T: Ord + Debug>(presorted: &[T]) { + for slice in presorted.windows(2) { + let a = &slice[0]; + let b = &slice[1]; + + assert_eq!(a, cmp::min(a, b)); + assert_eq!(b, cmp::max(a, b)); + } + } +} diff --git a/src/test/run-pass/regions-refcell.rs b/src/test/run-pass/regions-refcell.rs index febf5f92ef6..63525b36206 100644 --- a/src/test/run-pass/regions-refcell.rs +++ b/src/test/run-pass/regions-refcell.rs @@ -29,7 +29,7 @@ fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) { // supposed to match the lifetime `'a`) ... fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) { let one = [1]; - assert_eq!(map.borrow().get("one"), Some(&one.as_slice())); + assert_eq!(map.borrow().get("one"), Some(&&one[..])); } #[cfg(all(not(cannot_use_this_yet),not(cannot_use_this_yet_either)))] diff --git a/src/test/run-pass/simd-binop.rs b/src/test/run-pass/simd-binop.rs index 0d26b75c2ad..9f7b78e4e33 100644 --- a/src/test/run-pass/simd-binop.rs +++ b/src/test/run-pass/simd-binop.rs @@ -32,6 +32,7 @@ pub fn main() { assert!(eq_u32x4(u32x4(1, 2, 3, 4) + u32x4(4, 3, 2, 1), u32x4(5, 5, 5, 5))); assert!(eq_u32x4(u32x4(4, 5, 6, 7) - u32x4(4, 3, 2, 1), u32x4(0, 2, 4, 6))); assert!(eq_u32x4(u32x4(1, 2, 3, 4) * u32x4(4, 3, 2, 1), u32x4(4, 6, 6, 4))); + assert!(eq_u32x4(u32x4(1, 2, 3, 4) / u32x4(4, 3, 2, 1), u32x4(0, 0, 1, 4))); assert!(eq_u32x4(u32x4(1, 2, 3, 4) & u32x4(4, 3, 2, 1), u32x4(0, 2, 2, 0))); assert!(eq_u32x4(u32x4(1, 2, 3, 4) | u32x4(4, 3, 2, 1), u32x4(5, 3, 3, 5))); assert!(eq_u32x4(u32x4(1, 2, 3, 4) ^ u32x4(4, 3, 2, 1), u32x4(5, 1, 1, 5))); @@ -41,6 +42,7 @@ pub fn main() { assert!(eq_i32x4(i32x4(1, 2, 3, 4) + i32x4(4, 3, 2, 1), i32x4(5, 5, 5, 5))); assert!(eq_i32x4(i32x4(1, 2, 3, 4) - i32x4(4, 3, 2, 1), i32x4(-3, -1, 1, 3))); assert!(eq_i32x4(i32x4(1, 2, 3, 4) * i32x4(4, 3, 2, 1), i32x4(4, 6, 6, 4))); + assert!(eq_i32x4(i32x4(1, 2, 3, 4) / i32x4(4, 3, 2, 1), i32x4(0, 0, 1, 4))); assert!(eq_i32x4(i32x4(1, 2, 3, 4) & i32x4(4, 3, 2, 1), i32x4(0, 2, 2, 0))); assert!(eq_i32x4(i32x4(1, 2, 3, 4) | i32x4(4, 3, 2, 1), i32x4(5, 3, 3, 5))); assert!(eq_i32x4(i32x4(1, 2, 3, 4) ^ i32x4(4, 3, 2, 1), i32x4(5, 1, 1, 5))); diff --git a/src/test/run-pass/unit-like-struct-drop-run.rs b/src/test/run-pass/unit-like-struct-drop-run.rs index 9e1ced36402..c2db63ed251 100644 --- a/src/test/run-pass/unit-like-struct-drop-run.rs +++ b/src/test/run-pass/unit-like-struct-drop-run.rs @@ -14,7 +14,6 @@ #![feature(alloc)] -use std::boxed::BoxAny; use std::thread; struct Foo; |