Implement the Needle API for OsStr.

Author: kennytm

src/libcore/slice/needles.rs

@@ -401,7 +401,7 @@ where
     }
 
     #[inline]
-    pub fn next(&mut self, hay: &[T], range: Range<usize>) -> Option<Range<usize>> {
+    pub(crate) fn next(&mut self, hay: &[T], range: Range<usize>) -> Option<Range<usize>> {
         if self.memory != usize::MAX {
             self.do_next::<ShortPeriod>(hay, range)
         } else {
@@ -469,7 +469,7 @@ where
     }
 
     #[inline]
-    pub fn next_back(&mut self, hay: &[T], range: Range<usize>) -> Option<Range<usize>> {
+    pub(crate) fn next_back(&mut self, hay: &[T], range: Range<usize>) -> Option<Range<usize>> {
         if self.memory != usize::MAX {
             self.do_next_back::<ShortPeriod>(hay, range)
         } else {

src/libstd/ffi/os_str.rs

@@ -5,10 +5,13 @@ use crate::cmp;
 use crate::hash::{Hash, Hasher};
 use crate::rc::Rc;
 use crate::sync::Arc;
+use crate::needle::{Hay, Haystack, Needle, Span, Searcher, ReverseSearcher, Consumer, ReverseConsumer};
 
-use crate::sys::os_str::{Buf, Slice};
+use crate::sys::os_str::{Buf, Slice, OsStrSearcher};
 use crate::sys_common::{AsInner, IntoInner, FromInner};
 
+use core::slice::needles::{TwoWaySearcher, SliceSearcher, NaiveSearcher};
+
 /// A type that can represent owned, mutable platform-native strings, but is
 /// cheaply inter-convertible with Rust strings.
 ///
@@ -1246,3 +1249,166 @@ mod tests {
         assert_eq!(OsString::from_wide(&[0xDF0D, 0xD83C]), &os_str[7..11]);
     }
 }
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl Hay for OsStr {
+    type Index = usize;
+
+    #[inline]
+    fn empty<'a>() -> &'a Self {
+        Self::new("")
+    }
+
+    #[inline]
+    fn start_index(&self) -> usize {
+        0
+    }
+
+    #[inline]
+    fn end_index(&self) -> usize {
+        self.len()
+    }
+
+    #[inline]
+    unsafe fn slice_unchecked(&self, range: ops::Range<usize>) -> &Self {
+        &self[range]
+    }
+
+    #[inline]
+    unsafe fn next_index(&self, index: usize) -> usize {
+        self.inner.next_index(index)
+    }
+
+    #[inline]
+    unsafe fn prev_index(&self, index: usize) -> usize {
+        self.inner.prev_index(index)
+    }
+}
+
+// use a macro here since the type of `hay.inner.inner` is platform dependent
+// and we don't want to expose that type.
+macro_rules! span_as_inner {
+    ($span:expr) => {{
+        let (hay, range) = $span.into_parts();
+        unsafe { Span::from_parts(&hay.inner.inner, range) }
+    }}
+}
+
+fn span_as_inner_bytes(span: Span<&OsStr>) -> Span<&[u8]> {
+    let (hay, range) = span.into_parts();
+    unsafe { Span::from_parts(hay.inner.as_bytes_for_searcher(), range) }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> Searcher<OsStr> for TwoWaySearcher<'p, u8> {
+    #[inline]
+    fn search(&mut self, span: Span<&OsStr>) -> Option<ops::Range<usize>> {
+        self.search(span_as_inner_bytes(span))
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> ReverseSearcher<OsStr> for TwoWaySearcher<'p, u8> {
+    #[inline]
+    fn rsearch(&mut self, span: Span<&OsStr>) -> Option<ops::Range<usize>> {
+        self.rsearch(span_as_inner_bytes(span))
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> Consumer<OsStr> for NaiveSearcher<'p, u8> {
+    #[inline]
+    fn consume(&mut self, span: Span<&OsStr>) -> Option<usize> {
+        self.consume(span_as_inner_bytes(span))
+    }
+
+    #[inline]
+    fn trim_start(&mut self, hay: &OsStr) -> usize {
+        self.trim_start(hay.inner.as_bytes_for_searcher())
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> ReverseConsumer<OsStr> for NaiveSearcher<'p, u8> {
+    #[inline]
+    fn rconsume(&mut self, span: Span<&OsStr>) -> Option<usize> {
+        self.rconsume(span_as_inner_bytes(span))
+    }
+
+    #[inline]
+    fn trim_end(&mut self, hay: &OsStr) -> usize {
+        self.trim_end(hay.inner.as_bytes_for_searcher())
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> Searcher<OsStr> for OsStrSearcher<SliceSearcher<'p, u8>> {
+    #[inline]
+    fn search(&mut self, span: Span<&OsStr>) -> Option<ops::Range<usize>> {
+        self.search(span_as_inner!(span))
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> ReverseSearcher<OsStr> for OsStrSearcher<SliceSearcher<'p, u8>> {
+    #[inline]
+    fn rsearch(&mut self, span: Span<&OsStr>) -> Option<ops::Range<usize>> {
+        self.rsearch(span_as_inner!(span))
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> Consumer<OsStr> for OsStrSearcher<NaiveSearcher<'p, u8>> {
+    #[inline]
+    fn consume(&mut self, span: Span<&OsStr>) -> Option<usize> {
+        self.consume(span_as_inner!(span))
+    }
+
+    #[inline]
+    fn trim_start(&mut self, hay: &OsStr) -> usize {
+        self.trim_start(&hay.inner.inner)
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> ReverseConsumer<OsStr> for OsStrSearcher<NaiveSearcher<'p, u8>> {
+    #[inline]
+    fn rconsume(&mut self, span: Span<&OsStr>) -> Option<usize> {
+        self.rconsume(span_as_inner!(span))
+    }
+
+    #[inline]
+    fn trim_end(&mut self, hay: &OsStr) -> usize {
+        self.trim_end(&hay.inner.inner)
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+impl<'p, H: Haystack<Target = OsStr>> Needle<H> for &'p OsStr {
+    type Searcher = OsStrSearcher<SliceSearcher<'p, u8>>;
+    type Consumer = OsStrSearcher<NaiveSearcher<'p, u8>>;
+
+    fn into_searcher(self) -> Self::Searcher {
+        self.inner.into_searcher()
+    }
+
+    fn into_consumer(self) -> Self::Consumer {
+        self.inner.into_consumer()
+    }
+}
+
+// FIXME cannot impl `Needle<(_: Haystack<Target = OsStr>)>` due to RFC 1672 being postponed.
+// (need to wait for chalk)
+#[unstable(feature = "needle", issue = "56345")]
+impl<'h, 'p> Needle<&'h OsStr> for &'p str {
+    type Searcher = SliceSearcher<'p, u8>;
+    type Consumer = NaiveSearcher<'p, u8>;
+
+    fn into_searcher(self) -> Self::Searcher {
+        SliceSearcher::new(self.as_bytes())
+    }
+
+    fn into_consumer(self) -> Self::Consumer {
+        NaiveSearcher::new(self.as_bytes())
+    }
+}

src/libstd/sys/windows/os_str.rs

@@ -3,12 +3,14 @@
 
 use crate::borrow::Cow;
 use crate::fmt;
-use crate::sys_common::wtf8::{Wtf8, Wtf8Buf};
+use crate::sys_common::wtf8::{self, Wtf8, Wtf8Buf};
 use crate::mem;
 use crate::rc::Rc;
 use crate::sync::Arc;
 use crate::ops::{Index, Range, RangeFrom, RangeTo};
 use crate::sys_common::{AsInner, IntoInner, FromInner};
+use core::slice::needles::{SliceSearcher, NaiveSearcher};
+use crate::needle::Hay;
 
 #[derive(Clone, Hash)]
 pub struct Buf {
@@ -195,4 +197,26 @@ impl Slice {
         let rc = self.inner.into_rc();
         unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Slice) }
     }
+
+    pub unsafe fn next_index(&self, index: usize) -> usize {
+        self.inner.next_index(index)
+    }
+
+    pub unsafe fn prev_index(&self, index: usize) -> usize {
+        self.inner.prev_index(index)
+    }
+
+    pub fn into_searcher(&self) -> OsStrSearcher<SliceSearcher<'_, u8>> {
+        wtf8::new_wtf8_searcher(&self.inner)
+    }
+
+    pub fn into_consumer(&self) -> OsStrSearcher<NaiveSearcher<'_, u8>> {
+        wtf8::new_wtf8_consumer(&self.inner)
+    }
+
+    pub fn as_bytes_for_searcher(&self) -> &[u8] {
+        self.inner.as_inner()
+    }
 }
+
+pub use sys_common::wtf8::Wtf8Searcher as OsStrSearcher;

src/libstd/sys_common/os_str_bytes.rs

@@ -12,6 +12,8 @@ use crate::sync::Arc;
 use crate::sys_common::{FromInner, IntoInner, AsInner};
 use crate::sys_common::bytestring::debug_fmt_bytestring;
 use core::str::lossy::Utf8Lossy;
+use core::slice::needles::{SliceSearcher, NaiveSearcher};
+use needle::{Hay, Span, Searcher, ReverseSearcher, Consumer, ReverseConsumer};
 
 #[derive(Clone, Hash)]
 pub(crate) struct Buf {
@@ -203,6 +205,71 @@ impl Slice {
         let rc: Rc<[u8]> = Rc::from(&self.inner);
         unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Slice) }
     }
+
+    pub unsafe fn next_index(&self, index: usize) -> usize {
+        self.inner.next_index(index)
+    }
+
+    pub unsafe fn prev_index(&self, index: usize) -> usize {
+        self.inner.prev_index(index)
+    }
+
+    pub fn into_searcher(&self) -> OsStrSearcher<SliceSearcher<'_, u8>> {
+        OsStrSearcher(SliceSearcher::new(&self.inner))
+    }
+
+    pub fn into_consumer(&self) -> OsStrSearcher<NaiveSearcher<'_, u8>> {
+        OsStrSearcher(NaiveSearcher::new(&self.inner))
+    }
+
+    pub fn as_bytes_for_searcher(&self) -> &[u8] {
+        &self.inner
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+pub struct OsStrSearcher<S>(S);
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> Searcher<[u8]> for OsStrSearcher<SliceSearcher<'p, u8>> {
+    #[inline]
+    fn search(&mut self, span: Span<&[u8]>) -> Option<Range<usize>> {
+        self.0.search(span)
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> Consumer<[u8]> for OsStrSearcher<NaiveSearcher<'p, u8>> {
+    #[inline]
+    fn consume(&mut self, span: Span<&[u8]>) -> Option<usize> {
+        self.0.consume(span)
+    }
+
+    #[inline]
+    fn trim_start(&mut self, hay: &[u8]) -> usize {
+        self.0.trim_start(hay)
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> ReverseSearcher<[u8]> for OsStrSearcher<SliceSearcher<'p, u8>> {
+    #[inline]
+    fn rsearch(&mut self, span: Span<&[u8]>) -> Option<Range<usize>> {
+        self.0.rsearch(span)
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+unsafe impl<'p> ReverseConsumer<[u8]> for OsStrSearcher<NaiveSearcher<'p, u8>> {
+    #[inline]
+    fn rconsume(&mut self, span: Span<&[u8]>) -> Option<usize> {
+        self.0.rconsume(span)
+    }
+
+    #[inline]
+    fn trim_end(&mut self, hay: &[u8]) -> usize {
+        self.0.trim_end(hay)
+    }
 }
 
 /// Platform-specific extensions to [`OsString`].