Fix more warnings for deprecation and unsafeBitCast() (#953)

* Replace unsafeBitCast() with bindMemory()/withMemoryRebound()

* Convert deprecated initialize(from:) to UnsafeMutableBufferPointer.initialize(from:)

* warnings: Use names for implict closure arguments

* warnings: UnsafeMutablePointer.initialize(from:) deprecation

- Use UnsafeMutablePointer.initialize(from:count:) as a better
  alternative to UnsafeMutableBufferPointer.initialize(from:)

Author: spevans

Foundation/DateInterval.swift

@@ -155,8 +155,11 @@ public struct DateInterval : ReferenceConvertible, Comparable, Hashable {
 
     public var hashValue: Int {
         var buf: (UInt, UInt) = (UInt(start.timeIntervalSinceReferenceDate), UInt(end.timeIntervalSinceReferenceDate))
-        return withUnsafeMutablePointer(to: &buf) {
-            return Int(bitPattern: CFHashBytes(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self), CFIndex(MemoryLayout<UInt>.size * 2)))
+        return withUnsafeMutablePointer(to: &buf) { bufferPtr in
+            let count = MemoryLayout<UInt>.size * 2
+            return bufferPtr.withMemoryRebound(to: UInt8.self, capacity: count) { bufferBytes in
+                return Int(bitPattern: CFHashBytes(bufferBytes, CFIndex(count)))
+            }
         }
     }
 

Foundation/NSArray.swift

@@ -130,7 +130,7 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
 //        }
         let cnt = array.count
         let buffer = UnsafeMutablePointer<AnyObject>.allocate(capacity: cnt)
-        buffer.initialize(from: optionalArray)
+        buffer.initialize(from: optionalArray, count: cnt)
         self.init(objects: buffer, count: cnt)
         buffer.deinitialize(count: cnt)
         buffer.deallocate(capacity: cnt)
@@ -372,16 +372,17 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
     }
 
     open var sortedArrayHint: Data {
-        let size = count
-        let buffer = UnsafeMutablePointer<Int32>.allocate(capacity: size)
-        for idx in 0..<count {
-            let item = object(at: idx) as! NSObject
-            let hash = item.hash
-            buffer.advanced(by: idx).pointee = Int32(hash).littleEndian
+        let size = MemoryLayout<Int32>.size * count
+        let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: size)
+        buffer.withMemoryRebound(to: Int32.self, capacity: count) { (ptr) in
+            for idx in 0..<count {
+                let item = object(at: idx) as! NSObject
+                let hash = item.hash
+                ptr.advanced(by: idx).pointee = Int32(hash).littleEndian
+            }
         }
-        return Data(bytesNoCopy: unsafeBitCast(buffer, to: UnsafeMutablePointer<UInt8>.self), count: count * MemoryLayout<Int>.size, deallocator: .custom({ _ in
+        return Data(bytesNoCopy: buffer, count: size, deallocator: .custom({ _ in
             buffer.deallocate(capacity: size)
-            buffer.deinitialize(count: size)
         }))
     }
 

Foundation/NSDictionary.swift

@@ -124,10 +124,10 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,
 
     public convenience init(objects: [Any], forKeys keys: [NSObject]) {
         let keyBuffer = UnsafeMutablePointer<NSObject>.allocate(capacity: keys.count)
-        keyBuffer.initialize(from: keys)
+        keyBuffer.initialize(from: keys, count: keys.count)
 
         let valueBuffer = UnsafeMutablePointer<AnyObject>.allocate(capacity: objects.count)
-        valueBuffer.initialize(from: objects.map { _SwiftValue.store($0) })
+        valueBuffer.initialize(from: objects.map { _SwiftValue.store($0) }, count: objects.count)
 
         self.init(objects: valueBuffer, forKeys:keyBuffer, count: keys.count)
 

Foundation/Process.swift

@@ -223,7 +223,7 @@ open class Process: NSObject {
         let argv : UnsafeMutablePointer<UnsafeMutablePointer<Int8>?> = args.withUnsafeBufferPointer {
             let array : UnsafeBufferPointer<String> = $0
             let buffer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: array.count + 1)
-            buffer.initialize(from: array.map { $0.withCString(strdup) })
+            buffer.initialize(from: array.map { $0.withCString(strdup) }, count: array.count)
             buffer[array.count] = nil
             return buffer
         }
@@ -241,7 +241,7 @@ open class Process: NSObject {
         if let env = environment {
             let nenv = env.count
             envp = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: 1 + nenv)
-            envp.initialize(from: env.map { strdup("\($0)=\($1)") })
+            envp.initialize(from: env.map { strdup("\($0)=\($1)") }, count: 1 + nenv)
             envp[env.count] = nil
         } else {
             envp = _CFEnviron()

TestFoundation/TestNSData.swift

@@ -761,8 +761,9 @@ extension TestNSData {
         let expectedSize = MemoryLayout<UInt8>.stride * a.count
         XCTAssertEqual(expectedSize, data.count)
 
-        let underlyingBuffer = unsafeBitCast(malloc(expectedSize - 1)!, to: UnsafeMutablePointer<UInt8>.self)
-        let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: expectedSize - 1)
+        let size = expectedSize - 1
+        let underlyingBuffer = malloc(size)!
+        let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer.bindMemory(to: UInt8.self, capacity: size), count: size)
 
         // We should only copy in enough bytes that can fit in the buffer
         let copiedCount = data.copyBytes(to: buffer)
@@ -784,9 +785,10 @@ extension TestNSData {
         }
         let expectedSize = MemoryLayout<Int32>.stride * a.count
         XCTAssertEqual(expectedSize, data.count)
-        
-        let underlyingBuffer = unsafeBitCast(malloc(expectedSize + 1)!, to: UnsafeMutablePointer<UInt8>.self)
-        let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: expectedSize + 1)
+
+        let size = expectedSize + 1
+        let underlyingBuffer = malloc(size)!
+        let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer.bindMemory(to: UInt8.self, capacity: size), count: size)
 
         let copiedCount = data.copyBytes(to: buffer)
         XCTAssertEqual(expectedSize, copiedCount)
@@ -802,9 +804,10 @@ extension TestNSData {
             var data = a.withUnsafeBufferPointer {
                 return Data(buffer: $0)
             }
-            
-            let underlyingBuffer = unsafeBitCast(malloc(data.count)!, to: UnsafeMutablePointer<UInt8>.self)
-            let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: data.count)
+
+            let size = data.count
+            let underlyingBuffer = malloc(size)!
+            let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer.bindMemory(to: UInt8.self, capacity: size), count: size)
 
             var copiedCount : Int
 
@@ -831,10 +834,11 @@ extension TestNSData {
             let data = a.withUnsafeBufferPointer {
                 return Data(buffer: $0)
             }
-            
-            let underlyingBuffer = unsafeBitCast(malloc(10)!, to: UnsafeMutablePointer<UInt8>.self)
-            let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: 10)
-            
+
+            let size = 10
+            let underlyingBuffer = malloc(size)!
+            let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer.bindMemory(to: UInt8.self, capacity: size), count: size)
+
             var copiedCount : Int
 
             copiedCount = data.copyBytes(to: buffer, from: 0..<3)
@@ -854,9 +858,10 @@ extension TestNSData {
             let data = a.withUnsafeBufferPointer {
                 return Data(buffer: $0)
             }
-            
-            let underlyingBuffer = unsafeBitCast(malloc(4)!, to: UnsafeMutablePointer<UInt8>.self)
-            let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: 4)
+
+            let size = 4
+            let underlyingBuffer = malloc(size)!
+            let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer.bindMemory(to: UInt8.self, capacity: size), count: size)
 
             var copiedCount : Int
 
@@ -983,9 +988,9 @@ extension TestNSData {
         expectedSize += MemoryLayout<Bool>.stride * 2
         XCTAssertEqual(expectedSize, data.count)
 
-        let underlyingBuffer = unsafeBitCast(malloc(expectedSize)!, to: UnsafeMutablePointer<UInt8>.self)
-        
-        let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer, count: expectedSize)
+        let size = expectedSize
+        let underlyingBuffer = malloc(size)!
+        let buffer = UnsafeMutableBufferPointer(start: underlyingBuffer.bindMemory(to: UInt8.self, capacity: size), count: size)
         let copiedCount = data.copyBytes(to: buffer)
         XCTAssertEqual(copiedCount, expectedSize)