Fix performance of array initialization from a generic sequence.

This fixes a major perform bug involving array initialization from any
contiguously stored collection.	 This is not a recent regression. This fix
results in a 10,000X speedup (that's 4 zeros) for this code path:

func initializeFromSlice(_ a: [Int]) -> [Int] {
  return Array<Int>(a[...])
}

A benchmark is included.

Author: atrick

Diff for: benchmark/single-source/ArrayOfGenericPOD.swift

@@ -20,12 +20,21 @@
 
 import TestsUtils
 
-public let ArrayOfGenericPOD = BenchmarkInfo(
-  // Renamed benchmark to "2" when IUO test was removed, which
-  // effectively changed what we're benchmarking here.
-  name: "ArrayOfGenericPOD2",
-  runFunction: run_ArrayOfGenericPOD,
-  tags: [.validation, .api, .Array])
+public let ArrayOfGenericPOD = [
+  BenchmarkInfo(
+    // Renamed benchmark to "2" when IUO test was removed, which
+    // effectively changed what we're benchmarking here.
+    name: "ArrayOfGenericPOD2",
+    runFunction: run_ArrayOfGenericPOD,
+    tags: [.validation, .api, .Array]),
+
+  // Initialize an array of generic POD from a slice.
+  // This takes a unique path through stdlib customization points.
+  BenchmarkInfo(
+    name: "ArrayInitFromSlice",
+    runFunction: run_initFromSlice,
+    tags: [.validation, .api, .Array], setUpFunction: createArrayOfPOD)
+]
 
 class RefArray<T> {
   var array: [T]
@@ -64,3 +73,29 @@ public func run_ArrayOfGenericPOD(_ N: Int) {
     genStructArray()
   }
 }
+
+// --- ArrayInitFromSlice
+
+var globalArray = Array<UInt8>(repeating: 0, count: 4096)
+
+func createArrayOfPOD() {
+  blackHole(globalArray)
+}
+
+@inline(never)
+@_optimize(none)
+func copyElements<S: Sequence>(_ contents: S) -> [UInt8]
+  where S.Iterator.Element == UInt8
+{
+  return [UInt8](contents)
+}
+
+@inline(never)
+public func run_initFromSlice(_ N: Int) {
+  for _ in 0..<N {
+    for _ in 0..<1000 {
+      // Slice off at least one element so the array buffer can't be reused.
+      blackHole(copyElements(globalArray[0..<4095]))
+    }
+  }
+}

Diff for: stdlib/public/core/Array.swift

@@ -1306,7 +1306,7 @@ extension Array: RangeReplaceableCollection {
     if let n = _buffer.requestNativeBuffer() {
       return ContiguousArray(_buffer: n)
     }
-    return _copyCollectionToContiguousArray(_buffer)
+    return _copyCollectionToContiguousArray(self)
   }
 }
 

Diff for: stdlib/public/core/ArrayBuffer.swift

@@ -223,6 +223,14 @@ extension _ArrayBuffer {
     return UnsafeMutableRawPointer(result).assumingMemoryBound(to: Element.self)
   }
 
+  public __consuming func _copyContents(
+    initializing buffer: UnsafeMutableBufferPointer<Element>
+  ) -> (Iterator,UnsafeMutableBufferPointer<Element>.Index) {
+    // This customization point is not implemented for internal types.
+    // Accidentally calling it would be a catastrophic performance bug.
+    fatalError("unsupported")
+  }
+
   /// Returns a `_SliceBuffer` containing the given sub-range of elements in
   /// `bounds` from this buffer.
   @inlinable

Diff for: stdlib/public/core/ArraySlice.swift

@@ -668,10 +668,7 @@ extension ArraySlice: RangeReplaceableCollection {
   public init<S: Sequence>(_ s: S)
     where S.Element == Element {
 
-    self = ArraySlice(
-      _buffer: _Buffer(
-        _buffer: s._copyToContiguousArray()._buffer,
-        shiftedToStartIndex: 0))
+    self.init(_buffer: s._copyToContiguousArray()._buffer)
   }
 
   /// Creates a new array containing the specified number of a single, repeated
@@ -1100,7 +1097,7 @@ extension ArraySlice: RangeReplaceableCollection {
     if let n = _buffer.requestNativeBuffer() {
       return ContiguousArray(_buffer: n)
     }
-    return _copyCollectionToContiguousArray(_buffer)
+    return _copyCollectionToContiguousArray(self)
   }
 }
 

Diff for: stdlib/public/core/ContiguousArray.swift

@@ -520,10 +520,7 @@ extension ContiguousArray: RangeReplaceableCollection {
   /// - Parameter s: The sequence of elements to turn into an array.
   @inlinable
   public init<S: Sequence>(_ s: S) where S.Element == Element {
-    self = ContiguousArray(
-      _buffer: _Buffer(
-        _buffer: s._copyToContiguousArray()._buffer,
-        shiftedToStartIndex: 0))
+    self.init(_buffer: s._copyToContiguousArray()._buffer)
   }
 
   /// Creates a new array containing the specified number of a single, repeated
@@ -948,7 +945,7 @@ extension ContiguousArray: RangeReplaceableCollection {
     if let n = _buffer.requestNativeBuffer() {
       return ContiguousArray(_buffer: n)
     }
-    return _copyCollectionToContiguousArray(_buffer)
+    return _copyCollectionToContiguousArray(self)
   }
 }
 

Diff for: stdlib/public/core/ContiguousArrayBuffer.swift

@@ -398,6 +398,14 @@ internal struct _ContiguousArrayBuffer<Element> : _ArrayBufferProtocol {
     return target + initializedCount
   }
 
+  public __consuming func _copyContents(
+    initializing buffer: UnsafeMutableBufferPointer<Element>
+  ) -> (Iterator,UnsafeMutableBufferPointer<Element>.Index) {
+    // This customization point is not implemented for internal types.
+    // Accidentally calling it would be a catastrophic performance bug.
+    fatalError("unsupported")
+  }
+
   /// Returns a `_SliceBuffer` containing the given `bounds` of values
   /// from this buffer.
   @inlinable

Diff for: stdlib/public/core/SliceBuffer.swift

@@ -254,6 +254,14 @@ internal struct _SliceBuffer<Element>
     return target + c
   }
 
+  public __consuming func _copyContents(
+    initializing buffer: UnsafeMutableBufferPointer<Element>
+  ) -> (Iterator,UnsafeMutableBufferPointer<Element>.Index) {
+    // This customization point is not implemented for internal types.
+    // Accidentally calling it would be a catastrophic performance bug.
+    fatalError("unsupported")
+  }
+
   /// True, if the array is native and does not need a deferred type check.
   @inlinable
   internal var arrayPropertyIsNativeTypeChecked: Bool {