Address comments from Karoy and Michael

Author: Azoy

stdlib/private/StdlibUnicodeUnittest/WordBreaking.swift

@@ -25,18 +25,12 @@ func parseWordBreakTests(
       continue
     }
 
-    let info = line.split(separator: "#")
-    let components = info[0].split(separator: " ")
-    print(components)
+    let components = line.split(separator: "#").first!.split(separator: " ")
 
     var string = ""
     var words: [String] = [""]
 
-    for i in components.indices {
-      guard i != 0 else {
-        continue
-      }
-
+    for i in components.indices.dropFirst() {
       // If we're an odd index, this is a scalar.
       if !i.isMultiple(of: 2) {
         let scalar = Unicode.Scalar(UInt32(components[i], radix: 16)!)!

stdlib/public/core/StringIndex.swift

@@ -368,8 +368,7 @@ extension String.Index {
 extension String.Index {
   @_alwaysEmitIntoClient // Swift 5.7
   internal func _copyingAlignment(from index: Self) -> Self {
-    let mask = Self.__scalarAlignmentBit
-      | Self.__characterAlignmentBit
+    let mask = Self.__scalarAlignmentBit | Self.__characterAlignmentBit
     return Self((_rawBits & ~mask) | (index._rawBits & mask))
   }
 }

stdlib/public/core/StringIndexValidation.swift

@@ -401,7 +401,6 @@ extension _StringGuts {
 
 // Word index validation (String)
 extension _StringGuts {
-  @available(SwiftStdlib 5.7, *)
   internal func validateWordIndex(
     _ i: String._WordView.Index
   ) -> String._WordView.Index {
@@ -412,7 +411,6 @@ extension _StringGuts {
     )
   }
 
-  @available(SwiftStdlib 5.7, *)
   internal func validateInclusiveWordIndex(
     _ i: String._WordView.Index
   ) -> String._WordView.Index {

stdlib/public/core/StringWordBreaking.swift

@@ -10,7 +10,6 @@
 //===----------------------------------------------------------------------===//
 
 extension _StringGuts {
-  @inline(__always)
   internal func roundDownToNearestWord(
     _ i: String._WordView.Index
   ) -> String._WordView.Index {
@@ -30,11 +29,11 @@ extension _StringGuts {
     _ i: String._WordView.Index
   ) -> String._WordView.Index {
     let offset = i._encodedOffset
-    let start = _opaquePreviousWordIndex(endingAt: offset)
-    let stride = _opaqueNextWordIndex(startingAt: start) &- start
-    _internalInvariant(offset <= start + stride, "Word breaking inconsistency")
+    let start = previousWordIndex(endingAt: offset)
+    let end = nextWordIndex(startingAt: start)
+    _internalInvariant(offset <= end, "Word breaking inconsistency")
 
-    if offset >= start + stride {
+    if offset == end {
       return i
     }
 
@@ -43,9 +42,9 @@ extension _StringGuts {
 
   @inline(never)
   @_effects(releasenone)
-  internal func _opaqueNextWordIndex(startingAt i: Int) -> Int {
+  internal func nextWordIndex(startingAt i: Int) -> Int {
     if _slowPath(isForeign) {
-      return _foreignOpaqueNextWordIndex(startingAt: i)
+      return _foreignNextWordIndex(startingAt: i)
     }
 
     return withFastUTF8 { utf8 in
@@ -62,7 +61,7 @@ extension _StringGuts {
     }
   }
 
-  internal func _foreignOpaqueNextWordIndex(startingAt i: Int) -> Int {
+  internal func _foreignNextWordIndex(startingAt i: Int) -> Int {
 #if _runtime(_ObjC)
     return nextWordBoundary(startingAt: i) {
       _internalInvariant($0 >= 0)
@@ -84,9 +83,9 @@ extension _StringGuts {
 #endif
   }
 
-  internal func _opaquePreviousWordIndex(endingAt i: Int) -> Int {
+  internal func previousWordIndex(endingAt i: Int) -> Int {
     if _slowPath(isForeign) {
-      return _foreignOpaquePreviousWordIndex(endingAt: i)
+      return _foreignPreviousWordIndex(endingAt: i)
     }
 
     return withFastUTF8 { utf8 in
@@ -104,7 +103,7 @@ extension _StringGuts {
   }
 
   @inline(never)
-  internal func _foreignOpaquePreviousWordIndex(endingAt i: Int) -> Int {
+  internal func _foreignPreviousWordIndex(endingAt i: Int) -> Int {
     #if _runtime(_ObjC)
     return previousWordBoundary(endingAt: i) {
       _internalInvariant($0 <= count)
@@ -160,14 +159,12 @@ extension _StringGuts {
     startingAt index: Int,
     nextScalar: (Int) -> (scalar: Unicode.Scalar, end: Int)?
   ) -> Int {
+    _precondition(index < endIndex._encodedOffset)
+
     var (scalar, index) = nextScalar(index)!
     var state = _WordBreakingState(index: index)
 
-    while true {
-      guard let (scalar2, nextIndex) = nextScalar(state.index) else {
-        break
-      }
-
+    while let (scalar2, nextIndex) = nextScalar(state.index) {
       if shouldBreak(between: scalar, and: scalar2, with: &state) {
         break
       }
@@ -192,11 +189,7 @@ extension _StringGuts {
     var (scalar2, index) = previousScalar(index)!
     var state = _WordBreakingState(index: index)
 
-    while true {
-      guard let (scalar, previousIndex) = previousScalar(state.index) else {
-        break
-      }
-
+    while let (scalar, previousIndex) = previousScalar(state.index) {
       if shouldBreakBackward(between: scalar, and: scalar2, with: &state) {
         break
       }
@@ -271,11 +264,7 @@ extension _StringGuts {
       return false
 
     default:
-      var newX = x
-
-      if let previousProperty = state.previousProperty {
-        newX = previousProperty
-      }
+      let newX = state.previousProperty ?? x
 
       return decidePostFormat(between: newX, and: y, with: &state)
     }

stdlib/public/core/StringWordView.swift

@@ -20,8 +20,7 @@ extension String {
 }
 
 extension String._WordView: Collection {
-  internal struct Index {
-    @usableFromInline
+  internal struct Index: Hashable {
     internal var _encodedOffset: Int
   }
 
@@ -36,32 +35,27 @@ extension String._WordView: Collection {
   }
 
   func index(after i: Index) -> Index {
-    _internalInvariant(i < endIndex)
+    _precondition(i < endIndex)
 
-    let nextOffset = _guts._opaqueNextWordIndex(startingAt: i._encodedOffset)
+    let nextOffset = _guts.nextWordIndex(startingAt: i._encodedOffset)
     return Index(_encodedOffset: nextOffset)
   }
 
   subscript(position: Index) -> Element {
     let indexAfter = index(after: position)
 
-    let l = String.Index(_encodedOffset: position._encodedOffset)
-    let u = String.Index(_encodedOffset: indexAfter._encodedOffset)
+    let l = String.Index(
+      _encodedOffset: position._encodedOffset
+    )._characterAligned
+    let u = String.Index(
+      _encodedOffset: indexAfter._encodedOffset
+    )._characterAligned
 
     return String(_guts)[l ..< u]
   }
 }
 
-extension String._WordView.Index: Equatable {
-  @inlinable
-  @inline(__always)
-  static func == (lhs: Self, rhs: Self) -> Bool {
-    lhs._encodedOffset == rhs._encodedOffset
-  }
-}
-
 extension String._WordView.Index: Comparable {
-  @inlinable
   @inline(__always)
   static func < (lhs: Self, rhs: Self) -> Bool {
     lhs._encodedOffset < rhs._encodedOffset
@@ -78,11 +72,10 @@ extension String._WordView.Index: Sendable {}
 
 extension String._WordView: BidirectionalCollection {
   func index(before i: Index) -> Index {
-    _internalInvariant(i > startIndex)
+    _precondition(i > startIndex)
+    _precondition(i <= endIndex)
 
-    let previousOffset = _guts._opaquePreviousWordIndex(
-      endingAt: i._encodedOffset
-    )
+    let previousOffset = _guts.previousWordIndex(endingAt: i._encodedOffset)
 
     return Index(_encodedOffset: previousOffset)
   }