Fix AttributedString slicing behavior on range expressions (#727)

`AttributedString` goes out of its way to emulate the stdlib’s behavior for `String` slicing. Unfortunately, it went a little overboard:

```swift
import Foundation

let str1 = "F\u{301}a\u{308}n\u{303}c\u{327}y\u{30a}" // "F́äñçẙ"
let str2 = AttributedString(str1)

let substr1 = str1[...str1.startIndex] // “F\u{301}”
let substr2 = str2[...str2.startIndex] // “F”
print(Array(substr1.unicodeScalars))
print(Array(substr2.unicodeScalars))
```

We expect slicing on range expressions to always produce  consistent results between `String` and `AttributedString`.

When slicing character-based string views on `…str.startIndex`, we naturally expect the range expression to cover the entire first `Character`, and that is precisely what `String` does.

`AttributedString`’s default view is not as obviously `Character`-based as `String` is, but emulating the stdlib’s behavior is much preferable than to allow such simple, character-aligned range expressions to slice the attributed string at random sub-character positions.

Author: lorentey

Sources/FoundationEssentials/AttributedString/AttributedString.swift

@@ -292,8 +292,9 @@ extension AttributedString {
 
     public mutating func replaceSubrange(_ range: some RangeExpression<Index>, with s: some AttributedStringProtocol) {
         ensureUniqueReference()
-        // Note: we allow sub-Character ranges, so we must use `unicodeScalars` here, not `characters`.
-        let subrange = range.relative(to: unicodeScalars)._bstringRange
+        // Note: slicing generally allows sub-Character ranges, but we need to resolve range
+        // expressions using the characters view, to remain consistent with the stdlib.
+        let subrange = range.relative(to: characters)._bstringRange
         _guts.replaceSubrange(subrange, with: s)
     }
 }
@@ -327,14 +328,16 @@ extension AttributedString {
 extension AttributedString {
     public subscript(bounds: some RangeExpression<Index>) -> AttributedSubstring {
         get {
-            // Note: we allow sub-Character ranges, so we must use `unicodeScalars` here, not `characters`.
-            let bounds = bounds.relative(to: unicodeScalars)
+            // Note: slicing generally allows sub-Character ranges, but we need to resolve range
+            // expressions using the characters view, to remain consistent with the stdlib.
+            let bounds = bounds.relative(to: characters)
             return AttributedSubstring(_guts, in: bounds._bstringRange)
         }
         _modify {
             ensureUniqueReference()
-            // Note: we allow sub-Character ranges, so we must use `unicodeScalars` here, not `characters`.
-            let bounds = bounds.relative(to: unicodeScalars)
+            // Note: slicing generally allows sub-Character ranges, but we need to resolve range
+            // expressions using the characters view, to remain consistent with the stdlib.
+            let bounds = bounds.relative(to: characters)
             var substr = AttributedSubstring(_guts, in: bounds._bstringRange)
             let ident = Self._nextModifyIdentity
             substr._identity = ident
@@ -348,6 +351,10 @@ extension AttributedString {
             yield &substr
         }
         set {
+            // Note: slicing generally allows sub-Character ranges, but we need to resolve range
+            // expressions using the characters view, to remain consistent with the stdlib.
+            let bounds = bounds.relative(to: characters)
+
             // FIXME: Why is this allowed if _modify traps on replacement?
             self.replaceSubrange(bounds, with: newValue)
         }

Tests/FoundationEssentialsTests/AttributedString/AttributedStringTests.swift

@@ -1857,6 +1857,63 @@ E {
         XCTAssertEqual(b.count, 0)
     }
 
+    func testCharacterSlicing_RangeExpressions() {
+        // Make sure `AttributedString` and `String` produce consistent results when slicing,
+        // for every range expression, whether or not the bounds fall on `Character` boundaries.
+        //
+        // (SE-0180 mistakenly prevented `String` from rounding down indices to Character boundaries
+        // when slicing, and `AttributedString` has to emulate that choice. However,
+        // `AttributedSubstring` (intentionally, and unavoidably) has to round down the boundaries
+        // of its character view -- so we expect some differences when comparing `characters`.
+        // The substring's `unicodeScalars` view always gives us the precise original boundaries.)
+
+        let str = "F\u{301}a\u{308}n\u{303}c\u{327}y\u{30a}" // "F́äñçẙ"
+        let astr = AttributedString(str)
+
+        func check<T: Equatable>(
+            _ a: some Sequence<T>,
+            _ b: some Sequence<T>,
+            file: StaticString = #file, line: UInt = #line
+        ) {
+            XCTAssertTrue(
+                a.elementsEqual(b),
+                "'\(Array(a))' does not equal '\(Array(b))'",
+                file: file, line: line)
+        }
+
+        check(str, astr.characters)
+        check(str.unicodeScalars, astr.unicodeScalars)
+
+        // Go through all valid range expressions within the two strings and compare slicing
+        // results.
+        var i1 = str.unicodeScalars.startIndex
+        var i2 = astr.unicodeScalars.startIndex
+        while true {
+            check(str[..<i1].unicodeScalars, astr[..<i2].unicodeScalars)
+            check(str[i1...].unicodeScalars, astr[i2...].unicodeScalars)
+
+            var j1 = i1
+            var j2 = i2
+            while true {
+                check(str[i1..<j1].unicodeScalars, astr[i2..<j2].unicodeScalars)
+
+                if j1 == str.endIndex { break }
+
+                check(str[i1...j1].unicodeScalars, astr[i2...j2].unicodeScalars)
+
+                str.unicodeScalars.formIndex(after: &j1)
+                j2 = astr.index(afterUnicodeScalar: j2)
+            }
+
+            if i1 == str.endIndex { break }
+
+            check(str[...i1].unicodeScalars, astr[...i2].unicodeScalars)
+
+            str.unicodeScalars.formIndex(after: &i1)
+            i2 = astr.index(afterUnicodeScalar: i2)
+        }
+    }
+
     func testUnicodeScalarsSlicing() {
         let attrStr = AttributedString("Cafe\u{301}", attributes: AttributeContainer().testInt(1))
         let range = attrStr.startIndex ..< attrStr.endIndex