[WIP] [stdlib] Improve performance of Array initialization with known capacity

stdlib/public/core/Collection.swift

@@ -1325,17 +1325,31 @@ extension Collection {
       return []
     }
 
-    var result = ContiguousArray<T>()
-    result.reserveCapacity(n)
+    let result: ContiguousArray<T>
+    var p: UnsafeMutablePointer<T>
+    (result, p) = ContiguousArray<T>._allocateUninitialized(n)
 
     var i = self.startIndex
+    var initializedElements = 0
 
-    for _ in 0..<n {
-      result.append(try transform(self[i]))
-      formIndex(after: &i)
+    do {
+      for _ in 0..<n {
+        (p + initializedElements).initialize(to: try transform(self[i]))
+
+        formIndex(after: &i)
+        initializedElements += 1
+      }
+    } catch {
+      // The buffer may not have been initialized entirely. Set its count to
+      // number of actually initialized items to avoid accessing uninitialized
+      // memory
+      result._buffer.count = initializedElements
+      throw error
     }
 
     _expectEnd(of: self, is: i)
+    _debugPrecondition(initializedElements == n,
+                       "buffer not completely initialized")
     return Array(result)
   }
 

stdlib/public/core/Sequence.swift

@@ -822,15 +822,31 @@ extension Sequence {
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
     let initialCapacity = underestimatedCount
-    var result = ContiguousArray<T>()
-    result.reserveCapacity(initialCapacity)
+    var result: ContiguousArray<T>
+    var p: UnsafeMutablePointer<T>
+    (result, p) = ContiguousArray<T>._allocateUninitialized(initialCapacity)
 
     var iterator = self.makeIterator()
 
-    // Add elements up to the initial capacity without checking for regrowth.
-    for _ in 0..<initialCapacity {
-      result.append(try transform(iterator.next()!))
+    var initializedElements = 0
+
+    // Initialize the initial capacity of the array without needing to regrow it
+    do {
+      for _ in 0..<initialCapacity {
+        (p + initializedElements).initialize(to: try transform(iterator.next()!))
+        initializedElements += 1
+      }
+    } catch {
+      // The buffer may not have been initialized entirely. Set its count to
+      // number of actually initialized items to avoid accessing uninitialized
+      // memory
+      result._buffer.count = initializedElements
+      throw error
     }
+
+    _debugPrecondition(initializedElements == initialCapacity,
+                       "buffer not completely initialized")
+
     // Add remaining elements, if any.
     while let element = iterator.next() {
       result.append(try transform(element))

test/stdlib/ErrorHandling.swift

@@ -280,7 +280,7 @@ ErrorHandlingTests.test("ErrorHandling/operators") {
 
 ErrorHandlingTests.test("ErrorHandling/Sequence map") {
   let initialCount = NoisyCount
-  let sequence = AnySequence([1, 2, 3])
+  let sequence = stride(from: 1, through: 3, by: 1)
   for throwAtCount in 0...3 {
     var loopCount = 0
     do {