Remove word view, use index methods

Author: Azoy

stdlib/public/core/CMakeLists.txt

@@ -171,7 +171,6 @@ set(SWIFTLIB_ESSENTIAL
   StringUTF8View.swift
   StringUTF8Validation.swift
   StringWordBreaking.swift
-  StringWordView.swift
   Substring.swift
   SwiftNativeNSArray.swift
   TemporaryAllocation.swift

stdlib/public/core/GroupInfo.json

@@ -42,7 +42,6 @@
     "StringUTF8Validation.swift",
     "StringUnicodeScalarView.swift",
     "StringWordBreaking.swift",
-    "StringWordView.swift",
     "Substring.swift",
     "Unicode.swift",
     "UnicodeData.swift",

stdlib/public/core/StringIndexValidation.swift

@@ -402,22 +402,16 @@ extension _StringGuts {
 // Word index validation (String)
 extension _StringGuts {
   internal func validateWordIndex(
-    _ i: String._WordView.Index
-  ) -> String._WordView.Index {
-    let i = String.Index(_encodedOffset: i._encodedOffset)
-
-    return roundDownToNearestWord(
-      String._WordView.Index(scalarAlign(validateSubscalarIndex(i)))
-    )
+    _ i: String.Index
+  ) -> String.Index {
+    return roundDownToNearestWord(scalarAlign(validateSubscalarIndex(i)))
   }
 
   internal func validateInclusiveWordIndex(
-    _ i: String._WordView.Index
-  ) -> String._WordView.Index {
-    let i = String.Index(_encodedOffset: i._encodedOffset)
-
+    _ i: String.Index
+  ) -> String.Index {
     return roundDownToNearestWord(
-      String._WordView.Index(scalarAlign(validateInclusiveSubscalarIndex(i)))
+      scalarAlign(validateInclusiveSubscalarIndex(i))
     )
   }
 }

stdlib/public/core/StringWordBreaking.swift

@@ -11,8 +11,8 @@
 
 extension _StringGuts {
   internal func roundDownToNearestWord(
-    _ i: String._WordView.Index
-  ) -> String._WordView.Index {
+    _ i: String.Index
+  ) -> String.Index {
     _internalInvariant(i._encodedOffset <= count)
 
     let offset = i._encodedOffset
@@ -26,8 +26,8 @@ extension _StringGuts {
 
   @inline(never)
   internal func _slowRoundDownToNearestWord(
-    _ i: String._WordView.Index
-  ) -> String._WordView.Index {
+    _ i: String.Index
+  ) -> String.Index {
     let offset = i._encodedOffset
     let start = previousWordIndex(endingAt: offset)
     let end = nextWordIndex(startingAt: start)
@@ -37,7 +37,7 @@ extension _StringGuts {
       return i
     }
 
-    return String._WordView.Index(_encodedOffset: start)
+    return String.Index(_encodedOffset: start)
   }
 
   @inline(never)

stdlib/public/core/StringWordView.swift

@@ -199,3 +199,32 @@ extension Unicode.Scalar.Properties {
     return result
   }
 }
+
+//===----------------------------------------------------------------------===//
+// String Word Breaking
+//===----------------------------------------------------------------------===//
+
+extension String {
+  @_spi(_Unicode)
+  @available(SwiftStdlib 5.7, *)
+  public func _wordIndex(after i: String.Index) -> String.Index {
+    _precondition(i < endIndex)
+
+    let i = _guts.validateWordIndex(i)
+
+    let next = _guts.nextWordIndex(startingAt: i._encodedOffset)
+    return String.Index(_encodedOffset: next)
+  }
+
+  @_spi(_Unicode)
+  @available(SwiftStdlib 5.7, *)
+  public func _wordIndex(before i: String.Index) -> String.Index {
+    _precondition(i > startIndex)
+    _precondition(i <= endIndex)
+
+    let i = _guts.validateInclusiveWordIndex(i)
+
+    let previous = _guts.previousWordIndex(endingAt: i._encodedOffset)
+    return String.Index(_encodedOffset: previous)
+  }
+}

stdlib/public/core/UnicodeSPI.swift

@@ -28,18 +28,57 @@ let StringWordBreaking = TestSuite("StringWordBreaking")
 //   }
 // }
 
+extension String {
+  @available(SwiftStdlib 5.7, *)
+  var _words: [String] {
+    var result: [String] = []
+
+    var i = startIndex
+
+    while i < endIndex {
+      let start = i
+      let end = _wordIndex(after: i)
+
+      let substr = self[start ..< end]
+      result.append(String(substr))
+
+      i = end
+    }
+
+    return result
+  }
+
+  @available(SwiftStdlib 5.7, *)
+  var _wordsBackwards: [String] {
+    var result: [String] = []
+
+    var i = endIndex
+
+    while i > startIndex {
+      let end = i
+      let start = _wordIndex(before: i)
+
+      let substr = self[start ..< end]
+      result.append(String(substr))
+
+      i = start
+    }
+
+    return result
+  }
+}
+
 if #available(SwiftStdlib 5.7, *) {
   StringWordBreaking.test("word breaking") {
     for wordBreakTest in wordBreakTests {
       expectEqual(
         wordBreakTest.1,
-        wordBreakTest.0._words().map { String($0) },
+        wordBreakTest.0._words,
+        "string: \(String(reflecting: wordBreakTest.0))")
+      expectEqual(
+        wordBreakTest.1.reversed(),
+        wordBreakTest.0._wordsBackwards,
         "string: \(String(reflecting: wordBreakTest.0))")
-      // FIXME: Reenable once we figure out what to do with WordView
-      // expectEqual(
-      //   wordBreakTest.1.reversed(),
-      //   wordBreakTest.0._words().reversed().map { String($0) },
-      //   "string: \(String(reflecting: wordBreakTest.0))")
     }
   }
 }
@@ -107,13 +146,12 @@ if #available(SwiftStdlib 5.7, *) {
       expectTrue(test._guts._isForeign())
       expectEqual(
         wordBreakTest.1,
-        test._words().map { String($0) },
+        test._words,
+        "string: \(String(reflecting: wordBreakTest.0))")
+      expectEqual(
+        wordBreakTest.1.reversed(),
+        test._wordsBackwards,
         "string: \(String(reflecting: wordBreakTest.0))")
-      // FIXME: Reenable once we figure out what to do with WordView
-      // expectEqual(
-      //   wordBreakTest.1,
-      //   test._words().reversed().map { String($0) },
-      //   "string: \(String(reflecting: wordBreakTest.0))")
     }
   }
 }