[stdlib] String: prefer passing ranges to start+end argument pairs

Author: lorentey

stdlib/public/core/StringGraphemeBreaking.swift

@@ -109,22 +109,25 @@ extension _StringGuts {
 
   internal func roundDownToNearestCharacter(
     _ i: String.Index,
-    from start: String.Index,
-    to end: String.Index
+    in bounds: Range<String.Index>
   ) -> String.Index {
-    _internalInvariant(start._isScalarAligned && end._isScalarAligned)
-    _internalInvariant(hasMatchingEncoding(start) && hasMatchingEncoding(end))
-    _internalInvariant(start <= end && end <= endIndex)
+    _internalInvariant(
+      bounds.lowerBound._isScalarAligned && bounds.upperBound._isScalarAligned)
+    _internalInvariant(
+      hasMatchingEncoding(bounds.lowerBound) && hasMatchingEncoding(bounds.upperBound))
+    _internalInvariant(bounds.upperBound <= endIndex)
 
     _internalInvariant(i._isScalarAligned)
     _internalInvariant(hasMatchingEncoding(i))
-    _internalInvariant(i >= start && i <= end)
+    _internalInvariant(i >= bounds.lowerBound && i <= bounds.upperBound)
 
     // We can only use the `_isCharacterAligned` bit if the start index is also
     // character-aligned.
-    if start._isCharacterAligned && i._isCharacterAligned { return i }
+    if bounds.lowerBound._isCharacterAligned && i._isCharacterAligned {
+      return i
+    }
 
-    if i == start || i == end { return i }
+    if i == bounds.lowerBound || i == bounds.upperBound { return i }
 
     let offset = i._encodedOffset
     let prior = offset - _opaqueCharacterStride(endingAt: offset)
@@ -136,7 +139,7 @@ extension _StringGuts {
       return i
     }
     var r = String.Index(encodedOffset: prior, characterStride: stride)
-    if start._isCharacterAligned {
+    if bounds.lowerBound._isCharacterAligned {
       r = r._characterAligned
     } else {
       r = r._scalarAligned

stdlib/public/core/StringGuts.swift

@@ -449,13 +449,13 @@ extension _StringGuts {
   @_alwaysEmitIntoClient
   internal func validateScalarIndex(
     _ i: String.Index,
-    from start: String.Index,
-    to end: String.Index
+    in bounds: Range<String.Index>
   ) -> String.Index {
-    _internalInvariant(start <= end && end <= endIndex)
+    _internalInvariant(bounds.upperBound <= endIndex)
 
     let i = ensureMatchingEncoding(i)
-    _precondition(i >= start && i < end, "Substring index is out of bounds")
+    _precondition(i >= bounds.lowerBound && i < bounds.upperBound,
+      "Substring index is out of bounds")
     return scalarAlign(i)
   }
 }
@@ -486,13 +486,13 @@ extension _StringGuts {
   /// - is aligned on a scalar boundary.
   internal func validateInclusiveScalarIndex(
     _ i: String.Index,
-    from start: String.Index,
-    to end: String.Index
+    in bounds: Range<String.Index>
   ) -> String.Index {
-    _internalInvariant(start <= end && end <= endIndex)
+    _internalInvariant(bounds.upperBound <= endIndex)
 
     let i = ensureMatchingEncoding(i)
-    _precondition(i >= start && i <= end, "Substring index is out of bounds")
+    _precondition(i >= bounds.lowerBound && i <= bounds.upperBound,
+      "Substring index is out of bounds")
     return scalarAlign(i)
   }
 }
@@ -517,18 +517,20 @@ extension _StringGuts {
   @_alwaysEmitIntoClient
   internal func validateSubscalarRange(
     _ range: Range<String.Index>,
-    from start: String.Index,
-    to end: String.Index
+    in bounds: Range<String.Index>
   ) -> Range<String.Index> {
-    _internalInvariant(start <= end && end <= endIndex)
+    _internalInvariant(bounds.upperBound <= endIndex)
 
     let upper = ensureMatchingEncoding(range.upperBound)
     let lower = ensureMatchingEncoding(range.lowerBound)
 
     // Note: if only `lower` was miscoded, then the range invariant `lower <=
     // upper` may no longer hold after the above conversions, so we need to
     // re-check it here.
-    _precondition(upper <= end && lower >= start && lower <= upper,
+    _precondition(
+      upper <= bounds.upperBound
+      && lower >= bounds.lowerBound
+      && lower <= upper,
       "Substring index range is out of bounds")
 
     return Range(_uncheckedBounds: (lower, upper))
@@ -578,18 +580,20 @@ extension _StringGuts {
   /// - are aligned on a scalar boundary.
   internal func validateScalarRange(
     _ range: Range<String.Index>,
-    from start: String.Index,
-    to end: String.Index
+    in bounds: Range<String.Index>
   ) -> Range<String.Index> {
-    _internalInvariant(start <= end && end <= endIndex)
+    _internalInvariant(bounds.upperBound <= endIndex)
 
     var upper = ensureMatchingEncoding(range.upperBound)
     var lower = ensureMatchingEncoding(range.lowerBound)
 
     // Note: if only `lower` was miscoded, then the range invariant `lower <=
     // upper` may no longer hold after the above conversions, so we need to
     // re-check it here.
-    _precondition(upper <= end && lower >= start && lower <= upper,
+    _precondition(
+      upper <= bounds.upperBound
+      && lower >= bounds.lowerBound
+      && lower <= upper,
       "Substring index range is out of bounds")
 
     upper = scalarAlign(upper)

stdlib/public/core/Substring.swift

@@ -145,6 +145,23 @@ extension Substring {
     return Range(_uncheckedBounds: (lower, upper))
   }
 
+  @inlinable @inline(__always)
+  internal var _bounds: Range<Index> {
+    Range(_uncheckedBounds: (startIndex, endIndex))
+  }
+}
+
+extension Substring {
+  internal var _startIsCharacterAligned: Bool {
+    startIndex._isCharacterAligned
+  }
+
+  internal var _endIsCharacterAligned: Bool {
+    endIndex._isCharacterAligned
+  }
+}
+
+extension Substring {
   #if !INTERNAL_CHECKS_ENABLED
   @inlinable @inline(__always) internal func _invariantCheck() {}
   #else
@@ -167,28 +184,28 @@ extension Substring {
 extension Substring {
   @inline(__always)
   internal func _validateScalarIndex(_ i: String.Index) -> String.Index {
-    _wholeGuts.validateScalarIndex(i, from: startIndex, to: endIndex)
+    _wholeGuts.validateScalarIndex(i, in: _bounds)
   }
 
   @inline(__always)
   internal func _validateInclusiveScalarIndex(
     _ i: String.Index
   ) -> String.Index {
-    _wholeGuts.validateInclusiveScalarIndex(i, from: startIndex, to: endIndex)
+    _wholeGuts.validateInclusiveScalarIndex(i, in: _bounds)
   }
 
   @inline(__always)
   internal func _validateScalarRange(
     _ range: Range<String.Index>
   ) -> Range<String.Index> {
-    _wholeGuts.validateScalarRange(range, from: startIndex, to: endIndex)
+    _wholeGuts.validateScalarRange(range, in: _bounds)
   }
 
   @inline(__always)
   internal func _roundDownToNearestCharacter(
     _ i: String.Index
   ) -> String.Index {
-    _wholeGuts.roundDownToNearestCharacter(i, from: startIndex, to: endIndex)
+    _wholeGuts.roundDownToNearestCharacter(i, in: _bounds)
   }
 
   /// Return true if and only if `i` is a valid index in this substring,
@@ -647,16 +664,6 @@ extension Substring: StringProtocol {
   }
 }
 
-extension Substring {
-  internal var _startIsCharacterAligned: Bool {
-    startIndex._isCharacterAligned
-  }
-
-  internal var _endIsCharacterAligned: Bool {
-    endIndex._isCharacterAligned
-  }
-}
-
 extension Substring {
   internal func _characterStride(startingAt i: Index) -> Int {
     _internalInvariant(i._isScalarAligned)
@@ -737,6 +744,11 @@ extension Substring {
 
     @_alwaysEmitIntoClient @inline(__always)
     internal var _base: String.UTF8View { _slice._base }
+
+    @_alwaysEmitIntoClient @inline(__always)
+    internal var _bounds: Range<Index> {
+      Range(_uncheckedBounds: (_slice._startIndex, _slice._endIndex))
+    }
   }
 }
 
@@ -833,7 +845,7 @@ extension Substring.UTF8View: BidirectionalCollection {
   @inlinable
   public subscript(r: Range<Index>) -> Substring.UTF8View {
     // FIXME(strings): tests.
-    let r = _wholeGuts.validateSubscalarRange(r, from: startIndex, to: endIndex)
+    let r = _wholeGuts.validateSubscalarRange(r, in: _bounds)
     return Substring.UTF8View(_slice.base, _bounds: r)
   }
 }
@@ -894,6 +906,11 @@ extension Substring {
 
     @_alwaysEmitIntoClient @inline(__always)
     internal var _base: String.UTF16View { _slice._base }
+
+    @_alwaysEmitIntoClient @inline(__always)
+    internal var _bounds: Range<Index> {
+      Range(_uncheckedBounds: (_slice._startIndex, _slice._endIndex))
+    }
   }
 }
 
@@ -981,7 +998,7 @@ extension Substring.UTF16View: BidirectionalCollection {
 
   @inlinable
   public subscript(r: Range<Index>) -> Substring.UTF16View {
-    let r = _wholeGuts.validateSubscalarRange(r, from: startIndex, to: endIndex)
+    let r = _wholeGuts.validateSubscalarRange(r, in: _bounds)
     return Substring.UTF16View(_slice.base, _bounds: r)
   }
 }
@@ -1039,16 +1056,31 @@ extension Substring {
 
     /// Creates an instance that slices `base` at `_bounds`.
     @usableFromInline // This used to be inlinable before 5.7
-    @available(*, deprecated) // Use `init(_unchecked:)` in new code.
+    @available(*, deprecated, message: "Use `init(_unchecked:bounds)` in new code")
     internal init(_ base: String.UnicodeScalarView, _bounds: Range<Index>) {
       let start = base._guts.scalarAlign(_bounds.lowerBound)
       let end = base._guts.scalarAlign(_bounds.upperBound)
       _slice = Slice(base: base, bounds: Range(_uncheckedBounds: (start, end)))
     }
+  }
+}
 
-    @_alwaysEmitIntoClient
-    @inline(__always)
-    internal var _wholeGuts: _StringGuts { _slice._base._guts }
+extension Substring.UnicodeScalarView {
+  @_alwaysEmitIntoClient
+  @inline(__always)
+  internal var _wholeGuts: _StringGuts { _slice._base._guts }
+
+  @inline(__always)
+  internal var _offsetRange: Range<Int> {
+    let lower = _slice._startIndex._encodedOffset
+    let upper = _slice._endIndex._encodedOffset
+    return Range(_uncheckedBounds: (lower, upper))
+  }
+
+  @_alwaysEmitIntoClient
+  @inline(__always)
+  internal var _bounds: Range<Index> {
+    Range(_uncheckedBounds: (startIndex, endIndex))
   }
 }
 
@@ -1069,8 +1101,7 @@ extension Substring.UnicodeScalarView: BidirectionalCollection {
 
   @inlinable
   public subscript(index: Index) -> Element {
-    let index = _wholeGuts.validateScalarIndex(
-      index, from: startIndex, to: endIndex)
+    let index = _wholeGuts.validateScalarIndex(index, in: _bounds)
     return _wholeGuts.errorCorrectedScalar(startingAt: index._encodedOffset).0
   }
 
@@ -1130,7 +1161,7 @@ extension Substring.UnicodeScalarView: BidirectionalCollection {
 
   public subscript(r: Range<Index>) -> Substring.UnicodeScalarView {
     // Note: This used to be inlinable until Swift 5.7
-    let r = _wholeGuts.validateScalarRange(r, from: startIndex, to: endIndex)
+    let r = _wholeGuts.validateScalarRange(r, in: _bounds)
     return Substring.UnicodeScalarView(_unchecked: _slice._base, bounds: r)
   }
 }
@@ -1175,8 +1206,7 @@ extension Substring.UnicodeScalarView: RangeReplaceableCollection {
     _ subrange: Range<Index>, with replacement: C
   ) where C.Element == Element {
     // TODO(lorentey): Review index validation
-    let subrange = _slice._base._guts.validateScalarRange(
-      subrange, from: startIndex, to: endIndex)
+    let subrange = _wholeGuts.validateScalarRange(subrange, in: _bounds)
     _slice.replaceSubrange(subrange, with: replacement)
   }
 }