WIP: More directions in place

Author: milseman

stdlib/public/core/StringUTF8View.swift

@@ -448,7 +448,7 @@ extension String.UTF8View {
     }
 
     let (scalar, scalarLen) = _guts.foreignErrorCorrectedScalar(
-      endingAt: idx)
+      endingAt: idx.strippingTranscoding)
     let utf8Len = UTF8.width(scalar)
     return idx.encoded(
       offsetBy: -scalarLen
@@ -457,19 +457,18 @@ extension String.UTF8View {
 
   @usableFromInline @inline(never)
   @_effects(releasenone)
-  internal func _foreignSubscript(position i: Index) -> UTF8.CodeUnit {
+  internal func _foreignSubscript(position idx: Index) -> UTF8.CodeUnit {
     _internalInvariant(_guts.isForeign)
 
-    // FIXME: We should need some kind of alignment if given an index into a
-    // surrogate pair
+    let idx = _utf8AlignForeignIndex(idx)
 
     let scalar = _guts.foreignErrorCorrectedScalar(
-      startingAt: _guts.scalarAlign(i)).0
+      startingAt: idx.strippingTranscoding).0
     let encoded = Unicode.UTF8.encode(scalar)._unsafelyUnwrappedUnchecked
-    _internalInvariant(i.transcodedOffset < 1+encoded.count)
+    _internalInvariant(idx.transcodedOffset < 1+encoded.count)
 
     return encoded[
-      encoded.index(encoded.startIndex, offsetBy: i.transcodedOffset)]
+      encoded.index(encoded.startIndex, offsetBy: idx.transcodedOffset)]
   }
 
   @usableFromInline @inline(never)
@@ -492,24 +491,27 @@ extension String.UTF8View {
   @_effects(releasenone)
   internal func _foreignDistance(from i: Index, to j: Index) -> Int {
     _internalInvariant(_guts.isForeign)
-    
+
+    let i = _utf8AlignForeignIndex(i)
+    let j = _utf8AlignForeignIndex(j)
+
+
     #if _runtime(_ObjC)
-    // Currently, foreign  means NSString
+    // Currently, foreign means NSString
     if let count = _cocoaStringUTF8Count(
       _guts._object.cocoaObject,
       range: i._encodedOffset ..< j._encodedOffset
     ) {
-      //_cocoaStringUTF8Count gave us the scalar aligned count, but we still
-      //need to compensate for sub-scalar indexing, e.g. if `i` is in the middle
-      //of a two-byte UTF8 scalar.
+      // _cocoaStringUTF8Count gave us the scalar aligned count, but we still
+      // need to compensate for sub-scalar indexing, e.g. if `i` is in the
+      // middle of a two-byte UTF8 scalar.
       let refinedCount = count - (i.transcodedOffset + j.transcodedOffset)
       _internalInvariant(refinedCount == _distance(from: i, to: j))
       return refinedCount
     }
     #endif
 
     return _distance(from: i, to: j)
-   
   }
 
   @usableFromInline @inline(never)

test/stdlib/StringIndex.swift

@@ -376,12 +376,26 @@ StringIndexTests.test("Index interchange") {
           expect(curSubChar == str[curUTF8Idx])
           expect(!UTF16.isTrailSurrogate(str.utf16[curUTF8Idx]))
           expect(utf8StartIdx == str[curUTF8Idx...].startIndex)
+          expect(str[utf8StartIdx..<curUTF8Idx].isEmpty)
           expect(0 == str.utf16.distance(from: utf8StartIdx, to: curUTF8Idx))
 
           str.utf8.formIndex(after: &curUTF8Idx)
         }
         expect(curUTF8Idx == curScalarIdx)
 
+        var utf8RevIdx = curUTF8Idx
+        while utf8RevIdx > utf8StartIdx {
+          str.utf8.formIndex(before: &utf8RevIdx)
+
+          expect(curScalar == str.unicodeScalars[utf8RevIdx])
+          expect(curSubChar == str[utf8RevIdx])
+          expect(!UTF16.isTrailSurrogate(str.utf16[utf8RevIdx]))
+          expect(utf8StartIdx == str[utf8RevIdx...].startIndex)
+          expect(str[utf8StartIdx..<utf8RevIdx].isEmpty)
+          expect(0 == str.utf16.distance(from: utf8StartIdx, to: utf8RevIdx))
+        }
+        expect(utf8RevIdx == utf8StartIdx)
+
         let utf16StartIdx = curUTF16Idx
         defer {
           let sub = str.unicodeScalars[utf16StartIdx..<curUTF16Idx]
@@ -398,11 +412,26 @@ StringIndexTests.test("Index interchange") {
           expect(curSubChar == str[curUTF16Idx])
           expect(!UTF8.isContinuation(str.utf8[curUTF16Idx]))
           expect(utf16StartIdx == str[curUTF16Idx...].startIndex)
-          // expect(0 == str.utf8.distance(from: utf16StartIdx, to: curUTF16Idx))
+          expect(str[utf16StartIdx..<curUTF16Idx].isEmpty)
+          expect(0 == str.utf8.distance(from: utf16StartIdx, to: curUTF16Idx))
 
           str.utf16.formIndex(after: &curUTF16Idx)
         }
         expect(curUTF16Idx == curScalarIdx)
+
+        var utf16RevIdx = curUTF16Idx
+        while utf16RevIdx > utf16StartIdx {
+          str.utf16.formIndex(before: &utf16RevIdx)
+
+          expect(curScalar == str.unicodeScalars[utf16RevIdx])
+          expect(curSubChar == str[utf16RevIdx])
+          expect(!UTF8.isContinuation(str.utf8[utf16RevIdx]))
+          expect(utf16StartIdx == str[utf16RevIdx...].startIndex)
+          expect(str[utf16StartIdx..<utf16RevIdx].isEmpty)
+          expect(0 == str.utf8.distance(from: utf16StartIdx, to: utf16RevIdx))
+        }
+        expect(utf16RevIdx == utf16StartIdx)
+
       }
     }
   }