Merge pull request swiftlang#21135 from airspeedswift/test-contiguous-storage

Author: swift-ci

stdlib/private/StdlibCollectionUnittest/LoggingWrappers.swift

@@ -83,6 +83,7 @@ public class SequenceLog {
   public static var prefixWhile = TypeIndexed(0)
   public static var prefixMaxLength = TypeIndexed(0)
   public static var suffixMaxLength = TypeIndexed(0)
+  public static var withContiguousStorageIfAvailable = TypeIndexed(0)
   public static var _customContainsEquatableElement = TypeIndexed(0)
   public static var _copyToContiguousArray = TypeIndexed(0)
   public static var _copyContents = TypeIndexed(0)  
@@ -213,6 +214,13 @@ extension LoggingSequence: Sequence {
     SequenceLog.underestimatedCount[selfType] += 1
     return base.underestimatedCount
   }
+  
+  public func withContiguousStorageIfAvailable<R>(
+    _ body: (UnsafeBufferPointer<Element>) throws -> R
+  ) rethrows -> R? {
+    SequenceLog.withContiguousStorageIfAvailable[selfType] += 1
+    return try base.withContiguousStorageIfAvailable(body)
+  }
 
   public func _customContainsEquatableElement(_ element: Element) -> Bool? {
     SequenceLog._customContainsEquatableElement[selfType] += 1

stdlib/public/core/Sequence.swift

@@ -363,7 +363,6 @@ public protocol Sequence {
     initializing ptr: UnsafeMutableBufferPointer<Element>
   ) -> (Iterator,UnsafeMutableBufferPointer<Element>.Index)
 
-  @inlinable
   func withContiguousStorageIfAvailable<R>(
     _ body: (UnsafeBufferPointer<Element>) throws -> R
   ) rethrows -> R?  

test/stdlib/Inputs/CommonArrayTests.gyb

@@ -325,7 +325,48 @@ ${Suite}.test("${ArrayType}/_withUnsafeMutableBufferPointerIfSupported/Replacing
 }
 
 //===----------------------------------------------------------------------===//
-// _withUnsafeMutableBufferPointerIfSupported()
+// withContiguousStorageIfAvailableTests()
+//===----------------------------------------------------------------------===//
+
+struct WithContiguousStorageIfAvailableTest {
+  let sequence: [Int]
+  let loc: SourceLoc
+
+  init(
+    _ sequence: [Int],
+    file: String = #file, line: UInt = #line
+  ) {
+    self.sequence = sequence
+    self.loc = SourceLoc(file, line, comment: "test data")
+  }
+}
+
+let withContiguousStorageIfAvailableTests = [
+  WithContiguousStorageIfAvailableTest([]),
+  WithContiguousStorageIfAvailableTest([ 10 ]),
+  WithContiguousStorageIfAvailableTest([ 10, 20, 30, 40, 50 ]),
+]
+
+${Suite}.test("${ArrayType}/withContiguousStorageIfAvailable")
+  .code {
+  for test in withContiguousStorageIfAvailableTests {
+    var a = getFresh${ArrayType}(test.sequence.map(OpaqueValue.init))
+    do {
+      // Read.
+      var result = a.withContiguousStorageIfAvailable {
+        (bufferPointer) -> OpaqueValue<[OpaqueValue<Int>]> in
+        return OpaqueValue(Array(bufferPointer))
+      }
+      expectType(Optional<OpaqueValue<Array<OpaqueValue<Int>>>>.self, &result)
+      expectEqualSequence(test.sequence, result!.value.map { $0.value })
+      expectEqualSequence(test.sequence, a.map { $0.value })
+    }
+  }
+  // FIXME: tests for arrays bridged from Objective-C.
+}
+
+//===----------------------------------------------------------------------===//
+// withContiguousMutableStorageIfAvailableTests()
 //===----------------------------------------------------------------------===//
 
 struct WithContiguousMutableStorageIfAvailableTest {

validation-test/stdlib/SequenceType.swift.gyb

@@ -1049,6 +1049,20 @@ SequenceTypeTests.test("underestimatedCount/Sequence/CustomImplementation") {
   }
 }
 
+//===----------------------------------------------------------------------===//
+// withContiguousStorageIfAvailable()
+//===----------------------------------------------------------------------===//
+SequenceTypeTests.test("withContiguousMutableStorageIfAvailable")
+.code {
+  let s = [ 1, 2, 3 ].map(OpaqueValue.init)
+  let tester = SequenceLog.dispatchTester(s)
+  let result = tester.withContiguousStorageIfAvailable { buf in
+    buf.reduce(0) { $0 + $1.value }
+  }
+  expectEqual(6, result)
+  expectCustomizable(tester, tester.log.withContiguousStorageIfAvailable)
+}
+
 //===----------------------------------------------------------------------===//
 // _copyToContiguousArray()
 //===----------------------------------------------------------------------===//

validation-test/stdlib/UnsafeBufferPointer.swift.gyb

@@ -325,17 +325,27 @@ UnsafeMutableBufferPointerTestSuite.test("changeElementViaBuffer") {
   expectEqual(-1.0, allocated[count-1])
 }
 
-UnsafeMutableBufferPointerTestSuite.test("withContiguousMutableStorageIfAvailable") {
+UnsafeMutableBufferPointerTestSuite.test("withContiguous(Mutable)StorageIfAvailable") {
   let count = 4
   let allocated = UnsafeMutablePointer<Int>.allocate(capacity: count)
   defer { allocated.deallocate() }
   allocated.initialize(repeating: 1, count: count)
 
-  var buffer = UnsafeMutableBufferPointer(start: allocated, count: count)
-  let result = buffer.withContiguousMutableStorageIfAvailable { buffer in
-    return buffer.reduce(0, +)
+  var mutableBuffer = UnsafeMutableBufferPointer(start: allocated, count: count)
+  let executed: ()? = mutableBuffer.withContiguousMutableStorageIfAvailable { buf in
+    for i in 0..<buf.count { buf[i] *= 2 }
   }
-  expectEqual(count, result)
+  expectNotNil(executed)
+  let result1 = mutableBuffer.withContiguousStorageIfAvailable { buf in
+    return buf.reduce(0, +)
+  }
+  expectEqual(count*2, result1)
+
+  let immutableBuffer = UnsafeBufferPointer(start: allocated, count: count)
+  let result2 = immutableBuffer.withContiguousStorageIfAvailable { buf in
+    return buf.reduce(0, +)
+  }
+  expectEqual(result1, result2)
 }
 
 UnsafeMutableBufferPointerTestSuite.test("sort") {