Auto merge of #141808 - bend-n:faster_charsearcher_take2_with_memchr, r=<try>

faster charsearcher

attempt to do #141516 better
resolves #82471

r? `@workingjubilee`

Author: rust-bors[bot]

library/core/src/slice/memchr.rs

@@ -48,6 +48,7 @@ const fn memchr_naive(x: u8, text: &[u8]) -> Option<usize> {
 }
 
 #[rustc_allow_const_fn_unstable(const_eval_select)] // fallback impl has same behavior
+#[inline]
 const fn memchr_aligned(x: u8, text: &[u8]) -> Option<usize> {
     // The runtime version behaves the same as the compiletime version, it's
     // just more optimized.

library/core/src/str/iter.rs

@@ -656,7 +656,7 @@ impl<'a, P: Pattern> SplitInternal<'a, P> {
         None
     }
 
-    #[inline]
+    #[inline(always)]
     fn next(&mut self) -> Option<&'a str> {
         if self.finished {
             return None;

library/core/src/str/pattern.rs

@@ -429,8 +429,18 @@ unsafe impl<'a> Searcher<'a> for CharSearcher<'a> {
             SearchStep::Done
         }
     }
-    #[inline]
+    #[inline(always)]
     fn next_match(&mut self) -> Option<(usize, usize)> {
+        if self.utf8_size == 1 {
+            let find = |haystack: &[u8]| memchr::memchr(self.utf8_encoded[0], haystack);
+            return match find(self.haystack.as_bytes().get(self.finger..self.finger_back)?) {
+                Some(x) => {
+                    self.finger += x + 1;
+                    Some((self.finger - 1, self.finger))
+                }
+                None => None,
+            };
+        }
         loop {
             // get the haystack after the last character found
             let bytes = self.haystack.as_bytes().get(self.finger..self.finger_back)?;
@@ -498,6 +508,16 @@ unsafe impl<'a> ReverseSearcher<'a> for CharSearcher<'a> {
     }
     #[inline]
     fn next_match_back(&mut self) -> Option<(usize, usize)> {
+        if self.utf8_size == 1 {
+            let find = |haystack: &[u8]| memchr::memrchr(self.utf8_encoded[0], haystack);
+            return match find(self.haystack.as_bytes().get(self.finger..self.finger_back)?) {
+                Some(x) => {
+                    self.finger_back = self.finger + x;
+                    Some((self.finger_back, self.finger_back + 1))
+                }
+                None => None,
+            };
+        }
         let haystack = self.haystack.as_bytes();
         loop {
             // get the haystack up to but not including the last character searched