stdlib: change Collection._copyToNativeArrayBuffer() to be defined in terms of public types

Author: gribozavr

stdlib/private/StdlibCollectionUnittest/LoggingWrappers.swift.gyb

@@ -89,7 +89,7 @@ public class SequenceLog {
   public static var split = TypeIndexed(0)
   public static var _customContainsEquatableElement = TypeIndexed(0)
   public static var _preprocessingPass = TypeIndexed(0)
-  public static var _copyToNativeArrayBuffer = TypeIndexed(0)
+  public static var _copyToContiguousArray = TypeIndexed(0)
   public static var _copyContents = TypeIndexed(0)
 }
 
@@ -302,10 +302,10 @@ public struct ${Self}<
 
   /// Create a native array buffer containing the elements of `self`,
   /// in the same order.
-  public func _copyToNativeArrayBuffer()
-    -> _ContiguousArrayBuffer<Base.Iterator.Element> {
-    Log._copyToNativeArrayBuffer[selfType] += 1
-    return base._copyToNativeArrayBuffer()
+  public func _copyToContiguousArray()
+    -> ContiguousArray<Base.Iterator.Element> {
+    Log._copyToContiguousArray[selfType] += 1
+    return base._copyToContiguousArray()
   }
 
   /// Copy a Sequence into an array.

stdlib/public/core/Arrays.swift.gyb

@@ -936,7 +936,7 @@ extension ${Self} : ArrayLiteralConvertible {
   ///
   /// - Parameter elements: A variadic list of elements of the new array.
   public init(arrayLiteral elements: Element...) {
-    self.init(_buffer: _extractOrCopyToNativeArrayBuffer(elements._buffer))
+    self.init(_buffer: _extractOrCopyToContiguousArray(elements._buffer)._buffer)
   }
 %end
 }
@@ -1037,7 +1037,8 @@ extension ${Self} : RangeReplaceableCollection, _ArrayProtocol {
   public init<S : Sequence>(_ s: S)
     where S.Iterator.Element == Element {
 
-    self = ${Self}(_buffer: _Buffer(s._copyToNativeArrayBuffer(),
+    self = ${Self}(
+      _buffer: _Buffer(s._copyToContiguousArray()._buffer,
       shiftedToStartIndex: 0))
   }
 
@@ -1426,8 +1427,8 @@ extension ${Self} : RangeReplaceableCollection, _ArrayProtocol {
     }
   }
 
-  public func _copyToNativeArrayBuffer() -> _ContiguousArrayBuffer<Element> {
-    return _extractOrCopyToNativeArrayBuffer(self._buffer)
+  public func _copyToContiguousArray() -> ContiguousArray<Element> {
+    return _extractOrCopyToContiguousArray(self._buffer)
   }
 }
 
@@ -1976,18 +1977,27 @@ internal func _arrayReserve<_Buffer>(
   _arrayOutOfPlaceUpdate(&buffer, &newBuffer, count, 0, _IgnorePointer())
 }
 
-public // SPI(Foundation)
-func _extractOrCopyToNativeArrayBuffer<Buffer>(
+internal func _extractOrCopyToContiguousArray<Buffer>(
   _ source: Buffer
-) -> _ContiguousArrayBuffer<Buffer.Iterator.Element>
+) -> ContiguousArray<Buffer.Iterator.Element>
   where
   Buffer : _ArrayBufferProtocol,
   Buffer.Iterator.Element == Buffer.Element {
 
   if let n = source.requestNativeBuffer() {
-    return n
+    return ContiguousArray(_buffer: n)
   }
-  return _copyCollectionToNativeArrayBuffer(source)
+  return _copyCollectionToContiguousArray(source)
+}
+
+internal func _extractOrCopyToNativeArrayBuffer<Buffer>(
+  _ source: Buffer
+) -> _ContiguousArrayBuffer<Buffer.Iterator.Element>
+  where
+  Buffer : _ArrayBufferProtocol,
+  Buffer.Iterator.Element == Buffer.Element {
+
+  return _extractOrCopyToContiguousArray(source)._buffer
 }
 
 /// Append items from `newItems` to `buffer`.

stdlib/public/core/ContiguousArrayBuffer.swift

@@ -183,7 +183,8 @@ final class _ContiguousArrayStorage<Element> : _ContiguousArrayStorage1 {
 }
 
 @_fixed_layout
-public struct _ContiguousArrayBuffer<Element> : _ArrayBufferProtocol {
+public // @testable
+struct _ContiguousArrayBuffer<Element> : _ArrayBufferProtocol {
 
   /// Make a buffer with uninitialized elements.  After using this
   /// method, you must either initialize the `count` elements at the
@@ -539,15 +540,14 @@ extension _ContiguousArrayBuffer : RandomAccessCollection {
 }
 
 extension Sequence {
-  public func _copyToNativeArrayBuffer()
-    -> _ContiguousArrayBuffer<Iterator.Element> {
-    return _copySequenceToNativeArrayBuffer(self)
+  public func _copyToContiguousArray() -> ContiguousArray<Iterator.Element> {
+    return _copySequenceToContiguousArray(self)
   }
 }
 
-internal func _copySequenceToNativeArrayBuffer<
+internal func _copySequenceToContiguousArray<
   S : Sequence
->(_ source: S) -> _ContiguousArrayBuffer<S.Iterator.Element> {
+>(_ source: S) -> ContiguousArray<S.Iterator.Element> {
   let initialCapacity = source.underestimatedCount
   var builder =
     _UnsafePartiallyInitializedContiguousArrayBuffer<S.Iterator.Element>(
@@ -571,33 +571,32 @@ internal func _copySequenceToNativeArrayBuffer<
 }
 
 extension Collection {
-  public func _copyToNativeArrayBuffer(
-  ) -> _ContiguousArrayBuffer<Iterator.Element> {
-    return _copyCollectionToNativeArrayBuffer(self)
+  public func _copyToContiguousArray() -> ContiguousArray<Iterator.Element> {
+    return _copyCollectionToContiguousArray(self)
   }
 }
 
 extension _ContiguousArrayBuffer {
-  public func _copyToNativeArrayBuffer() -> _ContiguousArrayBuffer<Element> {
-    return self
+  public func _copyToContiguousArray() -> ContiguousArray<Element> {
+    return ContiguousArray(_buffer: self)
   }
 }
 
-/// This is a fast implementation of _copyToNativeArrayBuffer() for collections.
+/// This is a fast implementation of _copyToContiguousArray() for collections.
 ///
 /// It avoids the extra retain, release overhead from storing the
 /// ContiguousArrayBuffer into
 /// _UnsafePartiallyInitializedContiguousArrayBuffer. Since we do not support
 /// ARC loops, the extra retain, release overhead cannot be eliminated which
 /// makes assigning ranges very slow. Once this has been implemented, this code
 /// should be changed to use _UnsafePartiallyInitializedContiguousArrayBuffer.
-internal func _copyCollectionToNativeArrayBuffer<
+internal func _copyCollectionToContiguousArray<
   C : Collection
->(_ source: C) -> _ContiguousArrayBuffer<C.Iterator.Element>
+>(_ source: C) -> ContiguousArray<C.Iterator.Element>
 {
   let count: Int = numericCast(source.count)
   if count == 0 {
-    return _ContiguousArrayBuffer()
+    return ContiguousArray()
   }
 
   let result = _ContiguousArrayBuffer<C.Iterator.Element>(
@@ -613,7 +612,7 @@ internal func _copyCollectionToNativeArrayBuffer<
     p += 1
   }
   _expectEnd(i, source)
-  return result
+  return ContiguousArray(_buffer: result)
 }
 
 /// A "builder" interface for initializing array buffers.
@@ -678,7 +677,7 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
   /// Returns the fully-initialized buffer. `self` is reset to contain an
   /// empty buffer and cannot be used afterward.
   @inline(__always) // For performance reasons.
-  mutating func finish() -> _ContiguousArrayBuffer<Element> {
+  mutating func finish() -> ContiguousArray<Element> {
     // Adjust the initialized count of the buffer.
     result.count = result.capacity - remainingCapacity
 
@@ -692,12 +691,12 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
   /// Returns the fully-initialized buffer. `self` is reset to contain an
   /// empty buffer and cannot be used afterward.
   @inline(__always) // For performance reasons.
-  mutating func finishWithOriginalCount() -> _ContiguousArrayBuffer<Element> {
+  mutating func finishWithOriginalCount() -> ContiguousArray<Element> {
     _sanityCheck(remainingCapacity == result.capacity - result.count,
       "_UnsafePartiallyInitializedContiguousArrayBuffer has incorrect count")
     var finalResult = _ContiguousArrayBuffer<Element>()
     swap(&finalResult, &result)
     remainingCapacity = 0
-    return finalResult
+    return ContiguousArray(_buffer: finalResult)
   }
 }

stdlib/public/core/ExistentialCollection.swift.gyb

@@ -174,7 +174,7 @@ internal class _AnyRandomAccessCollectionBox<Element>
     _abstract()
   }
 
-  internal func __copyToNativeArrayBuffer() -> _ContiguousArrayStorageBase {
+  internal func __copyToContiguousArray() -> ContiguousArray<Element> {
     _abstract()
   }
 
@@ -358,8 +358,8 @@ internal final class _${Kind}Box<S : ${Kind}> : _Any${Kind}Box<S.Iterator.Elemen
   ) rethrows -> R? {
     return try _base._preprocessingPass(preprocess)
   }
-  internal override func __copyToNativeArrayBuffer() -> _ContiguousArrayStorageBase {
-    return _base._copyToNativeArrayBuffer()._storage
+  internal override func __copyToContiguousArray() -> ContiguousArray<Element> {
+    return _base._copyToContiguousArray()
   }
   internal override func __copyContents(initializing ptr: UnsafeMutablePointer<Element>)
     -> UnsafeMutablePointer<Element> {
@@ -627,8 +627,8 @@ extension Any${Kind} {
     return try _box.__preprocessingPass(preprocess)
   }
 
-  public func _copyToNativeArrayBuffer() -> _ContiguousArrayBuffer<Element> {
-    return _ContiguousArrayBuffer(self._box.__copyToNativeArrayBuffer())
+  public func _copyToContiguousArray() -> ContiguousArray<Element> {
+    return self._box.__copyToContiguousArray()
   }
 
   public func _copyContents(initializing ptr: UnsafeMutablePointer<Element>)

stdlib/public/core/Flatten.swift.gyb

@@ -336,14 +336,14 @@ public struct ${Collection}<Base> : ${collectionForTraversal(traversal)}
   // just return zero.
   public var underestimatedCount: Int { return 0 }
 
-  public func _copyToNativeArrayBuffer()
-    -> _ContiguousArrayBuffer<Base.Iterator.Element.Iterator.Element> {
+  public func _copyToContiguousArray()
+    -> ContiguousArray<Base.Iterator.Element.Iterator.Element> {
 
-    // The default implementation of `_copyToNativeArrayBuffer` queries the
+    // The default implementation of `_copyToContiguousArray` queries the
     // `count` property, which materializes every inner collection.  This is a
     // bad default for `flatMap()`.  So we treat `self` as a sequence and only
     // rely on underestimated count.
-    return _copySequenceToNativeArrayBuffer(self)
+    return _copySequenceToContiguousArray(self)
   }
 
   // TODO: swift-3-indexing-model - add docs

stdlib/public/core/Join.swift

@@ -110,8 +110,8 @@ public struct JoinedSequence<Base : Sequence> : Sequence
       separator: _separator)
   }
 
-  public func _copyToNativeArrayBuffer()
-    -> _ContiguousArrayBuffer<Base.Iterator.Element.Iterator.Element> {
+  public func _copyToContiguousArray()
+    -> ContiguousArray<Base.Iterator.Element.Iterator.Element> {
     var result = ContiguousArray<Iterator.Element>()
     let separatorSize: Int = numericCast(_separator.count)
 
@@ -132,7 +132,7 @@ public struct JoinedSequence<Base : Sequence> : Sequence
       for x in _base {
         result.append(contentsOf: x)
       }
-      return result._buffer
+      return result
     }
 
     var iter = _base.makeIterator()
@@ -144,7 +144,7 @@ public struct JoinedSequence<Base : Sequence> : Sequence
       }
     }
 
-    return result._buffer
+    return result
   }
 
   internal var _base: Base

stdlib/public/core/LazyCollection.swift.gyb

@@ -89,9 +89,9 @@ extension ${Self} : Sequence {
   /// - Complexity: O(N).
   public var underestimatedCount: Int { return _base.underestimatedCount }
 
-  public func _copyToNativeArrayBuffer() 
-     -> _ContiguousArrayBuffer<Base.Iterator.Element> {
-    return _base._copyToNativeArrayBuffer()
+  public func _copyToContiguousArray()
+     -> ContiguousArray<Base.Iterator.Element> {
+    return _base._copyToContiguousArray()
   }
 
   @discardableResult

stdlib/public/core/Sequence.swift

@@ -584,7 +584,7 @@ public protocol Sequence {
 
   /// Create a native array buffer containing the elements of `self`,
   /// in the same order.
-  func _copyToNativeArrayBuffer() -> _ContiguousArrayBuffer<Iterator.Element>
+  func _copyToContiguousArray() -> ContiguousArray<Iterator.Element>
 
   /// Copy a Sequence into an array, returning one past the last
   /// element initialized.

stdlib/public/core/SequenceWrapper.swift

@@ -110,9 +110,9 @@ extension Sequence
 
   /// Create a native array buffer containing the elements of `self`,
   /// in the same order.
-  public func _copyToNativeArrayBuffer()
-    -> _ContiguousArrayBuffer<Base.Iterator.Element> {
-    return _base._copyToNativeArrayBuffer()
+  public func _copyToContiguousArray()
+    -> ContiguousArray<Base.Iterator.Element> {
+    return _base._copyToContiguousArray()
   }
 
   /// Copy a Sequence into an array, returning one past the last

stdlib/public/core/SliceBuffer.swift

@@ -327,11 +327,11 @@ struct _SliceBuffer<Element> : _ArrayBufferProtocol, RandomAccessCollection {
 }
 
 extension _SliceBuffer {
-  public func _copyToNativeArrayBuffer() -> _ContiguousArrayBuffer<Element> {
+  public func _copyToContiguousArray() -> ContiguousArray<Element> {
     if _hasNativeBuffer {
       let n = nativeBuffer
       if count == n.count {
-        return n
+        return ContiguousArray(_buffer: n)
       }
     }
 
@@ -340,6 +340,6 @@ extension _SliceBuffer {
       minimumCapacity: 0)
     result.firstElementAddress.initializeFrom(
       firstElementAddress, count: count)
-    return result
+    return ContiguousArray(_buffer: result)
   }
 }

validation-test/stdlib/Arrays.swift.gyb

@@ -6,34 +6,34 @@ import StdlibCollectionUnittest
 
 let CopyToNativeArrayBufferTests = TestSuite("CopyToNativeArrayBufferTests")
 
-CopyToNativeArrayBufferTests.test("Sequence._copyToNativeArrayBuffer()") {
+CopyToNativeArrayBufferTests.test("Sequence._copyToContiguousArray()") {
   do {
     // Call from a static context.
     let s =
       MinimalSequence(elements: LifetimeTracked(10)..<LifetimeTracked(27))
 
     expectEqual(0, s.timesMakeIteratorCalled.value)
-    let buffer = s._copyToNativeArrayBuffer()
+    let copy = s._copyToContiguousArray()
     expectEqual(1, s.timesMakeIteratorCalled.value)
     expectEqualSequence(
       Array(10..<27),
-      buffer.map { $0.value })
+      copy.map { $0.value })
   }
   do {
     // Call from a generic context.
     let wrapped = MinimalSequence(elements: LifetimeTracked(10)..<LifetimeTracked(27))
     let s = LoggingSequence(wrapping: wrapped)
 
     expectEqual(0, wrapped.timesMakeIteratorCalled.value)
-    let buffer = s._copyToNativeArrayBuffer()
+    let copy = s._copyToContiguousArray()
     expectEqual(1, wrapped.timesMakeIteratorCalled.value)
     expectEqualSequence(
       Array(10..<27),
-      buffer.map { $0.value })
+      copy.map { $0.value })
   }
 }
 
-CopyToNativeArrayBufferTests.test("Collection._copyToNativeArrayBuffer()") {
+CopyToNativeArrayBufferTests.test("Collection._copyToContiguousArray()") {
   // Check that collections are handled with the collection-specific API.  This
   // means that we are calling the right default implementation (one for
   // collections, not the one for sequences).
@@ -45,12 +45,12 @@ CopyToNativeArrayBufferTests.test("Collection._copyToNativeArrayBuffer()") {
 
     expectEqual(0, c.timesMakeIteratorCalled.value)
     expectEqual(0, c.timesStartIndexCalled.value)
-    let buffer = c._copyToNativeArrayBuffer()
+    let copy = c._copyToContiguousArray()
     expectEqual(0, c.timesMakeIteratorCalled.value)
     expectNotEqual(0, c.timesStartIndexCalled.value)
     expectEqualSequence(
       Array(10..<27),
-      buffer.map { $0.value })
+      copy.map { $0.value })
   }
   do {
     // Call from a generic context.
@@ -59,13 +59,13 @@ CopyToNativeArrayBufferTests.test("Collection._copyToNativeArrayBuffer()") {
     let s = LoggingSequence(wrapping: wrapped)
     expectEqual(0, wrapped.timesMakeIteratorCalled.value)
     expectEqual(0, wrapped.timesStartIndexCalled.value)
-    let buffer = s._copyToNativeArrayBuffer()
+    let copy = s._copyToContiguousArray()
     expectEqual(0, wrapped.timesMakeIteratorCalled.value)
     expectNotEqual(0, wrapped.timesStartIndexCalled.value)
 
     expectEqualSequence(
       Array(10..<27),
-      buffer.map { $0.value })
+      copy.map { $0.value })
   }
 }