Honor ranges in the opaque path

Author: Lance Parker

stdlib/public/core/NormalizedCodeUnitIterator.swift

@@ -31,8 +31,8 @@ struct _NormalizedCodeUnitIterator: IteratorProtocol {
     source = _UnmanagedStringSource(unmanagedString, start: startIndex)
   }
 
-  init(_ guts: _StringGuts, startIndex: Int = 0) {
-    source = _StringGutsSource(guts, start: startIndex)
+  init(_ guts: _StringGuts, _ range: Range<Int>, startIndex: Int = 0) {
+    source = _StringGutsSource(guts, range, start: startIndex)
   }
 
   mutating func compare(with other: _NormalizedCodeUnitIterator) -> _Ordering {
@@ -137,21 +137,23 @@ struct _NormalizedCodeUnitIterator: IteratorProtocol {
 
   struct _StringGutsSource: _SegmentSource {
     var remaining: Int {
-      return guts.count - index
+      return range.count - index
     }
     var guts: _StringGuts
     var index: Int
+    var range: Range<Int>
 
-    init(_ guts: _StringGuts, start: Int = 0) {
+    init(_ guts: _StringGuts, _ range: Range<Int>, start: Int = 0) {
       self.guts = guts
-      index = start
+      self.range = range
+      index = range.lowerBound + start
     }
 
     mutating func tryFill(buffer: UnsafeMutableBufferPointer<UInt16>) -> Int? {
       var bufferIndex = 0
       let originalIndex = index
       repeat {
-        guard index < guts.count else {
+        guard index < range.count else {
           break
         }
 

stdlib/public/core/StringComparison.swift

@@ -209,11 +209,11 @@ extension _UnmanagedString where CodeUnit : FixedWidthInteger & UnsignedInteger
 }
 
 extension _UnmanagedOpaqueString {
-  internal func _findDiffIdx(_ other: _StringGuts
+  internal func _findDiffIdx(_ other: _StringGuts, _ otherRange: Range<Int>
   ) -> Int {
-    let count = Swift.min(self.count, other.count)
+    let count = Swift.min(self.count, otherRange.count)
     for idx in 0..<count {
-      guard self[idx] == other[idx] else {
+      guard self[idx] == other[idx + otherRange.lowerBound] else {
         return idx
       }
     }
@@ -552,13 +552,13 @@ extension _UnmanagedOpaqueString {
     let selfCount = selfRange.count
     let otherCount = otherRange.count
     let count = Swift.min(selfCount, otherCount)
-    let idx = self._findDiffIdx(other)
+    let idx = self[selfRange]._findDiffIdx(other, otherRange)
     if idx == count {
       return _lexicographicalCompare(selfCount, otherCount)
     }
 
     let selfCU = self[idx]
-    let otherCU = other[idx]
+    let otherCU = other[idx + otherRange.lowerBound]
 
     //
     // Fast path: if one is ASCII, we can often compare the code units directly.
@@ -587,7 +587,7 @@ extension _UnmanagedOpaqueString {
         }
 
         return self._compareOpaquePathological(
-          other, startingFrom: Swift.max(0, idx-1))
+          other, otherRange, startingFrom: Swift.max(0, idx-1))
       }
 
       if selfIsASCII && selfIsSingleSegmentScalar
@@ -600,19 +600,20 @@ extension _UnmanagedOpaqueString {
     }
 
     return self._compareOpaquePathological(
-      other, startingFrom: Swift.max(0, idx-1)
+      other, otherRange, startingFrom: Swift.max(0, idx-1)
     )
   }
 
   @inline(never)
   func _compareOpaquePathological(
-    _ other: _StringGuts, startingFrom: Int
+    _ other: _StringGuts, _ otherRange: Range<Int>,
+    startingFrom: Int
   ) -> _Ordering {
     // Compare by pulling in a segment at a time, normalizing then comparing
     // individual code units
     var selfIterator = _NormalizedCodeUnitIterator(self, startIndex: startingFrom)
     return selfIterator.compare(with:
-      _NormalizedCodeUnitIterator(other, startIndex: startingFrom)
+      _NormalizedCodeUnitIterator(other, otherRange, startIndex: startingFrom)
     )
   }
 }