[stdlib] Remove _StringCore from UTF8View.Index

Author: natecook1000

stdlib/public/core/StringUTF16.swift

@@ -407,7 +407,7 @@ extension String.UTF16View.Index {
       "Invalid String.UTF8Index for this UTF-16 view")
 
     // Detect positions that have no corresponding index.
-    if !utf8Index._isOnUnicodeScalarBoundary {
+    if !utf8Index._isOnUnicodeScalarBoundary(in: core) {
       return nil
     }
     _offset = utf8Index._coreIndex

stdlib/public/core/StringUTF8.swift

@@ -174,10 +174,10 @@ extension String {
 
     init(_ _core: _StringCore) {
       self._core = _core
-      self._endIndex = Index(_core, _core.endIndex, Index._emptyBuffer)
+      self._endIndex = Index(_coreIndex: _core.endIndex, Index._emptyBuffer)
       if _fastPath(_core.count != 0) {
         let (_, buffer) = _core._encodeSomeUTF8(from: 0)
-        self._startIndex = Index(_core, 0, buffer)
+        self._startIndex = Index(_coreIndex: 0, buffer)
       } else {
         self._startIndex = self._endIndex
       }
@@ -208,27 +208,23 @@ extension String {
     public struct Index : Comparable {
       internal typealias Buffer = _StringCore._UTF8Chunk
 
-      init(_ _core: _StringCore, _ _coreIndex: Int,
-           _ _buffer: Buffer) {
-        self._core = _core
+      init(_coreIndex: Int, _ _buffer: Buffer) {
         self._coreIndex = _coreIndex
         self._buffer = _buffer
-        _sanityCheck(_coreIndex >= 0)
-        _sanityCheck(_coreIndex <= _core.count)
       }
 
       /// True iff the index is at the end of its view or if the next
       /// byte begins a new UnicodeScalar.
-      internal var _isOnUnicodeScalarBoundary: Bool {
+      internal func _isOnUnicodeScalarBoundary(in core: _StringCore) -> Bool {
         let buffer = UInt32(truncatingBitPattern: _buffer)
         let (codePoint, _) = UTF8._decodeOne(buffer)
-        return codePoint != nil || _isAtEnd
+        return codePoint != nil || _isEndIndex(of: core)
       }
 
       /// True iff the index is at the end of its view
-      internal var _isAtEnd: Bool {
+      internal func _isEndIndex(of core: _StringCore) -> Bool {
         return _buffer == Index._emptyBuffer
-          && _coreIndex == _core.endIndex
+          && _coreIndex == core.endIndex
       }
 
       /// The value of the buffer when it is empty
@@ -247,13 +243,12 @@ extension String {
         return (thisBuffer >> 8) | _bufferHiByte
       }
 
-      /// The underlying buffer we're presenting as UTF-8
-      internal let _core: _StringCore
       /// The position of `self`, rounded up to the nearest unicode
       /// scalar boundary, in the underlying UTF-16.
       internal let _coreIndex: Int
-      /// If `self` is at the end of its `_core`, has the value `_endBuffer`.
-      /// Otherwise, the low byte contains the value of
+      /// If `self` is at the end of its `_core`, has the value `_emptyBuffer`.
+      /// Otherwise, the low byte contains the value of the UTF-8 code unit
+      /// at this position.
       internal let _buffer: Buffer
     }
 
@@ -292,21 +287,21 @@ extension String {
       let nextCoreIndex = i._coreIndex &+ increment
       let nextBuffer = Index._nextBuffer(after: i._buffer)
 
-      // if the nextBuffer is nonempty, we have all we need
+      // If the nextBuffer is nonempty, we have all we need
       if _fastPath(nextBuffer != Index._emptyBuffer) {
-        return Index(i._core, nextCoreIndex, nextBuffer)
+        return Index(_coreIndex: nextCoreIndex, nextBuffer)
       }
       // If the underlying UTF16 isn't exhausted, fill a new buffer
-      else if _fastPath(nextCoreIndex < i._core.endIndex) {
-        let (_, freshBuffer) = i._core._encodeSomeUTF8(from: nextCoreIndex)
-        return Index(_core, nextCoreIndex, freshBuffer)
+      else if _fastPath(nextCoreIndex < _core.endIndex) {
+        let (_, freshBuffer) = _core._encodeSomeUTF8(from: nextCoreIndex)
+        return Index(_coreIndex: nextCoreIndex, freshBuffer)
       }
       else {
         // Produce the endIndex
         _precondition(
-          nextCoreIndex == i._core.endIndex,
+          nextCoreIndex == _core.endIndex,
           "Can't increment past endIndex of String.UTF8View")
-        return Index(_core, nextCoreIndex, nextBuffer)
+        return Index(_coreIndex: nextCoreIndex, nextBuffer)
       }
     }
 
@@ -478,7 +473,7 @@ public func < (
 extension String.UTF8View.Index {
   internal init(_ core: _StringCore, _utf16Offset: Int) {
       let (_, buffer) = core._encodeSomeUTF8(from: _utf16Offset)
-      self.init(core, _utf16Offset, buffer)
+      self.init(_coreIndex: _utf16Offset, buffer)
   }
 
   /// Creates an index in the given UTF-8 view that corresponds exactly to the

stdlib/public/core/StringUnicodeScalarView.swift

@@ -471,7 +471,7 @@ extension String.UnicodeScalarIndex {
       "Invalid String.UTF8Index for this UnicodeScalar view")
 
     // Detect positions that have no corresponding index.
-    if !utf8Index._isOnUnicodeScalarBoundary {
+    if !utf8Index._isOnUnicodeScalarBoundary(in: core) {
       return nil
     }
     self.init(_position: utf8Index._coreIndex)