More test fixes and fallout of stability changes

Author: alexcrichton

src/liballoc/arc.rs

@@ -290,7 +290,7 @@ pub fn strong_count<T: ?Sized>(this: &Arc<T>) -> usize { Arc::strong_count(this)
              reason = "this function is unsafe with weak pointers")]
 pub unsafe fn get_mut<T: ?Sized>(this: &mut Arc<T>) -> Option<&mut T> {
     // FIXME(#24880) potential race with upgraded weak pointers here
-    if strong_count(this) == 1 && weak_count(this) == 0 {
+    if Arc::strong_count(this) == 1 && Arc::weak_count(this) == 0 {
         // This unsafety is ok because we're guaranteed that the pointer
         // returned is the *only* pointer that will ever be returned to T. Our
         // reference count is guaranteed to be 1 at this point, and we required

src/liballoc/boxed.rs

@@ -267,7 +267,7 @@ impl Box<Any> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object
-                let raw = into_raw(self);
+                let raw = Box::into_raw(self);
                 let to: TraitObject =
                     mem::transmute::<*mut Any, TraitObject>(raw);
 

src/liballoc/rc.rs

@@ -148,26 +148,24 @@
 //! ```
 
 #![stable(feature = "rust1", since = "1.0.0")]
+
+use core::prelude::*;
+
 #[cfg(not(test))]
-use boxed;
+use boxed::Box;
 #[cfg(test)]
-use std::boxed;
+use std::boxed::Box;
+
 use core::cell::Cell;
-use core::clone::Clone;
-use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
-use core::default::Default;
+use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{Hasher, Hash};
 use core::intrinsics::{assume, drop_in_place};
-use core::marker::{self, Sized, Unsize};
+use core::marker::{self, Unsize};
 use core::mem::{self, min_align_of, size_of, min_align_of_val, size_of_val, forget};
 use core::nonzero::NonZero;
-use core::ops::{CoerceUnsized, Deref, Drop};
-use core::option::Option;
-use core::option::Option::{Some, None};
+use core::ops::{CoerceUnsized, Deref};
 use core::ptr;
-use core::result::Result;
-use core::result::Result::{Ok, Err};
 
 use heap::deallocate;
 
@@ -212,7 +210,7 @@ impl<T> Rc<T> {
                 // pointers, which ensures that the weak destructor never frees
                 // the allocation while the strong destructor is running, even
                 // if the weak pointer is stored inside the strong one.
-                _ptr: NonZero::new(boxed::into_raw(box RcBox {
+                _ptr: NonZero::new(Box::into_raw(box RcBox {
                     strong: Cell::new(1),
                     weak: Cell::new(1),
                     value: value
@@ -230,14 +228,14 @@ impl<T> Rc<T> {
     ///
     /// ```
     /// # #![feature(rc_unique)]
-    /// use std::rc::{self, Rc};
+    /// use std::rc::Rc;
     ///
     /// let x = Rc::new(3);
-    /// assert_eq!(rc::try_unwrap(x), Ok(3));
+    /// assert_eq!(Rc::try_unwrap(x), Ok(3));
     ///
     /// let x = Rc::new(4);
     /// let _y = x.clone();
-    /// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4)));
+    /// assert_eq!(Rc::try_unwrap(x), Err(Rc::new(4)));
     /// ```
     #[inline]
     #[unstable(feature = "rc_unique")]
@@ -295,17 +293,16 @@ impl<T: ?Sized> Rc<T> {
     ///
     /// ```
     /// # #![feature(rc_unique)]
-    /// use std::rc;
     /// use std::rc::Rc;
     ///
     /// let five = Rc::new(5);
     ///
-    /// rc::is_unique(&five);
+    /// assert!(Rc::is_unique(&five));
     /// ```
     #[inline]
     #[unstable(feature = "rc_unique")]
     pub fn is_unique(rc: &Rc<T>) -> bool {
-        weak_count(rc) == 0 && strong_count(rc) == 1
+        Rc::weak_count(rc) == 0 && Rc::strong_count(rc) == 1
     }
 
     /// Returns a mutable reference to the contained value if the `Rc<T>` is
@@ -317,14 +314,14 @@ impl<T: ?Sized> Rc<T> {
     ///
     /// ```
     /// # #![feature(rc_unique)]
-    /// use std::rc::{self, Rc};
+    /// use std::rc::Rc;
     ///
     /// let mut x = Rc::new(3);
-    /// *rc::get_mut(&mut x).unwrap() = 4;
+    /// *Rc::get_mut(&mut x).unwrap() = 4;
     /// assert_eq!(*x, 4);
     ///
     /// let _y = x.clone();
-    /// assert!(rc::get_mut(&mut x).is_none());
+    /// assert!(Rc::get_mut(&mut x).is_none());
     /// ```
     #[inline]
     #[unstable(feature = "rc_unique")]
@@ -432,7 +429,7 @@ impl<T: Clone> Rc<T> {
     #[inline]
     #[unstable(feature = "rc_unique")]
     pub fn make_unique(&mut self) -> &mut T {
-        if !is_unique(self) {
+        if !Rc::is_unique(self) {
             *self = Rc::new((**self).clone())
         }
         // This unsafety is ok because we're guaranteed that the pointer

src/libcollections/bit.rs

@@ -86,6 +86,7 @@ use core::cmp::Ordering;
 use core::cmp;
 use core::fmt;
 use core::hash;
+#[allow(deprecated)]
 use core::iter::RandomAccessIterator;
 use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
 use core::iter::{self, FromIterator};
@@ -1188,6 +1189,7 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
 impl<'a> ExactSizeIterator for Iter<'a> {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow(deprecated)]
 impl<'a> RandomAccessIterator for Iter<'a> {
     #[inline]
     fn indexable(&self) -> usize {

src/libcollections/btree/map.rs

@@ -685,10 +685,7 @@ mod stack {
         /// tied to the original tree.
         pub fn into_top(mut self) -> &'a mut V {
             unsafe {
-                mem::copy_mut_lifetime(
-                    self.map,
-                    self.top.from_raw_mut().val_mut()
-                )
+                &mut *(self.top.from_raw_mut().val_mut() as *mut V)
             }
         }
     }

src/libcollections/lib.rs

@@ -34,7 +34,6 @@
 #![feature(box_patterns)]
 #![feature(box_raw)]
 #![feature(box_syntax)]
-#![feature(copy_lifetime)]
 #![feature(core)]
 #![feature(core_intrinsics)]
 #![feature(core_prelude)]
@@ -56,7 +55,7 @@
 #![feature(staged_api)]
 #![feature(step_by)]
 #![feature(str_char)]
-#![feature(str_internals)]
+#![feature(str_match_indices)]
 #![feature(unboxed_closures)]
 #![feature(unicode)]
 #![feature(unique)]

src/libcollections/slice.rs

@@ -151,6 +151,7 @@ mod hack {
         }
     }
 
+    #[allow(deprecated)]
     pub fn permutations<T>(s: &[T]) -> Permutations<T> where T: Clone {
         Permutations{
             swaps: ElementSwaps::new(s.len()),
@@ -871,6 +872,7 @@ impl<T> [T] {
     /// assert_eq!(Some(vec![1, 3, 2]), perms.next());
     /// assert_eq!(Some(vec![3, 1, 2]), perms.next());
     /// ```
+    #[allow(deprecated)]
     #[unstable(feature = "permutations")]
     #[deprecated(since = "1.2.0", reason = "not clear this should be in the stdlib")]
     #[inline]
@@ -896,6 +898,7 @@ impl<T> [T] {
     /// let b: &mut [_] = &mut [1, 0, 2];
     /// assert!(v == b);
     /// ```
+    #[allow(deprecated)]
     #[unstable(feature = "permutations",
                reason = "uncertain if this merits inclusion in std")]
     #[deprecated(since = "1.2.0", reason = "not clear this should be in the stdlib")]
@@ -920,6 +923,7 @@ impl<T> [T] {
     /// let b: &mut [_] = &mut [0, 1, 2];
     /// assert!(v == b);
     /// ```
+    #[allow(deprecated)]
     #[unstable(feature = "permutations",
                reason = "uncertain if this merits inclusion in std")]
     #[deprecated(since = "1.2.0", reason = "not clear this should be in the stdlib")]
@@ -1067,6 +1071,7 @@ impl<T: Clone, V: Borrow<[T]>> SliceConcatExt<T> for [V] {
 ///
 /// The last generated swap is always (0, 1), and it returns the
 /// sequence to its initial order.
+#[allow(deprecated)]
 #[unstable(feature = "permutations")]
 #[derive(Clone)]
 #[deprecated(since = "1.2.0", reason = "not clear this should be in the stdlib")]
@@ -1078,6 +1083,7 @@ pub struct ElementSwaps {
     swaps_made : usize,
 }
 
+#[allow(deprecated)]
 impl ElementSwaps {
     /// Creates an `ElementSwaps` iterator for a sequence of `length` elements.
     #[unstable(feature = "permutations")]
@@ -1137,6 +1143,7 @@ struct SizeDirection {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow(deprecated)]
 impl Iterator for ElementSwaps {
     type Item = (usize, usize);
 
@@ -1205,12 +1212,14 @@ impl Iterator for ElementSwaps {
 /// Generates even and odd permutations alternately.
 #[unstable(feature = "permutations")]
 #[deprecated(since = "1.2.0", reason = "not clear this should be in the stdlib")]
+#[allow(deprecated)]
 pub struct Permutations<T> {
     swaps: ElementSwaps,
     v: Vec<T>,
 }
 
 #[unstable(feature = "permutations", reason = "trait is unstable")]
+#[allow(deprecated)]
 impl<T: Clone> Iterator for Permutations<T> {
     type Item = Vec<T>;
 

src/libcollections/str.rs

@@ -1520,7 +1520,6 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(str_matches)]
     /// let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
     /// assert_eq!(v, ["abc", "abc", "abc"]);
     ///
@@ -1552,7 +1551,6 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(str_matches)]
     /// let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
     /// assert_eq!(v, ["abc", "abc", "abc"]);
     ///
@@ -1593,7 +1591,7 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(str_matches)]
+    /// # #![feature(str_match_indices)]
     /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect();
     /// assert_eq!(v, [(0, 3), (6, 9), (12, 15)]);
     ///
@@ -1637,7 +1635,7 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(str_matches)]
+    /// # #![feature(str_match_indices)]
     /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
     /// assert_eq!(v, [(12, 15), (6, 9), (0, 3)]);
     ///

src/libcollections/vec.rs

@@ -1709,12 +1709,14 @@ impl<'a, T> FromIterator<T> for Cow<'a, [T]> where T: Clone {
     }
 }
 
+#[allow(deprecated)]
 impl<'a, T: 'a> IntoCow<'a, [T]> for Vec<T> where T: Clone {
     fn into_cow(self) -> Cow<'a, [T]> {
         Cow::Owned(self)
     }
 }
 
+#[allow(deprecated)]
 impl<'a, T> IntoCow<'a, [T]> for &'a [T] where T: Clone {
     fn into_cow(self) -> Cow<'a, [T]> {
         Cow::Borrowed(self)

src/libcollections/vec_deque.rs

@@ -1530,6 +1530,7 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
 impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow(deprecated)]
 impl<'a, T> RandomAccessIterator for Iter<'a, T> {
     #[inline]
     fn indexable(&self) -> usize {