add char fast path

Author: LaihoE

library/alloc/src/str.rs

@@ -11,7 +11,7 @@ use core::borrow::{Borrow, BorrowMut};
 use core::iter::FusedIterator;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::str::pattern;
-use core::str::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher};
+use core::str::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher, Utf8Pattern};
 #[stable(feature = "encode_utf16", since = "1.8.0")]
 pub use core::str::EncodeUtf16;
 #[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
@@ -268,35 +268,17 @@ impl str {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn replace<P: Pattern>(&self, from: P, to: &str) -> String {
-        let mut capacity = 0;
-
-        #[inline]
-        fn get_minimum_result_capacity(input_len: usize, from_len: usize, to_len: usize) -> usize {
-            // check if output is going to be at least as long as input.
-            if from_len <= to_len {
-                return input_len;
+        // Fast path for ASCII to ASCII case.
+        if let Some(from_byte) = match from.as_utf8_pattern() {
+            Some(Utf8Pattern::Slice([from_byte])) => Some(*from_byte),
+            Some(Utf8Pattern::Char(c)) => c.as_ascii().map(|ascii_char| ascii_char.to_u8()),
+            _ => None,
+        } {
+            if let [to_byte] = to.as_bytes() {
+                return unsafe { replace_ascii(self.as_bytes(), from_byte, *to_byte) };
             }
-            // lower bound where we have the maximum number of matches:
-            // max_n_matches = len(input) / len(from)
-            // capacity = max_n_matches * to_utf8_len
-            let max_n_matches = input_len.checked_div(from_len).unwrap_or(0);
-            return max_n_matches * to_len;
         }
-
-        // Path for patterns that can be represented as utf8 bytes (str, char etc.).
-        if let Some(from_as_utf8) = from.as_utf8_bytes() {
-            let from_utf8_len = from_as_utf8.len();
-            let to_utf8_len = to.as_bytes().len();
-            // Fast path for ascii
-            if from_utf8_len == 1 && to_utf8_len == 1 {
-                return unsafe {
-                    replace_ascii(&self.as_bytes(), from_as_utf8[0], to.as_bytes()[0])
-                };
-            }
-            capacity = get_minimum_result_capacity(self.bytes().len(), from_utf8_len, to_utf8_len);
-        }
-
-        let mut result = String::with_capacity(capacity);
+        let mut result = String::new();
         let mut last_end = 0;
         for (start, part) in self.match_indices(from) {
             result.push_str(unsafe { self.get_unchecked(last_end..start) });
@@ -692,6 +674,8 @@ fn convert_while_ascii(b: &[u8], convert: fn(&u8) -> u8) -> Vec<u8> {
 #[inline]
 #[cfg(not(test))]
 #[cfg(not(no_global_oom_handling))]
+/// Faster implementation of string replacement for ASCII to ASCII cases.
+/// Should produce fast vectorized code.
 unsafe fn replace_ascii(utf8_bytes: &[u8], from: u8, to: u8) -> String {
     let result: Vec<u8> = utf8_bytes.iter().map(|b| if *b == from { to } else { *b }).collect();
     // SAFETY: We replaced ascii with ascii on valid utf8 strings.

library/alloc/src/string.rs

@@ -53,7 +53,7 @@ use core::ops::AddAssign;
 #[cfg(not(no_global_oom_handling))]
 use core::ops::Bound::{Excluded, Included, Unbounded};
 use core::ops::{self, Range, RangeBounds};
-use core::str::pattern::Pattern;
+use core::str::pattern::{Pattern, Utf8Pattern};
 use core::{fmt, hash, ptr, slice};
 
 #[cfg(not(no_global_oom_handling))]
@@ -2321,8 +2321,8 @@ impl<'b> Pattern for &'b String {
     }
 
     #[inline]
-    fn as_utf8_bytes(&self) -> Option<&[u8]> {
-        Some(self.as_bytes())
+    fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>> {
+        Some(Utf8Pattern::Slice(self.as_bytes()))
     }
 }
 

library/core/src/str/pattern.rs

@@ -162,7 +162,17 @@ pub trait Pattern: Sized {
     }
 
     /// Returns the pattern as utf-8 bytes if possible.
-    fn as_utf8_bytes(&self) -> Option<&[u8]>;
+    fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>>;
+}
+/// Result of calling [`Pattern::as_utf8_pattern()`].
+/// Can be used for inspecting the contents of a [`Pattern`] in cases
+/// where the underlying representation can be represented as UTF-8.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum Utf8Pattern<'a> {
+    /// Type returned by String and str types.
+    Slice(&'a [u8]),
+    /// Type returned by char types.
+    Char(char),
 }
 
 // Searcher
@@ -604,8 +614,8 @@ impl Pattern for char {
     }
 
     #[inline]
-    fn as_utf8_bytes(&self) -> Option<&[u8]> {
-        None
+    fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>> {
+        Some(Utf8Pattern::Char(*self))
     }
 }
 
@@ -667,7 +677,7 @@ impl<C: MultiCharEq> Pattern for MultiCharEqPattern<C> {
     }
 
     #[inline]
-    fn as_utf8_bytes(&self) -> Option<&[u8]> {
+    fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>> {
         None
     }
 }
@@ -762,7 +772,7 @@ macro_rules! pattern_methods {
         }
 
         #[inline]
-        fn as_utf8_bytes(&self) -> Option<&[u8]> {
+        fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>> {
             None
         }
     };
@@ -1042,8 +1052,8 @@ impl<'b> Pattern for &'b str {
     }
 
     #[inline]
-    fn as_utf8_bytes(&self) -> Option<&[u8]> {
-        Some(self.as_bytes())
+    fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>> {
+        Some(Utf8Pattern::Slice(self.as_bytes()))
     }
 }