Add a fast path for OsStr prefix functions with str patterns.

Author: jmillikin

library/core/src/str/pattern.rs

@@ -160,6 +160,12 @@ pub trait Pattern<'a>: Sized {
             None
         }
     }
+
+    /// Return the pattern as a fixed slice of UTF-8 bytes, if possible.
+    #[inline]
+    fn as_bytes(&self) -> Option<&[u8]> {
+        None
+    }
 }
 
 // Searcher
@@ -917,6 +923,11 @@ where
 /// Delegates to the `&str` impl.
 impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str {
     pattern_methods!(StrSearcher<'a, 'b>, |&s| s, |s| s);
+
+    #[inline]
+    fn as_bytes(&self) -> Option<&[u8]> {
+        (*self).as_bytes()
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -1001,6 +1012,11 @@ impl<'a, 'b> Pattern<'a> for &'b str {
             None
         }
     }
+
+    #[inline]
+    fn as_bytes(&self) -> Option<&[u8]> {
+        Some(str::as_bytes(self))
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////

library/std/src/sys/unix/os_str.rs

@@ -288,10 +288,18 @@ impl Slice {
 
     #[inline]
     pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pattern: P) -> bool {
+        if let Some(pattern_bytes) = pattern.as_bytes() {
+            return self.inner.starts_with(pattern_bytes);
+        }
         self.to_str_prefix().starts_with(pattern)
     }
 
     pub fn strip_prefix<'a, P: Pattern<'a>>(&'a self, prefix: P) -> Option<&'a Slice> {
+        if let Some(prefix_bytes) = prefix.as_bytes() {
+            let suffix = self.inner.strip_prefix(prefix_bytes)?;
+            return Some(Slice::from_u8_slice(suffix));
+        }
+
         let p = self.to_str_prefix();
         let prefix_len = match prefix.into_searcher(p).next() {
             SearchStep::Match(0, prefix_len) => prefix_len,

library/std/src/sys_common/wtf8.rs

@@ -801,10 +801,20 @@ impl Wtf8 {
 
     #[inline]
     pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pattern: P) -> bool {
+        if let Some(pattern_bytes) = pattern.as_bytes() {
+            return self.bytes.starts_with(pattern_bytes);
+        }
         self.to_str_prefix().starts_with(pattern)
     }
 
     pub fn strip_prefix<'a, P: Pattern<'a>>(&'a self, prefix: P) -> Option<&'a Wtf8> {
+        if let Some(prefix_bytes) = prefix.as_bytes() {
+            let suffix = self.bytes.strip_prefix(prefix_bytes)?;
+            // SAFETY: WTF-8 is a superset of UTF-8, so stripping off a UTF-8
+            // prefix will yield a suffix that is valid WTF-8.
+            return unsafe { Some(Wtf8::from_bytes_unchecked(suffix)) };
+        }
+
         let p = self.to_str_prefix();
         let prefix_len = match prefix.into_searcher(p).next() {
             SearchStep::Match(0, prefix_len) => prefix_len,