Fix build and test failure

Author: kennytm

src/liballoc/str.rs

@@ -29,14 +29,13 @@
 #![allow(unused_imports)]
 
 use core::fmt;
-use core::str as core_str;
 use core::needle::{ext, Needle, Searcher, Consumer};
 use core::mem;
 use core::ptr;
 use core::iter::FusedIterator;
 use core::unicode::conversions;
 
-use crate::borrow::ToOwned;
+use crate::borrow::{Borrow, ToOwned};
 use crate::boxed::Box;
 use crate::slice::{SliceConcatExt, SliceIndex};
 use crate::string::String;

src/liballoc/tests/lib.rs

@@ -4,8 +4,6 @@
 #![feature(exact_size_is_empty)]
 #![feature(repeat_generic_slice)]
 #![feature(needle)]
-#![feature(slice_sort_by_cached_key)]
-#![feature(str_escape)]
 #![feature(try_reserve)]
 #![feature(unboxed_closures)]
 #![feature(vecdeque_rotate)]

src/liballoc/tests/slice.rs

@@ -1674,24 +1674,20 @@ fn test_match_indices_nan_haystack() {
 #[test]
 fn test_match_indices_nan_needle() {
     let haystack = &[1.0, 2.0, NAN, 1.0, 2.0, NAN, 1.0, NAN, NAN, NAN, 2.0, 1.0, 2.0][..];
-    let needle = &[1.0, 2.0][..];
+    let needle = &[2.0, NAN][..];
 
     assert_eq!(haystack.match_indices(needle).collect::<Vec<_>>(), vec![
-        (0, needle),
-        (3, needle),
-        (11, needle),
     ]);
 }
 
 #[test]
 fn test_match_indices_negative_zero() {
-    let haystack = &[1.0, 2.0, NAN, 1.0, 2.0, NAN, 1.0, NAN, NAN, NAN, 2.0, 1.0, 2.0][..];
-    let needle = &[1.0, 2.0][..];
+    let haystack = &[-0.0, 0.0, 0.0, -0.0, 0.0][..];
+    let needle = &[0.0, -0.0][..];
 
     assert_eq!(haystack.match_indices(needle).collect::<Vec<_>>(), vec![
         (0, needle),
-        (3, needle),
-        (11, needle),
+        (2, needle),
     ]);
 }
 

src/liballoc/tests/str.rs

@@ -1724,7 +1724,8 @@ fn test_mut_str() {
         assert_eq!(res, vec!["a", "b", "c", "d", "e"]);
     }
     {
-        let res: Vec<(Range<usize>, &mut str)> = s.match_ranges_mut(|c: char| c.is_ascii_digit()).collect();
+        let res: Vec<(Range<usize>, &mut str)> =
+            s.match_ranges_mut(|c: char| c.is_ascii_digit()).collect();
         let res = res.into_iter().map(|(r, ss)| (r, &*ss)).collect::<Vec<_>>();
         assert_eq!(res, vec![
             (1..2, "1"),
@@ -1734,7 +1735,8 @@ fn test_mut_str() {
         ]);
     }
     {
-        let res: Vec<(Range<usize>, &mut str)> = s.rmatch_ranges_mut(|c: char| c.is_ascii_digit()).collect();
+        let res: Vec<(Range<usize>, &mut str)> =
+            s.rmatch_ranges_mut(|c: char| c.is_ascii_digit()).collect();
         let res = res.into_iter().map(|(r, ss)| (r, &*ss)).collect::<Vec<_>>();
         assert_eq!(res, vec![
             (7..8, "4"),

src/liballoc/vec.rs

@@ -65,16 +65,12 @@ use core::marker::PhantomData;
 use core::mem;
 use core::ops::{self, Index, IndexMut, RangeBounds};
 use core::ops::Bound::{Excluded, Included, Unbounded};
-use core::ops::{Index, IndexMut, RangeBounds};
-use core::ops;
-use core::ptr;
-use core::ptr::NonNull;
-use core::slice;
+use core::ptr::{self, NonNull};
+use core::slice::{self, SliceIndex};
 use core::needle::Needle;
 
+use crate::borrow::{ToOwned, Cow};
 use crate::collections::CollectionAllocErr;
-use crate::borrow::ToOwned;
-use crate::borrow::Cow;
 use crate::boxed::Box;
 use crate::raw_vec::RawVec;
 

src/libcore/needle/haystack.rs

@@ -5,8 +5,8 @@ use ops::{Deref, Range};
 ///
 /// Every [`Haystack`] type can be borrowed as references to `Hay` types. This
 /// allows multiple similar types to share the same implementation (e.g. the
-/// haystacks `&[T]`, `&mut [T]` and `Vec<T>` all have the same corresponding
-/// hay type `[T]`).
+/// haystacks `&[T]` and `&mut [T]` both have the same corresponding hay type
+/// `[T]`).
 ///
 /// In the other words, a `Haystack` is a generalized reference to `Hay`.
 /// `Hay`s are typically implemented on unsized slice types like `str` and `[T]`.
@@ -91,7 +91,8 @@ pub unsafe trait Hay {
     /// # Examples
     ///
     /// ```rust
-    /// use pattern_3::Hay;
+    /// #![feature(needle)]
+    /// use std::needle::Hay;
     ///
     /// let sample = "A→😀";
     /// unsafe {
@@ -115,7 +116,8 @@ pub unsafe trait Hay {
     /// # Examples
     ///
     /// ```rust
-    /// use pattern_3::Hay;
+    /// #![feature(needle)]
+    /// use std::needle::Hay;
     ///
     /// let sample = "A→😀";
     /// unsafe {
@@ -210,8 +212,8 @@ pub unsafe trait Haystack: Deref + Sized where Self::Target: Hay {
     /// (original.start + parent.start)..(original.start + parent.end)
     /// ```
     ///
-    /// If this haystack is a [`SharedHaystack`], this method would never be
-    /// called.
+    /// If this haystack is a [`SharedHaystack`], this method should never be
+    /// called, and calling it would cause an unreachable panic.
     ///
     /// # Safety
     ///
@@ -240,9 +242,13 @@ pub unsafe trait Haystack: Deref + Sized where Self::Target: Hay {
     /// #![feature(needle)]
     /// use std::needle::Haystack;
     ///
-    /// let hay = b"This is a sample haystack";
-    /// let this = hay[2..23][3..19].to_vec();
-    /// assert_eq!(&*this, &hay[this.restore_range(2..23, 3..19)]);
+    /// let mut hay = *b"This is a sample haystack";
+    /// let restored = {
+    ///     let this = &mut hay[2..23][3..19];
+    ///     assert_eq!(b"is a sample hays", this);
+    ///     this.restore_range(2..23, 3..19)
+    /// };
+    /// assert_eq!(b"is a sample hays", &hay[restored]);
     /// ```
     fn restore_range(
         &self,
@@ -412,7 +418,7 @@ where H::Target: Hay // FIXME: RFC 2089 or 2289
 /// let subspan = unsafe { span.slice_unchecked(4..8) };
 ///
 /// // obtains the substring.
-/// let substring = subspan.into();
+/// let substring: &str = subspan.into();
 /// assert_eq!(substring, "o世");
 /// ```
 ///
@@ -716,5 +722,3 @@ unsafe impl<'h, T: 'h> Haystack for &'h mut [T] {
         (subrange.start + range.start)..(subrange.end + range.start)
     }
 }
-
-

src/libcore/needle/needle.rs

@@ -215,7 +215,7 @@ pub unsafe trait Consumer<A: Hay + ?Sized> {
     ///
     /// ```rust
     /// #![feature(needle)]
-    /// use std::needle::{Consumer, Needle, Span};
+    /// use std::needle::{Consumer, Needle};
     ///
     /// let mut consumer = Needle::<&str>::into_consumer('x');
     /// assert_eq!(consumer.trim_start("xxxyy"), 3);
@@ -331,7 +331,7 @@ pub unsafe trait ReverseConsumer<A: Hay + ?Sized>: Consumer<A> {
     ///
     /// ```
     /// #![feature(needle)]
-    /// use std:needle::{ReverseConsumer, Needle, Span};
+    /// use std::needle::{ReverseConsumer, Needle, Span};
     ///
     /// let mut consumer = Needle::<&str>::into_consumer(|c: char| c.is_ascii());
     /// let span = Span::from("Hi😋!!");
@@ -364,7 +364,7 @@ pub unsafe trait ReverseConsumer<A: Hay + ?Sized>: Consumer<A> {
     ///
     /// ```rust
     /// #![feature(needle)]
-    /// use std::needle::{ReverseConsumer, Needle, Span};
+    /// use std::needle::{ReverseConsumer, Needle};
     ///
     /// let mut consumer = Needle::<&str>::into_consumer('x');
     /// assert_eq!(consumer.trim_end("yyxxx"), 2);

src/libcore/slice/mod.rs

@@ -34,7 +34,6 @@ use result::Result::{Ok, Err};
 use ptr;
 use mem;
 use marker::{Copy, Send, Sync, Sized, self};
-use iter_private::TrustedRandomAccess;
 use needle::{ext, Needle, Searcher, ReverseSearcher, Consumer, ReverseConsumer,DoubleEndedConsumer};
 
 #[unstable(feature = "slice_internals", issue = "0",
@@ -46,11 +45,8 @@ mod rotate;
 mod sort;
 
 /// Needle implementations for slices
-#[unstable(
-    feature = "slice_internals",
-    issue = "0",
-    reason = "exposed from core to be reused in std",
-)]
+#[unstable(feature = "slice_internals", issue = "0",
+           reason = "exposed from core to be reused in std")]
 #[doc(hidden)]
 pub mod needles;
 
@@ -1018,7 +1014,7 @@ impl<T> [T] {
     ///
     /// ```
     /// let slice = [10, 40, 33, 20];
-    /// let mut iter = slice.split(|num| num % 3 == 0);
+    /// let mut iter = slice.split(|num: &i32| num % 3 == 0);
     ///
     /// assert_eq!(iter.next().unwrap(), &[10, 40]);
     /// assert_eq!(iter.next().unwrap(), &[20]);
@@ -1032,7 +1028,7 @@ impl<T> [T] {
     ///
     /// ```
     /// let slice = [10, 40, 33];
-    /// let mut iter = slice.split(|num| num % 3 == 0);
+    /// let mut iter = slice.split(|num: &i32| num % 3 == 0);
     ///
     /// assert_eq!(iter.next().unwrap(), &[10, 40]);
     /// assert_eq!(iter.next().unwrap(), &[]);
@@ -1044,7 +1040,7 @@ impl<T> [T] {
     ///
     /// ```
     /// let slice = [10, 6, 33, 20];
-    /// let mut iter = slice.split(|num| num % 3 == 0);
+    /// let mut iter = slice.split(|num: &i32| num % 3 == 0);
     ///
     /// assert_eq!(iter.next().unwrap(), &[10]);
     /// assert_eq!(iter.next().unwrap(), &[]);
@@ -1070,7 +1066,7 @@ impl<T> [T] {
     /// ```
     /// let mut v = [10, 40, 30, 20, 60, 50];
     ///
-    /// for group in v.split_mut(|num| *num % 3 == 0) {
+    /// for group in v.split_mut(|num: &i32| *num % 3 == 0) {
     ///     group[0] = 1;
     /// }
     /// assert_eq!(v, [1, 40, 30, 1, 60, 1]);
@@ -1094,7 +1090,7 @@ impl<T> [T] {
     ///
     /// ```
     /// let slice = [11, 22, 33, 0, 44, 55];
-    /// let mut iter = slice.rsplit(|num| *num == 0);
+    /// let mut iter = slice.rsplit(|num: &i32| *num == 0);
     ///
     /// assert_eq!(iter.next().unwrap(), &[44, 55]);
     /// assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
@@ -1106,7 +1102,7 @@ impl<T> [T] {
     ///
     /// ```
     /// let v = &[0, 1, 1, 2, 3, 5, 8];
-    /// let mut it = v.rsplit(|n| *n % 2 == 0);
+    /// let mut it = v.rsplit(|n: &i32| *n % 2 == 0);
     /// assert_eq!(it.next().unwrap(), &[]);
     /// assert_eq!(it.next().unwrap(), &[3, 5]);
     /// assert_eq!(it.next().unwrap(), &[1, 1]);
@@ -1134,7 +1130,7 @@ impl<T> [T] {
     /// let mut v = [100, 400, 300, 200, 600, 500];
     ///
     /// let mut count = 0;
-    /// for group in v.rsplit_mut(|num| *num % 3 == 0) {
+    /// for group in v.rsplit_mut(|num: &i32| *num % 3 == 0) {
     ///     count += 1;
     ///     group[0] = count;
     /// }
@@ -1167,7 +1163,7 @@ impl<T> [T] {
     /// ```
     /// let v = [10, 40, 30, 20, 60, 50];
     ///
-    /// for group in v.splitn(2, |num| *num % 3 == 0) {
+    /// for group in v.splitn(2, |num: &i32| *num % 3 == 0) {
     ///     println!("{:?}", group);
     /// }
     /// ```
@@ -1194,7 +1190,7 @@ impl<T> [T] {
     /// ```
     /// let mut v = [10, 40, 30, 20, 60, 50];
     ///
-    /// for group in v.splitn_mut(2, |num| *num % 3 == 0) {
+    /// for group in v.splitn_mut(2, |num: &i32| *num % 3 == 0) {
     ///     group[0] = 1;
     /// }
     /// assert_eq!(v, [1, 40, 30, 1, 60, 50]);
@@ -1226,7 +1222,7 @@ impl<T> [T] {
     /// ```
     /// let v = [10, 40, 30, 20, 60, 50];
     ///
-    /// for group in v.rsplitn(2, |num| *num % 3 == 0) {
+    /// for group in v.rsplitn(2, |num: &i32| *num % 3 == 0) {
     ///     println!("{:?}", group);
     /// }
     /// ```
@@ -1254,7 +1250,7 @@ impl<T> [T] {
     /// ```
     /// let mut s = [10, 40, 30, 20, 60, 50];
     ///
-    /// for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
+    /// for group in s.rsplitn_mut(2, |num: &i32| *num % 3 == 0) {
     ///     group[0] = 1;
     /// }
     /// assert_eq!(s, [1, 40, 30, 20, 60, 1]);