Merge pull request swiftlang#16 from lorentey/string_guts.rebase

Cherry-pick commits lost with latest rebase

Author: milseman

stdlib/public/core/Builtin.swift

@@ -579,14 +579,6 @@ extension ManagedBufferPointer {
     self._nativeBuffer = buffer
   }
 }
-extension _StringBuffer {
-  @_inlineable
-  public // FIXME: String Guts
-  var _nativeObject: _BuiltinNativeObject {
-    @inline(__always)
-    get { return _storage._nativeBuffer }
-  }
-}
 
 /// Create a `BridgeObject` around the given `nativeObject` with the
 /// given spare bits.

stdlib/public/core/CMakeLists.txt

@@ -123,9 +123,7 @@ set(SWIFTLIB_ESSENTIAL
   StringHashable.swift  # ORDER DEPENDENCY: Must precede String.swift
   String.swift
   StringBridge.swift
-  StringBuffer.swift
   StringComparable.swift
-  StringCore.swift
   StringGuts.swift
   StringObject.swift
   StringIndex.swift

stdlib/public/core/CString.swift

@@ -195,11 +195,14 @@ internal func _decodeCString<Encoding : _UnicodeEncoding>(
 -> (result: String, repairsMade: Bool)? {
 
   let buffer = UnsafeBufferPointer<Encoding.CodeUnit>(
-    start: cString, count: length)
+    start: cString,
+    count: length)
 
-  let (stringBuffer, hadError) = _StringBuffer.fromCodeUnits(
-    buffer, encoding: encoding, repairIllFormedSequences: isRepairing)
-  return stringBuffer.map {
-    (result: String(_storage: $0), repairsMade: hadError)
+  let (guts, hadError) = _StringGuts.fromCodeUnits(
+    buffer,
+    encoding: encoding,
+    repairIllFormedSequences: isRepairing)
+  return guts.map {
+    (result: String($0), repairsMade: hadError)
   }
 }

stdlib/public/core/FixedArray.swift.gyb

@@ -37,7 +37,29 @@ internal struct _FixedArray${N}<T> {
   )
 
   @_versioned // FIXME(sil-serialize-all)
-  internal static var _arraySize : Int { return ${N} }
+  var _count: Int8
+}
+
+
+extension _FixedArray${N} {
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal static var capacity: Int {
+    @inline(__always) get { return ${N} }
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal var capacity: Int {
+    @inline(__always) get { return ${N} }
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal var count : Int {
+    @inline(__always) get { return Int(truncatingIfNeeded: _count) }
+    @inline(__always) set { _count = Int8(newValue) }
+  }
 }
 
 extension _FixedArray${N} : RandomAccessCollection, MutableCollection {
@@ -52,18 +74,17 @@ extension _FixedArray${N} : RandomAccessCollection, MutableCollection {
   @_inlineable // FIXME(sil-serialize-all)
   @_versioned // FIXME(sil-serialize-all)
   internal var endIndex : Index {
-    return _FixedArray${N}._arraySize
+    return count
   }
 
-  @_versioned // FIXME(sil-serialize-all)
-  internal var count : Int { return _FixedArray${N}._arraySize }
-
   @_inlineable // FIXME(sil-serialize-all)
   @_versioned // FIXME(sil-serialize-all)
   internal subscript(i: Index) -> T {
     @_versioned
     @inline(__always)
     get {
+      let count = self.count // for exclusive access
+      _sanityCheck(i >= 0 && i < count)
       var copy = storage
       let res: T = withUnsafeBytes(of: &copy) {
         (rawPtr : UnsafeRawBufferPointer) -> T in
@@ -79,16 +100,9 @@ extension _FixedArray${N} : RandomAccessCollection, MutableCollection {
     @_versioned
     @inline(__always)
     set {
-      let count = self.count
-      withUnsafeBytes(of: &storage) {
-        (rawPtr : UnsafeRawBufferPointer) -> () in
-        let rawPtr = UnsafeMutableRawBufferPointer(mutating: rawPtr)
-        let stride = MemoryLayout<T>.stride
-        _sanityCheck(rawPtr.count == ${N}*stride, "layout mismatch?")
-        let bufPtr = UnsafeMutableBufferPointer(
-          start: rawPtr.baseAddress!.assumingMemoryBound(to: T.self),
-          count: count)
-        bufPtr[i] = newValue
+      _sanityCheck(i >= 0 && i < count)
+      self.withUnsafeMutableBufferPointer { buffer in
+        buffer[i] = newValue
       }
     }
   }
@@ -106,22 +120,45 @@ extension _FixedArray${N} : RandomAccessCollection, MutableCollection {
   internal func index(before i: Index) -> Index {
     return i-1
   }
+}
 
-  // TODO: Any customization hooks it's profitable to override, e.g. append?
-
+extension _FixedArray${N} {
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned
+  internal mutating func append(_ newElement: T) {
+    _sanityCheck(count < capacity)
+    self[count] = newElement
+    _count += 1
+  }
 }
 
 extension _FixedArray${N} where T : ExpressibleByIntegerLiteral {
   @_inlineable // FIXME(sil-serialize-all)
   @_versioned // FIXME(sil-serialize-all)
   @inline(__always)
-  internal init(allZeros: ()) {
+  internal init(count: Int) {
+    _sanityCheck(count >= 0 && count <= _FixedArray${N}.capacity)
     self.storage = (
 % for i in range(0, N-1):
     0,
 % end
     0
     )
+    self._count = Int8(truncatingIfNeeded: count)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  @inline(__always)
+  internal init() {
+    self.init(count: 0)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  @inline(__always)
+  internal init(allZeros: ()) {
+    self.init(count: ${N})
   }
 }
 
@@ -131,8 +168,10 @@ extension _FixedArray${N} {
   internal mutating func withUnsafeMutableBufferPointer<R>(
     _ body: (UnsafeMutableBufferPointer<Element>) throws -> R
   ) rethrows -> R {
-    let count = self.count
+    let count = self.count // for exclusive access
     return try withUnsafeMutableBytes(of: &storage) { rawBuffer in
+      _sanityCheck(rawBuffer.count == ${N}*MemoryLayout<T>.stride,
+        "layout mismatch?")
       let buffer = UnsafeMutableBufferPointer<Element>(
         start: rawBuffer.baseAddress._unsafelyUnwrappedUnchecked
           .assumingMemoryBound(to: Element.self),
@@ -146,8 +185,10 @@ extension _FixedArray${N} {
   internal mutating func withUnsafeBufferPointer<R>(
     _ body: (UnsafeBufferPointer<Element>) throws -> R
   ) rethrows -> R {
-    let count = self.count
+    let count = self.count // for exclusive access
     return try withUnsafeBytes(of: &storage) { rawBuffer in
+      _sanityCheck(rawBuffer.count == ${N}*MemoryLayout<T>.stride,
+        "layout mismatch?")
       let buffer = UnsafeBufferPointer<Element>(
         start: rawBuffer.baseAddress._unsafelyUnwrappedUnchecked
         .assumingMemoryBound(to: Element.self),

stdlib/public/core/GroupInfo.json

@@ -12,10 +12,8 @@
     "StaticString.swift",
     "String.swift",
     "StringBridge.swift",
-    "StringBuffer.swift",
     "StringCharacterView.swift",
     "StringComparable.swift",
-    "StringCore.swift",
     "StringObject.swift",
     "StringGuts.swift",
     "StringGraphemeBreaking.swift",  

stdlib/public/core/String.swift

@@ -784,12 +784,6 @@ public struct String {
   init(_ _guts: _StringGuts) {
     self._guts = _guts
   }
-
-  public // @testable
-  var _core: _LegacyStringCore {
-    get { return _guts._legacyCore }
-    set { self._guts = _StringGuts(newValue) }
-  }
 }
 
 extension String {
@@ -1048,28 +1042,6 @@ extension String {
     Builtin.unreachable()
   }
 
-  @_inlineable // FIXME(sil-serialize-all)
-  public // SPI(Foundation)
-  init(_storage: _StringBuffer) { // FIXME: Replace with _SwiftStringStorage
-    if _storage.elementWidth == 1 {
-      let native = _SwiftStringStorage<UInt8>.create(
-        capacity: _storage.capacity,
-        count: _storage.usedCount)
-      native.start.initialize(
-        from: _storage.start.assumingMemoryBound(to: UInt8.self),
-        count: _storage.usedCount)
-      _guts = _StringGuts(native)
-    } else {
-      let native = _SwiftStringStorage<UInt16>.create(
-        capacity: _storage.capacity,
-        count: _storage.usedCount)
-      native.start.initialize(
-        from: _storage.start.assumingMemoryBound(to: UInt16.self),
-        count: _storage.usedCount)
-      _guts = _StringGuts(native)
-    }
-  }
-
   @_inlineable // FIXME(sil-serialize-all)
   public
   init<CodeUnit>(_storage: _SwiftStringStorage<CodeUnit>)
@@ -1281,7 +1253,7 @@ internal func _nativeUnicodeUppercaseString(_ str: String) -> String {
       dest, Int32(utf16.count), // FIXME: handle overflow case
       utf16.start, Int32(utf16.count))
   }
-  return String(_storage: buffer)
+  return String(_storage: storage)
 }
 #endif
 

stdlib/public/core/StringBridge.swift

@@ -48,29 +48,6 @@ func _stdlib_binary_CFStringGetCharactersPtr(
 /// Loading Foundation initializes these function variables
 /// with useful values
 
-/// Produces a `_StringBuffer` from a given subrange of a source
-/// `_CocoaString`, having the given minimum capacity.
-@_versioned // FIXME(sil-serialize-all)
-@inline(never) // Hide the CF dependency
-internal func _cocoaStringToContiguous(
-  source: _CocoaString, range: Range<Int>, minimumCapacity: Int
-) -> _StringBuffer {
-  _sanityCheck(_swift_stdlib_CFStringGetCharactersPtr(source) == nil,
-    "Known contiguously stored strings should already be converted to Swift")
-
-  let startIndex = range.lowerBound
-  let count = range.upperBound - startIndex
-
-  let buffer = _StringBuffer(capacity: max(count, minimumCapacity), 
-                             initialSize: count, elementWidth: 2)
-
-  _swift_stdlib_CFStringGetCharacters(
-    source, _swift_shims_CFRange(location: startIndex, length: count), 
-    buffer.start.assumingMemoryBound(to: _swift_shims_UniChar.self))
-  
-  return buffer
-}
-
 /// Copies the entire contents of a _CocoaString into contiguous
 /// storage of sufficient capacity.
 @_versioned // FIXME(sil-serialize-all)
@@ -193,40 +170,6 @@ func _makeCocoaStringGuts(_ cocoaString: _CocoaString) -> _StringGuts {
     start: start)
 }
 
-@inline(never) // Hide the CF dependency
-internal
-func makeCocoaLegacyStringCore(_cocoaString: AnyObject) -> _LegacyStringCore {
-  if let wrapped = _cocoaString as? _NSContiguousString {
-    return wrapped._core
-  }
-
-  // "copy" it into a value to be sure nobody will modify behind
-  // our backs.  In practice, when value is already immutable, this
-  // just does a retain.
-  let cfImmutableValue
-    = _stdlib_binary_CFStringCreateCopy(_cocoaString) as AnyObject
-
-  let length = _swift_stdlib_CFStringGetLength(cfImmutableValue)
-
-  // Look first for null-terminated ASCII
-  // Note: the code in clownfish appears to guarantee
-  // nul-termination, but I'm waiting for an answer from Chris Kane
-  // about whether we can count on it for all time or not.
-  let nulTerminatedASCII = _swift_stdlib_CFStringGetCStringPtr(
-    cfImmutableValue, kCFStringEncodingASCII)
-
-  // start will hold the base pointer of contiguous storage, if it
-  // is found.
-  let (start, isUTF16) = _getCocoaStringPointer(cfImmutableValue)
-
-  return _LegacyStringCore(
-    baseAddress: UnsafeMutableRawPointer(mutating: start),
-    count: length,
-    elementShift: isUTF16 ? 1 : 0,
-    hasCocoaBuffer: true,
-    owner: cfImmutableValue)
-}
-
 extension String {
   public // SPI(Foundation)
   init(_cocoaString: AnyObject) {
@@ -405,11 +348,6 @@ public final class _NSContiguousString : _SwiftNativeNSString, _NSStringCore {
     }
     return try body(selfAsPointer, rhsAsPointer)
   }
-
-  public // @testable
-  var _core: _LegacyStringCore {
-    return _guts._legacyCore
-  }
 }
 
 extension String {