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

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: ContiguousArray(elements)._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,11 @@ extension ${Self} : RangeReplaceableCollection, _ArrayProtocol {
     }
   }
 
-  public func _copyToNativeArrayBuffer() -> _ContiguousArrayBuffer<Element> {
-    return _extractOrCopyToNativeArrayBuffer(self._buffer)
+  public func _copyToContiguousArray() -> ContiguousArray<Element> {
+    if let n = _buffer.requestNativeBuffer() {
+      return ContiguousArray(_buffer: n)
+    }
+    return _copyCollectionToContiguousArray(_buffer)
   }
 }
 
@@ -1487,10 +1491,9 @@ extension ${Self} {
     if _fastPath(p != nil || isEmpty) {
       return (_owner, UnsafePointer(p))
     }
-    let n = _extractOrCopyToNativeArrayBuffer(self._buffer)
+    let n = ContiguousArray(self._buffer)._buffer
     return (n.owner, UnsafePointer(n.firstElementAddress))
   }
-
 }
 
 extension ${Self} {
@@ -1976,20 +1979,6 @@ internal func _arrayReserve<_Buffer>(
   _arrayOutOfPlaceUpdate(&buffer, &newBuffer, count, 0, _IgnorePointer())
 }
 
-public // SPI(Foundation)
-func _extractOrCopyToNativeArrayBuffer<Buffer>(
-  _ source: Buffer
-) -> _ContiguousArrayBuffer<Buffer.Iterator.Element>
-  where
-  Buffer : _ArrayBufferProtocol,
-  Buffer.Iterator.Element == Buffer.Element {
-
-  if let n = source.requestNativeBuffer() {
-    return n
-  }
-  return _copyCollectionToNativeArrayBuffer(source)
-}
-
 /// Append items from `newItems` to `buffer`.
 internal func _arrayAppendSequence<Buffer, S>(
   _ buffer: inout Buffer, _ newItems: S

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)
   }
 }