Update raw version to return a typed buffer

Author: airspeedswift

stdlib/public/core/UnsafeRawBufferPointer.swift.gyb

@@ -427,7 +427,7 @@ public struct Unsafe${Mutable}RawBufferPointer
   /// `source` and binds the initialized memory to type `T`.
   ///
   /// Returns an iterator to any elements of `source` that didn't fit in the 
-  /// buffer, and an index into the buffer one past the last byte written.
+  /// buffer, and a typed buffer of the written elements.
   ///
   /// - Precondition: The memory in `startIndex..<(source.count *
   ///   MemoryLayout<T>.stride)` is uninitialized or initialized to a
@@ -436,16 +436,18 @@ public struct Unsafe${Mutable}RawBufferPointer
   /// - Precondition: The buffer must contain sufficient memory to
   ///   accommodate at least `source.underestimateCount` elements.
   ///
-  /// - Postcondition: The memory at `self[startIndex..<returned index]                 
+  /// - Postcondition: The memory at `self[startIndex..<source.count *
+  ///   MemoryLayout<T>.stride]                 
   ///   is bound to type `T`.
   ///
-  /// - Postcondition: The `T` values at `self[startIndex..<returned index]`
+  /// - Postcondition: The `T` values at `self[startIndex..<source.count *
+  ///   MemoryLayout<T>.stride]`
   ///   are initialized.
   ///
   // TODO: Optimize where `C` is a `ContiguousArrayBuffer`.
   public func initializeMemory<S: Sequence>(
     as: S.Iterator.Element.Type, from source: S
-  ) -> (unwritten: S.Iterator, initializedUpTo: Index) {
+  ) -> (unwritten: S.Iterator, initialized: UnsafeMutableBufferPointer<S.Iterator.Element>) {
 
     var it = source.makeIterator()
     var idx = startIndex
@@ -456,8 +458,9 @@ public struct Unsafe${Mutable}RawBufferPointer
       "insufficient space to accommodate source.underestimatedCount elements")
     guard let base = baseAddress else {
       // this can be a precondition since only an invalid argument should be costly
-      _precondition(source.underestimatedCount == 0, "no memory available to initialize from source")
-      return (it, startIndex)
+      _precondition(source.underestimatedCount == 0, 
+        "no memory available to initialize from source")
+      return (it, UnsafeMutableBufferPointer(start: nil, count: 0))
     }  
 
     for p in stride(from: base, 
@@ -472,7 +475,9 @@ public struct Unsafe${Mutable}RawBufferPointer
       formIndex(&idx, offsetBy: elementStride)
     }
 
-    return (it, idx)
+    return (it, UnsafeMutableBufferPointer(
+                  start: base.assumingMemoryBound(to: S.Iterator.Element.self), 
+                  count: idx / elementStride))
   }
   %  end # mutable
 

test/stdlib/UnsafeRawBufferPointer.swift

@@ -79,12 +79,13 @@ UnsafeRawBufferPointerTestSuite.test("initializeMemory(as:from:).underflow") {
   let buffer = UnsafeMutableRawBufferPointer.allocate(count: 30)
   defer { buffer.deallocate() }
   let source = stride(from: 5 as Int64, to: 0, by: -1)
-  var (it,idx) = buffer.initializeMemory(as: Int64.self, from: source)
+  var (it,bound) = buffer.initializeMemory(as: Int64.self, from: source)
+  let idx = bound.endIndex * MemoryLayout<Int64>.stride
   expectEqual(it.next()!, 2)
   expectEqual(idx, 24)
-  ([5, 4, 3] as [Int64]).withUnsafeBytes {
-    expectEqualSequence($0,buffer[0..<idx])
-  }
+  let expected: [Int64] = [5,4,3]
+  expected.withUnsafeBytes { expectEqualSequence($0,buffer[0..<idx]) }
+  expectEqualSequence([5, 4, 3],bound)
 }
 
 UnsafeRawBufferPointerTestSuite.test("initializeMemory(as:from:).overflow") {
@@ -94,35 +95,39 @@ UnsafeRawBufferPointerTestSuite.test("initializeMemory(as:from:).overflow") {
   if _isDebugAssertConfiguration() {
     expectCrashLater()
   }
-  var (it, idx) = buffer.initializeMemory(as: Int64.self, from: source)
+  var (it,bound) = buffer.initializeMemory(as: Int64.self, from: source)
+  let idx = bound.endIndex * MemoryLayout<Int64>.stride
   expectEqual(it.next()!, 2)
   expectEqual(idx, 24)
-  ([5, 4, 3] as [Int64]).withUnsafeBytes {
-    expectEqualSequence($0,buffer[0..<idx])
-  }
+  let expected: [Int64] = [5,4,3]
+  expected.withUnsafeBytes { expectEqualSequence($0,buffer[0..<idx]) }
+  expectEqualSequence([5, 4, 3],bound)
 }
 
 UnsafeRawBufferPointerTestSuite.test("initializeMemory(as:from:).exact") {
   let buffer = UnsafeMutableRawBufferPointer.allocate(count: 24)
   defer { buffer.deallocate() }
   let source: [Int64] = [5, 4, 3]
-  var (it, idx) = buffer.initializeMemory(as: Int64.self, from: source)
+  var (it,bound) = buffer.initializeMemory(as: Int64.self, from: source)
+  let idx = bound.endIndex * MemoryLayout<Int64>.stride
   expectNil(it.next())
   expectEqual(idx, buffer.endIndex)
   source.withUnsafeBytes { expectEqualSequence($0,buffer) }
+  expectEqualSequence([5, 4, 3],bound)
 }
 
 UnsafeRawBufferPointerTestSuite.test("initializeMemory(as:from:).invalidNilPtr") {
   let buffer = UnsafeMutableRawBufferPointer(start: nil, count: 0)
   let source: [Int64] = [5, 4, 3, 2, 1]
   expectCrashLater()
-  var (it, idx) = buffer.initializeMemory(as: Int64.self, from: source)
+  var (it, bound) = buffer.initializeMemory(as: Int64.self, from: source)
 }
 
 UnsafeRawBufferPointerTestSuite.test("initializeMemory(as:from:).validNilPtr") {
   let buffer = UnsafeMutableRawBufferPointer(start: nil, count: 0)
   let source: [Int64] = []
-  var (it, idx) = buffer.initializeMemory(as: Int64.self, from: source)
+  var (it, bound) = buffer.initializeMemory(as: Int64.self, from: source)
+  let idx = bound.endIndex * MemoryLayout<Int64>.stride
   expectNil(it.next())
   expectEqual(idx, source.endIndex)
 }