[String] Add generic String.Index and range inits within a String

Adds a generic version of String.Index.init?(_:within:) and
Range<String.Index>.init?(_:in:).

Tests added

Author: milseman

stdlib/public/Darwin/Foundation/NSRange.swift

@@ -175,17 +175,33 @@ extension Range where Bound == Int {
 }
 
 extension Range where Bound == String.Index {
-  public init?(_ range: NSRange, in string: __shared String) {
+  private init?<S: StringProtocol>(
+    _ range: NSRange, _genericIn string: __shared S
+  ) {
+    // Corresponding stdlib version
+    guard #available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *) else {
+      fatalError()
+    }
     let u = string.utf16
     guard range.location != NSNotFound,
-      let start = u.index(u.startIndex, offsetBy: range.location, limitedBy: u.endIndex),
-      let end = u.index(u.startIndex, offsetBy: range.location + range.length, limitedBy: u.endIndex),
+      let start = u.index(
+        u.startIndex, offsetBy: range.location, limitedBy: u.endIndex),
+      let end = u.index(
+        start, offsetBy: range.length, limitedBy: u.endIndex),
       let lowerBound = String.Index(start, within: string),
       let upperBound = String.Index(end, within: string)
     else { return nil }
-    
+
     self = lowerBound..<upperBound
   }
+
+  public init?(_ range: NSRange, in string: __shared String) {
+    self.init(range, _genericIn: string)
+  }
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+  public init?<S: StringProtocol>(_ range: NSRange, in string: __shared S) {
+    self.init(range, _genericIn: string)
+  }
 }
 
 extension NSRange : CustomReflectable {

stdlib/public/core/StringIndexConversions.swift

@@ -11,6 +11,15 @@
 //===----------------------------------------------------------------------===//
 
 extension String.Index {
+  private init?<S: StringProtocol>(
+    _ sourcePosition: String.Index, _genericWithin target: S
+  ) {
+    guard target._wholeGuts.isOnGraphemeClusterBoundary(sourcePosition) else {
+      return nil
+    }
+    self = sourcePosition
+  }
+
   /// Creates an index in the given string that corresponds exactly to the
   /// specified position.
   ///
@@ -49,14 +58,53 @@ extension String.Index {
   ///     `sourcePosition` must be a valid index of at least one of the views
   ///     of `target`.
   ///   - target: The string referenced by the resulting index.
-  public init?(
-    _ sourcePosition: String.Index,
-    within target: String
+  public init?(_ sourcePosition: String.Index, within target: String) {
+    self.init(sourcePosition, _genericWithin: target)
+  }
+
+  /// Creates an index in the given string that corresponds exactly to the
+  /// specified position.
+  ///
+  /// If the index passed as `sourcePosition` represents the start of an
+  /// extended grapheme cluster---the element type of a string---then the
+  /// initializer succeeds.
+  ///
+  /// The following example converts the position of the Unicode scalar `"e"`
+  /// into its corresponding position in the string. The character at that
+  /// position is the composed `"é"` character.
+  ///
+  ///     let cafe = "Cafe\u{0301}"
+  ///     print(cafe)
+  ///     // Prints "Café"
+  ///
+  ///     let scalarsIndex = cafe.unicodeScalars.firstIndex(of: "e")!
+  ///     let stringIndex = String.Index(scalarsIndex, within: cafe)!
+  ///
+  ///     print(cafe[...stringIndex])
+  ///     // Prints "Café"
+  ///
+  /// If the index passed as `sourcePosition` doesn't have an exact
+  /// corresponding position in `target`, the result of the initializer is
+  /// `nil`. For example, an attempt to convert the position of the combining
+  /// acute accent (`"\u{0301}"`) fails. Combining Unicode scalars do not have
+  /// their own position in a string.
+  ///
+  ///     let nextScalarsIndex = cafe.unicodeScalars.index(after: scalarsIndex)
+  ///     let nextStringIndex = String.Index(nextScalarsIndex, within: cafe)
+  ///
+  ///     print(nextStringIndex)
+  ///     // Prints "nil"
+  ///
+  /// - Parameters:
+  ///   - sourcePosition: A position in a view of the `target` parameter.
+  ///     `sourcePosition` must be a valid index of at least one of the views
+  ///     of `target`.
+  ///   - target: The string referenced by the resulting index.
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+  public init?<S: StringProtocol>(
+    _ sourcePosition: String.Index, within target: S
   ) {
-    guard target._guts.isOnGraphemeClusterBoundary(sourcePosition) else {
-      return nil
-    }
-    self = sourcePosition
+    self.init(sourcePosition, _genericWithin: target)
   }
 
   /// Returns the position in the given UTF-8 view that corresponds exactly to
@@ -81,7 +129,7 @@ extension String.Index {
   ///   position of a UTF-16 trailing surrogate returns `nil`.
   public func samePosition(
     in utf8: String.UTF8View
-    ) -> String.UTF8View.Index? {
+  ) -> String.UTF8View.Index? {
     return String.UTF8View.Index(self, within: utf8)
   }
 

test/stdlib/StringIndex.swift

@@ -202,6 +202,44 @@ StringIndexTests.test("Scalar Align UTF-8 indices") {
   expectEqual(roundedIdx, roundedIdx3)
 }
 
+import Foundation
+StringIndexTests.test("String.Index(_:within) / Range<String.Index>(_:in:)") {
+  guard #available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *) else {
+    return
+  }
 
+  let str = simpleStrings.joined()
+  let substr = str[...]
+  for idx in str.utf8.indices {
+    expectEqual(
+      String.Index(idx, within: str), String.Index(idx, within: substr))
+  }
+
+  let utf16Count = str.utf16.count
+  let utf16Indices = Array(str.utf16.indices) + [str.utf16.endIndex]
+  for location in 0..<utf16Count {
+    for length in 0...(utf16Count - location) {
+      let strLB = String.Index(utf16Indices[location], within: str)
+      let substrLB = String.Index(utf16Indices[location], within: substr)
+      let strUB = String.Index(utf16Indices[location+length], within: str)
+      let substrUB = String.Index(utf16Indices[location+length], within: substr)
+      expectEqual(strLB, substrLB)
+      expectEqual(strUB, substrUB)
+
+      if #available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *) {
+        let nsRange = NSRange(location: location, length: length)
+        let strRange = Range<String.Index>(nsRange, in: str)
+        let substrRange = Range<String.Index>(nsRange, in: substr)
+
+        expectEqual(strRange, substrRange)
+        guard strLB != nil && strUB != nil else {
+          expectNil(strRange)
+          continue
+        }
+        expectEqual(strRange, Range(uncheckedBounds: (strLB!, strUB!)))
+      }
+    }
+  }
+}
 
 runAllTests()