FixedArray: Implement append & working count

Author: lorentey

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/StringGraphemeBreaking.swift

@@ -273,17 +273,15 @@ extension _UnmanagedOpaqueString {
 
     // Pull out some code units into a fixed array and try to perform grapheme
     // breaking on that.
-    var shortBuffer = _FixedArray16<UInt16>(allZeros:())
-    let maxShortCount = shortBuffer.count
-    let shortCount = Swift.min(maxShortCount, count)
+    typealias ShortBuffer = _FixedArray16<UInt16>
+    var shortBuffer = ShortBuffer(count: Swift.min(ShortBuffer.capacity, count))
     shortBuffer.withUnsafeMutableBufferPointer { buffer in
-      self.prefix(shortCount)._copy(into: buffer)
+      self.prefix(buffer.count)._copy(into: buffer)
     }
     let shortLength = shortBuffer.withUnsafeBufferPointer { buffer in
-      UTF16._measureFirstExtendedGraphemeCluster(
-        in: UnsafeBufferPointer(rebasing: buffer.prefix(shortCount)))
+      UTF16._measureFirstExtendedGraphemeCluster(in: buffer)
     }
-    if _fastPath(shortLength < maxShortCount) {
+    if _fastPath(shortLength < shortBuffer.capacity) {
       return shortLength
     }
 
@@ -302,17 +300,15 @@ extension _UnmanagedOpaqueString {
 
     // Pull out some code units into a fixed array and try to perform grapheme
     // breaking on that.
-    var shortBuffer = _FixedArray16<UInt16>(allZeros:())
-    let maxShortCount = shortBuffer.count
-    let shortCount = Swift.min(maxShortCount, count)
+    typealias ShortBuffer = _FixedArray16<UInt16>
+    var shortBuffer = ShortBuffer(count: Swift.min(ShortBuffer.capacity, count))
     shortBuffer.withUnsafeMutableBufferPointer { buffer in
-      self.suffix(shortCount)._copy(into: buffer)
+      self.suffix(buffer.count)._copy(into: buffer)
     }
     let shortLength = shortBuffer.withUnsafeBufferPointer { buffer in
-      UTF16._measureLastExtendedGraphemeCluster(
-        in: UnsafeBufferPointer(rebasing: buffer.prefix(shortCount)))
+      UTF16._measureLastExtendedGraphemeCluster(in: buffer)
     }
-    if _fastPath(shortLength < maxShortCount) {
+    if _fastPath(shortLength < shortBuffer.capacity) {
       return shortLength
     }
 

stdlib/public/core/UnmanagedOpaqueString.swift

@@ -73,14 +73,11 @@ extension _UnmanagedOpaqueString : Sequence {
     internal var _nextIndex: Int
 
     @_versioned
-    internal var _buffer = _FixedArray16<Element>(allZeros: ())
+    internal var _buffer = _FixedArray16<Element>()
 
     @_versioned
     internal var _bufferIndex: Int8 = 0
 
-    @_versioned
-    internal var _bufferCount: Int8 = 0
-
     @_inlineable
     @_versioned
     init(_ string: _UnmanagedOpaqueString, startingAt start: Int) {
@@ -93,7 +90,7 @@ extension _UnmanagedOpaqueString : Sequence {
     @_versioned
     @inline(__always)
     mutating func next() -> Element? {
-      if _fastPath(_bufferIndex < _bufferCount) {
+      if _fastPath(_bufferIndex < _buffer.count) {
         let result = _buffer[Int(_bufferIndex)]
         _bufferIndex += 1
         return result
@@ -106,20 +103,18 @@ extension _UnmanagedOpaqueString : Sequence {
     @_versioned
     mutating func _nextOnSlowPath() -> Element {
       // Fill buffer
-      _sanityCheck(Element.self == UTF16.CodeUnit.self)
       _sanityCheck(_nextIndex < _endIndex)
-      let capacity = _buffer.count
-      let end = Swift.min(_nextIndex + capacity, _endIndex)
+      let end = Swift.min(_nextIndex + _buffer.capacity, _endIndex)
       unowned(unsafe) let object = _object
-      withUnsafeMutableBytes(of: &_buffer.storage) { b in
-        _sanityCheck(b.count == MemoryLayout<Element>.stride * capacity)
+      _buffer.count = end - _nextIndex
+      _buffer.withUnsafeMutableBufferPointer { b in
+        _sanityCheck(b.count == end - _nextIndex)
         _cocoaStringCopyCharacters(
           from: object,
           range: _nextIndex..<end,
-          into: b.baseAddress!.assumingMemoryBound(to: UTF16.CodeUnit.self))
+          into: b.baseAddress!)
       }
       _bufferIndex = 1
-      _bufferCount = Int8(end - _nextIndex)
       _nextIndex = end
       _fixLifetime(_object)
       return _buffer[0]