Add a string-specific search algorithm

This adds a Boyer-Moore substring search algorithm, and updates the
`firstRange(of:)` and `ranges(of:)` methods to use that when both
pieces of the search are strings/substrings.

Still need to look at availability and switch the "replacing" methods
to use this new search algorithm.

Author: natecook1000

Sources/_StringProcessing/Algorithms/Algorithms/FirstRange.swift

@@ -21,21 +21,49 @@ extension Collection {
 }
 
 // MARK: Fixed pattern algorithms
+extension Substring {
+  @usableFromInline
+  func _firstRangeSubstring(
+    of other: Substring
+  ) -> Range<String.Index>? {
+    var searcher = SubstringSearcher(text: self, pattern: other)
+    return searcher.next()
+  }
+}
 
 extension Collection where Element: Equatable {
+  @usableFromInline
+  func _firstRangeGeneric<C: Collection>(
+    of other: C
+  ) -> Range<Index>? where C.Element == Element {
+    let searcher = ZSearcher<SubSequence>(pattern: Array(other), by: ==)
+    return searcher.search(self[...], in: startIndex..<endIndex)
+  }
+
   /// Finds and returns the range of the first occurrence of a given collection
   /// within this collection.
   ///
   /// - Parameter other: The collection to search for.
   /// - Returns: A range in the collection of the first occurrence of `sequence`.
   /// Returns nil if `sequence` is not found.
   @available(SwiftStdlib 5.7, *)
+  @inline(__always)
   public func firstRange<C: Collection>(
     of other: C
   ) -> Range<Index>? where C.Element == Element {
-    // TODO: Use a more efficient search algorithm
-    let searcher = ZSearcher<SubSequence>(pattern: Array(other), by: ==)
-    return searcher.search(self[...], in: startIndex..<endIndex)
+    switch (self, other) {
+    case (let str as String, let other as String):
+      return str[...]._firstRangeSubstring(of: other[...]) as! Range<Index>?
+    case (let str as Substring, let other as String):
+      return str._firstRangeSubstring(of: other[...]) as! Range<Index>?
+    case (let str as String, let other as Substring):
+      return str[...]._firstRangeSubstring(of: other) as! Range<Index>?
+    case (let str as Substring, let other as Substring):
+      return str._firstRangeSubstring(of: other) as! Range<Index>?
+      
+    default:
+      return _firstRangeGeneric(of: other)
+    }
   }
 }
 
@@ -47,11 +75,23 @@ extension BidirectionalCollection where Element: Comparable {
   /// - Returns: A range in the collection of the first occurrence of `sequence`.
   /// Returns `nil` if `sequence` is not found.
   @available(SwiftStdlib 5.7, *)
+  @inline(__always)
   public func firstRange<C: Collection>(
     of other: C
   ) -> Range<Index>? where C.Element == Element {
-    let searcher = ZSearcher<SubSequence>(pattern: Array(other), by: ==)
-    return searcher.search(self[...], in: startIndex..<endIndex)
+    switch (self, other) {
+    case (let str as String, let other as String):
+      return str[...]._firstRangeSubstring(of: other[...]) as! Range<Index>?
+    case (let str as Substring, let other as String):
+      return str._firstRangeSubstring(of: other[...]) as! Range<Index>?
+    case (let str as String, let other as Substring):
+      return str[...]._firstRangeSubstring(of: other) as! Range<Index>?
+    case (let str as Substring, let other as Substring):
+      return str._firstRangeSubstring(of: other) as! Range<Index>?
+      
+    default:
+      return _firstRangeGeneric(of: other)
+    }
   }
 }
 

Sources/_StringProcessing/Algorithms/Algorithms/Ranges.swift

@@ -135,6 +135,13 @@ extension Collection where Element: Equatable {
   ) -> RangesCollection<ZSearcher<Self>> where C.Element == Element {
     _ranges(of: ZSearcher(pattern: Array(other), by: ==))
   }
+  
+  @usableFromInline
+  func _rangesGeneric<C: Collection>(
+    of other: C
+  ) -> [Range<Index>] where C.Element == Element {
+    Array(_ranges(of: other))
+  }
 
   // FIXME: Return `some Collection<Range<Index>>` for SE-0346
   /// Finds and returns the ranges of the all occurrences of a given sequence
@@ -143,10 +150,23 @@ extension Collection where Element: Equatable {
   /// - Returns: A collection of ranges of all occurrences of `other`. Returns
   ///  an empty collection if `other` is not found.
   @available(SwiftStdlib 5.7, *)
+  @inline(__always)
   public func ranges<C: Collection>(
     of other: C
   ) -> [Range<Index>] where C.Element == Element {
-    Array(_ranges(of: other))
+    switch (self, other) {
+    case (let str as String, let other as String):
+      return Array(SubstringSearcher(text: str[...], pattern: other[...])) as! [Range<Index>]
+    case (let str as Substring, let other as String):
+      return Array(SubstringSearcher(text: str, pattern: other[...])) as! [Range<Index>]
+    case (let str as String, let other as Substring):
+      return Array(SubstringSearcher(text: str[...], pattern: other)) as! [Range<Index>]
+    case (let str as Substring, let other as Substring):
+      return Array(SubstringSearcher(text: str, pattern: other)) as! [Range<Index>]
+      
+    default:
+      return _rangesGeneric(of: other)
+    }
   }
 }
 

Sources/_StringProcessing/Algorithms/Algorithms/SubstringSearcher.swift

@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+/// An implementation of the Boyer-Moore algorithm, for string-specific
+/// searching.
+@usableFromInline
+struct SubstringSearcher: Sequence, IteratorProtocol {
+  @usableFromInline
+  let text: Substring
+  @usableFromInline
+  let pattern: Substring
+  @usableFromInline
+  let badCharacterOffsets: [Character: Int]
+  @usableFromInline
+  let patternCount: Int
+  @usableFromInline
+  var endOfSearch: String.Index?
+  
+  @usableFromInline
+  init(text: Substring, pattern: Substring) {
+    self.text = text
+    self.pattern = pattern
+    self.patternCount = pattern.count
+    self.endOfSearch = text.index(
+      text.startIndex, offsetBy: patternCount, limitedBy: text.endIndex)
+    self.badCharacterOffsets = Dictionary(
+      zip(pattern, 0...), uniquingKeysWith: { _, last in last })
+  }
+
+  @inlinable
+  mutating func next() -> Range<String.Index>? {
+    while let end = endOfSearch {
+      // Empty pattern matches at every position.
+      if patternCount == 0 {
+        endOfSearch = end == text.endIndex ? nil : text.index(after: end)
+        return end..<end
+      }
+      
+      var patternOffset = patternCount - 1
+      var patternCursor = pattern.index(before: pattern.endIndex)
+      var textCursor = text.index(before: end)
+      
+      // Search backwards from `end` to the start of the pattern
+      while patternCursor >= pattern.startIndex
+              && pattern[patternCursor] == text[textCursor]
+      {
+        patternOffset -= 1
+        
+        // Success!
+        if patternCursor == pattern.startIndex {
+          // Calculate the offset for the next search.
+          endOfSearch = text.index(end, offsetBy: patternCount, limitedBy: text.endIndex)
+          return textCursor..<end
+        }
+        
+        precondition(textCursor > text.startIndex)
+        text.formIndex(before: &textCursor)
+        pattern.formIndex(before: &patternCursor)
+      }
+      
+      // Match failed - calculate the end index of the next possible
+      // candidate, based on the `badCharacterOffsets` table and the
+      // current position in the pattern.
+      let shiftOffset = Swift.max(
+        1,
+        patternOffset - (badCharacterOffsets[text[textCursor]] ?? 0))
+      endOfSearch = text.index(
+        end, offsetBy: shiftOffset, limitedBy: text.endIndex)
+    }
+    return nil
+  }
+}
+