diff --git a/src/doc/reference.md b/src/doc/reference.md index 0bc4414999d74..b3d5ad3b55d0f 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -977,7 +977,6 @@ An example of `use` declarations: ``` # #![feature(core)] -use std::iter::range_step; use std::option::Option::{Some, None}; use std::collections::hash_map::{self, HashMap}; @@ -985,9 +984,6 @@ fn foo(_: T){} fn bar(map1: HashMap, map2: hash_map::HashMap){} fn main() { - // Equivalent to 'std::iter::range_step(0, 10, 2);' - range_step(0, 10, 2); - // Equivalent to 'foo(vec![std::option::Option::Some(1.0f64), // std::option::Option::None]);' foo(vec![Some(1.0f64), None]); diff --git a/src/doc/trpl/iterators.md b/src/doc/trpl/iterators.md index 8d7b1c3bd8393..55776bee3b585 100644 --- a/src/doc/trpl/iterators.md +++ b/src/doc/trpl/iterators.md @@ -243,11 +243,12 @@ for num in nums.iter() { ``` These two basic iterators should serve you well. There are some more -advanced iterators, including ones that are infinite. Like `count`: +advanced iterators, including ones that are infinite. Like using range syntax +and `step_by`: ```rust -# #![feature(core)] -std::iter::count(1, 5); +# #![feature(step_by)] +(1..).step_by(5); ``` This iterator counts up from one, adding five each time. It will give @@ -292,11 +293,11 @@ just use `for` instead. There are tons of interesting iterator adapters. `take(n)` will return an iterator over the next `n` elements of the original iterator, note that this has no side effect on the original iterator. Let's try it out with our infinite -iterator from before, `count()`: +iterator from before: ```rust -# #![feature(core)] -for i in std::iter::count(1, 5).take(5) { +# #![feature(step_by)] +for i in (1..).step_by(5).take(5) { println!("{}", i); } ``` diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index 3ed8ca2bea98b..8874ac6eb872f 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -38,7 +38,7 @@ //! [sieve]: http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes //! //! ``` -//! # #![feature(collections, core)] +//! # #![feature(collections, core, step_by)] //! use std::collections::{BitSet, BitVec}; //! use std::num::Float; //! use std::iter; @@ -60,7 +60,7 @@ //! if bv[i] { //! // Mark all multiples of i as non-prime (any multiples below i * i //! // will have been marked as non-prime previously) -//! for j in iter::range_step(i * i, max_prime, i) { bv.set(j, false) } +//! for j in (i * i..max_prime).step_by(i) { bv.set(j, false) } //! } //! } //! BitSet::from_bit_vec(bv) @@ -1264,14 +1264,6 @@ impl BitSet { BitSet { bit_vec: bit_vec } } - /// Deprecated: use `from_bit_vec`. - #[inline] - #[deprecated(since = "1.0.0", reason = "renamed to from_bit_vec")] - #[unstable(feature = "collections")] - pub fn from_bitv(bit_vec: BitVec) -> BitSet { - BitSet { bit_vec: bit_vec } - } - /// Returns the capacity in bits for this bit vector. Inserting any /// element less than this amount will not trigger a resizing. /// diff --git a/src/libcollections/borrow.rs b/src/libcollections/borrow.rs index 88d59f699d183..b955e9b71e461 100644 --- a/src/libcollections/borrow.rs +++ b/src/libcollections/borrow.rs @@ -192,26 +192,6 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned { Owned(owned) => owned } } - - /// Returns true if this `Cow` wraps a borrowed value - #[deprecated(since = "1.0.0", reason = "match on the enum instead")] - #[unstable(feature = "std_misc")] - pub fn is_borrowed(&self) -> bool { - match *self { - Borrowed(_) => true, - _ => false, - } - } - - /// Returns true if this `Cow` wraps an owned value - #[deprecated(since = "1.0.0", reason = "match on the enum instead")] - #[unstable(feature = "std_misc")] - pub fn is_owned(&self) -> bool { - match *self { - Owned(_) => true, - _ => false, - } - } } #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index c769b3df37f62..bdc2cf96734f6 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -68,22 +68,6 @@ pub use string::String; pub use vec::Vec; pub use vec_map::VecMap; -#[deprecated(since = "1.0.0", reason = "renamed to vec_deque")] -#[unstable(feature = "collections")] -pub use vec_deque as ring_buf; - -#[deprecated(since = "1.0.0", reason = "renamed to linked_list")] -#[unstable(feature = "collections")] -pub use linked_list as dlist; - -#[deprecated(since = "1.0.0", reason = "renamed to bit_vec")] -#[unstable(feature = "collections")] -pub use bit_vec as bitv; - -#[deprecated(since = "1.0.0", reason = "renamed to bit_set")] -#[unstable(feature = "collections")] -pub use bit_set as bitv_set; - // Needed for the vec! macro pub use alloc::boxed; @@ -108,10 +92,6 @@ pub mod vec_map; reason = "RFC 509")] pub mod bit_vec { pub use bit::{BitVec, Iter}; - - #[deprecated(since = "1.0.0", reason = "renamed to BitVec")] - #[unstable(feature = "collections")] - pub use bit::BitVec as Bitv; } #[unstable(feature = "collections", @@ -119,10 +99,6 @@ pub mod bit_vec { pub mod bit_set { pub use bit::{BitSet, Union, Intersection, Difference, SymmetricDifference}; pub use bit::SetIter as Iter; - - #[deprecated(since = "1.0.0", reason = "renamed to BitSet")] - #[unstable(feature = "collections")] - pub use bit::BitSet as BitvSet; } #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs index 52da4902b758c..392dc7346c60d 100644 --- a/src/libcollections/linked_list.rs +++ b/src/libcollections/linked_list.rs @@ -32,10 +32,6 @@ use core::iter::{self, FromIterator, IntoIterator}; use core::mem; use core::ptr; -#[deprecated(since = "1.0.0", reason = "renamed to LinkedList")] -#[unstable(feature = "collections")] -pub use LinkedList as DList; - /// A doubly-linked list. #[stable(feature = "rust1", since = "1.0.0")] pub struct LinkedList { @@ -844,7 +840,7 @@ impl ExactSizeIterator for IntoIter {} #[stable(feature = "rust1", since = "1.0.0")] impl FromIterator for LinkedList { fn from_iter>(iter: T) -> LinkedList { - let mut ret = DList::new(); + let mut ret = LinkedList::new(); ret.extend(iter); ret } diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 050997f2dd3f0..d0e86f56d262f 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -107,7 +107,6 @@ pub use core::slice::{IntSliceExt, SplitMut, ChunksMut, Split}; pub use core::slice::{SplitN, RSplitN, SplitNMut, RSplitNMut}; pub use core::slice::{bytes, mut_ref_slice, ref_slice}; pub use core::slice::{from_raw_parts, from_raw_parts_mut}; -pub use core::slice::{from_raw_buf, from_raw_mut_buf}; //////////////////////////////////////////////////////////////////////////////// // Basic slice extension methods @@ -281,33 +280,6 @@ impl [T] { cmp::min(self.len(), end-start) } - /// Deprecated: use `&s[start .. end]` notation instead. - #[unstable(feature = "collections", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &s[start .. end] instead")] - #[inline] - pub fn slice(&self, start: usize, end: usize) -> &[T] { - &self[start .. end] - } - - /// Deprecated: use `&s[start..]` notation instead. - #[unstable(feature = "collections", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &s[start..] instead")] - #[inline] - pub fn slice_from(&self, start: usize) -> &[T] { - &self[start ..] - } - - /// Deprecated: use `&s[..end]` notation instead. - #[unstable(feature = "collections", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &s[..end] instead")] - #[inline] - pub fn slice_to(&self, end: usize) -> &[T] { - &self[.. end] - } - /// Divides one slice into two at an index. /// /// The first will contain all indices from `[0, mid)` (excluding @@ -611,42 +583,6 @@ impl [T] { core_slice::SliceExt::get_mut(self, index) } - /// Deprecated: use `&mut s[..]` instead. - #[unstable(feature = "collections", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")] - #[allow(deprecated)] - pub fn as_mut_slice(&mut self) -> &mut [T] { - core_slice::SliceExt::as_mut_slice(self) - } - - /// Deprecated: use `&mut s[start .. end]` instead. - #[unstable(feature = "collections", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &mut s[start .. end] instead")] - #[inline] - pub fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] { - &mut self[start .. end] - } - - /// Deprecated: use `&mut s[start ..]` instead. - #[unstable(feature = "collections", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &mut s[start ..] instead")] - #[inline] - pub fn slice_from_mut(&mut self, start: usize) -> &mut [T] { - &mut self[start ..] - } - - /// Deprecated: use `&mut s[.. end]` instead. - #[unstable(feature = "collections", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &mut s[.. end] instead")] - #[inline] - pub fn slice_to_mut(&mut self, end: usize) -> &mut [T] { - &mut self[.. end] - } - /// Returns an iterator that allows modifying each value #[stable(feature = "rust1", since = "1.0.0")] #[inline] @@ -937,13 +873,6 @@ impl [T] { core_slice::SliceExt::binary_search(self, x) } - /// Deprecated: use `binary_search` instead. - #[unstable(feature = "collections")] - #[deprecated(since = "1.0.0", reason = "use binary_search instead")] - pub fn binary_search_elem(&self, x: &T) -> Result where T: Ord { - self.binary_search(x) - } - /// Mutates the slice to the next lexicographic permutation. /// /// Returns `true` if successful and `false` if the slice is at the diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 9ddf8988f1ee7..35ec8af0a45f8 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -70,11 +70,11 @@ use vec::Vec; use slice::SliceConcatExt; pub use core::str::{FromStr, Utf8Error, Str}; -pub use core::str::{Lines, LinesAny, MatchIndices, SplitStr, CharRange}; +pub use core::str::{Lines, LinesAny, MatchIndices, CharRange}; pub use core::str::{Split, SplitTerminator, SplitN}; pub use core::str::{RSplit, RSplitN}; -pub use core::str::{from_utf8, CharEq, Chars, CharIndices, Bytes}; -pub use core::str::{from_utf8_unchecked, from_c_str, ParseBoolError}; +pub use core::str::{from_utf8, Chars, CharIndices, Bytes}; +pub use core::str::{from_utf8_unchecked, ParseBoolError}; pub use unicode::str::{Words, Graphemes, GraphemeIndices}; pub use core::str::Pattern; pub use core::str::{Searcher, ReverseSearcher, DoubleEndedSearcher, SearchStep}; @@ -536,22 +536,6 @@ impl str { core_str::StrExt::contains(&self[..], pat) } - /// Returns `true` if `self` contains a `char`. - /// - /// # Examples - /// - /// ``` - /// # #![feature(collections)] - /// assert!("hello".contains_char('e')); - /// - /// assert!(!"hello".contains_char('z')); - /// ``` - #[unstable(feature = "collections")] - #[deprecated(since = "1.0.0", reason = "use `contains()` with a char")] - pub fn contains_char<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool { - core_str::StrExt::contains_char(&self[..], pat) - } - /// An iterator over the codepoints of `self`. /// /// # Examples @@ -778,25 +762,6 @@ impl str { core_str::StrExt::match_indices(&self[..], pat) } - /// An iterator over the substrings of `self` separated by a `&str`. - /// - /// # Examples - /// - /// ``` - /// # #![feature(collections)] - /// let v: Vec<&str> = "abcXXXabcYYYabc".split_str("abc").collect(); - /// assert_eq!(v, ["", "XXX", "YYY", ""]); - /// - /// let v: Vec<&str> = "1abcabc2".split_str("abc").collect(); - /// assert_eq!(v, ["1", "", "2"]); - /// ``` - #[unstable(feature = "collections")] - #[deprecated(since = "1.0.0", reason = "use `split()` with a `&str`")] - #[allow(deprecated) /* for SplitStr */] - pub fn split_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitStr<'a, P> { - core_str::StrExt::split_str(&self[..], pat) - } - /// An iterator over the lines of a string, separated by `\n`. /// /// This does not include the empty string after a trailing `\n`. @@ -848,31 +813,6 @@ impl str { pub fn lines_any(&self) -> LinesAny { core_str::StrExt::lines_any(&self[..]) } - - /// Deprecated: use `s[a .. b]` instead. - #[unstable(feature = "collections", - reason = "use slice notation [a..b] instead")] - #[deprecated(since = "1.0.0", reason = "use slice notation [a..b] instead")] - pub fn slice(&self, begin: usize, end: usize) -> &str { - &self[begin..end] - } - - /// Deprecated: use `s[a..]` instead. - #[unstable(feature = "collections", - reason = "use slice notation [a..b] instead")] - #[deprecated(since = "1.0.0", reason = "use slice notation [a..] instead")] - pub fn slice_from(&self, begin: usize) -> &str { - &self[begin..] - } - - /// Deprecated: use `s[..a]` instead. - #[unstable(feature = "collections", - reason = "use slice notation [a..b] instead")] - #[deprecated(since = "1.0.0", reason = "use slice notation [..a] instead")] - pub fn slice_to(&self, end: usize) -> &str { - &self[..end] - } - /// Returns a slice of the string from the character range [`begin`..`end`). /// /// That is, start at the `begin`-th code point of the string and continue @@ -1306,27 +1246,6 @@ impl str { core_str::StrExt::rfind(&self[..], pat) } - /// Returns the byte index of the first matching substring if it exists. - /// - /// Returns `None` if it doesn't exist. - /// - /// The pattern can be a simple `&str`, or a closure that determines the split. - /// - /// # Examples - /// - /// ``` - /// # #![feature(collections)] - /// let s = "Löwe 老虎 Léopard"; - /// - /// assert_eq!(s.find_str("老虎 L"), Some(6)); - /// assert_eq!(s.find_str("muffin man"), None); - /// ``` - #[unstable(feature = "collections")] - #[deprecated(since = "1.0.0", reason = "use `find()` with a `&str`")] - pub fn find_str<'a, P: Pattern<'a>>(&'a self, needle: P) -> Option { - core_str::StrExt::find_str(&self[..], needle) - } - /// Retrieves the first character from a `&str` and returns it. /// /// This does not allocate a new string; instead, it returns a slice that points one character diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index dbf214a712b65..7ae5c6b5e6692 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -1072,11 +1072,6 @@ impl<'a> Str for Cow<'a, str> { } } -/// A clone-on-write string -#[deprecated(since = "1.0.0", reason = "use Cow<'a, str> instead")] -#[stable(feature = "rust1", since = "1.0.0")] -pub type CowString<'a> = Cow<'a, str>; - #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Write for String { #[inline] diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 3595288a6c940..288cfc77d8964 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1679,11 +1679,6 @@ impl<'a> From<&'a str> for Vec { // Clone-on-write //////////////////////////////////////////////////////////////////////////////// -/// A clone-on-write vector -#[deprecated(since = "1.0.0", reason = "use Cow<'a, [T]> instead")] -#[unstable(feature = "collections")] -pub type CowVec<'a, T> = Cow<'a, [T]>; - #[unstable(feature = "collections")] impl<'a, T> FromIterator for Cow<'a, [T]> where T: Clone { fn from_iter>(it: I) -> Cow<'a, [T]> { diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index 392e5092e3b6a..99a19b2a00b35 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -36,10 +36,6 @@ use core::cmp; use alloc::heap; -#[deprecated(since = "1.0.0", reason = "renamed to VecDeque")] -#[unstable(feature = "collections")] -pub use VecDeque as RingBuf; - const INITIAL_CAPACITY: usize = 7; // 2^3 - 1 const MINIMUM_CAPACITY: usize = 1; // 2 - 1 @@ -1902,7 +1898,7 @@ mod test { // len is the length *after* insertion for len in 1..cap { // 0, 1, 2, .., len - 1 - let expected = iter::count(0, 1).take(len).collect(); + let expected = (0..).take(len).collect(); for tail_pos in 0..cap { for to_insert in 0..len { tester.tail = tail_pos; @@ -1935,7 +1931,7 @@ mod test { // len is the length *after* removal for len in 0..cap - 1 { // 0, 1, 2, .., len - 1 - let expected = iter::count(0, 1).take(len).collect(); + let expected = (0..).take(len).collect(); for tail_pos in 0..cap { for to_remove in 0..len + 1 { tester.tail = tail_pos; @@ -1973,7 +1969,7 @@ mod test { for len in 0..cap + 1 { // 0, 1, 2, .., len - 1 - let expected = iter::count(0, 1).take(len).collect(); + let expected = (0..).take(len).collect(); for tail_pos in 0..max_cap + 1 { tester.tail = tail_pos; tester.head = tail_pos; @@ -2006,9 +2002,9 @@ mod test { // index to split at for at in 0..len + 1 { // 0, 1, 2, .., at - 1 (may be empty) - let expected_self = iter::count(0, 1).take(at).collect(); + let expected_self = (0..).take(at).collect(); // at, at + 1, .., len - 1 (may be empty) - let expected_other = iter::count(at, 1).take(len - at).collect(); + let expected_other = (at..).take(len - at).collect(); for tail_pos in 0..cap { tester.tail = tail_pos; diff --git a/src/libcollectionstest/bit/set.rs b/src/libcollectionstest/bit/set.rs index 4b4995d5fa7d9..19ea25ee345fa 100644 --- a/src/libcollectionstest/bit/set.rs +++ b/src/libcollectionstest/bit/set.rs @@ -10,7 +10,6 @@ use std::cmp::Ordering::{Equal, Greater, Less}; use std::collections::{BitSet, BitVec}; -use std::iter::range_step; #[test] fn test_bit_set_show() { @@ -42,7 +41,7 @@ fn test_bit_set_iterator() { assert_eq!(idxs, [0, 2, 3]); let long: BitSet = (0..10000).filter(|&n| n % 2 == 0).collect(); - let real: Vec<_> = range_step(0, 10000, 2).collect(); + let real: Vec<_> = (0..10000).step_by(2).collect(); let idxs: Vec<_> = long.iter().collect(); assert_eq!(idxs, real); diff --git a/src/libcollectionstest/fmt.rs b/src/libcollectionstest/fmt.rs index 9a9aa71b58bfa..70e21c65a1806 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 f03a073e274e3..456c658a9c6dc 100644 --- a/src/libcollectionstest/lib.rs +++ b/src/libcollectionstest/lib.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(deprecated)] #![feature(box_syntax)] #![feature(collections)] #![feature(core)] @@ -21,6 +20,7 @@ #![feature(unicode)] #![feature(unsafe_destructor)] #![feature(into_cow)] +#![feature(step_by)] #![cfg_attr(test, feature(str_char))] #[macro_use] extern crate log; diff --git a/src/libcollectionstest/slice.rs b/src/libcollectionstest/slice.rs index 4168fe88a4b56..041d9fba57cc3 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); @@ -685,7 +685,7 @@ fn test_capacity() { #[test] fn test_slice_2() { let v = vec![1, 2, 3, 4, 5]; - let v = v.slice(1, 3); + let v = &v[1..3]; assert_eq!(v.len(), 2); assert_eq!(v[0], 2); assert_eq!(v[1], 3); diff --git a/src/libcollectionstest/str.rs b/src/libcollectionstest/str.rs index 5cfa800905415..72a9f596d884b 100644 --- a/src/libcollectionstest/str.rs +++ b/src/libcollectionstest/str.rs @@ -89,32 +89,32 @@ fn test_into_bytes() { #[test] fn test_find_str() { // byte positions - assert_eq!("".find_str(""), Some(0)); - assert!("banana".find_str("apple pie").is_none()); + assert_eq!("".find(""), Some(0)); + assert!("banana".find("apple pie").is_none()); let data = "abcabc"; - assert_eq!(data[0..6].find_str("ab"), Some(0)); - assert_eq!(data[2..6].find_str("ab"), Some(3 - 2)); - assert!(data[2..4].find_str("ab").is_none()); + assert_eq!(data[0..6].find("ab"), Some(0)); + assert_eq!(data[2..6].find("ab"), Some(3 - 2)); + assert!(data[2..4].find("ab").is_none()); let string = "ประเทศไทย中华Việt Nam"; let mut data = String::from_str(string); data.push_str(string); - assert!(data.find_str("ไท华").is_none()); - assert_eq!(data[0..43].find_str(""), Some(0)); - assert_eq!(data[6..43].find_str(""), Some(6 - 6)); + assert!(data.find("ไท华").is_none()); + assert_eq!(data[0..43].find(""), Some(0)); + assert_eq!(data[6..43].find(""), Some(6 - 6)); - assert_eq!(data[0..43].find_str("ประ"), Some( 0)); - assert_eq!(data[0..43].find_str("ทศไ"), Some(12)); - assert_eq!(data[0..43].find_str("ย中"), Some(24)); - assert_eq!(data[0..43].find_str("iệt"), Some(34)); - assert_eq!(data[0..43].find_str("Nam"), Some(40)); + assert_eq!(data[0..43].find("ประ"), Some( 0)); + assert_eq!(data[0..43].find("ทศไ"), Some(12)); + assert_eq!(data[0..43].find("ย中"), Some(24)); + assert_eq!(data[0..43].find("iệt"), Some(34)); + assert_eq!(data[0..43].find("Nam"), Some(40)); - assert_eq!(data[43..86].find_str("ประ"), Some(43 - 43)); - assert_eq!(data[43..86].find_str("ทศไ"), Some(55 - 43)); - assert_eq!(data[43..86].find_str("ย中"), Some(67 - 43)); - assert_eq!(data[43..86].find_str("iệt"), Some(77 - 43)); - assert_eq!(data[43..86].find_str("Nam"), Some(83 - 43)); + assert_eq!(data[43..86].find("ประ"), Some(43 - 43)); + assert_eq!(data[43..86].find("ทศไ"), Some(55 - 43)); + assert_eq!(data[43..86].find("ย中"), Some(67 - 43)); + assert_eq!(data[43..86].find("iệt"), Some(77 - 43)); + assert_eq!(data[43..86].find("Nam"), Some(83 - 43)); } #[test] @@ -297,16 +297,16 @@ fn test_replace_2d() { #[test] fn test_slice() { - assert_eq!("ab", "abc".slice(0, 2)); - assert_eq!("bc", "abc".slice(1, 3)); - assert_eq!("", "abc".slice(1, 1)); - assert_eq!("\u{65e5}", "\u{65e5}\u{672c}".slice(0, 3)); + assert_eq!("ab", &"abc"[0..2]); + assert_eq!("bc", &"abc"[1..3]); + assert_eq!("", &"abc"[1..1]); + assert_eq!("\u{65e5}", &"\u{65e5}\u{672c}"[0..3]); let data = "ประเทศไทย中华"; - assert_eq!("ป", data.slice(0, 3)); - assert_eq!("ร", data.slice(3, 6)); - assert_eq!("", data.slice(3, 3)); - assert_eq!("华", data.slice(30, 33)); + assert_eq!("ป", &data[0..3]); + assert_eq!("ร", &data[3..6]); + assert_eq!("", &data[3..3]); + assert_eq!("华", &data[30..33]); fn a_million_letter_x() -> String { let mut i = 0; @@ -328,23 +328,23 @@ fn test_slice() { } let letters = a_million_letter_x(); assert!(half_a_million_letter_x() == - String::from_str(letters.slice(0, 3 * 500000))); + String::from_str(&letters[0..3 * 500000])); } #[test] fn test_slice_2() { let ss = "中华Việt Nam"; - assert_eq!("华", ss.slice(3, 6)); - assert_eq!("Việt Nam", ss.slice(6, 16)); + assert_eq!("华", &ss[3..6]); + assert_eq!("Việt Nam", &ss[6..16]); - assert_eq!("ab", "abc".slice(0, 2)); - assert_eq!("bc", "abc".slice(1, 3)); - assert_eq!("", "abc".slice(1, 1)); + assert_eq!("ab", &"abc"[0..2]); + assert_eq!("bc", &"abc"[1..3]); + assert_eq!("", &"abc"[1..1]); - assert_eq!("中", ss.slice(0, 3)); - assert_eq!("华V", ss.slice(3, 7)); - assert_eq!("", ss.slice(3, 3)); + assert_eq!("中", &ss[0..3]); + assert_eq!("华V", &ss[3..7]); + assert_eq!("", &ss[3..3]); /*0: 中 3: 华 6: V @@ -360,20 +360,20 @@ fn test_slice_2() { #[test] #[should_panic] fn test_slice_fail() { - "中华Việt Nam".slice(0, 2); + &"中华Việt Nam"[0..2]; } #[test] fn test_slice_from() { - assert_eq!("abcd".slice_from(0), "abcd"); - assert_eq!("abcd".slice_from(2), "cd"); - assert_eq!("abcd".slice_from(4), ""); + assert_eq!(&"abcd"[0..], "abcd"); + assert_eq!(&"abcd"[2..], "cd"); + assert_eq!(&"abcd"[4..], ""); } #[test] fn test_slice_to() { - assert_eq!("abcd".slice_to(0), ""); - assert_eq!("abcd".slice_to(2), "ab"); - assert_eq!("abcd".slice_to(4), "abcd"); + assert_eq!(&"abcd"[..0], ""); + assert_eq!(&"abcd"[..2], "ab"); + assert_eq!(&"abcd"[..4], "abcd"); } #[test] @@ -660,10 +660,10 @@ fn test_contains() { #[test] fn test_contains_char() { - assert!("abc".contains_char('b')); - assert!("a".contains_char('a')); - assert!(!"abc".contains_char('d')); - assert!(!"".contains_char('a')); + assert!("abc".contains('b')); + assert!("a".contains('a')); + assert!(!"abc".contains('d')); + assert!(!"".contains('a')); } #[test] @@ -1445,9 +1445,9 @@ fn test_graphemes() { } #[test] -fn test_split_strator() { +fn test_splitator() { fn t(s: &str, sep: &str, u: &[&str]) { - let v: Vec<&str> = s.split_str(sep).collect(); + let v: Vec<&str> = s.split(sep).collect(); assert_eq!(v, u); } t("--1233345--", "12345", &["--1233345--"]); @@ -1466,19 +1466,6 @@ fn test_split_strator() { t("zzzzz", "zz", &["","","z"]); } -#[test] -fn test_str_default() { - use std::default::Default; - - fn t() { - let s: S = Default::default(); - assert_eq!(s.as_slice(), ""); - } - - t::<&str>(); - t::(); -} - #[test] fn test_str_container() { fn sum_len(v: &[&str]) -> usize { diff --git a/src/libcollectionstest/string.rs b/src/libcollectionstest/string.rs index 4768d5e92ac30..5d6aa8ac0dcc3 100644 --- a/src/libcollectionstest/string.rs +++ b/src/libcollectionstest/string.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::borrow::IntoCow; +use std::borrow::{IntoCow, Cow}; use std::iter::repeat; use std::str::Utf8Error; -use std::string::{CowString, as_string}; +use std::string::as_string; use test::Bencher; @@ -52,11 +52,11 @@ fn test_from_utf8() { #[test] fn test_from_utf8_lossy() { let xs = b"hello"; - let ys: CowString = "hello".into_cow(); + let ys: Cow = "hello".into_cow(); assert_eq!(String::from_utf8_lossy(xs), ys); let xs = "ศไทย中华Việt Nam".as_bytes(); - let ys: CowString = "ศไทย中华Việt Nam".into_cow(); + let ys: Cow = "ศไทย中华Việt Nam".into_cow(); assert_eq!(String::from_utf8_lossy(xs), ys); let xs = b"Hello\xC2 There\xFF Goodbye"; diff --git a/src/libcollectionstest/vec_deque.rs b/src/libcollectionstest/vec_deque.rs index fe752d5a7e190..ec03ce620fd32 100644 --- a/src/libcollectionstest/vec_deque.rs +++ b/src/libcollectionstest/vec_deque.rs @@ -18,7 +18,6 @@ use self::Taggy::*; use self::Taggypar::*; #[test] -#[allow(deprecated)] fn test_simple() { let mut d = VecDeque::new(); assert_eq!(d.len(), 0); @@ -545,7 +544,7 @@ fn test_from_iter() { let u: Vec<_> = deq.iter().cloned().collect(); assert_eq!(u, v); - let seq = iter::count(0, 2).take(256); + let seq = (0..).step_by(2).take(256); let deq: VecDeque<_> = seq.collect(); for (i, &x) in deq.iter().enumerate() { assert_eq!(2*i, x); diff --git a/src/libcore/atomic.rs b/src/libcore/atomic.rs index 91b4b46ac3979..8c396a4e7fbcb 100644 --- a/src/libcore/atomic.rs +++ b/src/libcore/atomic.rs @@ -1062,144 +1062,3 @@ pub fn fence(order: Ordering) { } } } - -#[unstable(feature = "core")] -#[deprecated(since = "1.0.0", - reason = "renamed to AtomicIsize")] -#[allow(missing_docs)] -pub struct AtomicInt { - v: UnsafeCell, -} - -#[allow(deprecated)] -unsafe impl Sync for AtomicInt {} - -#[unstable(feature = "core")] -#[deprecated(since = "1.0.0", - reason = "renamed to AtomicUsize")] -#[allow(missing_docs)] -pub struct AtomicUint { - v: UnsafeCell, -} - -#[allow(deprecated)] -unsafe impl Sync for AtomicUint {} - -#[unstable(feature = "core")] -#[deprecated(since = "1.0.0", - reason = "use ATOMIC_ISIZE_INIT instead")] -#[allow(missing_docs, deprecated)] -pub const ATOMIC_INT_INIT: AtomicInt = - AtomicInt { v: UnsafeCell { value: 0 } }; -#[unstable(feature = "core")] -#[deprecated(since = "1.0.0", - reason = "use ATOMIC_USIZE_INIT instead")] -#[allow(missing_docs, deprecated)] -pub const ATOMIC_UINT_INIT: AtomicUint = - AtomicUint { v: UnsafeCell { value: 0, } }; - -#[allow(missing_docs, deprecated)] -impl AtomicInt { - #[inline] - pub fn new(v: isize) -> AtomicInt { - AtomicInt {v: UnsafeCell::new(v)} - } - - #[inline] - pub fn load(&self, order: Ordering) -> isize { - unsafe { atomic_load(self.v.get(), order) } - } - - #[inline] - pub fn store(&self, val: isize, order: Ordering) { - unsafe { atomic_store(self.v.get(), val, order); } - } - - #[inline] - pub fn swap(&self, val: isize, order: Ordering) -> isize { - unsafe { atomic_swap(self.v.get(), val, order) } - } - - #[inline] - pub fn compare_and_swap(&self, old: isize, new: isize, order: Ordering) -> isize { - unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) } - } - - #[inline] - pub fn fetch_add(&self, val: isize, order: Ordering) -> isize { - unsafe { atomic_add(self.v.get(), val, order) } - } - - #[inline] - pub fn fetch_sub(&self, val: isize, order: Ordering) -> isize { - unsafe { atomic_sub(self.v.get(), val, order) } - } - - #[inline] - pub fn fetch_and(&self, val: isize, order: Ordering) -> isize { - unsafe { atomic_and(self.v.get(), val, order) } - } - - #[inline] - pub fn fetch_or(&self, val: isize, order: Ordering) -> isize { - unsafe { atomic_or(self.v.get(), val, order) } - } - - #[inline] - pub fn fetch_xor(&self, val: isize, order: Ordering) -> isize { - unsafe { atomic_xor(self.v.get(), val, order) } - } -} - -#[allow(missing_docs, deprecated)] -impl AtomicUint { - #[inline] - pub fn new(v: usize) -> AtomicUint { - AtomicUint { v: UnsafeCell::new(v) } - } - - #[inline] - pub fn load(&self, order: Ordering) -> usize { - unsafe { atomic_load(self.v.get(), order) } - } - - #[inline] - pub fn store(&self, val: usize, order: Ordering) { - unsafe { atomic_store(self.v.get(), val, order); } - } - - #[inline] - pub fn swap(&self, val: usize, order: Ordering) -> usize { - unsafe { atomic_swap(self.v.get(), val, order) } - } - - #[inline] - pub fn compare_and_swap(&self, old: usize, new: usize, order: Ordering) -> usize { - unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) } - } - - #[inline] - pub fn fetch_add(&self, val: usize, order: Ordering) -> usize { - unsafe { atomic_add(self.v.get(), val, order) } - } - - #[inline] - pub fn fetch_sub(&self, val: usize, order: Ordering) -> usize { - unsafe { atomic_sub(self.v.get(), val, order) } - } - - #[inline] - pub fn fetch_and(&self, val: usize, order: Ordering) -> usize { - unsafe { atomic_and(self.v.get(), val, order) } - } - - #[inline] - pub fn fetch_or(&self, val: usize, order: Ordering) -> usize { - unsafe { atomic_or(self.v.get(), val, order) } - } - - #[inline] - pub fn fetch_xor(&self, val: usize, order: Ordering) -> usize { - unsafe { atomic_xor(self.v.get(), val, order) } - } -} diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 9e6dbce032593..906c87f3ffda6 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -343,23 +343,6 @@ impl RefCell { } } - /// Attempts to immutably borrow the wrapped value. - /// - /// The borrow lasts until the returned `Ref` exits scope. Multiple - /// immutable borrows can be taken out at the same time. - /// - /// Returns `None` if the value is currently mutably borrowed. - #[unstable(feature = "core", reason = "may be renamed or removed")] - #[deprecated(since = "1.0.0", - reason = "dispatch on `cell.borrow_state()` instead")] - #[inline] - pub fn try_borrow<'a>(&'a self) -> Option> { - match BorrowRef::new(&self.borrow) { - Some(b) => Some(Ref { _value: unsafe { &*self.value.get() }, _borrow: b }), - None => None, - } - } - /// Immutably borrows the wrapped value. /// /// The borrow lasts until the returned `Ref` exits scope. Multiple @@ -407,23 +390,6 @@ impl RefCell { } } - /// Mutably borrows the wrapped value. - /// - /// The borrow lasts until the returned `RefMut` exits scope. The value - /// cannot be borrowed while this borrow is active. - /// - /// Returns `None` if the value is currently borrowed. - #[unstable(feature = "core", reason = "may be renamed or removed")] - #[deprecated(since = "1.0.0", - reason = "dispatch on `cell.borrow_state()` instead")] - #[inline] - pub fn try_borrow_mut<'a>(&'a self) -> Option> { - match BorrowRefMut::new(&self.borrow) { - Some(b) => Some(RefMut { _value: unsafe { &mut *self.value.get() }, _borrow: b }), - None => None, - } - } - /// Mutably borrows the wrapped value. /// /// The borrow lasts until the returned `RefMut` exits scope. The value diff --git a/src/libcore/error.rs b/src/libcore/error.rs index 9430aa0066871..bd5d8d3272500 100644 --- a/src/libcore/error.rs +++ b/src/libcore/error.rs @@ -50,30 +50,30 @@ //! ``` //! #![feature(core)] //! use std::error::FromError; -//! use std::{io, str}; //! use std::fs::File; +//! use std::io; //! //! enum MyError { //! Io(io::Error), -//! Utf8(str::Utf8Error), +//! CustomError, //! } //! //! impl FromError for MyError { -//! fn from_error(err: io::Error) -> MyError { MyError::Io(err) } +//! fn from_error(err: io::Error) -> MyError { +//! MyError::Io(err) +//! } //! } //! -//! impl FromError for MyError { -//! fn from_error(err: str::Utf8Error) -> MyError { MyError::Utf8(err) } -//! } -//! -//! #[allow(unused_variables)] //! fn open_and_map() -> Result<(), MyError> { -//! let b = b"foo.txt"; -//! let s = try!(str::from_utf8(b)); -//! let f = try!(File::open(s)); -//! +//! let f = try!(File::open("foo.txt")); +//! let m = try!(work_with_file(&f)); //! // do something interesting here... -//! Ok(()) +//! # Ok(()) +//! } +//! +//! fn work_with_file(file: &File) -> Result<(), MyError> { +//! // ... +//! # return Ok(()) //! } //! ``` diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs deleted file mode 100644 index 93a7d2bb17b92..0000000000000 --- a/src/libcore/finally.rs +++ /dev/null @@ -1,111 +0,0 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! The Finally trait provides a method, `finally` on -//! stack closures that emulates Java-style try/finally blocks. -//! -//! Using the `finally` method is sometimes convenient, but the type rules -//! prohibit any shared, mutable state between the "try" case and the -//! "finally" case. For advanced cases, the `try_finally` function can -//! also be used. See that function for more details. -//! -//! # Examples -//! -//! ``` -//! # #![feature(core)] -//! # #![feature(unboxed_closures)] -//! -//! use std::finally::Finally; -//! -//! (|| { -//! // ... -//! }).finally(|| { -//! // this code is always run -//! }) -//! ``` - -#![unstable(feature = "core")] -#![deprecated(since = "1.0.0", - reason = "It is unclear if this module is more robust than implementing \ - Drop on a custom type, and this module is being removed with no \ - replacement. Use a custom Drop implementation to regain existing \ - functionality.")] -#![allow(deprecated)] - -use ops::{Drop, FnMut, FnOnce}; - -/// A trait for executing a destructor unconditionally after a block of code, -/// regardless of whether the blocked fails. -pub trait Finally { - /// Executes this object, unconditionally running `dtor` after this block of - /// code has run. - fn finally(&mut self, dtor: F) -> T where F: FnMut(); -} - -impl Finally for F where F: FnMut() -> T { - fn finally(&mut self, mut dtor: G) -> T where G: FnMut() { - try_finally(&mut (), self, |_, f| (*f)(), |_| dtor()) - } -} - -/// The most general form of the `finally` functions. The function -/// `try_fn` will be invoked first; whether or not it panics, the -/// function `finally_fn` will be invoked next. The two parameters -/// `mutate` and `drop` are used to thread state through the two -/// closures. `mutate` is used for any shared, mutable state that both -/// closures require access to; `drop` is used for any state that the -/// `try_fn` requires ownership of. -/// -/// **WARNING:** While shared, mutable state between the try and finally -/// function is often necessary, one must be very careful; the `try` -/// function could have panicked at any point, so the values of the shared -/// state may be inconsistent. -/// -/// # Examples -/// -/// ``` -/// # #![feature(core)] -/// use std::finally::try_finally; -/// -/// struct State<'a> { buffer: &'a mut [u8], len: usize } -/// # let mut buf = []; -/// let mut state = State { buffer: &mut buf, len: 0 }; -/// try_finally( -/// &mut state, (), -/// |state, ()| { -/// // use state.buffer, state.len -/// }, -/// |state| { -/// // use state.buffer, state.len to cleanup -/// }) -/// ``` -pub fn try_finally(mutate: &mut T, drop: U, try_fn: F, finally_fn: G) -> R where - F: FnOnce(&mut T, U) -> R, - G: FnMut(&mut T), -{ - let f = Finallyalizer { - mutate: mutate, - dtor: finally_fn, - }; - try_fn(&mut *f.mutate, drop) -} - -struct Finallyalizer<'a, A:'a, F> where F: FnMut(&mut A) { - mutate: &'a mut A, - dtor: F, -} - -#[unsafe_destructor] -impl<'a, A, F> Drop for Finallyalizer<'a, A, F> where F: FnMut(&mut A) { - #[inline] - fn drop(&mut self) { - (self.dtor)(self.mutate); - } -} diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index e65fbac926bd9..6820a7025fca6 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -114,11 +114,6 @@ impl SipHasher { state } - /// Returns the computed hash. - #[unstable(feature = "hash")] - #[deprecated(since = "1.0.0", reason = "renamed to finish")] - pub fn result(&self) -> u64 { self.finish() } - fn reset(&mut self) { self.length = 0; self.v0 = self.k0 ^ 0x736f6d6570736575; diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 44d48f9f4bf9d..6af26e254b36d 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -66,8 +66,7 @@ use marker; use mem; use num::{Int, Zero, One, ToPrimitive}; use ops::{Add, Sub, FnMut, RangeFrom}; -use option::Option; -use option::Option::{Some, None}; +use option::Option::{self, Some, None}; use marker::Sized; use usize; @@ -433,7 +432,7 @@ pub trait Iterator { /// # #![feature(core)] /// let xs = [2, 3]; /// let ys = [0, 1, 0, 1, 2]; - /// let it = xs.iter().flat_map(|&x| std::iter::count(0, 1).take(x)); + /// let it = xs.iter().flat_map(|&x| (0..).take(x)); /// // Check that `it` has the same elements as `ys` /// for (i, x) in it.enumerate() { /// assert_eq!(x, ys[i]); @@ -1244,10 +1243,10 @@ pub trait MultiplicativeIterator { /// /// ``` /// # #![feature(core)] - /// use std::iter::{count, MultiplicativeIterator}; + /// use std::iter::MultiplicativeIterator; /// /// fn factorial(n: usize) -> usize { - /// count(1, 1).take_while(|&i| i <= n).product() + /// (1..).take_while(|&i| i <= n).product() /// } /// assert!(factorial(0) == 1); /// assert!(factorial(1) == 1); @@ -2544,26 +2543,6 @@ impl ::ops::Range { } } -/// An infinite iterator starting at `start` and advancing by `step` with each -/// iteration -#[unstable(feature = "core", - reason = "may be renamed or replaced by range notation adapters")] -#[deprecated(since = "1.0.0-beta", reason = "use range notation and step_by")] -pub type Counter = StepBy>; - -/// Deprecated: use `(start..).step_by(step)` instead. -#[inline] -#[unstable(feature = "core", - reason = "may be renamed or replaced by range notation adapters")] -#[deprecated(since = "1.0.0-beta", reason = "use (start..).step_by(step) instead")] -#[allow(deprecated)] -pub fn count(start: A, step: A) -> Counter { - StepBy { - range: RangeFrom { start: start }, - step_by: step, - } -} - #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for StepBy> where A: Clone, @@ -2584,108 +2563,12 @@ impl Iterator for StepBy> where } } -/// An iterator over the range [start, stop) -#[allow(deprecated)] -#[derive(Clone)] -#[unstable(feature = "core", - reason = "will be replaced by range notation")] -#[deprecated(since = "1.0.0-beta", reason = "use range notation")] -pub struct Range { - state: A, - stop: A, - one: A, -} - -/// Deprecated: use `(start..stop)` instead. -#[inline] -#[unstable(feature = "core", reason = "will be replaced by range notation")] -#[deprecated(since = "1.0.0-beta", reason = "use (start..stop) instead")] -#[allow(deprecated)] -pub fn range(start: A, stop: A) -> Range { - Range { - state: start, - stop: stop, - one: Int::one(), - } -} - -// FIXME: #10414: Unfortunate type bound -#[unstable(feature = "core", - reason = "will be replaced by range notation")] -#[deprecated(since = "1.0.0-beta", reason = "use range notation")] -#[allow(deprecated)] -impl Iterator for Range { - type Item = A; - - #[inline] - fn next(&mut self) -> Option { - if self.state < self.stop { - let result = self.state.clone(); - self.state = self.state + self.one; - Some(result) - } else { - None - } - } - - #[inline] - fn size_hint(&self) -> (usize, Option) { - // This first checks if the elements are representable as i64. If they aren't, try u64 (to - // handle cases like range(huge, huger)). We don't use usize/isize because the difference of - // the i64/u64 might lie within their range. - let bound = match self.state.to_i64() { - Some(a) => { - let sz = self.stop.to_i64().map(|b| b.checked_sub(a)); - match sz { - Some(Some(bound)) => bound.to_usize(), - _ => None, - } - }, - None => match self.state.to_u64() { - Some(a) => { - let sz = self.stop.to_u64().map(|b| b.checked_sub(a)); - match sz { - Some(Some(bound)) => bound.to_usize(), - _ => None - } - }, - None => None - } - }; - - match bound { - Some(b) => (b, Some(b)), - // Standard fallback for unbounded/unrepresentable bounds - None => (0, None) - } - } -} - -/// `Int` is required to ensure the range will be the same regardless of -/// the direction it is consumed. -#[unstable(feature = "core", - reason = "will be replaced by range notation")] -#[deprecated(since = "1.0.0-beta", reason = "use range notation")] -#[allow(deprecated)] -impl DoubleEndedIterator for Range { - #[inline] - fn next_back(&mut self) -> Option { - if self.stop > self.state { - self.stop = self.stop - self.one; - Some(self.stop.clone()) - } else { - None - } - } -} - /// An iterator over the range [start, stop] #[derive(Clone)] #[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] -#[allow(deprecated)] pub struct RangeInclusive { - range: Range, + range: ops::Range, done: bool, } @@ -2693,17 +2576,15 @@ pub struct RangeInclusive { #[inline] #[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] -#[allow(deprecated)] pub fn range_inclusive(start: A, stop: A) -> RangeInclusive { RangeInclusive { - range: range(start, stop), + range: start..stop, done: false, } } #[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] -#[allow(deprecated)] impl Iterator for RangeInclusive { type Item = A; @@ -2712,9 +2593,9 @@ impl Iterator for RangeInclusive { match self.range.next() { Some(x) => Some(x), None => { - if !self.done && self.range.state == self.range.stop { + if !self.done && self.range.start == self.range.end { self.done = true; - Some(self.range.stop.clone()) + Some(self.range.end.clone()) } else { None } @@ -2740,43 +2621,22 @@ impl Iterator for RangeInclusive { #[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] -#[allow(deprecated)] impl DoubleEndedIterator for RangeInclusive { #[inline] fn next_back(&mut self) -> Option { - if self.range.stop > self.range.state { - let result = self.range.stop.clone(); - self.range.stop = self.range.stop - self.range.one; + if self.range.end > self.range.start { + let result = self.range.end.clone(); + self.range.end = self.range.end - A::one(); Some(result) - } else if !self.done && self.range.state == self.range.stop { + } else if !self.done && self.range.start == self.range.end { self.done = true; - Some(self.range.stop.clone()) + Some(self.range.end.clone()) } else { None } } } -/// An iterator over the range [start, stop) by `step`. It handles overflow by stopping. -#[unstable(feature = "core", - reason = "likely to be replaced by range notation and adapters")] -#[deprecated(since = "1.0.0-beta", reason = "use range notation and step_by")] -pub type RangeStep = StepBy>; - -/// Deprecated: use `(start..stop).step_by(step)` instead. -#[inline] -#[unstable(feature = "core", - reason = "likely to be replaced by range notation and adapters")] -#[deprecated(since = "1.0.0-beta", - reason = "use `(start..stop).step_by(step)` instead")] -#[allow(deprecated)] -pub fn range_step(start: A, stop: A, step: A) -> RangeStep { - StepBy { - step_by: step, - range: ::ops::Range { start: start, end: stop }, - } -} - #[stable(feature = "rust1", since = "1.0.0")] #[allow(deprecated)] impl Iterator for StepBy> { diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index cf5cb0c2f5e39..5e8b7fba1f15c 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -136,7 +136,6 @@ pub mod atomic; pub mod cell; pub mod char; pub mod panicking; -pub mod finally; pub mod iter; pub mod option; pub mod raw; diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs index d5a7c1d6b2647..07fac66d41c3f 100644 --- a/src/libcore/macros.rs +++ b/src/libcore/macros.rs @@ -233,7 +233,7 @@ macro_rules! writeln { /// ``` /// # #![feature(core)] /// fn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3 -/// for i in std::iter::count(0, 1) { +/// for i in 0.. { /// if 3*i < i { panic!("u32 overflow"); } /// if x < 3*i { return i-1; } /// } diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 3f4b39da4b3bb..339670435f182 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -415,42 +415,6 @@ mod impls { unsafe impl<'a, T: Send + ?Sized> Send for &'a mut T {} } -/// Old-style marker trait. Deprecated. -#[unstable(feature = "core", reason = "deprecated")] -#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData<&'a ()>`")] -#[lang="contravariant_lifetime"] -pub struct ContravariantLifetime<'a>; - -/// Old-style marker trait. Deprecated. -#[unstable(feature = "core", reason = "deprecated")] -#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData`")] -#[lang="covariant_lifetime"] -pub struct CovariantLifetime<'a>; - -/// Old-style marker trait. Deprecated. -#[unstable(feature = "core", reason = "deprecated")] -#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData>`")] -#[lang="invariant_lifetime"] -pub struct InvariantLifetime<'a>; - -/// Old-style marker trait. Deprecated. -#[unstable(feature = "core", reason = "deprecated")] -#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData`")] -#[lang="contravariant_type"] -pub struct ContravariantType; - -/// Old-style marker trait. Deprecated. -#[unstable(feature = "core", reason = "deprecated")] -#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData`")] -#[lang="covariant_type"] -pub struct CovariantType; - -/// Old-style marker trait. Deprecated. -#[unstable(feature = "core", reason = "deprecated")] -#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData>`")] -#[lang="invariant_type"] -pub struct InvariantType; - /// A marker trait indicates a type that can be reflected over. This /// trait is implemented for all types. Its purpose is to ensure that /// when you write a generic function that will employ reflection, diff --git a/src/libcore/option.rs b/src/libcore/option.rs index c5102ede29fcf..6db7c9bd99d9b 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -154,8 +154,6 @@ use mem; use ops::FnOnce; use result::Result::{Ok, Err}; use result::Result; -#[allow(deprecated)] -use slice::AsSlice; use slice; // Note that this is not a lang item per se, but it has a hidden dependency on @@ -765,25 +763,6 @@ impl Option { // Trait implementations ///////////////////////////////////////////////////////////////////////////// -#[unstable(feature = "core", - reason = "waiting on the stability of the trait itself")] -#[deprecated(since = "1.0.0", - reason = "use the inherent method instead")] -#[allow(deprecated)] -impl AsSlice for Option { - /// Convert from `Option` to `&[T]` (without copying) - #[inline] - fn as_slice<'a>(&'a self) -> &'a [T] { - match *self { - Some(ref x) => slice::ref_slice(x), - None => { - let result: &[_] = &[]; - result - } - } - } -} - #[stable(feature = "rust1", since = "1.0.0")] impl Default for Option { #[inline] diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs index 448b90c0dbdaf..e60bc49408195 100644 --- a/src/libcore/prelude.rs +++ b/src/libcore/prelude.rs @@ -37,10 +37,11 @@ pub use char::CharExt; pub use clone::Clone; pub use cmp::{PartialEq, PartialOrd, Eq, Ord}; pub use convert::{AsRef, AsMut, Into, From}; -pub use iter::Extend; -pub use iter::{Iterator, DoubleEndedIterator}; -pub use iter::{ExactSizeIterator}; +pub use iter::{Iterator, DoubleEndedIterator, Extend, ExactSizeIterator}; pub use option::Option::{self, Some, None}; pub use result::Result::{self, Ok, Err}; -pub use slice::{AsSlice, SliceExt}; -pub use str::{Str, StrExt}; +pub use slice::SliceExt; +pub use str::StrExt; + +#[allow(deprecated)] pub use slice::AsSlice; +#[allow(deprecated)] pub use str::Str; diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 41a70ef708f30..ff51e25fcbf25 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -157,21 +157,6 @@ pub fn null() -> *const T { 0 as *const T } #[stable(feature = "rust1", since = "1.0.0")] pub fn null_mut() -> *mut T { 0 as *mut T } -/// Zeroes out `count * size_of::` bytes of memory at `dst`. `count` may be -/// `0`. -/// -/// # Safety -/// -/// Beyond accepting a raw pointer, this is unsafe because it will not drop the -/// contents of `dst`, and may be used to create invalid instances of `T`. -#[inline] -#[unstable(feature = "core", - reason = "may play a larger role in std::ptr future extensions")] -#[deprecated(since = "1.0.0", reason = "use `write_bytes` instead")] -pub unsafe fn zero_memory(dst: *mut T, count: usize) { - write_bytes(dst, 0, count); -} - /// Swaps the values at two mutable locations of the same type, without /// deinitialising either. They may overlap, unlike `mem::swap` which is /// otherwise equivalent. diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 8502a9c53c4a8..47d1f3a1a3ccf 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -64,19 +64,6 @@ pub struct Slice { impl Copy for Slice {} -/// The representation of an old closure. -#[repr(C)] -#[derive(Copy)] -#[unstable(feature = "core")] -#[deprecated(reason = "unboxed new closures do not have a universal representation; \ - `&Fn` (etc) trait objects should use `TraitObject` instead", - since= "1.0.0")] -#[allow(deprecated) /* for deriving Copy impl */] -pub struct Closure { - pub code: *mut (), - pub env: *mut (), -} - /// The representation of a trait object like `&SomeTrait`. /// /// This struct has the same layout as types like `&SomeTrait` and diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 223a0bdae36cd..d8856130fab33 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -88,10 +88,6 @@ pub trait SliceExt { fn len(&self) -> usize; fn is_empty(&self) -> bool { self.len() == 0 } fn get_mut<'a>(&'a mut self, index: usize) -> Option<&'a mut Self::Item>; - #[unstable(feature = "core", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")] - fn as_mut_slice<'a>(&'a mut self) -> &'a mut [Self::Item]; fn iter_mut<'a>(&'a mut self) -> IterMut<'a, Self::Item>; fn first_mut<'a>(&'a mut self) -> Option<&'a mut Self::Item>; fn tail_mut<'a>(&'a mut self) -> &'a mut [Self::Item]; @@ -263,12 +259,6 @@ impl SliceExt for [T] { if index < self.len() { Some(&mut self[index]) } else { None } } - #[inline] - #[unstable(feature = "core", - reason = "will be replaced by slice syntax")] - #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")] - fn as_mut_slice(&mut self) -> &mut [T] { self } - #[inline] fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) { unsafe { @@ -1502,54 +1492,6 @@ pub unsafe fn from_raw_parts_mut<'a, T>(p: *mut T, len: usize) -> &'a mut [T] { transmute(RawSlice { data: p, len: len }) } -/// Forms a slice from a pointer and a length. -/// -/// The pointer given is actually a reference to the base of the slice. This -/// reference is used to give a concrete lifetime to tie the returned slice to. -/// Typically this should indicate that the slice is valid for as long as the -/// pointer itself is valid. -/// -/// The `len` argument is the number of **elements**, not the number of bytes. -/// -/// This function is unsafe as there is no guarantee that the given pointer is -/// valid for `len` elements, nor whether the lifetime provided is a suitable -/// lifetime for the returned slice. -/// -/// # Examples -/// -/// ``` -/// #![feature(core)] -/// use std::slice; -/// -/// // manifest a slice out of thin air! -/// let ptr = 0x1234 as *const usize; -/// let amt = 10; -/// unsafe { -/// let slice = slice::from_raw_buf(&ptr, amt); -/// } -/// ``` -#[inline] -#[unstable(feature = "core")] -#[deprecated(since = "1.0.0", - reason = "use from_raw_parts")] -pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: usize) -> &'a [T] { - transmute(RawSlice { data: *p, len: len }) -} - -/// Performs the same functionality as `from_raw_buf`, except that a mutable -/// slice is returned. -/// -/// This function is unsafe for the same reasons as `from_raw_buf`, as well as -/// not being able to provide a non-aliasing guarantee of the returned mutable -/// slice. -#[inline] -#[unstable(feature = "core")] -#[deprecated(since = "1.0.0", - reason = "use from_raw_parts_mut")] -pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: usize) -> &'a mut [T] { - transmute(RawSlice { data: *p, len: len }) -} - // // Submodules // diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index f9e2b47d9b634..934c4515614ef 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -28,8 +28,6 @@ use iter::ExactSizeIterator; use iter::{Map, Iterator, DoubleEndedIterator}; use marker::Sized; use mem; -#[allow(deprecated)] -use num::Int; use ops::{Fn, FnMut, FnOnce}; use option::Option::{self, None, Some}; use raw::{Repr, Slice}; @@ -243,78 +241,6 @@ pub unsafe fn from_utf8_unchecked<'a>(v: &'a [u8]) -> &'a str { mem::transmute(v) } -/// Constructs a static string slice from a given raw pointer. -/// -/// This function will read memory starting at `s` until it finds a 0, and then -/// transmute the memory up to that point as a string slice, returning the -/// corresponding `&'static str` value. -/// -/// This function is unsafe because the caller must ensure the C string itself -/// has the static lifetime and that the memory `s` is valid up to and including -/// the first null byte. -/// -/// # Panics -/// -/// This function will panic if the string pointed to by `s` is not valid UTF-8. -#[unstable(feature = "core")] -#[deprecated(since = "1.0.0", - reason = "use std::ffi::c_str_to_bytes + str::from_utf8")] -pub unsafe fn from_c_str(s: *const i8) -> &'static str { - let s = s as *const u8; - let mut len: usize = 0; - while *s.offset(len as isize) != 0 { - len += 1; - } - let v: &'static [u8] = ::mem::transmute(Slice { data: s, len: len }); - from_utf8(v).ok().expect("from_c_str passed invalid utf-8 data") -} - -/// Something that can be used to compare against a character -#[unstable(feature = "core")] -#[deprecated(since = "1.0.0", - reason = "use `Pattern` instead")] -// NB: Rather than removing it, make it private and move it into self::pattern -pub trait CharEq { - /// Determine if the splitter should split at the given character - fn matches(&mut self, char) -> bool; - /// Indicate if this is only concerned about ASCII characters, - /// which can allow for a faster implementation. - fn only_ascii(&self) -> bool; -} - -#[allow(deprecated) /* for CharEq */ ] -impl CharEq for char { - #[inline] - fn matches(&mut self, c: char) -> bool { *self == c } - - #[inline] - fn only_ascii(&self) -> bool { (*self as u32) < 128 } -} - -#[allow(deprecated) /* for CharEq */ ] -impl CharEq for F where F: FnMut(char) -> bool { - #[inline] - fn matches(&mut self, c: char) -> bool { (*self)(c) } - - #[inline] - fn only_ascii(&self) -> bool { false } -} - -#[allow(deprecated) /* for CharEq */ ] -impl<'a> CharEq for &'a [char] { - #[inline] - #[allow(deprecated) /* for CharEq */ ] - fn matches(&mut self, c: char) -> bool { - self.iter().any(|&m| { let mut m = m; m.matches(c) }) - } - - #[inline] - #[allow(deprecated) /* for CharEq */ ] - fn only_ascii(&self) -> bool { - self.iter().all(|m| m.only_ascii()) - } -} - #[stable(feature = "rust1", since = "1.0.0")] impl Error for Utf8Error { fn description(&self) -> &str { @@ -1047,22 +973,6 @@ impl<'a, P: Pattern<'a>> Iterator for MatchIndices<'a, P> { } } -/// An iterator over the substrings of a string separated by a given -/// search string -#[unstable(feature = "core")] -#[deprecated(since = "1.0.0", reason = "use `Split` with a `&str`")] -pub struct SplitStr<'a, P: Pattern<'a>>(Split<'a, P>); -#[allow(deprecated)] -impl<'a, P: Pattern<'a>> Iterator for SplitStr<'a, P> { - type Item = &'a str; - - #[inline] - #[allow(deprecated)] - fn next(&mut self) -> Option<&'a str> { - Iterator::next(&mut self.0) - } -} - impl<'a, 'b> OldMatchIndices<'a, 'b> { #[inline] #[allow(dead_code)] @@ -1444,8 +1354,6 @@ pub trait StrExt { fn rsplitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> where P::Searcher: ReverseSearcher<'a>; fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P>; - #[allow(deprecated) /* for SplitStr */] - fn split_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitStr<'a, P>; fn lines<'a>(&'a self) -> Lines<'a>; fn lines_any<'a>(&'a self) -> LinesAny<'a>; fn char_len(&self) -> usize; @@ -1565,12 +1473,6 @@ impl StrExt for str { MatchIndices(pat.into_searcher(self)) } - #[inline] - #[allow(deprecated) /* for SplitStr */ ] - fn split_str<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitStr<'a, P> { - SplitStr(self.split(pat)) - } - #[inline] fn lines(&self) -> Lines { Lines { inner: self.split_terminator('\n').0 } diff --git a/src/libcore/str/pattern.rs b/src/libcore/str/pattern.rs index 98b6533980dd9..922ab2c14a6b7 100644 --- a/src/libcore/str/pattern.rs +++ b/src/libcore/str/pattern.rs @@ -8,10 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(deprecated) /* for CharEq */ ] - use prelude::*; -use super::CharEq; // Pattern @@ -228,6 +225,40 @@ pub trait DoubleEndedSearcher<'a>: ReverseSearcher<'a> {} // Impl for a CharEq wrapper +#[doc(hidden)] +trait CharEq { + fn matches(&mut self, char) -> bool; + fn only_ascii(&self) -> bool; +} + +impl CharEq for char { + #[inline] + fn matches(&mut self, c: char) -> bool { *self == c } + + #[inline] + fn only_ascii(&self) -> bool { (*self as u32) < 128 } +} + +impl CharEq for F where F: FnMut(char) -> bool { + #[inline] + fn matches(&mut self, c: char) -> bool { (*self)(c) } + + #[inline] + fn only_ascii(&self) -> bool { false } +} + +impl<'a> CharEq for &'a [char] { + #[inline] + fn matches(&mut self, c: char) -> bool { + self.iter().any(|&m| { let mut m = m; m.matches(c) }) + } + + #[inline] + fn only_ascii(&self) -> bool { + self.iter().all(|m| m.only_ascii()) + } +} + struct CharEqPattern(C); struct CharEqSearcher<'a, C: CharEq> { @@ -425,65 +456,116 @@ fn str_search_step(mut m: &mut StrSearcher, } } -macro_rules! associated_items { - ($t:ty, $s:ident, $e:expr) => { - // FIXME: #22463 - //type Searcher = $t; - - fn into_searcher(self, haystack: &'a str) -> $t { - let $s = self; - $e.into_searcher(haystack) +macro_rules! char_eq_pattern_impl { + ($wrapper:ty, $wrapper_ident:ident) => { + fn into_searcher(self, haystack: &'a str) -> $wrapper { + $wrapper_ident(CharEqPattern(self).into_searcher(haystack)) } - #[inline] fn is_contained_in(self, haystack: &'a str) -> bool { - let $s = self; - $e.is_contained_in(haystack) + CharEqPattern(self).is_contained_in(haystack) } - #[inline] fn is_prefix_of(self, haystack: &'a str) -> bool { - let $s = self; - $e.is_prefix_of(haystack) + CharEqPattern(self).is_prefix_of(haystack) } - - // FIXME: #21750 - /*#[inline] + #[inline] fn is_suffix_of(self, haystack: &'a str) -> bool - where $t: ReverseSearcher<'a> + where $wrapper: ReverseSearcher<'a> { - let $s = self; - $e.is_suffix_of(haystack) - }*/ + CharEqPattern(self).is_suffix_of(haystack) + } } } -// CharEq delegation impls +// Pattern for char -/// Searches for chars that are equal to a given char impl<'a> Pattern<'a> for char { - type Searcher = as Pattern<'a>>::Searcher; - associated_items!( as Pattern<'a>>::Searcher, - s, CharEqPattern(s)); + type Searcher = CharSearcher<'a>; + char_eq_pattern_impl!(CharSearcher<'a>, CharSearcher); +} + +pub struct CharSearcher<'a>(CharEqSearcher<'a, char>); + +unsafe impl<'a> Searcher<'a> for CharSearcher<'a> { + #[inline] + fn haystack(&self) -> &'a str { self.0.haystack() } + #[inline] + fn next(&mut self) -> SearchStep { self.0.next() } +} +unsafe impl<'a> ReverseSearcher<'a> for CharSearcher<'a> { + #[inline] + fn next_back(&mut self) -> SearchStep { self.0.next_back() } } +impl<'a> DoubleEndedSearcher<'a> for CharSearcher<'a> {} + +// Pattern for &[char] -/// Searches for chars that are equal to any of the chars in the array impl<'a, 'b> Pattern<'a> for &'b [char] { - type Searcher = as Pattern<'a>>::Searcher; - associated_items!( as Pattern<'a>>::Searcher, - s, CharEqPattern(s)); + type Searcher = CharSliceSearcher<'a, 'b>; + char_eq_pattern_impl!(CharSliceSearcher<'a, 'b>, CharSliceSearcher); } -/// A convenience impl that delegates to the impl for `&str` -impl<'a, 'b> Pattern<'a> for &'b &'b str { - type Searcher = <&'b str as Pattern<'a>>::Searcher; - associated_items!(<&'b str as Pattern<'a>>::Searcher, - s, (*s)); +pub struct CharSliceSearcher<'a, 'b>(CharEqSearcher<'a, &'b [char]>); + +unsafe impl<'a, 'b> Searcher<'a> for CharSliceSearcher<'a, 'b> { + #[inline] + fn haystack(&self) -> &'a str { self.0.haystack() } + #[inline] + fn next(&mut self) -> SearchStep { self.0.next() } +} +unsafe impl<'a, 'b> ReverseSearcher<'a> for CharSliceSearcher<'a, 'b> { + #[inline] + fn next_back(&mut self) -> SearchStep { self.0.next_back() } +} +impl<'a, 'b> DoubleEndedSearcher<'a> for CharSliceSearcher<'a, 'b> {} + +// Pattern for predicates + +impl<'a, F: FnMut(char) -> bool> Pattern<'a> for F { + type Searcher = CharPredSearcher<'a, F>; + char_eq_pattern_impl!(CharPredSearcher<'a, F>, CharPredSearcher); +} + +pub struct CharPredSearcher<'a, F: FnMut(char) -> bool>(CharEqSearcher<'a, F>); + +unsafe impl<'a, F> Searcher<'a> for CharPredSearcher<'a, F> + where F: FnMut(char) -> bool +{ + #[inline] + fn haystack(&self) -> &'a str { self.0.haystack() } + #[inline] + fn next(&mut self) -> SearchStep { self.0.next() } +} +unsafe impl<'a, F> ReverseSearcher<'a> for CharPredSearcher<'a, F> + where F: FnMut(char) -> bool +{ + #[inline] + fn next_back(&mut self) -> SearchStep { self.0.next_back() } } +impl<'a, F> DoubleEndedSearcher<'a> for CharPredSearcher<'a, F> + where F: FnMut(char) -> bool +{} -/// Searches for chars that match the given predicate -impl<'a, F> Pattern<'a> for F where F: FnMut(char) -> bool { - type Searcher = as Pattern<'a>>::Searcher; - associated_items!( as Pattern<'a>>::Searcher, - s, CharEqPattern(s)); +// Pattern for &&str + +impl<'a, 'b> Pattern<'a> for &'b &'b str { + type Searcher = <&'b str as Pattern<'a>>::Searcher; + #[inline] + fn into_searcher(self, haystack: &'a str) + -> <&'b str as Pattern<'a>>::Searcher { + (*self).into_searcher(haystack) + } + #[inline] + fn is_contained_in(self, haystack: &'a str) -> bool { + (*self).is_contained_in(haystack) + } + #[inline] + fn is_prefix_of(self, haystack: &'a str) -> bool { + (*self).is_prefix_of(haystack) + } + #[inline] + fn is_suffix_of(self, haystack: &'a str) -> bool { + (*self).is_suffix_of(haystack) + } } diff --git a/src/libcoretest/cell.rs b/src/libcoretest/cell.rs index fff3cc14eadfd..85dd10390038f 100644 --- a/src/libcoretest/cell.rs +++ b/src/libcoretest/cell.rs @@ -59,7 +59,6 @@ fn double_imm_borrow() { fn no_mut_then_imm_borrow() { let x = RefCell::new(0); let _b1 = x.borrow_mut(); - assert!(x.try_borrow().is_none()); assert_eq!(x.borrow_state(), BorrowState::Writing); } @@ -67,7 +66,6 @@ fn no_mut_then_imm_borrow() { fn no_imm_then_borrow_mut() { let x = RefCell::new(0); let _b1 = x.borrow(); - assert!(x.try_borrow_mut().is_none()); assert_eq!(x.borrow_state(), BorrowState::Reading); } @@ -76,7 +74,6 @@ fn no_double_borrow_mut() { let x = RefCell::new(0); assert_eq!(x.borrow_state(), BorrowState::Unused); let _b1 = x.borrow_mut(); - assert!(x.try_borrow_mut().is_none()); assert_eq!(x.borrow_state(), BorrowState::Writing); } @@ -105,7 +102,7 @@ fn double_borrow_single_release_no_borrow_mut() { { let _b2 = x.borrow(); } - assert!(x.try_borrow_mut().is_none()); + assert_eq!(x.borrow_state(), BorrowState::Reading); } #[test] @@ -122,14 +119,14 @@ fn clone_ref_updates_flag() { let x = RefCell::new(0); { let b1 = x.borrow(); - assert!(x.try_borrow_mut().is_none()); + assert_eq!(x.borrow_state(), BorrowState::Reading); { let _b2 = clone_ref(&b1); - assert!(x.try_borrow_mut().is_none()); + assert_eq!(x.borrow_state(), BorrowState::Reading); } - assert!(x.try_borrow_mut().is_none()); + assert_eq!(x.borrow_state(), BorrowState::Reading); } - assert!(x.try_borrow_mut().is_some()); + assert_eq!(x.borrow_state(), BorrowState::Unused); } #[test] diff --git a/src/libcoretest/finally.rs b/src/libcoretest/finally.rs deleted file mode 100644 index 2a48395271db3..0000000000000 --- a/src/libcoretest/finally.rs +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright 2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -#![allow(deprecated)] - -use core::finally::{try_finally, Finally}; -use std::thread; - -#[test] -fn test_success() { - let mut i = 0; - try_finally( - &mut i, (), - |i, ()| { - *i = 10; - }, - |i| { - assert!(!thread::panicking()); - assert_eq!(*i, 10); - *i = 20; - }); - assert_eq!(i, 20); -} - -#[test] -#[should_panic] -fn test_fail() { - let mut i = 0; - try_finally( - &mut i, (), - |i, ()| { - *i = 10; - panic!(); - }, - |i| { - assert!(thread::panicking()); - assert_eq!(*i, 10); - }) -} - -#[test] -fn test_retval() { - let mut closure = || 10; - // FIXME(#16640) `: i32` annotation shouldn't be necessary - let i: i32 = closure.finally(|| { }); - assert_eq!(i, 10); -} - -#[test] -fn test_compact() { - fn do_some_fallible_work() {} - fn but_always_run_this_function() { } - let mut f = do_some_fallible_work; - f.finally(but_always_run_this_function); -} diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs index 15938a5dcb477..af80d347f028e 100644 --- a/src/libcoretest/iter.rs +++ b/src/libcoretest/iter.rs @@ -72,7 +72,7 @@ fn test_multi_iter() { #[test] fn test_counter_from_iter() { - let it = count(0, 5).take(10); + let it = (0..).step_by(5).take(10); let xs: Vec = FromIterator::from_iter(it); assert_eq!(xs, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]); } @@ -90,7 +90,7 @@ fn test_iterator_chain() { } assert_eq!(i, expected.len()); - let ys = count(30, 10).take(4); + let ys = (30..).step_by(10).take(4); let it = xs.iter().cloned().chain(ys); let mut i = 0; for x in it { @@ -102,7 +102,7 @@ fn test_iterator_chain() { #[test] fn test_filter_map() { - let it = count(0, 1).take(10) + let it = (0..).step_by(1).take(10) .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None }); assert_eq!(it.collect::>(), [0*0, 2*2, 4*4, 6*6, 8*8]); } @@ -244,7 +244,7 @@ fn test_iterator_scan() { fn test_iterator_flat_map() { let xs = [0, 3, 6]; let ys = [0, 1, 2, 3, 4, 5, 6, 7, 8]; - let it = xs.iter().flat_map(|&x| count(x, 1).take(3)); + let it = xs.iter().flat_map(|&x| (x..).step_by(1).take(3)); let mut i = 0; for x in it { assert_eq!(x, ys[i]); @@ -291,13 +291,13 @@ fn test_unfoldr() { #[test] fn test_cycle() { let cycle_len = 3; - let it = count(0, 1).take(cycle_len).cycle(); + let it = (0..).step_by(1).take(cycle_len).cycle(); assert_eq!(it.size_hint(), (usize::MAX, None)); for (i, x) in it.take(100).enumerate() { assert_eq!(i % cycle_len, x); } - let mut it = count(0, 1).take(0).cycle(); + let mut it = (0..).step_by(1).take(0).cycle(); assert_eq!(it.size_hint(), (0, Some(0))); assert_eq!(it.next(), None); } @@ -360,7 +360,7 @@ fn test_iterator_min() { #[test] fn test_iterator_size_hint() { - let c = count(0, 1); + let c = (0..).step_by(1); let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; let v2 = &[10, 11, 12]; let vi = v.iter(); diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs index 9cc3063dee678..7ae0dcbb5f9d4 100644 --- a/src/libcoretest/lib.rs +++ b/src/libcoretest/lib.rs @@ -39,7 +39,6 @@ mod atomic; mod cell; mod char; mod cmp; -mod finally; mod fmt; mod hash; mod iter; diff --git a/src/libcoretest/str.rs b/src/libcoretest/str.rs index 38cab4f0e0942..c935b5545740c 100644 --- a/src/libcoretest/str.rs +++ b/src/libcoretest/str.rs @@ -163,9 +163,9 @@ fn starts_short_long() { #[test] fn contains_weird_cases() { - assert!("* \t".contains_char(' ')); - assert!(!"* \t".contains_char('?')); - assert!(!"* \t".contains_char('\u{1F4A9}')); + assert!("* \t".contains(' ')); + assert!(!"* \t".contains('?')); + assert!(!"* \t".contains('\u{1F4A9}')); } #[test] @@ -347,11 +347,11 @@ malesuada sollicitudin quam eu fermentum!"); make_test!(chars_count, s, s.chars().count()); make_test!(contains_bang_str, s, s.contains("!")); - make_test!(contains_bang_char, s, s.contains_char('!')); + make_test!(contains_bang_char, s, s.contains('!')); make_test!(match_indices_a_str, s, s.match_indices("a").count()); - make_test!(split_str_a_str, s, s.split_str("a").count()); + make_test!(split_a_str, s, s.split("a").count()); make_test!(trim_ascii_char, s, { use std::ascii::AsciiExt; @@ -368,11 +368,11 @@ malesuada sollicitudin quam eu fermentum!"); make_test!(find_underscore_char, s, s.find('_')); make_test!(rfind_underscore_char, s, s.rfind('_')); - make_test!(find_underscore_str, s, s.find_str("_")); + make_test!(find_underscore_str, s, s.find("_")); make_test!(find_zzz_char, s, s.find('\u{1F4A4}')); make_test!(rfind_zzz_char, s, s.rfind('\u{1F4A4}')); - make_test!(find_zzz_str, s, s.find_str("\u{1F4A4}")); + make_test!(find_zzz_str, s, s.find("\u{1F4A4}")); make_test!(split_space_char, s, s.split(' ').count()); make_test!(split_terminator_space_char, s, s.split_terminator(' ').count()); @@ -380,6 +380,6 @@ malesuada sollicitudin quam eu fermentum!"); make_test!(splitn_space_char, s, s.splitn(10, ' ').count()); make_test!(rsplitn_space_char, s, s.rsplitn(10, ' ').count()); - make_test!(split_str_space_str, s, s.split_str(" ").count()); - make_test!(split_str_ad_str, s, s.split_str("ad").count()); + make_test!(split_space_str, s, s.split(" ").count()); + make_test!(split_ad_str, s, s.split("ad").count()); } diff --git a/src/librand/chacha.rs b/src/librand/chacha.rs index 91abb548d2ee1..44187a4fc9942 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/librustc/util/common.rs b/src/librustc/util/common.rs index 60ae053dbaf04..d71a68e205052 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -228,8 +228,9 @@ pub fn memoized(cache: &RefCell>, arg: T, f: F) -> #[cfg(unix)] pub fn path2cstr(p: &Path) -> CString { use std::os::unix::prelude::*; - use std::ffi::AsOsStr; - CString::new(p.as_os_str().as_bytes()).unwrap() + use std::ffi::OsStr; + let p: &OsStr = p.as_ref(); + CString::new(p.as_bytes()).unwrap() } #[cfg(windows)] pub fn path2cstr(p: &Path) -> CString { diff --git a/src/librustc_back/fs.rs b/src/librustc_back/fs.rs index 6d8891dd4fe07..d3f3b1dad7847 100644 --- a/src/librustc_back/fs.rs +++ b/src/librustc_back/fs.rs @@ -9,6 +9,7 @@ // except according to those terms. use std::io; +use std::env; #[allow(deprecated)] use std::old_path::{self, GenericPath}; #[allow(deprecated)] use std::old_io; use std::path::{Path, PathBuf}; @@ -29,9 +30,9 @@ pub fn realpath(original: &Path) -> io::Result { #[allow(deprecated)] fn old_realpath(original: &old_path::Path) -> old_io::IoResult { use std::old_io::fs; - use std::os; const MAX_LINKS_FOLLOWED: usize = 256; - let original = try!(os::getcwd()).join(original); + let original = old_path::Path::new(env::current_dir().unwrap() + .to_str().unwrap()).join(original); // Right now lstat on windows doesn't work quite well if cfg!(windows) { diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs index fe457841e9116..0814d53acd198 100644 --- a/src/librustc_back/lib.rs +++ b/src/librustc_back/lib.rs @@ -39,12 +39,10 @@ #![feature(io)] #![feature(old_io)] #![feature(old_path)] -#![feature(os)] #![feature(rustc_private)] #![feature(staged_api)] #![feature(rand)] #![feature(path_ext)] -#![feature(std_misc)] #![feature(step_by)] #![feature(convert)] #![cfg_attr(test, feature(test, rand))] diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs index 8f0387059e4a9..898f20e74518f 100644 --- a/src/librustc_back/sha2.rs +++ b/src/librustc_back/sha2.rs @@ -14,7 +14,7 @@ #![allow(deprecated)] // to_be32 -use std::iter::{range_step, repeat}; +use std::iter::repeat; use std::num::Int; use std::slice::bytes::{MutableByteVector, copy_memory}; use serialize::hex::ToHex; @@ -368,7 +368,7 @@ impl Engine256State { // Putting the message schedule inside the same loop as the round calculations allows for // the compiler to generate better code. - for t in range_step(0, 48, 8) { + for t in (0..48).step_by(8) { schedule_round!(t + 16); schedule_round!(t + 17); schedule_round!(t + 18); @@ -388,7 +388,7 @@ impl Engine256State { sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7); } - for t in range_step(48, 64, 8) { + for t in (48..64).step_by(8) { sha2_round!(a, b, c, d, e, f, g, h, K32, t); sha2_round!(h, a, b, c, d, e, f, g, K32, t + 1); sha2_round!(g, h, a, b, c, d, e, f, K32, t + 2); diff --git a/src/librustc_back/tempdir.rs b/src/librustc_back/tempdir.rs index d4503ae7fc987..6935499f5a0d4 100644 --- a/src/librustc_back/tempdir.rs +++ b/src/librustc_back/tempdir.rs @@ -11,7 +11,7 @@ use std::env; use std::io::{self, Error, ErrorKind}; use std::fs; -use std::path::{self, PathBuf, AsPath}; +use std::path::{self, PathBuf, Path}; use std::rand::{thread_rng, Rng}; /// A wrapper for a path to temporary directory implementing automatic @@ -36,10 +36,10 @@ impl TempDir { /// /// If no directory can be created, `Err` is returned. #[allow(deprecated)] // rand usage - pub fn new_in(tmpdir: &P, prefix: &str) - -> io::Result { + pub fn new_in>(tmpdir: P, prefix: &str) + -> io::Result { let storage; - let mut tmpdir = tmpdir.as_path(); + let mut tmpdir = tmpdir.as_ref(); if !tmpdir.is_absolute() { let cur_dir = try!(env::current_dir()); storage = cur_dir.join(tmpdir); diff --git a/src/librustc_llvm/archive_ro.rs b/src/librustc_llvm/archive_ro.rs index cc6a85e86ce07..647f4bc6a40fd 100644 --- a/src/librustc_llvm/archive_ro.rs +++ b/src/librustc_llvm/archive_ro.rs @@ -42,8 +42,9 @@ impl ArchiveRO { #[cfg(unix)] fn path2cstr(p: &Path) -> CString { use std::os::unix::prelude::*; - use std::ffi::AsOsStr; - CString::new(p.as_os_str().as_bytes()).unwrap() + use std::ffi::OsStr; + let p: &OsStr = p.as_ref(); + CString::new(p.as_bytes()).unwrap() } #[cfg(windows)] fn path2cstr(p: &Path) -> CString { diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index c7b5b2e75346f..cba2188ef7906 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -30,7 +30,7 @@ #![feature(libc)] #![feature(link_args)] #![feature(staged_api)] -#![cfg_attr(unix, feature(std_misc))] +#![cfg_attr(unix, feature(convert))] extern crate libc; #[macro_use] #[no_link] extern crate rustc_bitflags; diff --git a/src/librustdoc/flock.rs b/src/librustdoc/flock.rs index 8c85eaff23ce5..f8c56b68577b4 100644 --- a/src/librustdoc/flock.rs +++ b/src/librustdoc/flock.rs @@ -20,7 +20,7 @@ pub use self::imp::Lock; #[cfg(unix)] mod imp { - use std::ffi::{AsOsStr, CString}; + use std::ffi::{CString, OsStr}; use std::os::unix::prelude::*; use std::path::Path; use std::io; @@ -116,7 +116,8 @@ mod imp { impl Lock { pub fn new(p: &Path) -> Lock { - let buf = CString::new(p.as_os_str().as_bytes()).unwrap(); + let os: &OsStr = p.as_ref(); + let buf = CString::new(os.as_bytes()).unwrap(); let fd = unsafe { libc::open(buf.as_ptr(), libc::O_RDWR | libc::O_CREAT, libc::S_IRWXU) @@ -164,9 +165,9 @@ mod imp { #[cfg(windows)] mod imp { use libc; - use std::ffi::AsOsStr; use std::io; use std::mem; + use std::ffi::OsStr; use std::os::windows::prelude::*; use std::path::Path; use std::ptr; @@ -194,7 +195,8 @@ mod imp { impl Lock { pub fn new(p: &Path) -> Lock { - let mut p_16: Vec<_> = p.as_os_str().encode_wide().collect(); + let p: &OsStr = p.as_ref(); + let mut p_16: Vec<_> = p.encode_wide().collect(); p_16.push(0); let handle = unsafe { libc::CreateFileW(p_16.as_ptr(), diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index aa3195cbf018b..053ceceb49621 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -15,7 +15,7 @@ use self::BucketState::*; use clone::Clone; use cmp; use hash::{Hash, Hasher}; -use iter::{Iterator, ExactSizeIterator, count}; +use iter::{Iterator, ExactSizeIterator}; use marker::{Copy, Send, Sync, Sized, self}; use mem::{min_align_of, size_of}; use mem; diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index d8a95133d9414..9a68a60361c04 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -18,7 +18,7 @@ use prelude::v1::*; use env; -use ffi::{AsOsStr, CString, OsString}; +use ffi::{CString, OsString}; use mem; use path::{Path, PathBuf}; diff --git a/src/libstd/env.rs b/src/libstd/env.rs index 71f072302fb21..ec0e4b6737ffc 100644 --- a/src/libstd/env.rs +++ b/src/libstd/env.rs @@ -20,7 +20,7 @@ use prelude::v1::*; use iter::IntoIterator; use error::Error; -use ffi::{OsString, AsOsStr}; +use ffi::{OsStr, OsString}; use fmt; use io; use path::{Path, PathBuf}; @@ -176,7 +176,7 @@ impl Iterator for VarsOs { /// } /// ``` #[stable(feature = "env", since = "1.0.0")] -pub fn var(key: &K) -> Result where K: AsOsStr { +pub fn var(key: &K) -> Result where K: AsRef { match var_os(key) { Some(s) => s.into_string().map_err(VarError::NotUnicode), None => Err(VarError::NotPresent) @@ -198,9 +198,9 @@ pub fn var(key: &K) -> Result where K: AsOsStr { /// } /// ``` #[stable(feature = "env", since = "1.0.0")] -pub fn var_os(key: &K) -> Option where K: AsOsStr { +pub fn var_os(key: &K) -> Option where K: AsRef { let _g = ENV_LOCK.lock(); - os_imp::getenv(key.as_os_str()) + os_imp::getenv(key.as_ref()) } /// Possible errors from the `env::var` method. @@ -255,17 +255,17 @@ impl Error for VarError { /// ``` #[stable(feature = "env", since = "1.0.0")] pub fn set_var(k: &K, v: &V) - where K: AsOsStr, V: AsOsStr + where K: AsRef, V: AsRef { let _g = ENV_LOCK.lock(); - os_imp::setenv(k.as_os_str(), v.as_os_str()) + os_imp::setenv(k.as_ref(), v.as_ref()) } /// Remove a variable from the environment entirely. #[stable(feature = "env", since = "1.0.0")] -pub fn remove_var(k: &K) where K: AsOsStr { +pub fn remove_var(k: &K) where K: AsRef { let _g = ENV_LOCK.lock(); - os_imp::unsetenv(k.as_os_str()) + os_imp::unsetenv(k.as_ref()) } /// An iterator over `Path` instances for parsing an environment variable @@ -296,8 +296,8 @@ pub struct SplitPaths<'a> { inner: os_imp::SplitPaths<'a> } /// } /// ``` #[stable(feature = "env", since = "1.0.0")] -pub fn split_paths(unparsed: &T) -> SplitPaths { - SplitPaths { inner: os_imp::split_paths(unparsed.as_os_str()) } +pub fn split_paths + ?Sized>(unparsed: &T) -> SplitPaths { + SplitPaths { inner: os_imp::split_paths(unparsed.as_ref()) } } #[stable(feature = "env", since = "1.0.0")] @@ -340,7 +340,7 @@ pub struct JoinPathsError { /// ``` #[stable(feature = "env", since = "1.0.0")] pub fn join_paths(paths: I) -> Result - where I: IntoIterator, T: AsOsStr + where I: IntoIterator, T: AsRef { os_imp::join_paths(paths.into_iter()).map_err(|e| { JoinPathsError { inner: e } @@ -740,7 +740,7 @@ mod tests { let mut rng = rand::thread_rng(); let n = format!("TEST{}", rng.gen_ascii_chars().take(10) .collect::()); - let n = OsString::from_string(n); + let n = OsString::from(n); assert!(var_os(&n).is_none()); n } diff --git a/src/libstd/ffi/c_str.rs b/src/libstd/ffi/c_str.rs index a00f77080252c..544d6bcc2c645 100644 --- a/src/libstd/ffi/c_str.rs +++ b/src/libstd/ffi/c_str.rs @@ -132,15 +132,6 @@ pub struct CStr { #[stable(feature = "rust1", since = "1.0.0")] pub struct NulError(usize, Vec); -/// A conversion trait used by the constructor of `CString` for types that can -/// be converted to a vector of bytes. -#[deprecated(since = "1.0.0", reason = "use std::convert::Into> instead")] -#[unstable(feature = "std_misc")] -pub trait IntoBytes { - /// Consumes this container, returning a vector of bytes. - fn into_bytes(self) -> Vec; -} - impl CString { /// Create a new C-compatible string from a container of bytes. /// @@ -178,57 +169,6 @@ impl CString { } } - /// Create a new C-compatible string from a byte slice. - /// - /// This method will copy the data of the slice provided into a new - /// allocation, ensuring that there is a trailing 0 byte. - /// - /// # Examples - /// - /// ```no_run - /// # #![feature(libc)] - /// extern crate libc; - /// use std::ffi::CString; - /// - /// extern { fn puts(s: *const libc::c_char); } - /// - /// fn main() { - /// let to_print = CString::new("Hello!").unwrap(); - /// unsafe { - /// puts(to_print.as_ptr()); - /// } - /// } - /// ``` - /// - /// # Panics - /// - /// This function will panic if the provided slice contains any - /// interior nul bytes. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", reason = "use CString::new instead")] - #[allow(deprecated)] - pub fn from_slice(v: &[u8]) -> CString { - CString::from_vec(v.to_vec()) - } - - /// Create a C-compatible string from a byte vector. - /// - /// This method will consume ownership of the provided vector, appending a 0 - /// byte to the end after verifying that there are no interior 0 bytes. - /// - /// # Panics - /// - /// This function will panic if the provided slice contains any - /// interior nul bytes. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", reason = "use CString::new instead")] - pub fn from_vec(v: Vec) -> CString { - match v.iter().position(|x| *x == 0) { - Some(i) => panic!("null byte found in slice at: {}", i), - None => unsafe { CString::from_vec_unchecked(v) }, - } - } - /// Create a C-compatible string from a byte vector without checking for /// interior 0 bytes. /// @@ -424,41 +364,6 @@ impl Ord for CStr { } } -/// Deprecated in favor of `CStr` -#[unstable(feature = "std_misc")] -#[deprecated(since = "1.0.0", reason = "use CStr::from_ptr(p).to_bytes() instead")] -pub unsafe fn c_str_to_bytes<'a>(raw: &'a *const libc::c_char) -> &'a [u8] { - let len = libc::strlen(*raw); - slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize) -} - -/// Deprecated in favor of `CStr` -#[unstable(feature = "std_misc")] -#[deprecated(since = "1.0.0", - reason = "use CStr::from_ptr(p).to_bytes_with_nul() instead")] -pub unsafe fn c_str_to_bytes_with_nul<'a>(raw: &'a *const libc::c_char) - -> &'a [u8] { - let len = libc::strlen(*raw) + 1; - slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize) -} - -#[allow(deprecated)] -impl<'a> IntoBytes for &'a str { - fn into_bytes(self) -> Vec { self.as_bytes().to_vec() } -} -#[allow(deprecated)] -impl<'a> IntoBytes for &'a [u8] { - fn into_bytes(self) -> Vec { self.to_vec() } -} -#[allow(deprecated)] -impl IntoBytes for String { - fn into_bytes(self) -> Vec { self.into_bytes() } -} -#[allow(deprecated)] -impl IntoBytes for Vec { - fn into_bytes(self) -> Vec { self } -} - #[cfg(test)] mod tests { use prelude::v1::*; diff --git a/src/libstd/ffi/mod.rs b/src/libstd/ffi/mod.rs index f17dc6542491b..1b7e913d46cbf 100644 --- a/src/libstd/ffi/mod.rs +++ b/src/libstd/ffi/mod.rs @@ -13,17 +13,10 @@ #![stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")] -pub use self::c_str::{CString, CStr}; -pub use self::c_str::{NulError, IntoBytes}; -#[allow(deprecated)] -pub use self::c_str::c_str_to_bytes; -#[allow(deprecated)] -pub use self::c_str::c_str_to_bytes_with_nul; +pub use self::c_str::{CString, CStr, NulError}; #[stable(feature = "rust1", since = "1.0.0")] -pub use self::os_str::OsString; -#[stable(feature = "rust1", since = "1.0.0")] -pub use self::os_str::OsStr; +pub use self::os_str::{OsString, OsStr}; mod c_str; mod os_str; diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs index 49dbac4585bc3..d9a6a1006f4e1 100644 --- a/src/libstd/ffi/os_str.rs +++ b/src/libstd/ffi/os_str.rs @@ -29,7 +29,7 @@ //! for conversion to/from various other string types. Eventually these types //! will offer a full-fledged string API. -#![unstable(feature = "os", +#![unstable(feature = "os_str", reason = "recently added as part of path/io reform")] use core::prelude::*; @@ -61,22 +61,6 @@ pub struct OsStr { } impl OsString { - /// Constructs an `OsString` at no cost by consuming a `String`. - #[stable(feature = "rust1", since = "1.0.0")] - #[deprecated(since = "1.0.0", reason = "use `from` instead")] - pub fn from_string(s: String) -> OsString { - OsString::from(s) - } - - /// Constructs an `OsString` by copying from a `&str` slice. - /// - /// Equivalent to: `OsString::from_string(String::from_str(s))`. - #[stable(feature = "rust1", since = "1.0.0")] - #[deprecated(since = "1.0.0", reason = "use `from` instead")] - pub fn from_str(s: &str) -> OsString { - OsString::from(s) - } - /// Constructs a new empty `OsString`. #[stable(feature = "rust1", since = "1.0.0")] pub fn new() -> OsString { @@ -91,13 +75,6 @@ impl OsString { self.inner.into_string().map_err(|buf| OsString { inner: buf} ) } - /// Extend the string with the given `&OsStr` slice. - #[deprecated(since = "1.0.0", reason = "renamed to `push`")] - #[unstable(feature = "os")] - pub fn push_os_str(&mut self, s: &OsStr) { - self.inner.push_slice(&s.inner) - } - /// Extend the string with the given `&OsStr` slice. #[stable(feature = "rust1", since = "1.0.0")] pub fn push>(&mut self, s: T) { diff --git a/src/libstd/fs/mod.rs b/src/libstd/fs.rs similarity index 99% rename from src/libstd/fs/mod.rs rename to src/libstd/fs.rs index a3128ef0f8d95..071e5b5c28cfa 100644 --- a/src/libstd/fs/mod.rs +++ b/src/libstd/fs.rs @@ -25,11 +25,6 @@ use sys::fs2 as fs_imp; use sys_common::{AsInnerMut, FromInner, AsInner}; use vec::Vec; -#[allow(deprecated)] -pub use self::tempdir::TempDir; - -mod tempdir; - /// A reference to an open file on the filesystem. /// /// An instance of a `File` can be read and/or written depending on what options @@ -1327,7 +1322,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 +1617,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/fs/tempdir.rs b/src/libstd/fs/tempdir.rs deleted file mode 100644 index 8cc1dde98a0b8..0000000000000 --- a/src/libstd/fs/tempdir.rs +++ /dev/null @@ -1,127 +0,0 @@ -// Copyright 2015 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -#![unstable(feature = "tempdir", reason = "needs an RFC before stabilization")] -#![deprecated(since = "1.0.0", - reason = "use the `tempdir` crate from crates.io instead")] -#![allow(deprecated)] - -use prelude::v1::*; - -use env; -use io::{self, Error, ErrorKind}; -use fs; -use path::{self, PathBuf}; -use rand::{thread_rng, Rng}; - -/// A wrapper for a path to temporary directory implementing automatic -/// scope-based deletion. -pub struct TempDir { - path: Option, -} - -// How many times should we (re)try finding an unused random name? It should be -// enough that an attacker will run out of luck before we run out of patience. -const NUM_RETRIES: u32 = 1 << 31; -// How many characters should we include in a random file name? It needs to -// be enough to dissuade an attacker from trying to preemptively create names -// of that length, but not so huge that we unnecessarily drain the random number -// generator of entropy. -const NUM_RAND_CHARS: usize = 12; - -impl TempDir { - /// Attempts to make a temporary directory inside of `tmpdir` whose name - /// will have the prefix `prefix`. The directory will be automatically - /// deleted once the returned wrapper is destroyed. - /// - /// If no directory can be created, `Err` is returned. - #[allow(deprecated)] // rand usage - pub fn new_in>(tmpdir: P, prefix: &str) -> io::Result { - let storage; - let mut tmpdir = tmpdir.as_ref(); - if !tmpdir.is_absolute() { - let cur_dir = try!(env::current_dir()); - storage = cur_dir.join(tmpdir); - tmpdir = &storage; - // return TempDir::new_in(&cur_dir.join(tmpdir), prefix); - } - - let mut rng = thread_rng(); - for _ in 0..NUM_RETRIES { - let suffix: String = rng.gen_ascii_chars().take(NUM_RAND_CHARS).collect(); - let leaf = if prefix.len() > 0 { - format!("{}.{}", prefix, suffix) - } else { - // If we're given an empty string for a prefix, then creating a - // directory starting with "." would lead to it being - // semi-invisible on some systems. - suffix - }; - let path = tmpdir.join(&leaf); - match fs::create_dir(&path) { - Ok(_) => return Ok(TempDir { path: Some(path) }), - Err(ref e) if e.kind() == ErrorKind::AlreadyExists => {} - Err(e) => return Err(e) - } - } - - Err(Error::new(ErrorKind::AlreadyExists, - "too many temporary directories already exist", - None)) - } - - /// Attempts to make a temporary directory inside of `env::temp_dir()` whose - /// name will have the prefix `prefix`. The directory will be automatically - /// deleted once the returned wrapper is destroyed. - /// - /// If no directory can be created, `Err` is returned. - #[allow(deprecated)] - pub fn new(prefix: &str) -> io::Result { - TempDir::new_in(&env::temp_dir(), prefix) - } - - /// Unwrap the wrapped `std::path::Path` from the `TempDir` wrapper. - /// This discards the wrapper so that the automatic deletion of the - /// temporary directory is prevented. - pub fn into_path(mut self) -> PathBuf { - self.path.take().unwrap() - } - - /// Access the wrapped `std::path::Path` to the temporary directory. - pub fn path(&self) -> &path::Path { - self.path.as_ref().unwrap() - } - - /// Close and remove the temporary directory - /// - /// Although `TempDir` removes the directory on drop, in the destructor - /// any errors are ignored. To detect errors cleaning up the temporary - /// directory, call `close` instead. - pub fn close(mut self) -> io::Result<()> { - self.cleanup_dir() - } - - fn cleanup_dir(&mut self) -> io::Result<()> { - match self.path { - Some(ref p) => fs::remove_dir_all(p), - None => Ok(()) - } - } -} - -impl Drop for TempDir { - fn drop(&mut self) { - let _ = self.cleanup_dir(); - } -} - -// the tests for this module need to change the path using change_dir, -// and this doesn't play nicely with other tests so these unit tests are located -// in src/test/run-pass/tempfile.rs diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs index d8e403376bdc7..ad81143b7b4dc 100644 --- a/src/libstd/io/cursor.rs +++ b/src/libstd/io/cursor.rs @@ -281,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); @@ -303,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/error.rs b/src/libstd/io/error.rs index f445ace081e4f..615df771e9b44 100644 --- a/src/libstd/io/error.rs +++ b/src/libstd/io/error.rs @@ -9,7 +9,6 @@ // except according to those terms. use boxed::Box; -use clone::Clone; use error; use fmt; use option::Option::{self, Some, None}; @@ -179,27 +178,6 @@ impl Error { Repr::Custom(ref c) => c.kind, } } - - /// Returns a short description for this error message - #[unstable(feature = "io")] - #[deprecated(since = "1.0.0", reason = "use the Error trait's description \ - method instead")] - pub fn description(&self) -> &str { - match self.repr { - Repr::Os(..) => "os error", - Repr::Custom(ref c) => c.desc, - } - } - - /// Returns a detailed error message for this error (if one is available) - #[unstable(feature = "io")] - #[deprecated(since = "1.0.0", reason = "use the to_string() method instead")] - pub fn detail(&self) -> Option { - match self.repr { - Repr::Os(code) => Some(sys::os::error_string(code)), - Repr::Custom(ref s) => s.detail.clone(), - } - } } #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index b7cb8f9ed50fd..578e057cbb642 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -173,8 +173,6 @@ pub use core::clone; #[cfg(not(test))] pub use core::cmp; pub use core::convert; pub use core::default; -#[allow(deprecated)] -pub use core::finally; pub use core::hash; pub use core::intrinsics; pub use core::iter; diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs index 869faa795f9c3..9611e40e1e955 100644 --- a/src/libstd/net/tcp.rs +++ b/src/libstd/net/tcp.rs @@ -100,13 +100,6 @@ impl TcpStream { self.0.peer_addr() } - /// Returns the socket address of the local half of this TCP connection. - #[unstable(feature = "net")] - #[deprecated(since = "1.0.0", reason = "renamed to local_addr")] - pub fn socket_addr(&self) -> io::Result { - self.0.socket_addr() - } - /// Returns the socket address of the local half of this TCP connection. #[stable(feature = "rust1", since = "1.0.0")] pub fn local_addr(&self) -> io::Result { @@ -195,13 +188,6 @@ impl TcpListener { self.0.socket_addr() } - /// Deprecated, renamed to local_addr - #[unstable(feature = "net")] - #[deprecated(since = "1.0.0", reason = "renamed to local_addr")] - pub fn socket_addr(&self) -> io::Result { - self.0.socket_addr() - } - /// Create a new independently owned handle to the underlying socket. /// /// The returned `TcpListener` is a reference to the same socket that this @@ -349,7 +335,7 @@ mod tests { let _t = thread::spawn(move|| { let mut stream = t!(TcpStream::connect(&addr)); t!(stream.write(&[99])); - tx.send(t!(stream.socket_addr())).unwrap(); + tx.send(t!(stream.local_addr())).unwrap(); }); let (mut stream, addr) = t!(acceptor.accept()); @@ -499,7 +485,7 @@ mod tests { fn socket_and_peer_name_ip4() { each_ip(&mut |addr| { let listener = t!(TcpListener::bind(&addr)); - let so_name = t!(listener.socket_addr()); + let so_name = t!(listener.local_addr()); assert_eq!(addr, so_name); let _t = thread::spawn(move|| { t!(listener.accept()); diff --git a/src/libstd/net/udp.rs b/src/libstd/net/udp.rs index 811511149628e..85831c2de3444 100644 --- a/src/libstd/net/udp.rs +++ b/src/libstd/net/udp.rs @@ -80,13 +80,6 @@ impl UdpSocket { } } - /// Returns the socket address that this socket was created from. - #[unstable(feature = "net")] - #[deprecated(since = "1.0.0", reason = "renamed to local_addr")] - pub fn socket_addr(&self) -> io::Result { - self.0.socket_addr() - } - /// Returns the socket address that this socket was created from. #[stable(feature = "rust1", since = "1.0.0")] pub fn local_addr(&self) -> io::Result { @@ -203,7 +196,7 @@ mod tests { fn socket_name_ip4() { each_ip(&mut |addr, _| { let server = t!(UdpSocket::bind(&addr)); - assert_eq!(addr, t!(server.socket_addr())); + assert_eq!(addr, t!(server.local_addr())); }) } diff --git a/src/libstd/old_io/fs.rs b/src/libstd/old_io/fs.rs index 6aa63c395c625..bef6ea53e5085 100644 --- a/src/libstd/old_io/fs.rs +++ b/src/libstd/old_io/fs.rs @@ -951,7 +951,8 @@ mod test { pub fn tmpdir() -> TempDir { use os; use rand; - let ret = os::tmpdir().join(format!("rust-{}", rand::random::())); + let temp = Path::new(::env::temp_dir().to_str().unwrap()); + let ret = temp.join(format!("rust-{}", rand::random::())); check!(old_io::fs::mkdir(&ret, old_io::USER_RWX)); TempDir(ret) } @@ -1639,7 +1640,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 64803191d4f14..c92e74fbc565e 100644 --- a/src/libstd/old_io/mem.rs +++ b/src/libstd/old_io/mem.rs @@ -399,7 +399,7 @@ impl<'a> Buffer for BufReader<'a> { mod test { extern crate test as test_crate; use old_io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek, Buffer}; - use prelude::v1::{Ok, Err, Vec, AsSlice}; + use prelude::v1::{Ok, Err, Vec}; use prelude::v1::Iterator; use old_io; use iter::repeat; @@ -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/mod.rs b/src/libstd/old_io/mod.rs index df8ac78f7e581..9d7e1082d33b1 100644 --- a/src/libstd/old_io/mod.rs +++ b/src/libstd/old_io/mod.rs @@ -274,7 +274,7 @@ use mem::transmute; use ops::FnOnce; use option::Option; use option::Option::{Some, None}; -use os; +use sys::os; use boxed::Box; use result::Result; use result::Result::{Ok, Err}; diff --git a/src/libstd/old_io/pipe.rs b/src/libstd/old_io/pipe.rs index 26f2460047982..fd1df49473e58 100644 --- a/src/libstd/old_io/pipe.rs +++ b/src/libstd/old_io/pipe.rs @@ -124,9 +124,9 @@ mod test { use os; use old_io::pipe::PipeStream; - let os::Pipe { reader, writer } = unsafe { os::pipe().unwrap() }; - let out = PipeStream::open(writer); - let mut input = PipeStream::open(reader); + let (reader, writer) = unsafe { ::sys::os::pipe().unwrap() }; + let out = PipeStream::open(writer.unwrap()); + let mut input = PipeStream::open(reader.unwrap()); let (tx, rx) = channel(); let _t = thread::spawn(move|| { let mut out = out; diff --git a/src/libstd/old_io/process.rs b/src/libstd/old_io/process.rs index 06940bf6860a4..d0fa7dd6882be 100644 --- a/src/libstd/old_io/process.rs +++ b/src/libstd/old_io/process.rs @@ -246,7 +246,7 @@ impl Command { None => { // if the env is currently just inheriting from the parent's, // materialize the parent's env into a hashtable. - self.env = Some(os::env_as_bytes().into_iter().map(|(k, v)| { + self.env = Some(::env::vars().map(|(k, v)| { (EnvKey(CString::new(k).unwrap()), CString::new(v).unwrap()) }).collect()); @@ -764,11 +764,9 @@ impl Drop for Process { #[cfg(test)] mod tests { + use prelude::v1::*; use old_io::{Truncate, Write, TimedOut, timer, process, FileNotFound}; use old_io::{Reader, Writer}; - use prelude::v1::{Ok, Err, drop, Some, None, Vec}; - use prelude::v1::{String, Clone}; - use prelude::v1::{Str, AsSlice, ToString}; use old_path::{GenericPath, Path}; use old_io::fs::PathExtensions; use old_io::timer::*; @@ -1003,7 +1001,7 @@ mod tests { let prog = pwd_cmd().spawn().unwrap(); let output = String::from_utf8(prog.wait_with_output().unwrap().output).unwrap(); - let parent_dir = os::getcwd().unwrap(); + let parent_dir = Path::new(::env::current_dir().unwrap().to_str().unwrap()); let child_dir = Path::new(output.trim()); let parent_stat = parent_dir.stat().unwrap(); @@ -1018,7 +1016,7 @@ mod tests { use os; // test changing to the parent of os::getcwd() because we know // the path exists (and os::getcwd() is not expected to be root) - let parent_dir = os::getcwd().unwrap().dir_path(); + let parent_dir = Path::new(::env::current_dir().unwrap().to_str().unwrap()); let prog = pwd_cmd().cwd(&parent_dir).spawn().unwrap(); let output = String::from_utf8(prog.wait_with_output().unwrap().output).unwrap(); @@ -1058,11 +1056,11 @@ mod tests { let prog = env_cmd().spawn().unwrap(); let output = String::from_utf8(prog.wait_with_output().unwrap().output).unwrap(); - let r = os::env(); - for &(ref k, ref v) in &r { + let r = ::env::vars(); + for (k, v) in r { // don't check windows magical empty-named variables assert!(k.is_empty() || - output.contains(&format!("{}={}", *k, *v)), + output.contains(&format!("{}={}", k, v)), "output doesn't contain `{}={}`\n{}", k, v, output); } @@ -1076,16 +1074,12 @@ mod tests { let mut prog = env_cmd().spawn().unwrap(); let output = String::from_utf8(prog.wait_with_output().unwrap().output).unwrap(); - let r = os::env(); - for &(ref k, ref v) in &r { + let r = env::vars(); + for (k, v) in r { // don't check android RANDOM variables - if *k != "RANDOM".to_string() { - assert!(output.contains(&format!("{}={}", - *k, - *v)) || - output.contains(&format!("{}=\'{}\'", - *k, - *v))); + if k != "RANDOM".to_string() { + assert!(output.contains(&format!("{}={}", k, v)) || + output.contains(&format!("{}=\'{}\'", k, v))); } } } @@ -1100,9 +1094,9 @@ mod tests { // PATH to our sub-process. let path_val: String; let mut new_env = vec![("RUN_TEST_NEW_ENV", "123")]; - match os::getenv("PATH") { - None => {} - Some(val) => { + match ::env::var("PATH") { + Err(..) => {} + Ok(val) => { path_val = val; new_env.push(("PATH", &path_val)) } diff --git a/src/libstd/old_io/tempfile.rs b/src/libstd/old_io/tempfile.rs index 0a2cc517a0631..94faa5540bb30 100644 --- a/src/libstd/old_io/tempfile.rs +++ b/src/libstd/old_io/tempfile.rs @@ -100,7 +100,8 @@ impl TempDir { #[allow(deprecated)] pub fn new_in(tmpdir: &Path, prefix: &str) -> IoResult { if !tmpdir.is_absolute() { - let cur_dir = try!(::os::getcwd()); + let cur_dir = ::env::current_dir().unwrap(); + let cur_dir = Path::new(cur_dir.to_str().unwrap()); return TempDir::new_in(&cur_dir.join(tmpdir), prefix); } @@ -136,7 +137,8 @@ impl TempDir { /// If no directory can be created, `Err` is returned. #[allow(deprecated)] pub fn new(prefix: &str) -> IoResult { - TempDir::new_in(&::os::tmpdir(), prefix) + let tmp = Path::new(::env::temp_dir().to_str().unwrap()); + TempDir::new_in(&tmp, prefix) } /// Unwrap the wrapped `std::path::Path` from the `TempDir` wrapper. diff --git a/src/libstd/old_io/test.rs b/src/libstd/old_io/test.rs index db409ecde4526..8c46e2c06b84f 100644 --- a/src/libstd/old_io/test.rs +++ b/src/libstd/old_io/test.rs @@ -43,7 +43,7 @@ fn next_test_unix_socket() -> String { pub fn next_test_unix() -> Path { let string = next_test_unix_socket(); if cfg!(unix) { - ::os::tmpdir().join(string) + Path::new(::env::temp_dir().to_str().unwrap()).join(string) } else { Path::new(format!("{}{}", r"\\.\pipe\", string)) } diff --git a/src/libstd/old_path/mod.rs b/src/libstd/old_path/mod.rs index c405df2824e81..9c88533d3bac6 100644 --- a/src/libstd/old_path/mod.rs +++ b/src/libstd/old_path/mod.rs @@ -69,12 +69,13 @@ use core::marker::Sized; use ffi::CString; use clone::Clone; +use borrow::Cow; use fmt; use iter::Iterator; use option::Option; use option::Option::{None, Some}; use str; -use string::{String, CowString}; +use string::String; use vec::Vec; /// Typedef for POSIX file paths. @@ -907,7 +908,7 @@ impl<'a, P: GenericPath> Display<'a, P> { /// If the path is not UTF-8, invalid sequences will be replaced with the /// Unicode replacement char. This involves allocation. #[inline] - pub fn as_cow(&self) -> CowString<'a> { + pub fn as_cow(&self) -> Cow<'a, str> { String::from_utf8_lossy(if self.filename { match self.path.filename() { None => { diff --git a/src/libstd/old_path/posix.rs b/src/libstd/old_path/posix.rs index bbc1756bee632..f215e73202c17 100644 --- a/src/libstd/old_path/posix.rs +++ b/src/libstd/old_path/posix.rs @@ -20,7 +20,7 @@ use iter::{Iterator, Map}; use marker::Sized; use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; -use slice::{AsSlice, Split, SliceConcatExt}; +use slice::{Split, SliceConcatExt}; use str::{self, FromStr}; use vec::Vec; @@ -339,11 +339,11 @@ impl Path { /// Returns a normalized byte vector representation of a path, by removing all empty /// components, and unnecessary . and .. components. - fn normalize>(v: &V) -> Vec { + fn normalize(v: &[u8]) -> Vec { // borrowck is being very picky let val = { - let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE; - let v_ = if is_abs { &v.as_slice()[1..] } else { v.as_slice() }; + let is_abs = !v.is_empty() && v[0] == SEP_BYTE; + let v_ = if is_abs { &v[1..] } else { v }; let comps = normalize_helper(v_, is_abs); match comps { None => None, @@ -371,7 +371,7 @@ impl Path { } }; match val { - None => v.as_slice().to_vec(), + None => v.to_vec(), Some(val) => val } } @@ -446,8 +446,7 @@ mod tests { use clone::Clone; use option::Option::{self, Some, None}; use old_path::GenericPath; - use slice::AsSlice; - use str::{self, Str}; + use str; use string::ToString; use vec::Vec; use iter::Iterator; diff --git a/src/libstd/old_path/windows.rs b/src/libstd/old_path/windows.rs index bd67855bf1b8c..0b88f368b3952 100644 --- a/src/libstd/old_path/windows.rs +++ b/src/libstd/old_path/windows.rs @@ -1129,8 +1129,6 @@ mod tests { use iter::Iterator; use option::Option::{self, Some, None}; use old_path::GenericPath; - use slice::AsSlice; - use str::Str; use string::ToString; use vec::Vec; diff --git a/src/libstd/os.rs b/src/libstd/os.rs index e19c734b8a3ac..ee0f04cb9911c 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -8,1826 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! Higher-level interfaces to libc::* functions and operating system services. -//! -//! In general these take and return rust types, use rust idioms (enums, -//! closures, vectors) rather than C idioms, and do more extensive safety -//! checks. -//! -//! This module is not meant to only contain 1:1 mappings to libc entries; any -//! os-interface code that is reasonably useful and broadly applicable can go -//! here. Including utility routines that merely build on other os code. -//! -//! We assume the general case is that users do not care, and do not want to be -//! made to care, which operating system they are on. While they may want to -//! special case various special cases -- and so we will not _hide_ the facts of -//! which OS the user is on -- they should be given the opportunity to write -//! OS-ignorant code by default. +//! OS-specific functionality -#![unstable(feature = "os")] -#![deprecated(since = "1.0.0", reason = "replaced with std::env APIs")] - -#![allow(missing_docs)] -#![allow(non_snake_case)] -#![allow(unused_imports)] -#![allow(deprecated)] - -use self::MemoryMapKind::*; -use self::MapOption::*; -use self::MapError::*; - -use boxed::Box; -use clone::Clone; -use convert::From; -use env; -use error::{FromError, Error}; -use ffi::{OsString, OsStr}; -use fmt; -use iter::Iterator; -use libc::{c_void, c_int, c_char}; -use libc; -use marker::{Copy, Send}; -use old_io::{IoResult, IoError}; -use ops::{Drop, FnOnce}; -use option::Option::{Some, None}; -use option::Option; -use old_path::{Path, GenericPath, BytesContainer}; -use path::{self, PathBuf}; -use ptr; -use result::Result::{Err, Ok}; -use result::Result; -use slice::AsSlice; -use str::Str; -use str; -use string::{String, ToString}; -use sync::atomic::{AtomicIsize, ATOMIC_ISIZE_INIT, Ordering}; -use sys::os as os_imp; -use sys; -use vec::Vec; - -#[cfg(unix)] use ffi::{self, CString}; +#![stable(feature = "os", since = "1.0.0")] #[cfg(unix)] pub use sys::ext as unix; #[cfg(windows)] pub use sys::ext as windows; - -fn err2old(new: ::io::Error) -> IoError { - IoError { - kind: ::old_io::OtherIoError, - desc: "os error", - detail: Some(new.to_string()), - } -} - -#[cfg(windows)] -fn path2new(path: &Path) -> PathBuf { - PathBuf::from(path.as_str().unwrap()) -} -#[cfg(unix)] -fn path2new(path: &Path) -> PathBuf { - use os::unix::prelude::*; - PathBuf::from(::from_bytes(path.as_vec())) -} - -#[cfg(unix)] -fn path2old(path: &path::Path) -> Path { - use os::unix::prelude::*; - use ffi::AsOsStr; - Path::new(path.as_os_str().as_bytes()) -} -#[cfg(windows)] -fn path2old(path: &path::Path) -> Path { - Path::new(path.to_str().unwrap()) -} - -/// Get the number of cores available -pub fn num_cpus() -> usize { - unsafe { - return rust_get_num_cpus() as usize; - } - - extern { - fn rust_get_num_cpus() -> libc::uintptr_t; - } -} - -pub const TMPBUF_SZ : usize = 1000; - -/// Returns the current working directory as a `Path`. -/// -/// # Errors -/// -/// Returns an `Err` if the current working directory value is invalid. -/// Possible cases: -/// -/// * Current directory does not exist. -/// * There are insufficient permissions to access the current directory. -/// * The internal buffer is not large enough to hold the path. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os, old_path)] -/// use std::os; -/// use std::old_path::{Path, GenericPath}; -/// -/// // We assume that we are in a valid directory. -/// let current_working_directory = os::getcwd().unwrap(); -/// println!("The current directory is {:?}", current_working_directory.display()); -/// ``` -#[unstable(feature = "os")] -pub fn getcwd() -> IoResult { - env::current_dir().map_err(err2old).map(|s| path2old(&s)) -} - -/// Returns a vector of (variable, value) pairs, for all the environment -/// variables of the current process. -/// -/// Invalid UTF-8 bytes are replaced with \uFFFD. See `String::from_utf8_lossy()` -/// for details. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os)] -/// use std::os; -/// -/// // We will iterate through the references to the element returned by os::env(); -/// for &(ref key, ref value) in os::env().iter() { -/// println!("'{}': '{}'", key, value ); -/// } -/// ``` -#[deprecated(since = "1.0.0", reason = "use env::vars instead")] -#[unstable(feature = "os")] -pub fn env() -> Vec<(String,String)> { - env::vars_os().map(|(k, v)| { - (k.to_string_lossy().into_owned(), v.to_string_lossy().into_owned()) - }).collect() -} - -/// Returns a vector of (variable, value) byte-vector pairs for all the -/// environment variables of the current process. -#[deprecated(since = "1.0.0", reason = "use env::vars_os instead")] -#[unstable(feature = "os")] -pub fn env_as_bytes() -> Vec<(Vec, Vec)> { - env::vars_os().map(|(k, v)| (byteify(k), byteify(v))).collect() -} - -/// Fetches the environment variable `n` from the current process, returning -/// None if the variable isn't set. -/// -/// Any invalid UTF-8 bytes in the value are replaced by \uFFFD. See -/// `String::from_utf8_lossy()` for details. -/// -/// # Panics -/// -/// Panics if `n` has any interior NULs. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os)] -/// use std::os; -/// -/// let key = "HOME"; -/// match os::getenv(key) { -/// Some(val) => println!("{}: {}", key, val), -/// None => println!("{} is not defined in the environment.", key) -/// } -/// ``` -#[deprecated(since = "1.0.0", reason = "use env::var instead")] -#[unstable(feature = "os")] -pub fn getenv(n: &str) -> Option { - env::var(n).ok() -} - -/// Fetches the environment variable `n` byte vector from the current process, -/// returning None if the variable isn't set. -/// -/// # Panics -/// -/// Panics if `n` has any interior NULs. -#[deprecated(since = "1.0.0", reason = "use env::var_os instead")] -#[unstable(feature = "os")] -pub fn getenv_as_bytes(n: &str) -> Option> { - env::var_os(n).map(byteify) -} - -#[cfg(unix)] -fn byteify(s: OsString) -> Vec { - use os::unix::prelude::*; - s.into_vec() -} -#[cfg(windows)] -fn byteify(s: OsString) -> Vec { - s.to_string_lossy().as_bytes().to_vec() -} - -/// Sets the environment variable `n` to the value `v` for the currently running -/// process. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os)] -/// use std::os; -/// -/// let key = "KEY"; -/// os::setenv(key, "VALUE"); -/// match os::getenv(key) { -/// Some(ref val) => println!("{}: {}", key, val), -/// None => println!("{} is not defined in the environment.", key) -/// } -/// ``` -#[deprecated(since = "1.0.0", reason = "renamed to env::set_var")] -#[unstable(feature = "os")] -pub fn setenv(n: &str, v: T) { - #[cfg(unix)] - fn _setenv(n: &str, v: &[u8]) { - use os::unix::prelude::*; - let v: OsString = OsStringExt::from_vec(v.to_vec()); - env::set_var(n, &v) - } - - #[cfg(windows)] - fn _setenv(n: &str, v: &[u8]) { - let v = str::from_utf8(v).unwrap(); - env::set_var(n, v) - } - - _setenv(n, v.container_as_bytes()) -} - -/// Remove a variable from the environment entirely. -#[deprecated(since = "1.0.0", reason = "renamed to env::remove_var")] -#[unstable(feature = "os")] -pub fn unsetenv(n: &str) { - env::remove_var(n) -} - -/// Parses input according to platform conventions for the `PATH` -/// environment variable. -/// -/// # Examples -/// -/// ``` -/// # #![feature(old_path, os)] -/// use std::os; -/// use std::old_path::{Path, GenericPath}; -/// -/// let key = "PATH"; -/// match os::getenv_as_bytes(key) { -/// Some(paths) => { -/// for path in os::split_paths(paths).iter() { -/// println!("'{}'", path.display()); -/// } -/// } -/// None => println!("{} is not defined in the environment.", key) -/// } -/// ``` -#[unstable(feature = "os")] -pub fn split_paths(unparsed: T) -> Vec { - let b = unparsed.container_as_bytes(); - let s = str::from_utf8(b).unwrap(); - env::split_paths(s).map(|s| path2old(&s)).collect() -} - -/// Joins a collection of `Path`s appropriately for the `PATH` -/// environment variable. -/// -/// Returns a `Vec` on success, since `Path`s are not utf-8 -/// encoded on all platforms. -/// -/// Returns an `Err` (containing an error message) if one of the input -/// `Path`s contains an invalid character for constructing the `PATH` -/// variable (a double quote on Windows or a colon on Unix). -/// -/// # Examples -/// -/// ``` -/// # #![feature(os, old_path, core)] -/// use std::os; -/// use std::old_path::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()); -/// ``` -#[unstable(feature = "os")] -pub fn join_paths(paths: &[T]) -> Result, &'static str> { - env::join_paths(paths.iter().map(|s| { - str::from_utf8(s.container_as_bytes()).unwrap() - })).map(|s| { - s.to_string_lossy().into_owned().into_bytes() - }).map_err(|_| "failed to join paths") -} - -/// A low-level OS in-memory pipe. -#[derive(Copy)] -pub struct Pipe { - /// A file descriptor representing the reading end of the pipe. Data written - /// on the `out` file descriptor can be read from this file descriptor. - pub reader: c_int, - /// A file descriptor representing the write end of the pipe. Data written - /// to this file descriptor can be read from the `input` file descriptor. - pub writer: c_int, -} - -/// Creates a new low-level OS in-memory pipe. -/// -/// This function can fail to succeed if there are no more resources available -/// to allocate a pipe. -/// -/// This function is also unsafe as there is no destructor associated with the -/// `Pipe` structure will return. If it is not arranged for the returned file -/// descriptors to be closed, the file descriptors will leak. For safe handling -/// of this scenario, use `std::old_io::PipeStream` instead. -pub unsafe fn pipe() -> IoResult { - let (reader, writer) = try!(sys::os::pipe()); - Ok(Pipe { - reader: reader.unwrap(), - writer: writer.unwrap(), - }) -} - -/// Returns the proper dll filename for the given basename of a file -/// as a String. -#[cfg(not(target_os="ios"))] -#[deprecated(since = "1.0.0", reason = "this function will be removed, use the constants directly")] -#[unstable(feature = "os")] -#[allow(deprecated)] -pub fn dll_filename(base: &str) -> String { - format!("{}{}{}", consts::DLL_PREFIX, base, consts::DLL_SUFFIX) -} - -/// Optionally returns the filesystem path to the current executable which is -/// running but with the executable name. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os, old_path)] -/// use std::os; -/// use std::old_path::{Path, GenericPath}; -/// -/// match os::self_exe_name() { -/// Some(exe_path) => println!("Path of this executable is: {}", exe_path.display()), -/// None => println!("Unable to get the path of this executable!") -/// }; -/// ``` -#[unstable(feature = "os")] -pub fn self_exe_name() -> Option { - env::current_exe().ok().map(|p| path2old(&p)) -} - -/// Optionally returns the filesystem path to the current executable which is -/// running. -/// -/// Like self_exe_name() but without the binary's name. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os, old_path)] -/// use std::os; -/// use std::old_path::{Path, GenericPath}; -/// -/// match os::self_exe_path() { -/// Some(exe_path) => println!("Executable's Path is: {}", exe_path.display()), -/// None => println!("Impossible to fetch the path of this executable.") -/// }; -/// ``` -#[unstable(feature = "os")] -pub fn self_exe_path() -> Option { - env::current_exe().ok().map(|p| { let mut p = path2old(&p); p.pop(); p }) -} - -/// Optionally returns the path to the current user's home directory if known. -/// -/// # Unix -/// -/// Returns the value of the 'HOME' environment variable if it is set -/// and not equal to the empty string. -/// -/// # Windows -/// -/// Returns the value of the 'HOME' environment variable if it is -/// set and not equal to the empty string. Otherwise, returns the value of the -/// 'USERPROFILE' environment variable if it is set and not equal to the empty -/// string. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os, old_path)] -/// use std::os; -/// use std::old_path::{Path, GenericPath}; -/// -/// match os::homedir() { -/// Some(ref p) => println!("{}", p.display()), -/// None => println!("Impossible to get your home dir!") -/// } -/// ``` -#[unstable(feature = "os")] -#[allow(deprecated)] -pub fn homedir() -> Option { - #[inline] - #[cfg(unix)] - fn _homedir() -> Option { - aux_homedir("HOME") - } - - #[inline] - #[cfg(windows)] - fn _homedir() -> Option { - aux_homedir("HOME").or(aux_homedir("USERPROFILE")) - } - - #[inline] - fn aux_homedir(home_name: &str) -> Option { - match getenv_as_bytes(home_name) { - Some(p) => { - if p.is_empty() { None } else { Path::new_opt(p) } - }, - _ => None - } - } - _homedir() -} - -/// Returns the path to a temporary directory. -/// -/// On Unix, returns the value of the 'TMPDIR' environment variable if it is -/// set, otherwise for non-Android it returns '/tmp'. If Android, since there -/// is no global temporary folder (it is usually allocated per-app), we return -/// '/data/local/tmp'. -/// -/// 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. -#[unstable(feature = "os")] -#[allow(deprecated)] -pub fn tmpdir() -> Path { - return lookup(); - - fn getenv_nonempty(v: &str) -> Option { - match getenv(v) { - Some(x) => - if x.is_empty() { - None - } else { - Path::new_opt(x) - }, - _ => None - } - } - - #[cfg(unix)] - fn lookup() -> Path { - let default = if cfg!(target_os = "android") { - Path::new("/data/local/tmp") - } else { - Path::new("/tmp") - }; - - getenv_nonempty("TMPDIR").unwrap_or(default) - } - - #[cfg(windows)] - fn lookup() -> Path { - getenv_nonempty("TMP").or( - getenv_nonempty("TEMP").or( - getenv_nonempty("USERPROFILE").or( - getenv_nonempty("WINDIR")))).unwrap_or(Path::new("C:\\Windows")) - } -} - -/// Convert a relative path to an absolute path -/// -/// If the given path is relative, return it prepended with the current working -/// directory. If the given path is already an absolute path, return it -/// as is. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os, old_path)] -/// use std::os; -/// use std::old_path::{Path, GenericPath}; -/// -/// // Assume we're in a path like /home/someuser -/// let rel_path = Path::new(".."); -/// let abs_path = os::make_absolute(&rel_path).unwrap(); -/// println!("The absolute path is {}", abs_path.display()); -/// // Prints "The absolute path is /home" -/// ``` -// NB: this is here rather than in path because it is a form of environment -// querying; what it does depends on the process working directory, not just -// the input paths. -#[deprecated(since = "1.0.0", reason = "use env::current_dir + .join directly")] -#[unstable(feature = "os")] -pub fn make_absolute(p: &Path) -> IoResult { - if p.is_absolute() { - Ok(p.clone()) - } else { - env::current_dir().map_err(err2old).map(|cwd| { - let mut cwd = path2old(&cwd); - cwd.push(p); - cwd - }) - } -} - -/// Changes the current working directory to the specified path, returning -/// whether the change was completed successfully or not. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os, old_path)] -/// use std::os; -/// use std::old_path::{Path, GenericPath}; -/// -/// let root = Path::new("/"); -/// assert!(os::change_dir(&root).is_ok()); -/// println!("Successfully changed working directory to {}!", root.display()); -/// ``` -#[unstable(feature = "os")] -pub fn change_dir(p: &Path) -> IoResult<()> { - sys::os::chdir(&path2new(p)).map_err(err2old) -} - -/// Returns the platform-specific value of errno -pub fn errno() -> i32 { - sys::os::errno() as i32 -} - -/// Return the string corresponding to an `errno()` value of `errnum`. -/// -/// # Examples -/// -/// ``` -/// # #![feature(os)] -/// use std::os; -/// -/// // Same as println!("{}", last_os_error()); -/// println!("{}", os::error_string(os::errno() as i32)); -/// ``` -pub fn error_string(errnum: i32) -> String { - return sys::os::error_string(errnum); -} - -/// Get a string representing the platform-dependent last error -pub fn last_os_error() -> String { - error_string(errno()) -} - -/// Sets the process exit code -/// -/// Sets the exit code returned by the process if all supervised tasks -/// terminate successfully (without panicking). If the current root task panics -/// and is supervised by the scheduler then any user-specified exit status is -/// ignored and the process exits with the default panic status. -/// -/// Note that this is not synchronized against modifications of other threads. -#[deprecated(since = "1.0.0", reason = "renamed to env::set_exit_status")] -#[unstable(feature = "os")] -pub fn set_exit_status(code: isize) { - env::set_exit_status(code as i32) -} - -/// Fetches the process's current exit code. This defaults to 0 and can change -/// by calling `set_exit_status`. -#[deprecated(since = "1.0.0", reason = "renamed to env::get_exit_status")] -#[unstable(feature = "os")] -pub fn get_exit_status() -> isize { - env::get_exit_status() as isize -} - -#[cfg(target_os = "macos")] -unsafe fn load_argc_and_argv(argc: isize, - argv: *const *const c_char) -> Vec> { - use ffi::CStr; - - (0..argc).map(|i| { - CStr::from_ptr(*argv.offset(i)).to_bytes().to_vec() - }).collect() -} - -/// Returns the command line arguments -/// -/// Returns a list of the command line arguments. -#[cfg(target_os = "macos")] -fn real_args_as_bytes() -> Vec> { - unsafe { - let (argc, argv) = (*_NSGetArgc() as isize, - *_NSGetArgv() as *const *const c_char); - load_argc_and_argv(argc, argv) - } -} - -// As _NSGetArgc and _NSGetArgv aren't mentioned in iOS docs -// and use underscores in their names - they're most probably -// are considered private and therefore should be avoided -// Here is another way to get arguments using Objective C -// runtime -// -// In general it looks like: -// res = Vec::new() -// let args = [[NSProcessInfo processInfo] arguments] -// for i in 0..[args count] -// res.push([args objectAtIndex:i]) -// res -#[cfg(target_os = "ios")] -fn real_args_as_bytes() -> Vec> { - use ffi::CStr; - use iter::range; - use mem; - - #[link(name = "objc")] - extern { - fn sel_registerName(name: *const libc::c_uchar) -> Sel; - fn objc_msgSend(obj: NsId, sel: Sel, ...) -> NsId; - fn objc_getClass(class_name: *const libc::c_uchar) -> NsId; - } - - #[link(name = "Foundation", kind = "framework")] - extern {} - - type Sel = *const libc::c_void; - type NsId = *const libc::c_void; - - let mut res = Vec::new(); - - unsafe { - let processInfoSel = sel_registerName("processInfo\0".as_ptr()); - let argumentsSel = sel_registerName("arguments\0".as_ptr()); - let utf8Sel = sel_registerName("UTF8String\0".as_ptr()); - let countSel = sel_registerName("count\0".as_ptr()); - let objectAtSel = sel_registerName("objectAtIndex:\0".as_ptr()); - - let klass = objc_getClass("NSProcessInfo\0".as_ptr()); - let info = objc_msgSend(klass, processInfoSel); - let args = objc_msgSend(info, argumentsSel); - - let cnt: isize = mem::transmute(objc_msgSend(args, countSel)); - for i in 0..cnt { - let tmp = objc_msgSend(args, objectAtSel, i); - let utf_c_str: *const libc::c_char = - mem::transmute(objc_msgSend(tmp, utf8Sel)); - res.push(CStr::from_ptr(utf_c_str).to_bytes().to_vec()); - } - } - - res -} - -#[cfg(any(target_os = "linux", - target_os = "android", - target_os = "freebsd", - target_os = "dragonfly", - target_os = "bitrig", - target_os = "openbsd"))] -fn real_args_as_bytes() -> Vec> { - use rt; - rt::args::clone().unwrap_or_else(|| vec![]) -} - -#[cfg(not(windows))] -fn real_args() -> Vec { - real_args_as_bytes().into_iter() - .map(|v| { - String::from_utf8_lossy(&v).into_owned() - }).collect() -} - -#[cfg(windows)] -fn real_args() -> Vec { - use slice; - use iter::range; - - let mut nArgs: c_int = 0; - let lpArgCount: *mut c_int = &mut nArgs; - let lpCmdLine = unsafe { GetCommandLineW() }; - let szArgList = unsafe { CommandLineToArgvW(lpCmdLine, lpArgCount) }; - - let args: Vec<_> = (0..nArgs as usize).map(|i| unsafe { - // Determine the length of this argument. - let ptr = *szArgList.offset(i as isize); - let mut len = 0; - while *ptr.offset(len as isize) != 0 { len += 1; } - - // Push it onto the list. - let ptr = ptr as *const u16; - let buf = slice::from_raw_parts(ptr, len); - let opt_s = String::from_utf16(sys::truncate_utf16_at_nul(buf)); - opt_s.ok().expect("CommandLineToArgvW returned invalid UTF-16") - }).collect(); - - unsafe { - LocalFree(szArgList as *mut c_void); - } - - return args -} - -#[cfg(windows)] -fn real_args_as_bytes() -> Vec> { - real_args().into_iter().map(|s| s.into_bytes()).collect() -} - -type LPCWSTR = *const u16; - -#[cfg(windows)] -#[link_name="kernel32"] -extern "system" { - fn GetCommandLineW() -> LPCWSTR; - fn LocalFree(ptr: *mut c_void); -} - -#[cfg(windows)] -#[link_name="shell32"] -extern "system" { - fn CommandLineToArgvW(lpCmdLine: LPCWSTR, - pNumArgs: *mut c_int) -> *mut *mut u16; -} - -/// Returns the arguments which this program was started with (normally passed -/// via the command line). -/// -/// The first element is traditionally the path to the executable, but it can be -/// set to arbitrary text, and it may not even exist, so this property should not -/// be relied upon for security purposes. -/// -/// The arguments are interpreted as utf-8, with invalid bytes replaced with \uFFFD. -/// See `String::from_utf8_lossy` for details. -/// # Examples -/// -/// ``` -/// # #![feature(os)] -/// use std::os; -/// -/// // Prints each argument on a separate line -/// for argument in os::args().iter() { -/// println!("{}", argument); -/// } -/// ``` -#[deprecated(since = "1.0.0", reason = "use std::env::args() instead")] -#[unstable(feature = "os")] -pub fn args() -> Vec { - real_args() -} - -/// Returns the arguments which this program was started with (normally passed -/// via the command line) as byte vectors. -#[deprecated(since = "1.0.0", reason = "use env::args_os instead")] -#[unstable(feature = "os")] -pub fn args_as_bytes() -> Vec> { - real_args_as_bytes() -} - -#[cfg(target_os = "macos")] -extern { - // These functions are in crt_externs.h. - fn _NSGetArgc() -> *mut c_int; - fn _NSGetArgv() -> *mut *mut *mut c_char; -} - -/// Returns the page size of the current architecture in bytes. -#[deprecated(since = "1.0.0", reason = "renamed to env::page_size")] -#[unstable(feature = "os")] -pub fn page_size() -> usize { - sys::os::page_size() -} - -/// A memory mapped file or chunk of memory. This is a very system-specific -/// interface to the OS's memory mapping facilities (`mmap` on POSIX, -/// `VirtualAlloc`/`CreateFileMapping` on Windows). It makes no attempt at -/// abstracting platform differences, besides in error values returned. Consider -/// yourself warned. -/// -/// The memory map is released (unmapped) when the destructor is run, so don't -/// let it leave scope by accident if you want it to stick around. -pub struct MemoryMap { - data: *mut u8, - len: usize, - kind: MemoryMapKind, -} - -/// Type of memory map -#[allow(raw_pointer_derive)] -#[derive(Copy)] -pub enum MemoryMapKind { - /// Virtual memory map. Usually used to change the permissions of a given - /// chunk of memory. Corresponds to `VirtualAlloc` on Windows. - MapFile(*const u8), - /// Virtual memory map. Usually used to change the permissions of a given - /// chunk of memory, or for allocation. Corresponds to `VirtualAlloc` on - /// Windows. - MapVirtual -} - -/// Options the memory map is created with -#[allow(raw_pointer_derive)] -#[derive(Copy)] -pub enum MapOption { - /// The memory should be readable - MapReadable, - /// The memory should be writable - MapWritable, - /// The memory should be executable - MapExecutable, - /// Create a map for a specific address range. Corresponds to `MAP_FIXED` on - /// POSIX. - MapAddr(*const u8), - /// Create a memory mapping for a file with a given HANDLE. - #[cfg(windows)] - MapFd(libc::HANDLE), - /// Create a memory mapping for a file with a given fd. - #[cfg(not(windows))] - MapFd(c_int), - /// When using `MapFd`, the start of the map is `usize` bytes from the start - /// of the file. - MapOffset(usize), - /// On POSIX, this can be used to specify the default flags passed to - /// `mmap`. By default it uses `MAP_PRIVATE` and, if not using `MapFd`, - /// `MAP_ANON`. This will override both of those. This is platform-specific - /// (the exact values used) and ignored on Windows. - MapNonStandardFlags(c_int), -} - -/// Possible errors when creating a map. -#[derive(Copy, Debug)] -pub enum MapError { - /// # The following are POSIX-specific - /// - /// fd was not open for reading or, if using `MapWritable`, was not open for - /// writing. - ErrFdNotAvail, - /// fd was not valid - ErrInvalidFd, - /// Either the address given by `MapAddr` or offset given by `MapOffset` was - /// not a multiple of `MemoryMap::granularity` (unaligned to page size). - ErrUnaligned, - /// With `MapFd`, the fd does not support mapping. - ErrNoMapSupport, - /// If using `MapAddr`, the address + `min_len` was outside of the process's - /// address space. If using `MapFd`, the target of the fd didn't have enough - /// resources to fulfill the request. - ErrNoMem, - /// A zero-length map was requested. This is invalid according to - /// [POSIX](http://pubs.opengroup.org/onlinepubs/9699919799/functions/mmap.html). - /// Not all platforms obey this, but this wrapper does. - ErrZeroLength, - /// Unrecognized error. The inner value is the unrecognized errno. - ErrUnknown(isize), - /// # The following are Windows-specific - /// - /// Unsupported combination of protection flags - /// (`MapReadable`/`MapWritable`/`MapExecutable`). - ErrUnsupProt, - /// When using `MapFd`, `MapOffset` was given (Windows does not support this - /// at all) - ErrUnsupOffset, - /// When using `MapFd`, there was already a mapping to the file. - ErrAlreadyExists, - /// Unrecognized error from `VirtualAlloc`. The inner value is the return - /// value of GetLastError. - ErrVirtualAlloc(i32), - /// Unrecognized error from `CreateFileMapping`. The inner value is the - /// return value of `GetLastError`. - ErrCreateFileMappingW(i32), - /// Unrecognized error from `MapViewOfFile`. The inner value is the return - /// value of `GetLastError`. - ErrMapViewOfFile(i32) -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Display for MapError { - fn fmt(&self, out: &mut fmt::Formatter) -> fmt::Result { - let str = match *self { - ErrFdNotAvail => "fd not available for reading or writing", - ErrInvalidFd => "Invalid fd", - ErrUnaligned => { - "Unaligned address, invalid flags, negative length or \ - unaligned offset" - } - ErrNoMapSupport=> "File doesn't support mapping", - ErrNoMem => "Invalid address, or not enough available memory", - ErrUnsupProt => "Protection mode unsupported", - ErrUnsupOffset => "Offset in virtual memory mode is unsupported", - ErrAlreadyExists => "File mapping for specified file already exists", - ErrZeroLength => "Zero-length mapping not allowed", - ErrUnknown(code) => { - return write!(out, "Unknown error = {}", code) - }, - ErrVirtualAlloc(code) => { - return write!(out, "VirtualAlloc failure = {}", code) - }, - ErrCreateFileMappingW(code) => { - return write!(out, "CreateFileMappingW failure = {}", code) - }, - ErrMapViewOfFile(code) => { - return write!(out, "MapViewOfFile failure = {}", code) - } - }; - write!(out, "{}", str) - } -} - -impl Error for MapError { - fn description(&self) -> &str { "memory map error" } -} - -// Round up `from` to be divisible by `to` -fn round_up(from: usize, to: usize) -> usize { - let r = if from % to == 0 { - from - } else { - from + to - (from % to) - }; - if r == 0 { - to - } else { - r - } -} - -#[cfg(unix)] -impl MemoryMap { - /// Create a new mapping with the given `options`, at least `min_len` bytes - /// long. `min_len` must be greater than zero; see the note on - /// `ErrZeroLength`. - pub fn new(min_len: usize, options: &[MapOption]) -> Result { - use libc::off_t; - - if min_len == 0 { - return Err(ErrZeroLength) - } - let mut addr: *const u8 = ptr::null(); - let mut prot = 0; - let mut flags = libc::MAP_PRIVATE; - let mut fd = -1; - let mut offset = 0; - let mut custom_flags = false; - let len = round_up(min_len, env::page_size()); - - for &o in options { - match o { - MapReadable => { prot |= libc::PROT_READ; }, - MapWritable => { prot |= libc::PROT_WRITE; }, - MapExecutable => { prot |= libc::PROT_EXEC; }, - MapAddr(addr_) => { - flags |= libc::MAP_FIXED; - addr = addr_; - }, - MapFd(fd_) => { - flags |= libc::MAP_FILE; - fd = fd_; - }, - MapOffset(offset_) => { offset = offset_ as off_t; }, - MapNonStandardFlags(f) => { custom_flags = true; flags = f }, - } - } - if fd == -1 && !custom_flags { flags |= libc::MAP_ANON; } - - let r = unsafe { - libc::mmap(addr as *mut c_void, len as libc::size_t, prot, flags, - fd, offset) - }; - if r == libc::MAP_FAILED { - Err(match errno() as c_int { - libc::EACCES => ErrFdNotAvail, - libc::EBADF => ErrInvalidFd, - libc::EINVAL => ErrUnaligned, - libc::ENODEV => ErrNoMapSupport, - libc::ENOMEM => ErrNoMem, - code => ErrUnknown(code as isize) - }) - } else { - Ok(MemoryMap { - data: r as *mut u8, - len: len, - kind: if fd == -1 { - MapVirtual - } else { - MapFile(ptr::null()) - } - }) - } - } - - /// Granularity that the offset or address must be for `MapOffset` and - /// `MapAddr` respectively. - pub fn granularity() -> usize { - env::page_size() - } -} - -#[cfg(unix)] -impl Drop for MemoryMap { - /// Unmap the mapping. Panics the task if `munmap` panics. - fn drop(&mut self) { - if self.len == 0 { /* workaround for dummy_stack */ return; } - - unsafe { - // `munmap` only panics due to logic errors - libc::munmap(self.data as *mut c_void, self.len as libc::size_t); - } - } -} - -#[cfg(windows)] -impl MemoryMap { - /// Create a new mapping with the given `options`, at least `min_len` bytes long. - pub fn new(min_len: usize, options: &[MapOption]) -> Result { - use libc::types::os::arch::extra::{LPVOID, DWORD, SIZE_T, HANDLE}; - - let mut lpAddress: LPVOID = ptr::null_mut(); - let mut readable = false; - let mut writable = false; - let mut executable = false; - let mut handle: HANDLE = libc::INVALID_HANDLE_VALUE; - let mut offset: usize = 0; - let len = round_up(min_len, env::page_size()); - - for &o in options { - match o { - MapReadable => { readable = true; }, - MapWritable => { writable = true; }, - MapExecutable => { executable = true; } - MapAddr(addr_) => { lpAddress = addr_ as LPVOID; }, - MapFd(handle_) => { handle = handle_; }, - MapOffset(offset_) => { offset = offset_; }, - MapNonStandardFlags(..) => {} - } - } - - let flProtect = match (executable, readable, writable) { - (false, false, false) if handle == libc::INVALID_HANDLE_VALUE => libc::PAGE_NOACCESS, - (false, true, false) => libc::PAGE_READONLY, - (false, true, true) => libc::PAGE_READWRITE, - (true, false, false) if handle == libc::INVALID_HANDLE_VALUE => libc::PAGE_EXECUTE, - (true, true, false) => libc::PAGE_EXECUTE_READ, - (true, true, true) => libc::PAGE_EXECUTE_READWRITE, - _ => return Err(ErrUnsupProt) - }; - - if handle == libc::INVALID_HANDLE_VALUE { - if offset != 0 { - return Err(ErrUnsupOffset); - } - let r = unsafe { - libc::VirtualAlloc(lpAddress, - len as SIZE_T, - libc::MEM_COMMIT | libc::MEM_RESERVE, - flProtect) - }; - match r as usize { - 0 => Err(ErrVirtualAlloc(errno())), - _ => Ok(MemoryMap { - data: r as *mut u8, - len: len, - kind: MapVirtual - }) - } - } else { - let dwDesiredAccess = match (executable, readable, writable) { - (false, true, false) => libc::FILE_MAP_READ, - (false, true, true) => libc::FILE_MAP_WRITE, - (true, true, false) => libc::FILE_MAP_READ | libc::FILE_MAP_EXECUTE, - (true, true, true) => libc::FILE_MAP_WRITE | libc::FILE_MAP_EXECUTE, - _ => return Err(ErrUnsupProt) // Actually, because of the check above, - // we should never get here. - }; - unsafe { - let hFile = handle; - let mapping = libc::CreateFileMappingW(hFile, - ptr::null_mut(), - flProtect, - 0, - 0, - ptr::null()); - if mapping == ptr::null_mut() { - return Err(ErrCreateFileMappingW(errno())); - } - if errno() as c_int == libc::ERROR_ALREADY_EXISTS { - return Err(ErrAlreadyExists); - } - let r = libc::MapViewOfFile(mapping, - dwDesiredAccess, - ((len as u64) >> 32) as DWORD, - (offset & 0xffff_ffff) as DWORD, - 0); - match r as usize { - 0 => Err(ErrMapViewOfFile(errno())), - _ => Ok(MemoryMap { - data: r as *mut u8, - len: len, - kind: MapFile(mapping as *const u8) - }) - } - } - } - } - - /// Granularity of MapAddr() and MapOffset() parameter values. - /// This may be greater than the value returned by page_size(). - pub fn granularity() -> usize { - use mem; - unsafe { - let mut info = mem::zeroed(); - libc::GetSystemInfo(&mut info); - - return info.dwAllocationGranularity as usize; - } - } -} - -#[cfg(windows)] -impl Drop for MemoryMap { - /// Unmap the mapping. Panics the task if any of `VirtualFree`, - /// `UnmapViewOfFile`, or `CloseHandle` fail. - fn drop(&mut self) { - use libc::types::os::arch::extra::{LPCVOID, HANDLE}; - use libc::consts::os::extra::FALSE; - if self.len == 0 { return } - - unsafe { - match self.kind { - MapVirtual => { - if libc::VirtualFree(self.data as *mut c_void, 0, - libc::MEM_RELEASE) == 0 { - println!("VirtualFree failed: {}", errno()); - } - }, - MapFile(mapping) => { - if libc::UnmapViewOfFile(self.data as LPCVOID) == FALSE { - println!("UnmapViewOfFile failed: {}", errno()); - } - if libc::CloseHandle(mapping as HANDLE) == FALSE { - println!("CloseHandle failed: {}", errno()); - } - } - } - } - } -} - -impl MemoryMap { - /// Returns the pointer to the memory created or modified by this map. - pub fn data(&self) -> *mut u8 { self.data } - /// Returns the number of bytes this map applies to. - pub fn len(&self) -> usize { self.len } - /// Returns the type of mapping this represents. - pub fn kind(&self) -> MemoryMapKind { self.kind } -} - -#[cfg(target_os = "linux")] -#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] -#[unstable(feature = "os")] -pub mod consts { - pub use os::arch_consts::ARCH; - - pub const FAMILY: &'static str = "unix"; - - /// A string describing the specific operating system in use: in this - /// case, `linux`. - pub const SYSNAME: &'static str = "linux"; - - /// Specifies the filename prefix used for shared libraries on this - /// platform: in this case, `lib`. - pub const DLL_PREFIX: &'static str = "lib"; - - /// Specifies the filename suffix used for shared libraries on this - /// platform: in this case, `.so`. - pub const DLL_SUFFIX: &'static str = ".so"; - - /// Specifies the file extension used for shared libraries on this - /// platform that goes after the dot: in this case, `so`. - pub const DLL_EXTENSION: &'static str = "so"; - - /// Specifies the filename suffix used for executable binaries on this - /// platform: in this case, the empty string. - pub const EXE_SUFFIX: &'static str = ""; - - /// Specifies the file extension, if any, used for executable binaries - /// on this platform: in this case, the empty string. - pub const EXE_EXTENSION: &'static str = ""; -} - -#[cfg(target_os = "macos")] -#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] -#[unstable(feature = "os")] -pub mod consts { - pub use os::arch_consts::ARCH; - - pub const FAMILY: &'static str = "unix"; - - /// A string describing the specific operating system in use: in this - /// case, `macos`. - pub const SYSNAME: &'static str = "macos"; - - /// Specifies the filename prefix used for shared libraries on this - /// platform: in this case, `lib`. - pub const DLL_PREFIX: &'static str = "lib"; - - /// Specifies the filename suffix used for shared libraries on this - /// platform: in this case, `.dylib`. - pub const DLL_SUFFIX: &'static str = ".dylib"; - - /// Specifies the file extension used for shared libraries on this - /// platform that goes after the dot: in this case, `dylib`. - pub const DLL_EXTENSION: &'static str = "dylib"; - - /// Specifies the filename suffix used for executable binaries on this - /// platform: in this case, the empty string. - pub const EXE_SUFFIX: &'static str = ""; - - /// Specifies the file extension, if any, used for executable binaries - /// on this platform: in this case, the empty string. - pub const EXE_EXTENSION: &'static str = ""; -} - -#[cfg(target_os = "ios")] -#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] -#[unstable(feature = "os")] -pub mod consts { - pub use os::arch_consts::ARCH; - - pub const FAMILY: &'static str = "unix"; - - /// A string describing the specific operating system in use: in this - /// case, `ios`. - pub const SYSNAME: &'static str = "ios"; - - /// Specifies the filename suffix used for executable binaries on this - /// platform: in this case, the empty string. - pub const EXE_SUFFIX: &'static str = ""; - - /// Specifies the file extension, if any, used for executable binaries - /// on this platform: in this case, the empty string. - pub const EXE_EXTENSION: &'static str = ""; -} - -#[cfg(target_os = "freebsd")] -#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] -#[unstable(feature = "os")] -pub mod consts { - pub use os::arch_consts::ARCH; - - pub const FAMILY: &'static str = "unix"; - - /// A string describing the specific operating system in use: in this - /// case, `freebsd`. - pub const SYSNAME: &'static str = "freebsd"; - - /// Specifies the filename prefix used for shared libraries on this - /// platform: in this case, `lib`. - pub const DLL_PREFIX: &'static str = "lib"; - - /// Specifies the filename suffix used for shared libraries on this - /// platform: in this case, `.so`. - pub const DLL_SUFFIX: &'static str = ".so"; - - /// Specifies the file extension used for shared libraries on this - /// platform that goes after the dot: in this case, `so`. - pub const DLL_EXTENSION: &'static str = "so"; - - /// Specifies the filename suffix used for executable binaries on this - /// platform: in this case, the empty string. - pub const EXE_SUFFIX: &'static str = ""; - - /// Specifies the file extension, if any, used for executable binaries - /// on this platform: in this case, the empty string. - pub const EXE_EXTENSION: &'static str = ""; -} - -#[cfg(target_os = "dragonfly")] -#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] -#[unstable(feature = "os")] -pub mod consts { - pub use os::arch_consts::ARCH; - - pub const FAMILY: &'static str = "unix"; - - /// A string describing the specific operating system in use: in this - /// case, `dragonfly`. - pub const SYSNAME: &'static str = "dragonfly"; - - /// Specifies the filename prefix used for shared libraries on this - /// platform: in this case, `lib`. - pub const DLL_PREFIX: &'static str = "lib"; - - /// Specifies the filename suffix used for shared libraries on this - /// platform: in this case, `.so`. - pub const DLL_SUFFIX: &'static str = ".so"; - - /// Specifies the file extension used for shared libraries on this - /// platform that goes after the dot: in this case, `so`. - pub const DLL_EXTENSION: &'static str = "so"; - - /// Specifies the filename suffix used for executable binaries on this - /// platform: in this case, the empty string. - pub const EXE_SUFFIX: &'static str = ""; - - /// Specifies the file extension, if any, used for executable binaries - /// on this platform: in this case, the empty string. - pub const EXE_EXTENSION: &'static str = ""; -} - -#[cfg(target_os = "bitrig")] -#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] -#[unstable(feature = "os")] -pub mod consts { - pub use os::arch_consts::ARCH; - - pub const FAMILY: &'static str = "unix"; - - /// A string describing the specific operating system in use: in this - /// case, `bitrig`. - pub const SYSNAME: &'static str = "bitrig"; - - /// Specifies the filename prefix used for shared libraries on this - /// platform: in this case, `lib`. - pub const DLL_PREFIX: &'static str = "lib"; - - /// Specifies the filename suffix used for shared libraries on this - /// platform: in this case, `.so`. - pub const DLL_SUFFIX: &'static str = ".so"; - - /// Specifies the file extension used for shared libraries on this - /// platform that goes after the dot: in this case, `so`. - pub const DLL_EXTENSION: &'static str = "so"; - - /// Specifies the filename suffix used for executable binaries on this - /// platform: in this case, the empty string. - pub const EXE_SUFFIX: &'static str = ""; - - /// Specifies the file extension, if any, used for executable binaries - /// on this platform: in this case, the empty string. - pub const EXE_EXTENSION: &'static str = ""; -} - -#[cfg(target_os = "openbsd")] -#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] -#[unstable(feature = "os")] -pub mod consts { - pub use os::arch_consts::ARCH; - - pub const FAMILY: &'static str = "unix"; - - /// A string describing the specific operating system in use: in this - /// case, `openbsd`. - pub const SYSNAME: &'static str = "openbsd"; - - /// Specifies the filename prefix used for shared libraries on this - /// platform: in this case, `lib`. - pub const DLL_PREFIX: &'static str = "lib"; - - /// Specifies the filename suffix used for shared libraries on this - /// platform: in this case, `.so`. - pub const DLL_SUFFIX: &'static str = ".so"; - - /// Specifies the file extension used for shared libraries on this - /// platform that goes after the dot: in this case, `so`. - pub const DLL_EXTENSION: &'static str = "so"; - - /// Specifies the filename suffix used for executable binaries on this - /// platform: in this case, the empty string. - pub const EXE_SUFFIX: &'static str = ""; - - /// Specifies the file extension, if any, used for executable binaries - /// on this platform: in this case, the empty string. - pub const EXE_EXTENSION: &'static str = ""; -} - -#[cfg(target_os = "android")] -#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] -#[unstable(feature = "os")] -pub mod consts { - pub use os::arch_consts::ARCH; - - pub const FAMILY: &'static str = "unix"; - - /// A string describing the specific operating system in use: in this - /// case, `android`. - pub const SYSNAME: &'static str = "android"; - - /// Specifies the filename prefix used for shared libraries on this - /// platform: in this case, `lib`. - pub const DLL_PREFIX: &'static str = "lib"; - - /// Specifies the filename suffix used for shared libraries on this - /// platform: in this case, `.so`. - pub const DLL_SUFFIX: &'static str = ".so"; - - /// Specifies the file extension used for shared libraries on this - /// platform that goes after the dot: in this case, `so`. - pub const DLL_EXTENSION: &'static str = "so"; - - /// Specifies the filename suffix used for executable binaries on this - /// platform: in this case, the empty string. - pub const EXE_SUFFIX: &'static str = ""; - - /// Specifies the file extension, if any, used for executable binaries - /// on this platform: in this case, the empty string. - pub const EXE_EXTENSION: &'static str = ""; -} - -#[cfg(target_os = "windows")] -#[deprecated(since = "1.0.0", reason = "renamed to env::consts")] -#[unstable(feature = "os")] -pub mod consts { - pub use os::arch_consts::ARCH; - - pub const FAMILY: &'static str = "windows"; - - /// A string describing the specific operating system in use: in this - /// case, `windows`. - pub const SYSNAME: &'static str = "windows"; - - /// Specifies the filename prefix used for shared libraries on this - /// platform: in this case, the empty string. - pub const DLL_PREFIX: &'static str = ""; - - /// Specifies the filename suffix used for shared libraries on this - /// platform: in this case, `.dll`. - pub const DLL_SUFFIX: &'static str = ".dll"; - - /// Specifies the file extension used for shared libraries on this - /// platform that goes after the dot: in this case, `dll`. - pub const DLL_EXTENSION: &'static str = "dll"; - - /// Specifies the filename suffix used for executable binaries on this - /// platform: in this case, `.exe`. - pub const EXE_SUFFIX: &'static str = ".exe"; - - /// Specifies the file extension, if any, used for executable binaries - /// on this platform: in this case, `exe`. - pub const EXE_EXTENSION: &'static str = "exe"; -} - -#[cfg(target_arch = "x86")] -mod arch_consts { - pub const ARCH: &'static str = "x86"; -} - -#[cfg(target_arch = "x86_64")] -mod arch_consts { - pub const ARCH: &'static str = "x86_64"; -} - -#[cfg(target_arch = "arm")] -mod arch_consts { - pub const ARCH: &'static str = "arm"; -} - -#[cfg(target_arch = "aarch64")] -mod arch_consts { - pub const ARCH: &'static str = "aarch64"; -} - -#[cfg(target_arch = "mips")] -mod arch_consts { - pub const ARCH: &'static str = "mips"; -} - -#[cfg(target_arch = "mipsel")] -mod arch_consts { - pub const ARCH: &'static str = "mipsel"; -} - -#[cfg(target_arch = "powerpc")] -mod arch_consts { - pub const ARCH: &'static str = "powerpc"; -} - -#[cfg(test)] -mod tests { - #![allow(deprecated)] // rand - - use prelude::v1::*; - - use iter::repeat; - use os::{env, getcwd, getenv, make_absolute}; - use os::{split_paths, join_paths, setenv, unsetenv}; - use os; - use rand::Rng; - use rand; - use old_path::{Path, GenericPath}; - use old_io::{Reader, Writer, Seek}; - - #[test] - pub fn last_os_error() { - debug!("{}", os::last_os_error()); - } - - fn make_rand_name() -> String { - let mut rng = rand::thread_rng(); - let n = format!("TEST{}", rng.gen_ascii_chars().take(10) - .collect::()); - assert!(getenv(&n).is_none()); - n - } - - #[test] - fn test_num_cpus() { - assert!(os::num_cpus() > 0); - } - - #[test] - fn test_setenv() { - let n = make_rand_name(); - setenv(&n, "VALUE"); - assert_eq!(getenv(&n), Some("VALUE".to_string())); - } - - #[test] - fn test_unsetenv() { - let n = make_rand_name(); - setenv(&n, "VALUE"); - unsetenv(&n); - assert_eq!(getenv(&n), None); - } - - #[test] - #[ignore] - fn test_setenv_overwrite() { - let n = make_rand_name(); - setenv(&n, "1"); - setenv(&n, "2"); - assert_eq!(getenv(&n), Some("2".to_string())); - setenv(&n, ""); - assert_eq!(getenv(&n), Some("".to_string())); - } - - // Windows GetEnvironmentVariable requires some extra work to make sure - // the buffer the variable is copied into is the right size - #[test] - #[ignore] - fn test_getenv_big() { - let mut s = "".to_string(); - let mut i = 0; - while i < 100 { - s.push_str("aaaaaaaaaa"); - i += 1; - } - let n = make_rand_name(); - setenv(&n, &s); - debug!("{}", s.clone()); - assert_eq!(getenv(&n), Some(s)); - } - - #[test] - fn test_self_exe_name() { - let path = os::self_exe_name(); - assert!(path.is_some()); - let path = path.unwrap(); - debug!("{}", path.display()); - - // Hard to test this function - assert!(path.is_absolute()); - } - - #[test] - fn test_self_exe_path() { - let path = os::self_exe_path(); - assert!(path.is_some()); - let path = path.unwrap(); - debug!("{}", path.display()); - - // Hard to test this function - assert!(path.is_absolute()); - } - - #[test] - #[ignore] - fn test_env_getenv() { - let e = env(); - assert!(e.len() > 0); - for p in &e { - let (n, v) = (*p).clone(); - debug!("{}", n); - let v2 = getenv(&n); - // MingW seems to set some funky environment variables like - // "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned - // from env() but not visible from getenv(). - assert!(v2.is_none() || v2 == Some(v)); - } - } - - #[test] - fn test_env_set_get_huge() { - let n = make_rand_name(); - let s = repeat("x").take(10000).collect::(); - setenv(&n, &s); - assert_eq!(getenv(&n), Some(s)); - unsetenv(&n); - assert_eq!(getenv(&n), None); - } - - #[test] - fn test_env_setenv() { - let n = make_rand_name(); - - let mut e = env(); - setenv(&n, "VALUE"); - assert!(!e.contains(&(n.clone(), "VALUE".to_string()))); - - e = env(); - assert!(e.contains(&(n, "VALUE".to_string()))); - } - - #[test] - fn test() { - assert!((!Path::new("test-path").is_absolute())); - - let cwd = getcwd().unwrap(); - debug!("Current working directory: {}", cwd.display()); - - debug!("{}", make_absolute(&Path::new("test-path")).unwrap().display()); - debug!("{}", make_absolute(&Path::new("/usr/bin")).unwrap().display()); - } - - #[test] - #[cfg(unix)] - fn homedir() { - let oldhome = getenv("HOME"); - - setenv("HOME", "/home/MountainView"); - assert!(os::homedir() == Some(Path::new("/home/MountainView"))); - - setenv("HOME", ""); - assert!(os::homedir().is_none()); - - if let Some(s) = oldhome { - setenv("HOME", s); - } - } - - #[test] - #[cfg(windows)] - fn homedir() { - - let oldhome = getenv("HOME"); - let olduserprofile = getenv("USERPROFILE"); - - setenv("HOME", ""); - setenv("USERPROFILE", ""); - - assert!(os::homedir().is_none()); - - setenv("HOME", "/home/MountainView"); - assert!(os::homedir() == Some(Path::new("/home/MountainView"))); - - setenv("HOME", ""); - - setenv("USERPROFILE", "/home/MountainView"); - assert!(os::homedir() == Some(Path::new("/home/MountainView"))); - - setenv("HOME", "/home/MountainView"); - setenv("USERPROFILE", "/home/PaloAlto"); - assert!(os::homedir() == Some(Path::new("/home/MountainView"))); - - if let Some(s) = oldhome { - setenv("HOME", &s); - } - if let Some(s) = olduserprofile { - setenv("USERPROFILE", &s); - } - } - - #[test] - fn memory_map_rw() { - use result::Result::{Ok, Err}; - - let chunk = match os::MemoryMap::new(16, &[ - os::MapOption::MapReadable, - os::MapOption::MapWritable - ]) { - Ok(chunk) => chunk, - Err(msg) => panic!("{:?}", msg) - }; - assert!(chunk.len >= 16); - - unsafe { - *chunk.data = 0xBE; - assert!(*chunk.data == 0xBE); - } - } - - #[test] - fn memory_map_file() { - use libc; - use os::*; - use old_io::fs::{File, unlink}; - use old_io::SeekStyle::SeekSet; - use old_io::FileMode::Open; - use old_io::FileAccess::ReadWrite; - - #[cfg(not(windows))] - fn get_fd(file: &File) -> libc::c_int { - use os::unix::prelude::*; - file.as_raw_fd() - } - - #[cfg(windows)] - fn get_fd(file: &File) -> libc::HANDLE { - use os::windows::prelude::*; - file.as_raw_handle() - } - - let mut path = tmpdir(); - path.push("mmap_file.tmp"); - let size = MemoryMap::granularity() * 2; - let mut file = File::open_mode(&path, Open, ReadWrite).unwrap(); - file.seek(size as i64, SeekSet).unwrap(); - file.write_u8(0).unwrap(); - - let chunk = MemoryMap::new(size / 2, &[ - MapOption::MapReadable, - MapOption::MapWritable, - MapOption::MapFd(get_fd(&file)), - MapOption::MapOffset(size / 2) - ]).unwrap(); - assert!(chunk.len > 0); - - unsafe { - *chunk.data = 0xbe; - assert!(*chunk.data == 0xbe); - } - drop(chunk); - - unlink(&path).unwrap(); - } - - #[test] - #[cfg(windows)] - fn split_paths_windows() { - fn check_parse(unparsed: &str, parsed: &[&str]) -> bool { - split_paths(unparsed) == - parsed.iter().map(|s| Path::new(*s)).collect::>() - } - - assert!(check_parse("", &mut [""])); - assert!(check_parse(r#""""#, &mut [""])); - assert!(check_parse(";;", &mut ["", "", ""])); - assert!(check_parse(r"c:\", &mut [r"c:\"])); - assert!(check_parse(r"c:\;", &mut [r"c:\", ""])); - assert!(check_parse(r"c:\;c:\Program Files\", - &mut [r"c:\", r"c:\Program Files\"])); - assert!(check_parse(r#"c:\;c:\"foo"\"#, &mut [r"c:\", r"c:\foo\"])); - assert!(check_parse(r#"c:\;c:\"foo;bar"\;c:\baz"#, - &mut [r"c:\", r"c:\foo;bar\", r"c:\baz"])); - } - - #[test] - #[cfg(unix)] - fn split_paths_unix() { - fn check_parse(unparsed: &str, parsed: &[&str]) -> bool { - split_paths(unparsed) == - parsed.iter().map(|s| Path::new(*s)).collect::>() - } - - assert!(check_parse("", &mut [""])); - assert!(check_parse("::", &mut ["", "", ""])); - assert!(check_parse("/", &mut ["/"])); - assert!(check_parse("/:", &mut ["/", ""])); - assert!(check_parse("/:/usr/local", &mut ["/", "/usr/local"])); - } - - #[test] - #[cfg(unix)] - fn join_paths_unix() { - fn test_eq(input: &[&str], output: &str) -> bool { - join_paths(input).unwrap() == output.as_bytes() - } - - assert!(test_eq(&[], "")); - assert!(test_eq(&["/bin", "/usr/bin", "/usr/local/bin"], - "/bin:/usr/bin:/usr/local/bin")); - assert!(test_eq(&["", "/bin", "", "", "/usr/bin", ""], - ":/bin:::/usr/bin:")); - assert!(join_paths(&["/te:st"]).is_err()); - } - - #[test] - #[cfg(windows)] - fn join_paths_windows() { - fn test_eq(input: &[&str], output: &str) -> bool { - join_paths(input).unwrap() == output.as_bytes() - } - - assert!(test_eq(&[], "")); - assert!(test_eq(&[r"c:\windows", r"c:\"], - r"c:\windows;c:\")); - assert!(test_eq(&["", r"c:\windows", "", "", r"c:\", ""], - r";c:\windows;;;c:\;")); - assert!(test_eq(&[r"c:\te;st", r"c:\"], - r#""c:\te;st";c:\"#)); - assert!(join_paths(&[r#"c:\te"st"#]).is_err()); - } - - // More recursive_mkdir tests are in extra::tempfile -} diff --git a/src/libstd/path.rs b/src/libstd/path.rs index 58d3ae9f7cfab..44421c40901c9 100644 --- a/src/libstd/path.rs +++ b/src/libstd/path.rs @@ -1318,7 +1318,7 @@ impl Path { #[stable(feature = "rust1", since = "1.0.0")] pub fn file_name(&self) -> Option<&OsStr> { self.components().next_back().and_then(|p| match p { - Component::Normal(p) => Some(p.as_os_str()), + Component::Normal(p) => Some(p.as_ref()), _ => None }) } diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index 297eccb9f7698..84a450867675c 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -42,12 +42,11 @@ #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use result::Result::{self, Ok, Err}; #[stable(feature = "rust1", since = "1.0.0")] -#[allow(deprecated)] -#[doc(no_inline)] pub use slice::{SliceConcatExt, AsSlice}; -#[stable(feature = "rust1", since = "1.0.0")] -#[allow(deprecated)] -#[doc(no_inline)] pub use str::Str; +#[doc(no_inline)] pub use slice::SliceConcatExt; #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use string::{String, ToString}; #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use vec::Vec; + +#[allow(deprecated)] pub use slice::AsSlice; +#[allow(deprecated)] pub use str::Str; diff --git a/src/libstd/process.rs b/src/libstd/process.rs index b4bd513e8f027..ece0aa8f064d3 100644 --- a/src/libstd/process.rs +++ b/src/libstd/process.rs @@ -16,15 +16,15 @@ use prelude::v1::*; use io::prelude::*; -use ffi::AsOsStr; +use ffi::OsStr; use fmt; use io::{self, Error, ErrorKind}; use libc; use path; use sync::mpsc::{channel, Receiver}; use sys::pipe2::{self, AnonPipe}; -use sys::process2::Process as ProcessImp; use sys::process2::Command as CommandImp; +use sys::process2::Process as ProcessImp; use sys::process2::ExitStatus as ExitStatusImp; use sys_common::{AsInner, AsInnerMut}; use thread; @@ -147,9 +147,9 @@ impl Command { /// Builder methods are provided to change these defaults and /// otherwise configure the process. #[stable(feature = "process", since = "1.0.0")] - pub fn new(program: S) -> Command { + pub fn new>(program: S) -> Command { Command { - inner: CommandImp::new(program.as_os_str()), + inner: CommandImp::new(program.as_ref()), stdin: None, stdout: None, stderr: None, @@ -158,15 +158,15 @@ impl Command { /// Add an argument to pass to the program. #[stable(feature = "process", since = "1.0.0")] - pub fn arg(&mut self, arg: S) -> &mut Command { - self.inner.arg(arg.as_os_str()); + pub fn arg>(&mut self, arg: S) -> &mut Command { + self.inner.arg(arg.as_ref()); self } /// Add multiple arguments to pass to the program. #[stable(feature = "process", since = "1.0.0")] - pub fn args(&mut self, args: &[S]) -> &mut Command { - self.inner.args(args.iter().map(AsOsStr::as_os_str)); + pub fn args>(&mut self, args: &[S]) -> &mut Command { + self.inner.args(args.iter().map(AsRef::as_ref)); self } @@ -176,16 +176,16 @@ impl Command { /// and case-sensitive on all other platforms. #[stable(feature = "process", since = "1.0.0")] pub fn env(&mut self, key: K, val: V) -> &mut Command - where K: AsOsStr, V: AsOsStr + where K: AsRef, V: AsRef { - self.inner.env(key.as_os_str(), val.as_os_str()); + self.inner.env(key.as_ref(), val.as_ref()); self } /// Removes an environment variable mapping. #[stable(feature = "process", since = "1.0.0")] - pub fn env_remove(&mut self, key: K) -> &mut Command { - self.inner.env_remove(key.as_os_str()); + pub fn env_remove>(&mut self, key: K) -> &mut Command { + self.inner.env_remove(key.as_ref()); self } @@ -199,7 +199,7 @@ impl Command { /// Set the working directory for the child process. #[stable(feature = "process", since = "1.0.0")] pub fn current_dir>(&mut self, dir: P) -> &mut Command { - self.inner.cwd(dir.as_ref().as_os_str()); + self.inner.cwd(dir.as_ref().as_ref()); self } @@ -378,11 +378,6 @@ enum StdioImp { } impl Stdio { - /// A new pipe should be arranged to connect the parent and child processes. - #[unstable(feature = "process_capture")] - #[deprecated(since = "1.0.0", reason = "renamed to `Stdio::piped`")] - pub fn capture() -> Stdio { Stdio::piped() } - /// A new pipe should be arranged to connect the parent and child processes. #[stable(feature = "process", since = "1.0.0")] pub fn piped() -> Stdio { Stdio(StdioImp::Piped) } @@ -529,11 +524,10 @@ impl Child { #[cfg(test)] mod tests { - use io::ErrorKind; + use prelude::v1::*; use io::prelude::*; - use prelude::v1::{Ok, Err, drop, Some, Vec}; - use prelude::v1::{String, Clone}; - use prelude::v1::{Str, AsSlice, ToString}; + + use io::ErrorKind; use old_path::{self, GenericPath}; use old_io::fs::PathExtensions; use rt::running_on_valgrind; @@ -678,7 +672,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 +714,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"); @@ -755,7 +749,8 @@ mod tests { let prog = pwd_cmd().spawn().unwrap(); let output = String::from_utf8(prog.wait_with_output().unwrap().stdout).unwrap(); - let parent_dir = os::getcwd().unwrap(); + let parent_dir = ::env::current_dir().unwrap().to_str().unwrap().to_string(); + let parent_dir = old_path::Path::new(parent_dir); let child_dir = old_path::Path::new(output.trim()); let parent_stat = parent_dir.stat().unwrap(); @@ -770,7 +765,8 @@ mod tests { use os; // test changing to the parent of os::getcwd() because we know // the path exists (and os::getcwd() is not expected to be root) - let parent_dir = os::getcwd().unwrap().dir_path(); + let parent_dir = ::env::current_dir().unwrap().to_str().unwrap().to_string(); + let parent_dir = old_path::Path::new(parent_dir).dir_path(); let result = pwd_cmd().current_dir(parent_dir.as_str().unwrap()).output().unwrap(); let output = String::from_utf8(result.stdout).unwrap(); @@ -855,7 +851,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 +860,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/rand/os.rs b/src/libstd/rand/os.rs index 51b6045cf16f8..0a619ff8cd056 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -15,17 +15,16 @@ pub use self::imp::OsRng; #[cfg(all(unix, not(target_os = "ios")))] mod imp { - extern crate libc; - + use prelude::v1::*; use self::OsRngInner::*; + use libc; + use mem; use old_io::{IoResult, File}; use old_path::Path; use rand::Rng; use rand::reader::ReaderRng; - use result::Result::Ok; - use mem; - use os::errno; + use sys::os::errno; #[cfg(all(target_os = "linux", any(target_arch = "x86_64", @@ -184,14 +183,13 @@ mod imp { #[cfg(target_os = "ios")] mod imp { - extern crate libc; + use prelude::v1::*; - use old_io::{IoResult}; + use old_io::IoResult; use mem; use os; use rand::Rng; - use result::Result::{Ok}; - use self::libc::{c_int, size_t}; + use libc::{c_int, size_t}; /// A random number generator that retrieves randomness straight from /// the operating system. Platform sources: @@ -251,16 +249,15 @@ mod imp { #[cfg(windows)] mod imp { - extern crate libc; + use prelude::v1::*; - use old_io::{IoResult, IoError}; + use io; use mem; - use ops::Drop; + use old_io::{IoResult, IoError}; use os; use rand::Rng; - use result::Result::{Ok, Err}; - use self::libc::{DWORD, BYTE, LPCSTR, BOOL}; - use self::libc::types::os::arch::extra::{LONG_PTR}; + use libc::types::os::arch::extra::{LONG_PTR}; + use libc::{DWORD, BYTE, LPCSTR, BOOL}; type HCRYPTPROV = LONG_PTR; @@ -330,7 +327,8 @@ mod imp { v.as_mut_ptr()) }; if ret == 0 { - panic!("couldn't generate random bytes: {}", os::last_os_error()); + panic!("couldn't generate random bytes: {}", + io::Error::last_os_error()); } } } @@ -341,7 +339,8 @@ mod imp { CryptReleaseContext(self.hcryptprov, 0) }; if ret == 0 { - panic!("couldn't release context: {}", os::last_os_error()); + panic!("couldn't release context: {}", + io::Error::last_os_error()); } } } diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs index 428bcaa49f7d9..2329861f29bc0 100644 --- a/src/libstd/rt/args.rs +++ b/src/libstd/rt/args.rs @@ -108,7 +108,6 @@ mod imp { #[cfg(test)] mod tests { use prelude::v1::*; - use finally::Finally; use super::*; @@ -127,14 +126,11 @@ mod imp { assert!(take() == Some(expected.clone())); assert!(take() == None); - (|| { - }).finally(|| { - // Restore the actual global state. - match saved_value { - Some(ref args) => put(args.clone()), - None => () - } - }) + // Restore the actual global state. + match saved_value { + Some(ref args) => put(args.clone()), + None => () + } } } } diff --git a/src/libstd/sync/mod.rs b/src/libstd/sync/mod.rs index 68137601c405c..a5259a00390f5 100644 --- a/src/libstd/sync/mod.rs +++ b/src/libstd/sync/mod.rs @@ -31,8 +31,6 @@ pub use self::barrier::{Barrier, BarrierWaitResult}; pub use self::poison::{PoisonError, TryLockError, TryLockResult, LockResult}; pub use self::future::Future; -#[allow(deprecated)] -pub use self::task_pool::TaskPool; pub mod mpsc; @@ -44,4 +42,3 @@ mod once; mod poison; mod rwlock; mod semaphore; -mod task_pool; diff --git a/src/libstd/sync/poison.rs b/src/libstd/sync/poison.rs index c07c83d37f488..6ae8e043e051d 100644 --- a/src/libstd/sync/poison.rs +++ b/src/libstd/sync/poison.rs @@ -122,12 +122,6 @@ impl PoisonError { PoisonError { guard: guard } } - /// Consumes this error indicating that a lock is poisoned, returning the - /// underlying guard to allow access regardless. - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", reason = "renamed to into_inner")] - pub fn into_guard(self) -> T { self.guard } - /// Consumes this error indicating that a lock is poisoned, returning the /// underlying guard to allow access regardless. #[unstable(feature = "std_misc")] diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs deleted file mode 100644 index 51cf70e615bcc..0000000000000 --- a/src/libstd/sync/task_pool.rs +++ /dev/null @@ -1,217 +0,0 @@ -// Copyright 2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Abstraction of a thread pool for basic parallelism. - -#![deprecated(since = "1.0.0", - reason = "This kind of API needs some time to bake in \ - crates.io. This functionality is available through \ - https://crates.io/crates/threadpool")] -#![unstable(feature = "std_misc")] - -#![allow(deprecated)] - -use core::prelude::*; - -use sync::{Arc, Mutex}; -use sync::mpsc::{channel, Sender, Receiver}; -use thread; -use thunk::Thunk; - -struct Sentinel<'a> { - jobs: &'a Arc>>>, - active: bool -} - -impl<'a> Sentinel<'a> { - fn new(jobs: &'a Arc>>>) -> Sentinel<'a> { - Sentinel { - jobs: jobs, - active: true - } - } - - // Cancel and destroy this sentinel. - fn cancel(mut self) { - self.active = false; - } -} - -#[unsafe_destructor] -impl<'a> Drop for Sentinel<'a> { - fn drop(&mut self) { - if self.active { - spawn_in_pool(self.jobs.clone()) - } - } -} - -/// A thread pool used to execute functions in parallel. -/// -/// Spawns `n` worker threads and replenishes the pool if any worker threads -/// panic. -/// -/// # Examples -/// -/// ``` -/// # #![feature(std_misc, core)] -/// use std::sync::TaskPool; -/// use std::iter::AdditiveIterator; -/// use std::sync::mpsc::channel; -/// -/// let pool = TaskPool::new(4); -/// -/// let (tx, rx) = channel(); -/// for _ in 0..8 { -/// let tx = tx.clone(); -/// pool.execute(move|| { -/// tx.send(1_u32).unwrap(); -/// }); -/// } -/// -/// assert_eq!(rx.iter().take(8).sum(), 8); -/// ``` -pub struct TaskPool { - // How the threadpool communicates with subthreads. - // - // This is the only such Sender, so when it is dropped all subthreads will - // quit. - jobs: Sender> -} - -impl TaskPool { - /// Spawns a new thread pool with `threads` threads. - /// - /// # Panics - /// - /// This function will panic if `threads` is 0. - pub fn new(threads: usize) -> TaskPool { - assert!(threads >= 1); - - let (tx, rx) = channel::(); - let rx = Arc::new(Mutex::new(rx)); - - // Threadpool threads - for _ in 0..threads { - spawn_in_pool(rx.clone()); - } - - TaskPool { jobs: tx } - } - - /// Executes the function `job` on a thread in the pool. - pub fn execute(&self, job: F) - where F : FnOnce(), F : Send + 'static - { - self.jobs.send(Thunk::new(job)).unwrap(); - } -} - -fn spawn_in_pool(jobs: Arc>>>) { - thread::spawn(move || { - // Will spawn a new thread on panic unless it is cancelled. - let sentinel = Sentinel::new(&jobs); - - loop { - let message = { - // Only lock jobs for the time it takes - // to get a job, not run it. - let lock = jobs.lock().unwrap(); - lock.recv() - }; - - match message { - Ok(job) => job.invoke(()), - - // The Taskpool was dropped. - Err(..) => break - } - } - - sentinel.cancel(); - }); -} - -#[cfg(test)] -mod test { - use prelude::v1::*; - use super::*; - use sync::mpsc::channel; - - const TEST_TASKS: usize = 4; - - #[test] - fn test_works() { - use iter::AdditiveIterator; - - let pool = TaskPool::new(TEST_TASKS); - - let (tx, rx) = channel(); - for _ in 0..TEST_TASKS { - let tx = tx.clone(); - pool.execute(move|| { - tx.send(1).unwrap(); - }); - } - - assert_eq!(rx.iter().take(TEST_TASKS).sum(), TEST_TASKS); - } - - #[test] - #[should_panic] - fn test_zero_tasks_panic() { - TaskPool::new(0); - } - - #[test] - fn test_recovery_from_subtask_panic() { - use iter::AdditiveIterator; - - let pool = TaskPool::new(TEST_TASKS); - - // Panic all the existing threads. - for _ in 0..TEST_TASKS { - pool.execute(move|| -> () { panic!() }); - } - - // Ensure new threads were spawned to compensate. - let (tx, rx) = channel(); - for _ in 0..TEST_TASKS { - let tx = tx.clone(); - pool.execute(move|| { - tx.send(1).unwrap(); - }); - } - - assert_eq!(rx.iter().take(TEST_TASKS).sum(), TEST_TASKS); - } - - #[test] - fn test_should_not_panic_on_drop_if_subtasks_panic_after_drop() { - use sync::{Arc, Barrier}; - - let pool = TaskPool::new(TEST_TASKS); - let waiter = Arc::new(Barrier::new(TEST_TASKS + 1)); - - // Panic all the existing threads in a bit. - for _ in 0..TEST_TASKS { - let waiter = waiter.clone(); - pool.execute(move|| { - waiter.wait(); - panic!(); - }); - } - - drop(pool); - - // Kick off the failure. - waiter.wait(); - } -} diff --git a/src/libstd/sys/unix/backtrace.rs b/src/libstd/sys/unix/backtrace.rs index 99a554a835f9f..ca805ad02422a 100644 --- a/src/libstd/sys/unix/backtrace.rs +++ b/src/libstd/sys/unix/backtrace.rs @@ -251,7 +251,6 @@ fn print(w: &mut Write, idx: isize, addr: *mut libc::c_void, fn print(w: &mut Write, idx: isize, addr: *mut libc::c_void, symaddr: *mut libc::c_void) -> io::Result<()> { use env; - use ffi::AsOsStr; use os::unix::prelude::*; use ptr; diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs index 2569653811f11..6b085c8eb7a85 100644 --- a/src/libstd/sys/unix/fs.rs +++ b/src/libstd/sys/unix/fs.rs @@ -388,9 +388,7 @@ mod tests { fn test_file_desc() { // Run this test with some pipes so we don't have to mess around with // opening or closing files. - let os::Pipe { reader, writer } = unsafe { os::pipe().unwrap() }; - let mut reader = FileDesc::new(reader, true); - let mut writer = FileDesc::new(writer, true); + let (mut reader, mut writer) = unsafe { ::sys::os::pipe().unwrap() }; writer.write(b"test").unwrap(); let mut buf = [0; 4]; diff --git a/src/libstd/sys/unix/fs2.rs b/src/libstd/sys/unix/fs2.rs index 202e5ddaec42b..f425c39667ae7 100644 --- a/src/libstd/sys/unix/fs2.rs +++ b/src/libstd/sys/unix/fs2.rs @@ -12,7 +12,7 @@ use core::prelude::*; use io::prelude::*; use os::unix::prelude::*; -use ffi::{CString, CStr, OsString, AsOsStr, OsStr}; +use ffi::{CString, CStr, OsString, OsStr}; use io::{self, Error, SeekFrom}; use libc::{self, c_int, size_t, off_t, c_char, mode_t}; use mem; diff --git a/src/libstd/sys/unix/helper_signal.rs b/src/libstd/sys/unix/helper_signal.rs index 17c8b21f8b3bc..fe0ede80fc663 100644 --- a/src/libstd/sys/unix/helper_signal.rs +++ b/src/libstd/sys/unix/helper_signal.rs @@ -11,15 +11,15 @@ #![allow(deprecated)] use libc; -use os; +use sys::os; use sys::fs::FileDesc; pub type signal = libc::c_int; pub fn new() -> (signal, signal) { - let os::Pipe { reader, writer } = unsafe { os::pipe().unwrap() }; - (reader, writer) + let (a, b) = unsafe { os::pipe().unwrap() }; + (a.unwrap(), b.unwrap()) } pub fn signal(fd: libc::c_int) { diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index fab443feebd0b..af5b40af93892 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -16,7 +16,7 @@ use prelude::v1::*; use os::unix::prelude::*; use error::Error as StdError; -use ffi::{CString, CStr, OsString, OsStr, AsOsStr}; +use ffi::{CString, CStr, OsString, OsStr}; use fmt; use io; use iter; @@ -125,7 +125,8 @@ pub fn getcwd() -> io::Result { } pub fn chdir(p: &path::Path) -> io::Result<()> { - let p = try!(CString::new(p.as_os_str().as_bytes())); + let p: &OsStr = p.as_ref(); + let p = try!(CString::new(p.as_bytes())); unsafe { match libc::chdir(p.as_ptr()) == (0 as c_int) { true => Ok(()), @@ -158,13 +159,13 @@ impl<'a> Iterator for SplitPaths<'a> { pub struct JoinPathsError; pub fn join_paths(paths: I) -> Result - where I: Iterator, T: AsOsStr + where I: Iterator, T: AsRef { let mut joined = Vec::new(); let sep = b':'; for (i, path) in paths.enumerate() { - let path = path.as_os_str().as_bytes(); + let path = path.as_ref().as_bytes(); if i > 0 { joined.push(sep) } if path.contains(&sep) { return Err(JoinPathsError) @@ -464,7 +465,7 @@ pub fn page_size() -> usize { } pub fn temp_dir() -> PathBuf { - getenv("TMPDIR".as_os_str()).map(os2path).unwrap_or_else(|| { + getenv("TMPDIR".as_ref()).map(os2path).unwrap_or_else(|| { if cfg!(target_os = "android") { PathBuf::from("/data/local/tmp") } else { @@ -474,7 +475,7 @@ pub fn temp_dir() -> PathBuf { } pub fn home_dir() -> Option { - return getenv("HOME".as_os_str()).or_else(|| unsafe { + return getenv("HOME".as_ref()).or_else(|| unsafe { fallback() }).map(os2path); diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs index 0d35ace185d84..8095325f83d1f 100644 --- a/src/libstd/sys/unix/process.rs +++ b/src/libstd/sys/unix/process.rs @@ -19,8 +19,9 @@ use hash::Hash; use old_io::process::{ProcessExit, ExitStatus, ExitSignal}; use old_io::{IoResult, EndOfFile}; use libc::{self, pid_t, c_void, c_int}; +use io; use mem; -use os; +use sys::os; use old_path::BytesContainer; use ptr; use sync::mpsc::{channel, Sender, Receiver}; @@ -496,7 +497,8 @@ impl Process { n if n > 0 => { ret = true; } 0 => return true, -1 if wouldblock() => return ret, - n => panic!("bad read {:?} ({:?})", os::last_os_error(), n), + n => panic!("bad read {} ({})", + io::Error::last_os_error(), n), } } } diff --git a/src/libstd/sys/unix/timer.rs b/src/libstd/sys/unix/timer.rs index d9a162302fc1c..9309147b15c44 100644 --- a/src/libstd/sys/unix/timer.rs +++ b/src/libstd/sys/unix/timer.rs @@ -54,7 +54,8 @@ use self::Req::*; use old_io::IoResult; use libc; use mem; -use os; +use sys::os; +use io; use ptr; use sync::atomic::{self, Ordering}; use sync::mpsc::{channel, Sender, Receiver, TryRecvError}; @@ -209,7 +210,7 @@ fn helper(input: libc::c_int, messages: Receiver, _: ()) { -1 if os::errno() == libc::EINTR as i32 => {} n => panic!("helper thread failed in select() with error: {} ({})", - n, os::last_os_error()) + n, io::Error::last_os_error()) } } } diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index 167db1e8ac2d7..1ebd4c571ac2d 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -16,7 +16,7 @@ use prelude::v1::*; use os::windows::prelude::*; use error::Error as StdError; -use ffi::{OsString, OsStr, AsOsStr}; +use ffi::{OsString, OsStr}; use fmt; use io; use libc::types::os::arch::extra::LPWCH; @@ -199,13 +199,13 @@ impl<'a> Iterator for SplitPaths<'a> { pub struct JoinPathsError; pub fn join_paths(paths: I) -> Result - where I: Iterator, T: AsOsStr + where I: Iterator, T: AsRef { let mut joined = Vec::new(); let sep = b';' as u16; for (i, path) in paths.enumerate() { - let path = path.as_os_str(); + let path = path.as_ref(); if i > 0 { joined.push(sep) } let v = path.encode_wide().collect::>(); if v.contains(&(b'"' as u16)) { @@ -245,7 +245,8 @@ pub fn getcwd() -> io::Result { } pub fn chdir(p: &path::Path) -> io::Result<()> { - let mut p = p.as_os_str().encode_wide().collect::>(); + let p: &OsStr = p.as_ref(); + let mut p = p.encode_wide().collect::>(); p.push(0); unsafe { @@ -361,8 +362,8 @@ pub fn temp_dir() -> PathBuf { } pub fn home_dir() -> Option { - getenv("HOME".as_os_str()).or_else(|| { - getenv("USERPROFILE".as_os_str()) + getenv("HOME".as_ref()).or_else(|| { + getenv("USERPROFILE".as_ref()) }).map(PathBuf::from).or_else(|| unsafe { let me = c::GetCurrentProcess(); let mut token = ptr::null_mut(); diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index 297f6e173abdc..2065df4fbe354 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -23,6 +23,7 @@ use mem; use old_io::process::{ProcessExit, ExitStatus}; use old_io::{IoResult, IoError}; use old_io; +use fs::PathExt; use os; use old_path::{BytesContainer, GenericPath}; use ptr; @@ -142,14 +143,19 @@ impl Process { let program = cfg.env().and_then(|env| { for (key, v) in env { if b"PATH" != key.container_as_bytes() { continue } + let v = match ::str::from_utf8(v.container_as_bytes()) { + Ok(s) => s, + Err(..) => continue, + }; // Split the value and test each path to see if the // program exists. - for path in os::split_paths(v.container_as_bytes()) { - let path = path.join(cfg.program().as_bytes()) + for path in ::env::split_paths(v) { + let program = str::from_utf8(cfg.program().as_bytes()).unwrap(); + let path = path.join(program) .with_extension(env::consts::EXE_EXTENSION); if path.exists() { - return Some(CString::from_slice(path.as_vec())) + return Some(CString::new(path.to_str().unwrap()).unwrap()) } } break @@ -482,9 +488,9 @@ mod tests { #[test] fn test_make_command_line() { fn test_wrapper(prog: &str, args: &[&str]) -> String { - make_command_line(&CString::from_slice(prog.as_bytes()), + make_command_line(&CString::new(prog), &args.iter() - .map(|a| CString::from_slice(a.as_bytes())) + .map(|a| CString::new(a)) .collect::>()) } diff --git a/src/libstd/thread/local.rs b/src/libstd/thread/local.rs index a2b824bb016ff..b9cbd01bed180 100644 --- a/src/libstd/thread/local.rs +++ b/src/libstd/thread/local.rs @@ -294,12 +294,6 @@ impl LocalKey { } } } - - /// Deprecated - #[unstable(feature = "std_misc")] - #[deprecated(since = "1.0.0", - reason = "function renamed to state() and returns more info")] - pub fn destroyed(&'static self) -> bool { self.state() == LocalKeyState::Destroyed } } #[cfg(all(any(target_os = "macos", target_os = "linux"), not(target_arch = "aarch64")))] diff --git a/src/libstd/thread/mod.rs b/src/libstd/thread/mod.rs index 074030bd07bdb..b9515c9a8a103 100644 --- a/src/libstd/thread/mod.rs +++ b/src/libstd/thread/mod.rs @@ -189,8 +189,6 @@ use sys_common::{stack, thread_info}; use thunk::Thunk; use time::Duration; -#[allow(deprecated)] use old_io::Writer; - //////////////////////////////////////////////////////////////////////////////// // Thread-local storage //////////////////////////////////////////////////////////////////////////////// @@ -243,28 +241,6 @@ impl Builder { self } - /// Redirect thread-local stdout. - #[unstable(feature = "std_misc", - reason = "Will likely go away after proc removal")] - #[deprecated(since = "1.0.0", - reason = "the old I/O module is deprecated and this function \ - will be removed with no replacement")] - #[allow(deprecated)] - pub fn stdout(self, _stdout: Box) -> Builder { - self - } - - /// Redirect thread-local stderr. - #[unstable(feature = "std_misc", - reason = "Will likely go away after proc removal")] - #[deprecated(since = "1.0.0", - reason = "the old I/O module is deprecated and this function \ - will be removed with no replacement")] - #[allow(deprecated)] - pub fn stderr(self, _stderr: Box) -> Builder { - self - } - /// Spawn a new thread, and return a join handle for it. /// /// The child thread may outlive the parent (unless the parent thread @@ -568,71 +544,6 @@ impl Thread { } } - /// Deprecated: use module-level free function. - #[deprecated(since = "1.0.0", reason = "use module-level free function")] - #[unstable(feature = "std_misc", - reason = "may change with specifics of new Send semantics")] - pub fn spawn(f: F) -> Thread where F: FnOnce(), F: Send + 'static { - Builder::new().spawn(f).unwrap().thread().clone() - } - - /// Deprecated: use module-level free function. - #[deprecated(since = "1.0.0", reason = "use module-level free function")] - #[unstable(feature = "std_misc", - reason = "may change with specifics of new Send semantics")] - pub fn scoped<'a, T, F>(f: F) -> JoinGuard<'a, T> where - T: Send + 'a, F: FnOnce() -> T, F: Send + 'a - { - Builder::new().scoped(f).unwrap() - } - - /// Deprecated: use module-level free function. - #[deprecated(since = "1.0.0", reason = "use module-level free function")] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn current() -> Thread { - thread_info::current_thread() - } - - /// Deprecated: use module-level free function. - #[deprecated(since = "1.0.0", reason = "use module-level free function")] - #[unstable(feature = "std_misc", reason = "name may change")] - pub fn yield_now() { - unsafe { imp::yield_now() } - } - - /// Deprecated: use module-level free function. - #[deprecated(since = "1.0.0", reason = "use module-level free function")] - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn panicking() -> bool { - unwind::panicking() - } - - /// Deprecated: use module-level free function. - #[deprecated(since = "1.0.0", reason = "use module-level free function")] - #[unstable(feature = "std_misc", reason = "recently introduced")] - pub fn park() { - let thread = current(); - let mut guard = thread.inner.lock.lock().unwrap(); - while !*guard { - guard = thread.inner.cvar.wait(guard).unwrap(); - } - *guard = false; - } - - /// Deprecated: use module-level free function. - #[deprecated(since = "1.0.0", reason = "use module-level free function")] - #[unstable(feature = "std_misc", reason = "recently introduced")] - pub fn park_timeout(duration: Duration) { - let thread = current(); - let mut guard = thread.inner.lock.lock().unwrap(); - if !*guard { - let (g, _) = thread.inner.cvar.wait_timeout(guard, duration).unwrap(); - guard = g; - } - *guard = false; - } - /// Atomically makes the handle's token available if it is not already. /// /// See the module doc for more detail. @@ -762,8 +673,8 @@ impl<'a, T: Send + 'a> JoinGuard<'a, T> { &self.inner.thread } - /// Wait for the associated thread to finish, returning the result of the thread's - /// calculation. + /// Wait for the associated thread to finish, returning the result of the + /// thread's calculation. /// /// # Panics /// @@ -777,17 +688,6 @@ impl<'a, T: Send + 'a> JoinGuard<'a, T> { } } -#[stable(feature = "rust1", since = "1.0.0")] -impl JoinGuard<'static, T> { - /// Detaches the child thread, allowing it to outlive its parent. - #[deprecated(since = "1.0.0", reason = "use spawn instead")] - #[unstable(feature = "std_misc")] - pub fn detach(mut self) { - unsafe { imp::detach(self.inner.native) }; - self.inner.joined = true; // avoid joining in the destructor - } -} - #[unsafe_destructor] #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: Send + 'a> Drop for JoinGuard<'a, T> { diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index ee0d190d729eb..2d56d7ddf1bcd 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -43,7 +43,6 @@ #![feature(std_misc)] #![feature(libc)] #![feature(set_stdio)] -#![feature(os)] #![feature(convert)] #![cfg_attr(test, feature(old_io))] @@ -857,7 +856,8 @@ fn get_concurrency() -> usize { if std::rt::util::limit_thread_creation_due_to_osx_and_valgrind() { 1 } else { - std::os::num_cpus() + extern { fn rust_get_num_cpus() -> libc::uintptr_t; } + unsafe { rust_get_num_cpus() as usize } } } } diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs index 64c3872213780..ce050cc73235d 100644 --- a/src/test/bench/shootout-binarytrees.rs +++ b/src/test/bench/shootout-binarytrees.rs @@ -38,11 +38,10 @@ // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED // OF THE POSSIBILITY OF SUCH DAMAGE. -#![feature(rustc_private, core)] +#![feature(rustc_private, core, step_by)] extern crate arena; -use std::iter::range_step; use std::thread; use arena::TypedArena; @@ -109,7 +108,7 @@ fn main() { let long_lived_arena = TypedArena::new(); let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth); - let messages = range_step(min_depth, max_depth + 1, 2).map(|depth| { + let messages = (min_depth..max_depth + 1).step_by(2).map(|depth| { use std::num::Int; let iterations = 2.pow((max_depth - depth + min_depth) as u32); thread::scoped(move || inner(depth, iterations)) diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs index 3a1da4c32af4c..af9ef80e609ba 100644 --- a/src/test/bench/shootout-fannkuch-redux.rs +++ b/src/test/bench/shootout-fannkuch-redux.rs @@ -38,9 +38,9 @@ // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED // OF THE POSSIBILITY OF SUCH DAMAGE. -#![feature(core)] +#![feature(step_by)] -use std::{cmp, iter, mem}; +use std::{cmp, mem}; use std::thread; fn rotate(x: &mut [i32]) { @@ -163,7 +163,7 @@ fn fannkuch(n: i32) -> (i32, i32) { let mut futures = vec![]; let k = perm.max() / N; - for (_, j) in (0..N).zip(iter::count(0, k)) { + for (_, j) in (0..N).zip((0..).step_by(k)) { let max = cmp::min(j+k, perm.max()); futures.push(thread::scoped(move|| { diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index de1d0103657e0..c190641bfbff0 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -193,7 +193,7 @@ fn main() { // start processing if this is the one ('>', false) => { - match line[1..].find_str("THREE") { + match line[1..].find("THREE") { Some(_) => { proc_mode = true; } None => { } } diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index cd89b822035c2..c0268e816cf3e 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -118,7 +118,9 @@ fn dot(v: &[f64], u: &[f64]) -> f64 { fn parallel<'a,T, F>(v: &mut [T], ref f: F) where T: Send + Sync + 'a, F: Fn(usize, &mut [T]) + Sync + 'a { - let size = v.len() / os::num_cpus() + 1; + // FIXME: pick a more appropriate parallel factor + let parallelism = 4; + let size = v.len() / parallelism + 1; v.chunks_mut(size).enumerate().map(|(i, chunk)| { thread::scoped(move|| { f(i * size, chunk) diff --git a/src/test/compile-fail/dropck_arr_cycle_checked.rs b/src/test/compile-fail/dropck_arr_cycle_checked.rs index 3aa2fae282693..40d992fe21f20 100644 --- a/src/test/compile-fail/dropck_arr_cycle_checked.rs +++ b/src/test/compile-fail/dropck_arr_cycle_checked.rs @@ -20,9 +20,9 @@ use id::Id; mod s { #![allow(unstable)] - use std::sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering}; + use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; - static S_COUNT: AtomicUint = ATOMIC_UINT_INIT; + static S_COUNT: AtomicUsize = ATOMIC_USIZE_INIT; pub fn next_count() -> usize { S_COUNT.fetch_add(1, Ordering::SeqCst) + 1 diff --git a/src/test/compile-fail/dropck_tarena_cycle_checked.rs b/src/test/compile-fail/dropck_tarena_cycle_checked.rs index 74e3c724b676d..9488882ca94a5 100644 --- a/src/test/compile-fail/dropck_tarena_cycle_checked.rs +++ b/src/test/compile-fail/dropck_tarena_cycle_checked.rs @@ -27,9 +27,9 @@ use id::Id; mod s { #![allow(unstable)] - use std::sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering}; + use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; - static S_COUNT: AtomicUint = ATOMIC_UINT_INIT; + static S_COUNT: AtomicUsize = ATOMIC_USIZE_INIT; pub fn next_count() -> usize { S_COUNT.fetch_add(1, Ordering::SeqCst) + 1 diff --git a/src/test/compile-fail/dropck_vec_cycle_checked.rs b/src/test/compile-fail/dropck_vec_cycle_checked.rs index 3f69c7d1a9c3e..9d92552244f28 100644 --- a/src/test/compile-fail/dropck_vec_cycle_checked.rs +++ b/src/test/compile-fail/dropck_vec_cycle_checked.rs @@ -19,9 +19,9 @@ use id::Id; mod s { #![allow(unstable)] - use std::sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering}; + use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; - static S_COUNT: AtomicUint = ATOMIC_UINT_INIT; + static S_COUNT: AtomicUsize = ATOMIC_USIZE_INIT; pub fn next_count() -> usize { S_COUNT.fetch_add(1, Ordering::SeqCst) + 1 diff --git a/src/test/compile-fail/estr-subtyping.rs b/src/test/compile-fail/estr-subtyping.rs index 6e64e01d7410d..b5c6db0cea9e3 100644 --- a/src/test/compile-fail/estr-subtyping.rs +++ b/src/test/compile-fail/estr-subtyping.rs @@ -18,7 +18,7 @@ fn has_uniq(x: String) { fn has_slice(x: &str) { wants_uniq(x); //~ ERROR mismatched types - wants_slice(x.as_slice()); + wants_slice(x); } fn main() { diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs index 50c4ac94d9032..8886dd80be503 100644 --- a/src/test/compile-fail/issue-13058.rs +++ b/src/test/compile-fail/issue-13058.rs @@ -8,14 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::iter::{Range,range}; +use std::ops::Range; trait Itble<'r, T, I: Iterator> { fn iter(&'r self) -> I; } impl<'r> Itble<'r, usize, Range> for (usize, usize) { fn iter(&'r self) -> Range { let &(min, max) = self; - range(min, max) + min..max } } diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs index 8ebf80a8db0dc..9e49abc463f15 100644 --- a/src/test/compile-fail/issue-17651.rs +++ b/src/test/compile-fail/issue-17651.rs @@ -13,6 +13,6 @@ fn main() { // FIXME (#22405): Replace `Box::new` with `box` here when/if possible. - (|| Box::new(*[0].as_slice()))(); + (|| Box::new(*(&[0][..])))(); //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[_]` } diff --git a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs index 0a8e4514b4334..d2d0dbf3e981f 100644 --- a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs +++ b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-2.rs @@ -10,14 +10,14 @@ // ignore-tidy-linelength -use std::iter::{Range,range}; +use std::ops::Range; trait Itble<'r, T, I: Iterator> { fn iter(&'r self) -> I; } impl<'r> Itble<'r, usize, Range> for (usize, usize) { fn iter(&'r self) -> Range { let &(min, max) = self; - range(min, max) + min..max } } diff --git a/src/test/compile-fail/variance-deprecated-markers.rs b/src/test/compile-fail/variance-deprecated-markers.rs deleted file mode 100644 index 8f9d24cb132c2..0000000000000 --- a/src/test/compile-fail/variance-deprecated-markers.rs +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright 2015 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// Test that the deprecated markers still have their old effect. - -#![feature(rustc_attrs)] - -use std::marker; - -#[rustc_variance] -struct A(marker::CovariantType); //~ ERROR types=[[+];[];[]] - -#[rustc_variance] -struct B(marker::ContravariantType); //~ ERROR types=[[-];[];[]] - -#[rustc_variance] -struct C(marker::InvariantType); //~ ERROR types=[[o];[];[]] - -#[rustc_variance] -struct D<'a>(marker::CovariantLifetime<'a>); //~ ERROR regions=[[+];[];[]] - -#[rustc_variance] -struct E<'a>(marker::ContravariantLifetime<'a>); //~ ERROR regions=[[-];[];[]] - -#[rustc_variance] -struct F<'a>(marker::InvariantLifetime<'a>); //~ ERROR regions=[[o];[];[]] - -fn main() { } diff --git a/src/test/compile-fail/vec-must-not-hide-type-from-dropck.rs b/src/test/compile-fail/vec-must-not-hide-type-from-dropck.rs index 6aaf51278afd8..44a3f716e3eea 100644 --- a/src/test/compile-fail/vec-must-not-hide-type-from-dropck.rs +++ b/src/test/compile-fail/vec-must-not-hide-type-from-dropck.rs @@ -30,9 +30,9 @@ use id::Id; mod s { #![allow(unstable)] - use std::sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering}; + use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; - static S_COUNT: AtomicUint = ATOMIC_UINT_INIT; + static S_COUNT: AtomicUsize = ATOMIC_USIZE_INIT; /// generates globally unique count (global across the current /// process, that is) diff --git a/src/test/compile-fail/vec_refs_data_with_early_death.rs b/src/test/compile-fail/vec_refs_data_with_early_death.rs index a191b3e56c417..0025449a3dbb7 100644 --- a/src/test/compile-fail/vec_refs_data_with_early_death.rs +++ b/src/test/compile-fail/vec_refs_data_with_early_death.rs @@ -27,5 +27,5 @@ fn main() { v.push(&x); //~ ERROR `x` does not live long enough v.push(&y); //~ ERROR `y` does not live long enough - assert_eq!(v.as_slice(), [&3, &4]); + assert_eq!(v, [&3, &4]); } diff --git a/src/test/run-fail/rt-set-exit-status-panic.rs b/src/test/run-fail/rt-set-exit-status-panic.rs index 0e72ab22dc8f9..249e2e1ac2d64 100644 --- a/src/test/run-fail/rt-set-exit-status-panic.rs +++ b/src/test/run-fail/rt-set-exit-status-panic.rs @@ -10,16 +10,16 @@ // error-pattern:whatever -#![feature(os, rustc_private)] +#![feature(exit_status, rustc_private)] #[macro_use] extern crate log; -use std::os; +use std::env; fn main() { error!("whatever"); // Setting the exit status only works when the scheduler terminates // normally. In this case we're going to panic, so instead of // returning 50 the process will return the typical rt failure code. - os::set_exit_status(50); + env::set_exit_status(50); panic!(); } diff --git a/src/test/run-fail/rt-set-exit-status-panic2.rs b/src/test/run-fail/rt-set-exit-status-panic2.rs index a71ce9ebab59b..fddff3c5a9f4f 100644 --- a/src/test/run-fail/rt-set-exit-status-panic2.rs +++ b/src/test/run-fail/rt-set-exit-status-panic2.rs @@ -10,10 +10,10 @@ // error-pattern:whatever -#![feature(os, rustc_private)] +#![feature(exit_status, rustc_private)] #[macro_use] extern crate log; -use std::os; +use std::env; use std::thread; struct r { @@ -25,7 +25,7 @@ struct r { // runtime's exit code impl Drop for r { fn drop(&mut self) { - os::set_exit_status(50); + env::set_exit_status(50); } } diff --git a/src/test/run-fail/rt-set-exit-status.rs b/src/test/run-fail/rt-set-exit-status.rs index 9425a1b1902b5..c33a8d2d03227 100644 --- a/src/test/run-fail/rt-set-exit-status.rs +++ b/src/test/run-fail/rt-set-exit-status.rs @@ -10,14 +10,14 @@ // error-pattern:whatever -#![feature(rustc_private, os)] +#![feature(rustc_private, exit_status)] #[macro_use] extern crate log; -use std::os; +use std::env; fn main() { error!("whatever"); // 101 is the code the runtime uses on task panic and the value // compiletest expects run-fail tests to return. - os::set_exit_status(101); + env::set_exit_status(101); } diff --git a/src/test/run-make/link-path-order/main.rs b/src/test/run-make/link-path-order/main.rs index b1576ccd48e9f..c1787eb03f592 100644 --- a/src/test/run-make/link-path-order/main.rs +++ b/src/test/run-make/link-path-order/main.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(libc, os)] +#![feature(libc, exit_status)] extern crate libc; @@ -23,6 +23,6 @@ fn main() { }; if result != 1 { - std::os::set_exit_status(255); + std::env::set_exit_status(255); } } diff --git a/src/test/run-make/unicode-input/span_length.rs b/src/test/run-make/unicode-input/span_length.rs index ebf3226334cc6..a70a160076520 100644 --- a/src/test/run-make/unicode-input/span_length.rs +++ b/src/test/run-make/unicode-input/span_length.rs @@ -95,10 +95,10 @@ fn main() { let expected_span = format!("\n{}^{}\n", repeat(" ").take(offset + 7).collect::(), repeat("~").take(8).collect::()); - assert!(err.contains(expected_span.as_slice())); + assert!(err.contains(&expected_span)); // Second snake is 8 ~s long, with 36 preceding spaces let expected_span = format!("\n{}^{}\n", repeat(" ").take(offset + 36).collect::(), repeat("~").take(8).collect::()); - assert!(err.contains(expected_span.as_slice())); + assert!(err.contains(&expected_span)); } diff --git a/src/test/run-pass-fulldeps/compiler-calls.rs b/src/test/run-pass-fulldeps/compiler-calls.rs index 7a3c32a45f912..4bacde0aadf3f 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/create-dir-all-bare.rs b/src/test/run-pass-fulldeps/create-dir-all-bare.rs similarity index 86% rename from src/test/run-pass/create-dir-all-bare.rs rename to src/test/run-pass-fulldeps/create-dir-all-bare.rs index 475df629f6376..d09d7c55722ba 100644 --- a/src/test/run-pass/create-dir-all-bare.rs +++ b/src/test/run-pass-fulldeps/create-dir-all-bare.rs @@ -8,10 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(tempdir)] +#![feature(rustc_private)] + +extern crate rustc_back; use std::env; -use std::fs::{self, TempDir}; +use std::fs; +use rustc_back::tempdir::TempDir; fn main() { let td = TempDir::new("create-dir-all-bare").unwrap(); diff --git a/src/test/run-pass/rename-directory.rs b/src/test/run-pass-fulldeps/rename-directory.rs similarity index 90% rename from src/test/run-pass/rename-directory.rs rename to src/test/run-pass-fulldeps/rename-directory.rs index f149a70817a8a..fa810f72fcbd1 100644 --- a/src/test/run-pass/rename-directory.rs +++ b/src/test/run-pass-fulldeps/rename-directory.rs @@ -13,10 +13,13 @@ // pretty-expanded FIXME #23616 -#![feature(tempdir, path_ext)] +#![feature(rustc_private, path_ext)] + +extern crate rustc_back; use std::ffi::CString; -use std::fs::{self, TempDir, File, PathExt}; +use std::fs::{self, File, PathExt}; +use rustc_back::tempdir::TempDir; fn rename_directory() { let tmpdir = TempDir::new("rename_directory").ok().expect("rename_directory failed"); diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs index 226a7c12df9ab..14d8bce061f5a 100644 --- a/src/test/run-pass/backtrace.rs +++ b/src/test/run-pass/backtrace.rs @@ -80,9 +80,9 @@ fn runtest(me: &str) { let s = str::from_utf8(&out.error).unwrap(); let mut i = 0; for _ in 0..2 { - i += s[i + 10..].find_str("stack backtrace").unwrap() + 10; + i += s[i + 10..].find("stack backtrace").unwrap() + 10; } - assert!(s[i + 10..].find_str("stack backtrace").is_none(), + assert!(s[i + 10..].find("stack backtrace").is_none(), "bad output4: {}", s); } diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs index b20de7113ec5d..f9b429a935a6a 100644 --- a/src/test/run-pass/capturing-logging.rs +++ b/src/test/run-pass/capturing-logging.rs @@ -22,7 +22,7 @@ use log::{set_logger, Logger, LogRecord}; use std::sync::mpsc::channel; use std::fmt; use std::old_io::{ChanReader, ChanWriter, Reader, Writer}; -use std::thread::Thread; +use std::thread; struct MyWriter(ChanWriter); @@ -36,7 +36,7 @@ impl Logger for MyWriter { fn main() { let (tx, rx) = channel(); let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx)); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { set_logger(box MyWriter(w) as Box); debug!("debug"); info!("info"); diff --git a/src/test/run-pass/child-outlives-parent.rs b/src/test/run-pass/child-outlives-parent.rs index 64642e51c094b..7da1416602f6d 100644 --- a/src/test/run-pass/child-outlives-parent.rs +++ b/src/test/run-pass/child-outlives-parent.rs @@ -14,10 +14,10 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; fn child2(_s: String) { } pub fn main() { - let _x = Thread::spawn(move|| child2("hi".to_string())); + let _x = thread::spawn(move|| child2("hi".to_string())); } diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs index fa663105ccdaf..16efceb9d7e0e 100644 --- a/src/test/run-pass/clone-with-exterior.rs +++ b/src/test/run-pass/clone-with-exterior.rs @@ -13,7 +13,7 @@ #![allow(unknown_features)] #![feature(box_syntax, std_misc)] -use std::thread::Thread; +use std::thread; struct Pair { a: isize, @@ -23,7 +23,7 @@ struct Pair { pub fn main() { let z: Box<_> = box Pair { a : 10, b : 12}; - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { assert_eq!(z.a, 10); assert_eq!(z.b, 12); }); diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index 43f10cfd06002..859599596ae7b 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -10,12 +10,12 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::mpsc::{channel, Sender}; pub fn main() { let (tx, rx) = channel(); - let _t = Thread::spawn(move|| { child(&tx) }); + let _t = thread::scoped(move|| { child(&tx) }); let y = rx.recv().unwrap(); println!("received"); println!("{}", y); diff --git a/src/test/run-pass/core-run-destroy.rs b/src/test/run-pass/core-run-destroy.rs index a969f6911545f..03bf3851257df 100644 --- a/src/test/run-pass/core-run-destroy.rs +++ b/src/test/run-pass/core-run-destroy.rs @@ -24,7 +24,7 @@ use std::old_io::{Process, Command, timer}; use std::time::Duration; use std::str; use std::sync::mpsc::channel; -use std::thread::Thread; +use std::thread; macro_rules! succeed { ($e:expr) => ( match $e { Ok(..) => {}, Err(e) => panic!("panic: {}", e) } @@ -86,7 +86,7 @@ pub fn test_destroy_actually_kills(force: bool) { let (tx, rx1) = channel(); let mut t = timer::Timer::new().unwrap(); let rx2 = t.oneshot(Duration::milliseconds(1000)); - Thread::spawn(move|| { + thread::spawn(move|| { select! { _ = rx2.recv() => unsafe { libc::exit(1) }, _ = rx1.recv() => {} diff --git a/src/test/run-pass/drop-with-type-ascription-2.rs b/src/test/run-pass/drop-with-type-ascription-2.rs index ddfaf54493fb4..3d4af80e30bb5 100644 --- a/src/test/run-pass/drop-with-type-ascription-2.rs +++ b/src/test/run-pass/drop-with-type-ascription-2.rs @@ -14,7 +14,7 @@ fn main() { let args = vec!("foobie", "asdf::asdf"); - let arr: Vec<&str> = args[1].split_str("::").collect(); + let arr: Vec<&str> = args[1].split("::").collect(); assert_eq!(arr[0], "asdf"); assert_eq!(arr[0], "asdf"); } diff --git a/src/test/run-pass/extern-call-scrub.rs b/src/test/run-pass/extern-call-scrub.rs index 069ecd92a56d0..e8c9bc76335f7 100644 --- a/src/test/run-pass/extern-call-scrub.rs +++ b/src/test/run-pass/extern-call-scrub.rs @@ -15,7 +15,7 @@ #![feature(libc, std_misc)] extern crate libc; -use std::thread::Thread; +use std::thread; mod rustrt { extern crate libc; @@ -46,7 +46,7 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t { pub fn main() { // Make sure we're on a task with small Rust stacks (main currently // has a large stack) - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { let result = count(12); println!("result = {}", result); assert_eq!(result, 2048); diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index 3d1b74438a845..5c96aaf4bd890 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -25,7 +25,7 @@ mod map_reduce { use std::collections::HashMap; use std::sync::mpsc::{channel, Sender}; use std::str; - use std::thread::Thread; + use std::thread; pub type putter<'a> = Box; @@ -37,7 +37,7 @@ mod map_reduce { for i in &inputs { let ctrl = ctrl.clone(); let i = i.clone(); - Thread::spawn(move|| map_task(ctrl.clone(), i.clone()) ); + thread::spawn(move|| map_task(ctrl.clone(), i.clone()) ); } } diff --git a/src/test/run-pass/init-large-type.rs b/src/test/run-pass/init-large-type.rs index ca4dba4198c03..26d58d34b9dea 100644 --- a/src/test/run-pass/init-large-type.rs +++ b/src/test/run-pass/init-large-type.rs @@ -16,7 +16,7 @@ #![feature(intrinsics, std_misc)] -use std::thread::Thread; +use std::thread; extern "rust-intrinsic" { pub fn init() -> T; @@ -26,7 +26,7 @@ const SIZE: usize = 1024 * 1024; fn main() { // do the test in a new thread to avoid (spurious?) stack overflows - let _ = Thread::scoped(|| { + let _ = thread::scoped(|| { let _memory: [u8; SIZE] = unsafe { init() }; }).join(); } diff --git a/src/test/run-pass/issue-13304.rs b/src/test/run-pass/issue-13304.rs index 876b329998e08..c260aa95b57f1 100644 --- a/src/test/run-pass/issue-13304.rs +++ b/src/test/run-pass/issue-13304.rs @@ -29,8 +29,8 @@ fn main() { fn parent() { let args: Vec = env::args().collect(); let mut p = Command::new(&args[0]).arg("child") - .stdout(Stdio::capture()) - .stdin(Stdio::capture()) + .stdout(Stdio::piped()) + .stdin(Stdio::piped()) .spawn().unwrap(); p.stdin.as_mut().unwrap().write_all(b"test1\ntest2\ntest3").unwrap(); let out = p.wait_with_output().unwrap(); diff --git a/src/test/run-pass/issue-13494.rs b/src/test/run-pass/issue-13494.rs index 6159edbfe1ee4..d1b1647de7881 100644 --- a/src/test/run-pass/issue-13494.rs +++ b/src/test/run-pass/issue-13494.rs @@ -16,7 +16,7 @@ #![feature(std_misc)] use std::sync::mpsc::{channel, Sender, Receiver}; -use std::thread::Thread; +use std::thread; fn helper(rx: Receiver>) { for tx in rx.iter() { @@ -26,7 +26,7 @@ fn helper(rx: Receiver>) { fn main() { let (tx, rx) = channel(); - let _t = Thread::spawn(move|| { helper(rx) }); + let _t = thread::scoped(move|| { helper(rx) }); let (snd, rcv) = channel::(); for _ in 1..100000 { snd.send(1).unwrap(); @@ -37,4 +37,5 @@ fn main() { _ = rcv.recv() => () } } + drop(tx); } diff --git a/src/test/run-pass/issue-14456.rs b/src/test/run-pass/issue-14456.rs index f897b00ceffef..ab9633ca1fe90 100644 --- a/src/test/run-pass/issue-14456.rs +++ b/src/test/run-pass/issue-14456.rs @@ -38,9 +38,9 @@ fn child() { fn test() { let args: Vec = env::args().collect(); let mut p = Command::new(&args[0]).arg("child") - .stdin(Stdio::capture()) - .stdout(Stdio::capture()) - .stderr(Stdio::capture()) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) .spawn().unwrap(); assert!(p.wait().unwrap().success()); } diff --git a/src/test/run-pass/issue-17351.rs b/src/test/run-pass/issue-17351.rs index 0dac3295c1bf6..6e93194647ad2 100644 --- a/src/test/run-pass/issue-17351.rs +++ b/src/test/run-pass/issue-17351.rs @@ -12,6 +12,10 @@ #![feature(core)] +trait Str { fn foo(&self) {} } +impl Str for str {} +impl<'a, S: ?Sized> Str for &'a S where S: Str {} + fn main() { let _: &Str = &"x"; } diff --git a/src/test/run-pass/issue-20454.rs b/src/test/run-pass/issue-20454.rs index 0e3d4e0e40d67..d527d9519cfbc 100644 --- a/src/test/run-pass/issue-20454.rs +++ b/src/test/run-pass/issue-20454.rs @@ -12,10 +12,12 @@ use std::thread; -fn main() { - thread::Thread::spawn(move || { // no need for -> () +fn _foo() { + let _t = thread::scoped(move || { // no need for -> () loop { println!("hello"); } }); } + +fn main() {} diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index 7842bcb7dd1ec..71d1439dd2bc8 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -21,7 +21,7 @@ pub mod pipes { use std::mem::{forget, transmute}; use std::mem::{replace, swap}; use std::mem; - use std::thread::Thread; + use std::thread; use std::marker::Send; pub struct Stuff { @@ -115,7 +115,7 @@ pub mod pipes { let old_state = swap_state_acq(&mut (*p).state, blocked); match old_state { - empty | blocked => { Thread::yield_now(); } + empty | blocked => { thread::yield_now(); } full => { let payload = replace(&mut p.payload, None); return Some(payload.unwrap()) diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs index 2bd56e8168787..45eb21374e298 100644 --- a/src/test/run-pass/issue-3609.rs +++ b/src/test/run-pass/issue-3609.rs @@ -11,7 +11,7 @@ #![allow(unknown_features)] #![feature(std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::mpsc::Sender; use std::thunk::Invoke; @@ -24,7 +24,7 @@ enum Msg } fn foo(name: String, samples_chan: Sender) { - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { let mut samples_chan = samples_chan; // FIXME (#22405): Replace `Box::new` with `box` here when/if possible. diff --git a/src/test/run-pass/issue-8827.rs b/src/test/run-pass/issue-8827.rs index 4e1ff84291eb1..280311af6fbd1 100644 --- a/src/test/run-pass/issue-8827.rs +++ b/src/test/run-pass/issue-8827.rs @@ -10,12 +10,12 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::mpsc::{channel, Receiver}; fn periodical(n: isize) -> Receiver { let (chan, port) = channel(); - Thread::spawn(move|| { + thread::spawn(move|| { loop { for _ in 1..n { match chan.send(false) { @@ -34,7 +34,7 @@ fn periodical(n: isize) -> Receiver { fn integers() -> Receiver { let (chan, port) = channel(); - Thread::spawn(move|| { + thread::spawn(move|| { let mut i = 1; loop { match chan.send(i) { diff --git a/src/test/run-pass/issue-9396.rs b/src/test/run-pass/issue-9396.rs index aeba6889f49e8..bfaf060e43c30 100644 --- a/src/test/run-pass/issue-9396.rs +++ b/src/test/run-pass/issue-9396.rs @@ -14,12 +14,12 @@ use std::sync::mpsc::{TryRecvError, channel}; use std::old_io::timer::Timer; -use std::thread::Thread; +use std::thread; use std::time::Duration; pub fn main() { let (tx, rx) = channel(); - let _t = Thread::scoped(move||{ + let _t = thread::scoped(move||{ let mut timer = Timer::new().unwrap(); timer.sleep(Duration::milliseconds(10)); tx.send(()).unwrap(); diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs index d5138f6fdbc59..8ae084dce8c37 100644 --- a/src/test/run-pass/ivec-tag.rs +++ b/src/test/run-pass/ivec-tag.rs @@ -12,7 +12,7 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::mpsc::{channel, Sender}; fn producer(tx: &Sender>) { @@ -23,7 +23,7 @@ fn producer(tx: &Sender>) { pub fn main() { let (tx, rx) = channel::>(); - let _prod = Thread::spawn(move|| { + let _prod = thread::scoped(move|| { producer(&tx) }); diff --git a/src/test/run-pass/kindck-implicit-close-over-mut-var.rs b/src/test/run-pass/kindck-implicit-close-over-mut-var.rs index 4645e8ff3924a..11b1d70137def 100644 --- a/src/test/run-pass/kindck-implicit-close-over-mut-var.rs +++ b/src/test/run-pass/kindck-implicit-close-over-mut-var.rs @@ -10,7 +10,7 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; fn user(_i: isize) {} @@ -18,7 +18,7 @@ fn foo() { // Here, i is *copied* into the proc (heap closure). // Requires allocation. The proc's copy is not mutable. let mut i = 0; - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { user(i); println!("spawned {}", i) }); @@ -31,7 +31,7 @@ fn bar() { // mutable outside of the proc. let mut i = 0; while i < 10 { - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { user(i); }); i += 1; @@ -42,7 +42,7 @@ fn car() { // Here, i must be shadowed in the proc to be mutable. let mut i = 0; while i < 10 { - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { let mut i = i; i += 1; user(i); diff --git a/src/test/run-pass/macro-with-braces-in-expr-position.rs b/src/test/run-pass/macro-with-braces-in-expr-position.rs index 80a3b8c9eddee..4881a5ab647ec 100644 --- a/src/test/run-pass/macro-with-braces-in-expr-position.rs +++ b/src/test/run-pass/macro-with-braces-in-expr-position.rs @@ -10,13 +10,13 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; macro_rules! expr { ($e: expr) => { $e } } macro_rules! spawn { ($($code: tt)*) => { - expr!(Thread::spawn(move|| {$($code)*})) + expr!(thread::spawn(move|| {$($code)*})) } } diff --git a/src/test/run-pass/method-two-traits-distinguished-via-where-clause.rs b/src/test/run-pass/method-two-traits-distinguished-via-where-clause.rs index 329b77776b639..77072bdec9051 100644 --- a/src/test/run-pass/method-two-traits-distinguished-via-where-clause.rs +++ b/src/test/run-pass/method-two-traits-distinguished-via-where-clause.rs @@ -33,6 +33,6 @@ impl B for *const [T] { fn main() { let x: [isize; 4] = [1,2,3,4]; - let xptr = x.as_slice() as *const [isize]; + let xptr = &x[..] as *const [isize]; xptr.foo(); } diff --git a/src/test/run-pass/moves-based-on-type-capture-clause.rs b/src/test/run-pass/moves-based-on-type-capture-clause.rs index f0eba366e7117..b6509d280366a 100644 --- a/src/test/run-pass/moves-based-on-type-capture-clause.rs +++ b/src/test/run-pass/moves-based-on-type-capture-clause.rs @@ -10,11 +10,11 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; pub fn main() { let x = "Hello world!".to_string(); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { println!("{}", x); }); } diff --git a/src/test/run-pass/option-ext.rs b/src/test/run-pass/option-ext.rs index 8f5a5e8ece75d..03ba6097cd929 100644 --- a/src/test/run-pass/option-ext.rs +++ b/src/test/run-pass/option-ext.rs @@ -12,7 +12,7 @@ pub fn main() { let thing = "{{ f }}"; - let f = thing.find_str("{{"); + let f = thing.find("{{"); if f.is_none() { println!("None!"); diff --git a/src/test/run-pass/out-of-stack-new-thread-no-split.rs b/src/test/run-pass/out-of-stack-new-thread-no-split.rs index 3c322f72b75b6..f08ed6e7f9cdc 100644 --- a/src/test/run-pass/out-of-stack-new-thread-no-split.rs +++ b/src/test/run-pass/out-of-stack-new-thread-no-split.rs @@ -18,7 +18,7 @@ use std::old_io::process::Command; use std::env; -use std::thread::Thread; +use std::thread; // lifted from the test module // Inlining to avoid llvm turning the recursive functions into tail calls, @@ -37,7 +37,7 @@ fn recurse() { fn main() { let args: Vec = env::args().collect(); if args.len() > 1 && args[1] == "recurse" { - let _t = Thread::scoped(recurse); + let _t = thread::scoped(recurse); } else { let recurse = Command::new(&args[0]).arg("recurse").output().unwrap(); assert!(!recurse.status.success()); diff --git a/src/test/run-pass/running-with-no-runtime.rs b/src/test/run-pass/running-with-no-runtime.rs index c5b59e6c6e071..abad08c7ac6b3 100644 --- a/src/test/run-pass/running-with-no-runtime.rs +++ b/src/test/run-pass/running-with-no-runtime.rs @@ -10,7 +10,7 @@ #![feature(start, os, std_misc, old_io)] -use std::ffi; +use std::ffi::CStr; use std::old_io::process::{Command, ProcessOutput}; use std::os; use std::rt::unwind::try; @@ -38,7 +38,7 @@ fn start(argc: isize, argv: *const *const u8) -> isize { let args = unsafe { (0..argc as usize).map(|i| { let ptr = *argv.offset(i as isize) as *const _; - ffi::c_str_to_bytes(&ptr).to_vec() + CStr::from_ptr(ptr).to_bytes().to_vec() }).collect::>() }; let me = &*args[0]; diff --git a/src/test/run-pass/rust-log-filter.rs b/src/test/run-pass/rust-log-filter.rs index bc379f1a76f7f..660b1e2036d33 100644 --- a/src/test/run-pass/rust-log-filter.rs +++ b/src/test/run-pass/rust-log-filter.rs @@ -19,7 +19,7 @@ extern crate log; use std::sync::mpsc::{channel, Sender, Receiver}; -use std::thread::Thread; +use std::thread; pub struct ChannelLogger { tx: Sender @@ -41,7 +41,7 @@ impl log::Logger for ChannelLogger { pub fn main() { let (logger, rx) = ChannelLogger::new(); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { log::set_logger(logger); info!("foo"); diff --git a/src/test/run-pass/send-is-not-static-par-for.rs b/src/test/run-pass/send-is-not-static-par-for.rs index 5815eaa01ea82..99ae3b7c7d87c 100644 --- a/src/test/run-pass/send-is-not-static-par-for.rs +++ b/src/test/run-pass/send-is-not-static-par-for.rs @@ -11,7 +11,7 @@ // pretty-expanded FIXME #23616 #![feature(core, std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::Mutex; fn par_for(iter: I, f: F) @@ -21,7 +21,7 @@ fn par_for(iter: I, f: F) { let f = &f; let _guards: Vec<_> = iter.map(|elem| { - Thread::scoped(move || { + thread::scoped(move || { f(elem) }) }).collect(); diff --git a/src/test/run-pass/send-resource.rs b/src/test/run-pass/send-resource.rs index 2c897c48a33c9..3f64b2adb6395 100644 --- a/src/test/run-pass/send-resource.rs +++ b/src/test/run-pass/send-resource.rs @@ -12,7 +12,7 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::mpsc::channel; struct test { @@ -32,7 +32,7 @@ fn test(f: isize) -> test { pub fn main() { let (tx, rx) = channel(); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { let (tx2, rx2) = channel(); tx.send(tx2).unwrap(); diff --git a/src/test/run-pass/stat.rs b/src/test/run-pass/stat.rs deleted file mode 100644 index c453f9252efe6..0000000000000 --- a/src/test/run-pass/stat.rs +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// pretty-expanded FIXME #23616 - -#![feature(tempdir, path_ext)] - -use std::fs::{File, TempDir}; -use std::io::prelude::*; - -pub fn main() { - let dir = TempDir::new_in(".", "").unwrap(); - let path = dir.path().join("file"); - - { - match File::create(&path) { - Err(..) => unreachable!(), - Ok(f) => { - let mut f = f; - for _ in 0..1000 { - f.write(&[0]); - } - } - } - } - - assert!(path.exists()); - assert_eq!(path.metadata().unwrap().len(), 1000); -} diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs index b3f503aad3444..8834fd39d1d88 100644 --- a/src/test/run-pass/syntax-extension-source-utils.rs +++ b/src/test/run-pass/syntax-extension-source-utils.rs @@ -36,7 +36,6 @@ pub fn main() { assert!( include_str!("syntax-extension-source-utils-files/includeme.\ fragment").to_string() - .as_slice() .starts_with("/* this is for ")); assert!( include_bytes!("syntax-extension-source-utils-files/includeme.fragment") @@ -44,8 +43,5 @@ pub fn main() { // The Windows tests are wrapped in an extra module for some reason assert!((m1::m2::where_am_i().ends_with("m1::m2"))); - assert!(match (47, "( 2 * 3 ) + 5") { - (line!(), stringify!((2*3) + 5)) => true, - _ => false - }) + assert_eq!((46, "( 2 * 3 ) + 5"), (line!(), stringify!((2*3) + 5))); } diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs index 05197cd6a3d89..786dd2c76123e 100644 --- a/src/test/run-pass/task-comm-0.rs +++ b/src/test/run-pass/task-comm-0.rs @@ -10,7 +10,7 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::mpsc::{channel, Sender}; pub fn main() { test05(); } @@ -26,7 +26,7 @@ fn test05_start(tx : &Sender) { fn test05() { let (tx, rx) = channel(); - let _t = Thread::spawn(move|| { test05_start(&tx) }); + let _t = thread::scoped(move|| { test05_start(&tx) }); let mut value: isize = rx.recv().unwrap(); println!("{}", value); value = rx.recv().unwrap(); diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs index e882d8506fc65..9c3466f162b03 100644 --- a/src/test/run-pass/task-comm-1.rs +++ b/src/test/run-pass/task-comm-1.rs @@ -10,13 +10,13 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; pub fn main() { test00(); } fn start() { println!("Started / Finished task."); } fn test00() { - let _ = Thread::scoped(move|| start() ).join(); + let _ = thread::scoped(move|| start() ).join(); println!("Completing."); } diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs index 99eebdb601a29..f25bb3ff71ae8 100644 --- a/src/test/run-pass/task-comm-10.rs +++ b/src/test/run-pass/task-comm-10.rs @@ -10,7 +10,7 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::mpsc::{channel, Sender}; fn start(tx: &Sender>) { @@ -29,10 +29,10 @@ fn start(tx: &Sender>) { pub fn main() { let (tx, rx) = channel(); - let _child = Thread::spawn(move|| { start(&tx) }); + let _child = thread::scoped(move|| { start(&tx) }); let mut c = rx.recv().unwrap(); c.send("A".to_string()).unwrap(); c.send("B".to_string()).unwrap(); - Thread::yield_now(); + thread::yield_now(); } diff --git a/src/test/run-pass/task-comm-11.rs b/src/test/run-pass/task-comm-11.rs index 9ef5afab2e091..ec9ed53c1dca0 100644 --- a/src/test/run-pass/task-comm-11.rs +++ b/src/test/run-pass/task-comm-11.rs @@ -13,7 +13,7 @@ #![feature(std_misc)] use std::sync::mpsc::{channel, Sender}; -use std::thread::Thread; +use std::thread; fn start(tx: &Sender>) { let (tx2, _rx) = channel(); @@ -22,7 +22,7 @@ fn start(tx: &Sender>) { pub fn main() { let (tx, rx) = channel(); - let _child = Thread::spawn(move|| { + let _child = thread::scoped(move|| { start(&tx) }); let _tx = rx.recv().unwrap(); diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs index 8921529c6bea3..03305091a2d07 100644 --- a/src/test/run-pass/task-comm-12.rs +++ b/src/test/run-pass/task-comm-12.rs @@ -10,7 +10,7 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; pub fn main() { test00(); } @@ -18,14 +18,14 @@ fn start(_task_number: isize) { println!("Started / Finished task."); } fn test00() { let i: isize = 0; - let mut result = Thread::scoped(move|| { + let mut result = thread::scoped(move|| { start(i) }); // Sleep long enough for the task to finish. let mut i = 0_usize; while i < 10000 { - Thread::yield_now(); + thread::yield_now(); i += 1; } diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs index 3a0757548e8c6..15ceacd672f8b 100644 --- a/src/test/run-pass/task-comm-13.rs +++ b/src/test/run-pass/task-comm-13.rs @@ -11,7 +11,7 @@ #![feature(std_misc)] use std::sync::mpsc::{channel, Sender}; -use std::thread::Thread; +use std::thread; fn start(tx: &Sender, start: isize, number_of_messages: isize) { let mut i: isize = 0; @@ -21,6 +21,6 @@ fn start(tx: &Sender, start: isize, number_of_messages: isize) { pub fn main() { println!("Check that we don't deadlock."); let (tx, rx) = channel(); - let _ = Thread::scoped(move|| { start(&tx, 0, 10) }).join(); + let _t = thread::scoped(move|| { start(&tx, 0, 10) }).join(); println!("Joined task"); } diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs index 2ef09cdcf874d..1e2d9fe52df15 100644 --- a/src/test/run-pass/task-comm-14.rs +++ b/src/test/run-pass/task-comm-14.rs @@ -11,7 +11,7 @@ #![feature(std_misc)] use std::sync::mpsc::{channel, Sender}; -use std::thread::Thread; +use std::thread; pub fn main() { let (tx, rx) = channel(); @@ -21,7 +21,7 @@ pub fn main() { while (i > 0) { println!("{}", i); let tx = tx.clone(); - Thread::spawn({let i = i; move|| { child(i, &tx) }}); + thread::scoped({let i = i; move|| { child(i, &tx) }}); i = i - 1; } diff --git a/src/test/run-pass/task-comm-15.rs b/src/test/run-pass/task-comm-15.rs index 605900495b50c..2663595aecfa1 100644 --- a/src/test/run-pass/task-comm-15.rs +++ b/src/test/run-pass/task-comm-15.rs @@ -13,7 +13,7 @@ #![feature(std_misc)] use std::sync::mpsc::{channel, Sender}; -use std::thread::Thread; +use std::thread; fn start(tx: &Sender, i0: isize) { let mut i = i0; @@ -29,7 +29,7 @@ pub fn main() { // the child's point of view the receiver may die. We should // drop messages on the floor in this case, and not crash! let (tx, rx) = channel(); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { start(&tx, 10) }); rx.recv(); diff --git a/src/test/run-pass/task-comm-17.rs b/src/test/run-pass/task-comm-17.rs index 6c27292d19d59..de334c77aa310 100644 --- a/src/test/run-pass/task-comm-17.rs +++ b/src/test/run-pass/task-comm-17.rs @@ -16,11 +16,11 @@ // This test is specifically about spawning temporary closures. -use std::thread::Thread; +use std::thread; fn f() { } pub fn main() { - let _t = Thread::scoped(move|| f() ).join(); + let _t = thread::scoped(move|| f() ).join(); } diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs index d742b7bb11ab6..254ad653c4813 100644 --- a/src/test/run-pass/task-comm-3.rs +++ b/src/test/run-pass/task-comm-3.rs @@ -12,7 +12,7 @@ // no-pretty-expanded FIXME #15189 -use std::thread::Thread; +use std::thread; use std::sync::mpsc::{channel, Sender}; pub fn main() { println!("===== WITHOUT THREADS ====="); test00(); } @@ -42,7 +42,7 @@ fn test00() { let mut results = Vec::new(); while i < number_of_tasks { let tx = tx.clone(); - results.push(Thread::scoped({ + results.push(thread::scoped({ let i = i; move|| { test00_start(&tx, i, number_of_messages) diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs index 82e8fe0af417e..b05e36552a24c 100644 --- a/src/test/run-pass/task-comm-7.rs +++ b/src/test/run-pass/task-comm-7.rs @@ -14,7 +14,7 @@ #![allow(dead_assignment)] use std::sync::mpsc::{channel, Sender}; -use std::thread::Thread; +use std::thread; pub fn main() { test00(); } @@ -31,19 +31,19 @@ fn test00() { let number_of_messages: isize = 10; let tx2 = tx.clone(); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { test00_start(&tx2, number_of_messages * 0, number_of_messages); }); let tx2 = tx.clone(); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { test00_start(&tx2, number_of_messages * 1, number_of_messages); }); let tx2 = tx.clone(); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { test00_start(&tx2, number_of_messages * 2, number_of_messages); }); let tx2 = tx.clone(); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { test00_start(&tx2, number_of_messages * 3, number_of_messages); }); diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs index 3e4a75b8e220f..758764aa9fdcc 100644 --- a/src/test/run-pass/task-comm-9.rs +++ b/src/test/run-pass/task-comm-9.rs @@ -10,7 +10,7 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::mpsc::{channel, Sender}; pub fn main() { test00(); } @@ -26,7 +26,7 @@ fn test00() { let (tx, rx) = channel(); let number_of_messages: isize = 10; - let result = Thread::scoped(move|| { + let result = thread::scoped(move|| { test00_start(&tx, number_of_messages); }); diff --git a/src/test/run-pass/task-life-0.rs b/src/test/run-pass/task-life-0.rs index 7da7a1afb9af8..b97f4355b3ee0 100644 --- a/src/test/run-pass/task-life-0.rs +++ b/src/test/run-pass/task-life-0.rs @@ -12,10 +12,10 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; pub fn main() { - let _t = Thread::spawn(move|| child("Hello".to_string()) ); + let _t = thread::scoped(move|| child("Hello".to_string()) ); } fn child(_s: String) { diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs index 637f564f72649..aa7b61bf112f9 100644 --- a/src/test/run-pass/task-spawn-move-and-copy.rs +++ b/src/test/run-pass/task-spawn-move-and-copy.rs @@ -13,7 +13,7 @@ #![allow(unknown_features)] #![feature(box_syntax, std_misc)] -use std::thread::Thread; +use std::thread; use std::sync::mpsc::channel; pub fn main() { @@ -22,7 +22,7 @@ pub fn main() { let x: Box = box 1; let x_in_parent = &(*x) as *const isize as usize; - let _t = Thread::spawn(move || { + let _t = thread::scoped(move || { let x_in_child = &(*x) as *const isize as usize; tx.send(x_in_child).unwrap(); }); diff --git a/src/test/run-pass/tcp-accept-stress.rs b/src/test/run-pass/tcp-accept-stress.rs index 99d36a179aaf5..00467e563347a 100644 --- a/src/test/run-pass/tcp-accept-stress.rs +++ b/src/test/run-pass/tcp-accept-stress.rs @@ -19,7 +19,7 @@ use std::old_io::{TcpListener, Listener, Acceptor, EndOfFile, TcpStream}; use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::mpsc::channel; -use std::thread::Thread; +use std::thread; static N: usize = 8; static M: usize = 20; @@ -40,7 +40,7 @@ fn test() { let a = a.clone(); let cnt = cnt.clone(); let srv_tx = srv_tx.clone(); - Thread::scoped(move|| { + thread::scoped(move|| { let mut a = a; loop { match a.accept() { @@ -59,7 +59,7 @@ fn test() { let _t = (0..N).map(|_| { let cli_tx = cli_tx.clone(); - Thread::scoped(move|| { + thread::scoped(move|| { for _ in 0..M { let _s = TcpStream::connect(addr).unwrap(); } diff --git a/src/test/run-pass/tcp-connect-timeouts.rs b/src/test/run-pass/tcp-connect-timeouts.rs index a9a16cd72dff7..64f07a60b3503 100644 --- a/src/test/run-pass/tcp-connect-timeouts.rs +++ b/src/test/run-pass/tcp-connect-timeouts.rs @@ -26,7 +26,7 @@ use std::old_io::test::*; use std::old_io; use std::time::Duration; use std::sync::mpsc::channel; -use std::thread::Thread; +use std::thread; #[cfg_attr(target_os = "freebsd", ignore)] fn eventual_timeout() { @@ -34,7 +34,7 @@ fn eventual_timeout() { let (tx1, rx1) = channel(); let (_tx2, rx2) = channel::<()>(); - let _t = Thread::spawn(move|| { + let _t = thread::scoped(move|| { let _l = TcpListener::bind(addr).unwrap().listen(); tx1.send(()).unwrap(); let _ = rx2.recv(); diff --git a/src/test/run-pass/tempfile.rs b/src/test/run-pass/tempfile.rs index 74290518364d0..49fac24d0b3a5 100644 --- a/src/test/run-pass/tempfile.rs +++ b/src/test/run-pass/tempfile.rs @@ -24,7 +24,7 @@ use std::old_path::{Path, GenericPath}; use std::old_io::fs::PathExtensions; use std::old_io::{fs, TempDir}; use std::old_io; -use std::os; +use std::env; use std::sync::mpsc::channel; use std::thread; @@ -129,7 +129,7 @@ fn test_rm_tempdir_close() { // to depend on std fn recursive_mkdir_rel() { let path = Path::new("frob"); - let cwd = os::getcwd().unwrap(); + let cwd = Path::new(env::current_dir().unwrap().to_str().unwrap()); println!("recursive_mkdir_rel: Making: {} in cwd {} [{}]", path.display(), cwd.display(), path.exists()); fs::mkdir_recursive(&path, old_io::USER_RWX); @@ -147,7 +147,7 @@ fn recursive_mkdir_dot() { fn recursive_mkdir_rel_2() { let path = Path::new("./frob/baz"); - let cwd = os::getcwd().unwrap(); + let cwd = Path::new(env::current_dir().unwrap().to_str().unwrap()); println!("recursive_mkdir_rel_2: Making: {} in cwd {} [{}]", path.display(), cwd.display(), path.exists()); fs::mkdir_recursive(&path, old_io::USER_RWX); @@ -196,7 +196,7 @@ pub fn dont_double_panic() { fn in_tmpdir(f: F) where F: FnOnce() { let tmpdir = TempDir::new("test").ok().expect("can't make tmpdir"); - assert!(os::change_dir(tmpdir.path()).is_ok()); + assert!(env::set_current_dir(tmpdir.path().as_str().unwrap()).is_ok()); f(); } diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs index 4fc0995290493..969a42a6f8715 100644 --- a/src/test/run-pass/threads.rs +++ b/src/test/run-pass/threads.rs @@ -10,12 +10,12 @@ #![feature(std_misc)] -use std::thread::Thread; +use std::thread; pub fn main() { let mut i = 10; while i > 0 { - Thread::scoped({let i = i; move|| child(i)}); + thread::scoped({let i = i; move|| child(i)}); i = i - 1; } println!("main thread exiting"); diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs index 2d97633771e61..02ea703705605 100644 --- a/src/test/run-pass/trait-bounds-in-arc.rs +++ b/src/test/run-pass/trait-bounds-in-arc.rs @@ -19,7 +19,7 @@ use std::sync::Arc; use std::sync::mpsc::channel; -use std::thread::Thread; +use std::thread; trait Pet { fn name(&self, blk: Box); @@ -83,13 +83,13 @@ pub fn main() { box dogge2 as Box)); let (tx1, rx1) = channel(); let arc1 = arc.clone(); - let _t1 = Thread::spawn(move|| { check_legs(arc1); tx1.send(()); }); + let _t1 = thread::scoped(move|| { check_legs(arc1); tx1.send(()); }); let (tx2, rx2) = channel(); let arc2 = arc.clone(); - let _t2 = Thread::spawn(move|| { check_names(arc2); tx2.send(()); }); + let _t2 = thread::scoped(move|| { check_names(arc2); tx2.send(()); }); let (tx3, rx3) = channel(); let arc3 = arc.clone(); - let _t3 = Thread::spawn(move|| { check_pedigree(arc3); tx3.send(()); }); + let _t3 = thread::scoped(move|| { check_pedigree(arc3); tx3.send(()); }); rx1.recv(); rx2.recv(); rx3.recv(); diff --git a/src/test/run-pass/variadic-ffi.rs b/src/test/run-pass/variadic-ffi.rs index 1688482ca3760..d81dc3afcd7af 100644 --- a/src/test/run-pass/variadic-ffi.rs +++ b/src/test/run-pass/variadic-ffi.rs @@ -14,7 +14,7 @@ extern crate libc; -use std::ffi::{self, CString}; +use std::ffi::{CStr, CString}; use libc::{c_char, c_int}; @@ -25,7 +25,7 @@ extern { unsafe fn check(expected: &str, f: F) where F: FnOnce(*mut c_char) -> T { let mut x = [0 as c_char; 50]; f(&mut x[0] as *mut c_char); - assert_eq!(expected.as_bytes(), ffi::c_str_to_bytes(&x.as_ptr())); + assert_eq!(expected.as_bytes(), CStr::from_ptr(x.as_ptr()).to_bytes()); } pub fn main() {