Merge pull request swiftlang#9 from lorentey/string_guts

More updates & fixes to failing tests

Author: milseman

stdlib/public/core/StringCharacterView.swift

@@ -70,16 +70,10 @@ extension String {
     @_versioned
     internal var _guts: _StringGuts
 
-    @_versioned
-    internal var _core: _LegacyStringCore {
-      get { return _guts._legacyCore }
-      set { self._guts = _StringGuts(newValue) }
-    }
-
-    /// The offset of this view's `_core` from an original core. This works
-    /// around the fact that `_LegacyStringCore` is always zero-indexed.
-    /// `_coreOffset` should be subtracted from `UnicodeScalarIndex.encodedOffset`
-    /// before that value is used as a `_core` index.
+    /// The offset of this view's `_guts` from an original guts. This works
+    /// around the fact that `_StringGuts` is always zero-indexed.
+    /// `_coreOffset` should be subtracted from `Index.encodedOffset` before
+    /// that value is used as a `_guts` index.
     @_versioned
     internal var _coreOffset: Int
 
@@ -794,8 +788,9 @@ extension String._CharacterView {
   ///   Objective-C, where *n* is the length of the string; otherwise, O(1).
   @_inlineable // FIXME(sil-serialize-all)
   public subscript(bounds: Range<Index>) -> String.CharacterView {
-    return String._CharacterView(
-      unicodeScalars[bounds]._guts,
-      coreOffset: bounds.lowerBound.encodedOffset)
+    let scalarSlice: String.UnicodeScalarView = unicodeScalars[bounds]
+    return String.CharacterView(
+      scalarSlice._guts,
+      coreOffset: scalarSlice._coreOffset)
   }
 }

stdlib/public/core/StringGuts.swift

@@ -169,6 +169,7 @@ extension _StringGuts {
     get { return _twoByteCodeUnitBit }
   }
 
+  @_inlineable
   public // @testable
   var isSingleByte: Bool {
     @inline(__always) get {
@@ -178,11 +179,13 @@ extension _StringGuts {
     }
   }
 
+  @_inlineable
   public // @testable
   var byteWidth: Int {
     @inline(__always) get { return isSingleByte ? 1 : 2 }
   }
 
+  @_inlineable
   @_versioned
   var bitWidth: Int {
     @inline(__always) get { return byteWidth &<< 3 }
@@ -264,7 +267,7 @@ extension _StringGuts {
   @_versioned
   internal
   var _isEmptyLiteral: Bool {
-    return _isUnmanaged && _unmanagedRawStart == _emptyStringBase
+    return _isUnmanaged && _unmanagedCount == 0
   }
 }
 
@@ -976,6 +979,7 @@ extension _StringGuts {
   @_inlineable
   public // @testable
   func _extractSlice(_ range: Range<Int>) -> _StringGuts {
+    if range.isEmpty { return _StringGuts() }
     if range == 0..<count { return self }
     switch (isASCII, _isUnmanaged) {
     case (true, true):
@@ -1265,23 +1269,26 @@ extension _StringGuts {
 }
 
 extension _StringGuts {
-  public mutating func replaceSubrange<C>(
+  @_versioned
+  mutating func _replaceSubrange<C, CodeUnit>(
     _ bounds: Range<Int>,
-    with newElements: C
-  ) where C : Collection, C.Element == UTF16.CodeUnit {
+    with newElements: C,
+    of codeUnit: CodeUnit.Type
+  ) where C : Collection, C.Element == UTF16.CodeUnit,
+  CodeUnit : FixedWidthInteger & UnsignedInteger {
     _precondition(bounds.lowerBound >= 0,
       "replaceSubrange: subrange start precedes String start")
 
     let newCount: Int = numericCast(newElements.count)
     let deltaCount = newCount - bounds.count
     let paramsOpt = allocationParametersForMutableStorage(
-      of: UTF16.CodeUnit.self,
+      of: CodeUnit.self,
       unusedCapacity: Swift.max(0, deltaCount))
 
     if _fastPath(paramsOpt == nil) {
       // We have unique native storage of the correct code unit,
       // with enough capacity to do the replacement inline.
-      unowned(unsafe) let storage = _nativeStorage(of: UTF16.CodeUnit.self)
+      unowned(unsafe) let storage = _nativeStorage(of: CodeUnit.self)
       _sanityCheck(storage.unusedCapacity >= deltaCount)
       let tailCount = storage.count - bounds.upperBound
       _precondition(tailCount >= 0,
@@ -1294,10 +1301,11 @@ extension _StringGuts {
           count: tailCount)
       }
       // Copy new elements in place
-      let (_, end) = UnsafeMutableBufferPointer(
-        start: dst,
-        count: newCount).initialize(from: newElements)
-      _precondition(end == newCount, "Collection misreported its count")
+      var it = newElements.makeIterator()
+      for p in dst ..< (dst + newCount) {
+        p.pointee = CodeUnit(it.next()!)
+      }
+      _precondition(it.next() == nil, "Collection misreported its count")
       storage.count += deltaCount
       _nativeCount += deltaCount
       _invariantCheck()
@@ -1309,7 +1317,7 @@ extension _StringGuts {
     let params = paramsOpt._unsafelyUnwrappedUnchecked
     _precondition(bounds.upperBound <= params.count,
         "replaceSubrange: subrange extends past String end")
-    let storage = _SwiftStringStorage<UTF16.CodeUnit>.create(
+    let storage = _SwiftStringStorage<CodeUnit>.create(
       capacity: params.capacity,
       count: params.count + deltaCount)
     var dst = storage.start
@@ -1321,9 +1329,11 @@ extension _StringGuts {
     dst += prefixRange.count
 
     // Copy new data
-    let (_, end) = UnsafeMutableBufferPointer(
-      start: dst, count: newCount).initialize(from: newElements)
-    _precondition(end == newCount, "Collection misreported its count")
+    var it = newElements.makeIterator()
+    for p in dst ..< (dst + newCount) {
+      p.pointee = CodeUnit(it.next()!)
+    }
+    _precondition(it.next() == nil, "Collection misreported its count")
     dst += newCount
 
     // Copy suffix from end of replaced range
@@ -1335,12 +1345,58 @@ extension _StringGuts {
     self = _StringGuts(storage)
     _invariantCheck()
   }
+
+  public mutating func replaceSubrange<C>(
+    _ bounds: Range<Int>,
+    with newElements: C
+  ) where C : Collection, C.Element == UTF16.CodeUnit {
+    if isASCII && !newElements.contains(where: {$0 > 0x7f}) {
+      self._replaceSubrange(bounds, with: newElements, of: UInt8.self)
+    } else {
+      self._replaceSubrange(bounds, with: newElements, of: UTF16.CodeUnit.self)
+    }
+  }
 }
 
 //
 // String API
 //
 
+// UnicodeScalarView operations
+extension _StringGuts {
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  func _unicodeScalarWidth(startingAt offset: Int) -> Int {
+    if _slowPath(_isOpaque) {
+      return _asOpaque()._unicodeScalarWidth(startingAt: offset)
+    }
+    if isASCII { return 1 }
+    return _unmanagedUTF16View._unicodeScalarWidth(startingAt: offset)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  func _unicodeScalarWidth(endingAt offset: Int) -> Int {
+    if _slowPath(_isOpaque) {
+      return _asOpaque()._unicodeScalarWidth(endingAt: offset)
+    }
+    if isASCII { return 1 }
+    return _unmanagedUTF16View._unicodeScalarWidth(endingAt: offset)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  func _decodeUnicodeScalar(startingAt offset: Int) -> UnicodeDecodingResult {
+    if _slowPath(_isOpaque) {
+      return _asOpaque()._decodeUnicodeScalar(startingAt: offset)
+    }
+    if isASCII {
+      return _unmanagedASCIIView._decodeUnicodeScalar(startingAt: offset)
+    }
+    return _unmanagedUTF16View._decodeUnicodeScalar(startingAt: offset)
+  }
+}
+
 // Some CharacterView operations
 extension String {
   /// Accesses the character at the given position.

stdlib/public/core/StringUTF16.swift

@@ -214,29 +214,28 @@ extension String {
 
       let index = _internalIndex(at: i.encodedOffset)
       let u = _guts[index]
-      if _fastPath((u &>> 11) != 0b1101_1) {
+      if _fastPath(UTF16._isScalar(u)) {
         // Neither high-surrogate, nor low-surrogate -- well-formed sequence
         // of 1 code unit.
         return u
       }
 
-      if (u &>> 10) == 0b1101_10 {
-        // `u` is a high-surrogate.  Sequence is well-formed if it
-        // is followed by a low-surrogate.
+      if UTF16.isLeadSurrogate(u) {
+        // Sequence is well-formed if `u` is followed by a low-surrogate.
         if _fastPath(
-               index + 1 < _guts.count &&
-               (_guts[index + 1] &>> 10) == 0b1101_11) {
+          index + 1 < _guts.count &&
+          UTF16.isTrailSurrogate(_guts[index + 1])) {
           return u
         }
-        return 0xfffd
+        return UTF16._replacementCodeUnit
       }
 
       // `u` is a low-surrogate.  Sequence is well-formed if
       // previous code unit is a high-surrogate.
-      if _fastPath(index != 0 && (_guts[index - 1] &>> 10) == 0b1101_10) {
+      if _fastPath(index != 0 && UTF16.isLeadSurrogate(_guts[index - 1])) {
         return u
       }
-      return 0xfffd
+      return UTF16._replacementCodeUnit
     }
 
 #if _runtime(_ObjC)