Merge pull request #3788 from bob-wilson/withUnsafePointer

bob-wilson · web-flow · commit 1d4a9707d6fa · 2016-07-26T19:45:23.000-07:00
[SE-0127] changes to withUnsafe[Mutable]Pointer
diff --git a/stdlib/private/SwiftPrivateLibcExtras/Subprocess.swift b/stdlib/private/SwiftPrivateLibcExtras/Subprocess.swift
@@ -118,7 +118,7 @@ public func spawnChild(_ args: [String])
     // parent write pipe.
     let errnoSize = sizeof(errno.dynamicType)
     var execveErrno = errno
-    let writtenBytes = withUnsafePointer(&execveErrno) {
+    let writtenBytes = withUnsafePointer(to: &execveErrno) {
       write(childToParentPipe.writeFD, UnsafePointer($0), errnoSize)
     }
 
diff --git a/stdlib/public/Platform/tgmath.swift.gyb b/stdlib/public/Platform/tgmath.swift.gyb
@@ -334,7 +334,7 @@ func _swift_Darwin_lgamma${f}_r(_: ${CT},
 @_transparent
 public func lgamma(_ x: ${T}) -> (${T}, Int) {
   var sign = Int32(0)
-  let value = withUnsafeMutablePointer(&sign) { 
+  let value = withUnsafeMutablePointer(to: &sign) {
     (signp: UnsafeMutablePointer<Int32>) -> ${CT} in
     return _swift_Darwin_lgamma${f}_r(${CT}(x), signp)
   }
diff --git a/stdlib/public/SDK/Foundation/DateInterval.swift b/stdlib/public/SDK/Foundation/DateInterval.swift
@@ -156,7 +156,7 @@ public struct DateInterval : ReferenceConvertible, Comparable, Hashable {
     
     public var hashValue: Int {
         var buf: (UInt, UInt) = (UInt(start.timeIntervalSinceReferenceDate), UInt(end.timeIntervalSinceReferenceDate))
-        return withUnsafeMutablePointer(&buf) {
+        return withUnsafeMutablePointer(to: &buf) {
             return Int(bitPattern: CFHashBytes(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self), CFIndex(sizeof(UInt.self) * 2)))
         }
     }
diff --git a/stdlib/public/SDK/Foundation/UUID.swift b/stdlib/public/SDK/Foundation/UUID.swift
@@ -22,14 +22,14 @@ public struct UUID : ReferenceConvertible, Hashable, Equatable, CustomStringConv
     
     /* Create a new UUID with RFC 4122 version 4 random bytes */
     public init() {
-        withUnsafeMutablePointer(&uuid) {
+        withUnsafeMutablePointer(to: &uuid) {
             uuid_generate_random(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self))
         }
     }
     
     fileprivate init(reference: NSUUID) {
         var bytes: uuid_t = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
-        withUnsafeMutablePointer(&bytes) {
+        withUnsafeMutablePointer(to: &bytes) {
             reference.getBytes(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self))
         }
         uuid = bytes
@@ -39,7 +39,7 @@ public struct UUID : ReferenceConvertible, Hashable, Equatable, CustomStringConv
     /// 
     /// Returns nil for invalid strings.
     public init?(uuidString string: String) {
-        let res = withUnsafeMutablePointer(&uuid) {
+        let res = withUnsafeMutablePointer(to: &uuid) {
             return uuid_parse(string, unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self))
         }
         if res != 0 {
@@ -56,15 +56,17 @@ public struct UUID : ReferenceConvertible, Hashable, Equatable, CustomStringConv
     public var uuidString: String {
         var bytes: uuid_string_t = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
         var localValue = uuid
-        return withUnsafeMutablePointers(&localValue, &bytes) { val, str -> String in
-            uuid_unparse(unsafeBitCast(val, to: UnsafePointer<UInt8>.self), unsafeBitCast(str, to: UnsafeMutablePointer<Int8>.self))
-            return String(cString: unsafeBitCast(str, to: UnsafePointer<CChar>.self), encoding: .utf8)!
+        return withUnsafeMutablePointer(to: &localValue) { val in
+            withUnsafeMutablePointer(to: &bytes) { str in
+                uuid_unparse(unsafeBitCast(val, to: UnsafePointer<UInt8>.self), unsafeBitCast(str, to: UnsafeMutablePointer<Int8>.self))
+                return String(cString: unsafeBitCast(str, to: UnsafePointer<CChar>.self), encoding: .utf8)!
+            }
         }
     }
     
     public var hashValue: Int {
         var localValue = uuid
-        return withUnsafeMutablePointer(&localValue) {
+        return withUnsafeMutablePointer(to: &localValue) {
             return Int(bitPattern: CFHashBytes(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self), CFIndex(sizeof(uuid_t.self))))
         }
     }
@@ -81,7 +83,7 @@ public struct UUID : ReferenceConvertible, Hashable, Equatable, CustomStringConv
     
     fileprivate var reference: NSUUID {
         var bytes = uuid
-        return withUnsafePointer(&bytes) {
+        return withUnsafePointer(to: &bytes) {
             return NSUUID(uuidBytes: unsafeBitCast($0, to: UnsafePointer<UInt8>.self))
         }
     }
diff --git a/stdlib/public/core/CocoaArray.swift b/stdlib/public/core/CocoaArray.swift
@@ -61,7 +61,7 @@ internal struct _CocoaArrayWrapper : RandomAccessCollection {
     // subRange.upperBound items are stored contiguously.  This is an
     // acceptable conservative behavior, but could potentially be
     // optimized for other cases.
-    let contiguousCount = withUnsafeMutablePointer(&enumerationState) {
+    let contiguousCount = withUnsafeMutablePointer(to: &enumerationState) {
       self.buffer.countByEnumerating(with: $0, objects: nil, count: 0)
     }
     
diff --git a/stdlib/public/core/FloatingPointParsing.swift.gyb b/stdlib/public/core/FloatingPointParsing.swift.gyb
@@ -56,7 +56,7 @@ extension ${Self} {
     let u16 = text.utf16
     func parseNTBS(_ chars: UnsafePointer<CChar>) -> (${Self}, Int) {
       var result: ${Self} = 0
-      let endPtr = withUnsafeMutablePointer(&result) {
+      let endPtr = withUnsafeMutablePointer(to: &result) {
         _swift_stdlib_strto${cFuncSuffix2[bits]}_clocale(
           chars, UnsafeMutablePointer($0))
       }
diff --git a/stdlib/public/core/HashedCollections.swift.gyb b/stdlib/public/core/HashedCollections.swift.gyb
@@ -4777,7 +4777,7 @@ final internal class _Cocoa${Self}Iterator : IteratorProtocol {
     let cocoa${Self} = self.cocoa${Self}
     if itemIndex == itemCount {
       let stackBufCount = _fastEnumerationStackBuf.count
-      // We can't use `withUnsafeMutablePointers` here to get pointers to
+      // We can't use `withUnsafeMutablePointer` here to get pointers to
       // properties, because doing so might introduce a writeback buffer, but
       // fast enumeration relies on the pointer identity of the enumeration
       // state struct.
diff --git a/stdlib/public/core/LifetimeManager.swift b/stdlib/public/core/LifetimeManager.swift
@@ -60,79 +60,38 @@ public func _fixLifetime<T>(_ x: T) {
 /// result. Useful for calling Objective-C APIs that take "in/out"
 /// parameters (and default-constructible "out" parameters) by pointer.
 public func withUnsafeMutablePointer<T, Result>(
-  _ arg: inout T,
+  to arg: inout T,
   _ body: @noescape (UnsafeMutablePointer<T>) throws -> Result
 ) rethrows -> Result
 {
   return try body(UnsafeMutablePointer<T>(Builtin.addressof(&arg)))
 }
 
-/// Like `withUnsafeMutablePointer`, but passes pointers to `arg0` and `arg1`.
-public func withUnsafeMutablePointers<A0, A1, Result>(
-  _ arg0: inout A0,
-  _ arg1: inout A1,
-  _ body: @noescape (
-    UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>) throws -> Result
-) rethrows -> Result {
-  return try body(
-    UnsafeMutablePointer<A0>(Builtin.addressof(&arg0)),
-    UnsafeMutablePointer<A1>(Builtin.addressof(&arg1)))
-}
-
-/// Like `withUnsafeMutablePointer`, but passes pointers to `arg0`, `arg1`,
-/// and `arg2`.
-public func withUnsafeMutablePointers<A0, A1, A2, Result>(
-  _ arg0: inout A0,
-  _ arg1: inout A1,
-  _ arg2: inout A2,
-  _ body: @noescape (
-    UnsafeMutablePointer<A0>,
-    UnsafeMutablePointer<A1>,
-    UnsafeMutablePointer<A2>
-  ) throws -> Result
-) rethrows -> Result {
-  return try body(
-    UnsafeMutablePointer<A0>(Builtin.addressof(&arg0)),
-    UnsafeMutablePointer<A1>(Builtin.addressof(&arg1)),
-    UnsafeMutablePointer<A2>(Builtin.addressof(&arg2)))
-}
-
 /// Invokes `body` with an `UnsafePointer` to `arg` and returns the
 /// result. Useful for calling Objective-C APIs that take "in/out"
 /// parameters (and default-constructible "out" parameters) by pointer.
 public func withUnsafePointer<T, Result>(
-  _ arg: inout T,
+  to arg: inout T,
   _ body: @noescape (UnsafePointer<T>) throws -> Result
 ) rethrows -> Result
 {
   return try body(UnsafePointer<T>(Builtin.addressof(&arg)))
 }
 
-/// Like `withUnsafePointer`, but passes pointers to `arg0` and `arg1`.
-public func withUnsafePointers<A0, A1, Result>(
-  _ arg0: inout A0,
-  _ arg1: inout A1,
-  _ body: @noescape (UnsafePointer<A0>, UnsafePointer<A1>) throws -> Result
-) rethrows -> Result {
-  return try body(
-    UnsafePointer<A0>(Builtin.addressof(&arg0)),
-    UnsafePointer<A1>(Builtin.addressof(&arg1)))
+@available(*, unavailable, renamed: "withUnsafeMutablePointer(to:_:)")
+public func withUnsafeMutablePointer<T, Result>(
+  _ arg: inout T,
+  _ body: @noescape (UnsafeMutablePointer<T>) throws -> Result
+) rethrows -> Result
+{
+  Builtin.unreachable()
 }
 
-/// Like `withUnsafePointer`, but passes pointers to `arg0`, `arg1`,
-/// and `arg2`.
-public func withUnsafePointers<A0, A1, A2, Result>(
-  _ arg0: inout A0,
-  _ arg1: inout A1,
-  _ arg2: inout A2,
-  _ body: @noescape (
-    UnsafePointer<A0>,
-    UnsafePointer<A1>,
-    UnsafePointer<A2>
-  ) throws -> Result
-) rethrows -> Result {
-  return try body(
-    UnsafePointer<A0>(Builtin.addressof(&arg0)),
-    UnsafePointer<A1>(Builtin.addressof(&arg1)),
-    UnsafePointer<A2>(Builtin.addressof(&arg2)))
+@available(*, unavailable, renamed: "withUnsafePointer(to:_:)")
+public func withUnsafePointer<T, Result>(
+  _ arg: inout T,
+  _ body: @noescape (UnsafePointer<T>) throws -> Result
+) rethrows -> Result
+{
+  Builtin.unreachable()
 }
diff --git a/stdlib/public/core/Runtime.swift.gyb b/stdlib/public/core/Runtime.swift.gyb
@@ -379,7 +379,7 @@ func _float${bits}ToString(_ value: Float${bits}, debug: Bool) -> String {
   _sanityCheck(sizeof(_Buffer72.self) == 72)
 
   var buffer = _Buffer32()
-  return withUnsafeMutablePointer(&buffer) {
+  return withUnsafeMutablePointer(to: &buffer) {
     (bufferPtr) in
     let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
     let actualLength = _float${bits}ToStringImpl(bufferUTF8Ptr, 32, value, debug)
@@ -408,7 +408,7 @@ func _int64ToString(
 ) -> String {
   if radix >= 10 {
     var buffer = _Buffer32()
-    return withUnsafeMutablePointer(&buffer) {
+    return withUnsafeMutablePointer(to: &buffer) {
       (bufferPtr) in
       let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
       let actualLength =
@@ -420,7 +420,7 @@ func _int64ToString(
     }
   } else {
     var buffer = _Buffer72()
-    return withUnsafeMutablePointer(&buffer) {
+    return withUnsafeMutablePointer(to: &buffer) {
       (bufferPtr) in
       let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
       let actualLength =
@@ -445,7 +445,7 @@ func _uint64ToString(
 ) -> String {
   if radix >= 10 {
     var buffer = _Buffer32()
-    return withUnsafeMutablePointer(&buffer) {
+    return withUnsafeMutablePointer(to: &buffer) {
       (bufferPtr) in
       let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
       let actualLength =
@@ -457,7 +457,7 @@ func _uint64ToString(
     }
   } else {
     var buffer = _Buffer72()
-    return withUnsafeMutablePointer(&buffer) {
+    return withUnsafeMutablePointer(to: &buffer) {
       (bufferPtr) in
       let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
       let actualLength =
diff --git a/stdlib/public/core/UnsafeRawPointer.swift.gyb b/stdlib/public/core/UnsafeRawPointer.swift.gyb
@@ -405,7 +405,7 @@ public struct Unsafe${Mutable}RawPointer : Strideable, Hashable, _Pointer {
       "storeBytes to misaligned raw pointer")
 
     var temp = value
-    withUnsafeMutablePointer(&temp) { source in
+    withUnsafeMutablePointer(to: &temp) { source in
       let rawSrc = UnsafeMutableRawPointer(source)._rawValue
       // FIXME: to be replaced by _memcpy when conversions are implemented.
       Builtin.int_memcpy_RawPointer_RawPointer_Int64(
diff --git a/test/1_stdlib/AllocRounding.swift b/test/1_stdlib/AllocRounding.swift
@@ -15,7 +15,7 @@ func foo() -> UInt64 {
   var v0: UInt64 = 1
   var v1: UInt64 = 2
   var b: Bool = true
-  return withUnsafeMutablePointer(&buffer) { bufferPtr in 
+  return withUnsafeMutablePointer(to: &buffer) { bufferPtr in
     bufferPtr.pointee.x0 = 5
     bufferPtr.pointee.x1 = v0
     bufferPtr.pointee.x2 = v1
diff --git a/test/Constraints/diagnostics.swift b/test/Constraints/diagnostics.swift
@@ -833,7 +833,7 @@ extension Foo23752537 {
 func read2(_ p: UnsafeMutableRawPointer, maxLength: Int) {}
 func read<T : Integer>() -> T? {
   var buffer : T 
-  let n = withUnsafePointer(&buffer) { (p) in
+  let n = withUnsafePointer(to: &buffer) { (p) in
     read2(UnsafePointer(p), maxLength: sizeof(T)) // expected-error {{cannot convert value of type 'UnsafePointer<_>' to expected argument type 'UnsafeMutableRawPointer'}}
   }
 }
diff --git a/validation-test/stdlib/CUUID.swift b/validation-test/stdlib/CUUID.swift
@@ -12,7 +12,7 @@ var CUUIDTestSuite = TestSuite("CUUID")
 /// Generates a random UUID
 CUUIDTestSuite.test("uuid") {
   var uuid: uuid_t = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
-  withUnsafeMutablePointer(&uuid) {
+  withUnsafeMutablePointer(to: &uuid) {
     uuid_generate_random(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self))
   }
 }
diff --git a/validation-test/stdlib/OpenCLSDKOverlay.swift b/validation-test/stdlib/OpenCLSDKOverlay.swift
@@ -131,7 +131,7 @@ tests.test("clSetKernelArgsListAPPLE") {
   program = KernelSource.withCString {
     (p: UnsafePointer<CChar>) -> cl_program in
     var s: UnsafePointer? = p
-    return withUnsafeMutablePointer(&s) {
+    return withUnsafeMutablePointer(to: &s) {
       return clCreateProgramWithSource(context, 1, $0, nil, &err)
     }
   }
@@ -186,13 +186,17 @@ tests.test("clSetKernelArgsListAPPLE") {
   // Set the arguments to our compute kernel
   //
   err = 0
-  err = withUnsafePointers(&input, &output, &count) {
-    inputPtr, outputPtr, countPtr in
-    clSetKernelArgsListAPPLE(
-      kernel!, 3,
-      0, sizeof(cl_mem.self), inputPtr,
-      1, sizeof(cl_mem.self), outputPtr,
-      2, sizeofValue(count), countPtr)
+  err = withUnsafePointer(to: &input) {
+    inputPtr in withUnsafePointer(to: &output) {
+      outputPtr in withUnsafePointer(to: &count) {
+        countPtr in
+        clSetKernelArgsListAPPLE(
+          kernel!, 3,
+          0, sizeof(cl_mem.self), inputPtr,
+          1, sizeof(cl_mem.self), outputPtr,
+          2, sizeofValue(count), countPtr)
+      }
+    }
   }
 
   

Original file line number	Diff line number	Diff line change
`@@ -118,7 +118,7 @@ public func spawnChild(_ args: [String])`
`118`	`118`	`// parent write pipe.`
`119`	`119`	`let errnoSize = sizeof(errno.dynamicType)`
`120`	`120`	`var execveErrno = errno`
`121`		`- let writtenBytes = withUnsafePointer(&execveErrno) {`
	`121`	`+ let writtenBytes = withUnsafePointer(to: &execveErrno) {`
`122`	`122`	`write(childToParentPipe.writeFD, UnsafePointer($0), errnoSize)`
`123`	`123`	`}`
`124`	`124`
Original file line number	Diff line number	Diff line change
`@@ -334,7 +334,7 @@ func _swift_Darwin_lgamma${f}_r(_: ${CT},`
`334`	`334`	`@_transparent`
`335`	`335`	`public func lgamma(_ x: ${T}) -> (${T}, Int) {`
`336`	`336`	`var sign = Int32(0)`
`337`		`- let value = withUnsafeMutablePointer(&sign) {`
	`337`	`+ let value = withUnsafeMutablePointer(to: &sign) {`
`338`	`338`	`(signp: UnsafeMutablePointer<Int32>) -> ${CT} in`
`339`	`339`	`return _swift_Darwin_lgamma${f}_r(${CT}(x), signp)`
`340`	`340`	`}`
Original file line number	Diff line number	Diff line change
`@@ -156,7 +156,7 @@ public struct DateInterval : ReferenceConvertible, Comparable, Hashable {`
`156`	`156`
`157`	`157`	`public var hashValue: Int {`
`158`	`158`	`var buf: (UInt, UInt) = (UInt(start.timeIntervalSinceReferenceDate), UInt(end.timeIntervalSinceReferenceDate))`
`159`		`- return withUnsafeMutablePointer(&buf) {`
	`159`	`+ return withUnsafeMutablePointer(to: &buf) {`
`160`	`160`	`return Int(bitPattern: CFHashBytes(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self), CFIndex(sizeof(UInt.self) * 2)))`
`161`	`161`	`}`
`162`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,14 +22,14 @@ public struct UUID : ReferenceConvertible, Hashable, Equatable, CustomStringConv`
`22`	`22`
`23`	`23`	`/* Create a new UUID with RFC 4122 version 4 random bytes */`
`24`	`24`	`public init() {`
`25`		`- withUnsafeMutablePointer(&uuid) {`
	`25`	`+ withUnsafeMutablePointer(to: &uuid) {`
`26`	`26`	`uuid_generate_random(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self))`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`fileprivate init(reference: NSUUID) {`
`31`	`31`	`var bytes: uuid_t = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)`
`32`		`- withUnsafeMutablePointer(&bytes) {`
	`32`	`+ withUnsafeMutablePointer(to: &bytes) {`
`33`	`33`	`reference.getBytes(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self))`
`34`	`34`	`}`
`35`	`35`	`uuid = bytes`
`@@ -39,7 +39,7 @@ public struct UUID : ReferenceConvertible, Hashable, Equatable, CustomStringConv`
`39`	`39`	`///`
`40`	`40`	`/// Returns nil for invalid strings.`
`41`	`41`	`public init?(uuidString string: String) {`
`42`		`- let res = withUnsafeMutablePointer(&uuid) {`
	`42`	`+ let res = withUnsafeMutablePointer(to: &uuid) {`
`43`	`43`	`return uuid_parse(string, unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self))`
`44`	`44`	`}`
`45`	`45`	`if res != 0 {`
`@@ -56,15 +56,17 @@ public struct UUID : ReferenceConvertible, Hashable, Equatable, CustomStringConv`
`56`	`56`	`public var uuidString: String {`
`57`	`57`	`var bytes: uuid_string_t = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)`
`58`	`58`	`var localValue = uuid`
`59`		`- return withUnsafeMutablePointers(&localValue, &bytes) { val, str -> String in`
`60`		`- uuid_unparse(unsafeBitCast(val, to: UnsafePointer<UInt8>.self), unsafeBitCast(str, to: UnsafeMutablePointer<Int8>.self))`
`61`		`- return String(cString: unsafeBitCast(str, to: UnsafePointer<CChar>.self), encoding: .utf8)!`
	`59`	`+ return withUnsafeMutablePointer(to: &localValue) { val in`
	`60`	`+ withUnsafeMutablePointer(to: &bytes) { str in`
	`61`	`+ uuid_unparse(unsafeBitCast(val, to: UnsafePointer<UInt8>.self), unsafeBitCast(str, to: UnsafeMutablePointer<Int8>.self))`
	`62`	`+ return String(cString: unsafeBitCast(str, to: UnsafePointer<CChar>.self), encoding: .utf8)!`
	`63`	`+ }`
`62`	`64`	`}`
`63`	`65`	`}`
`64`	`66`
`65`	`67`	`public var hashValue: Int {`
`66`	`68`	`var localValue = uuid`
`67`		`- return withUnsafeMutablePointer(&localValue) {`
	`69`	`+ return withUnsafeMutablePointer(to: &localValue) {`
`68`	`70`	`return Int(bitPattern: CFHashBytes(unsafeBitCast($0, to: UnsafeMutablePointer<UInt8>.self), CFIndex(sizeof(uuid_t.self))))`
`69`	`71`	`}`
`70`	`72`	`}`
`@@ -81,7 +83,7 @@ public struct UUID : ReferenceConvertible, Hashable, Equatable, CustomStringConv`
`81`	`83`
`82`	`84`	`fileprivate var reference: NSUUID {`
`83`	`85`	`var bytes = uuid`
`84`		`- return withUnsafePointer(&bytes) {`
	`86`	`+ return withUnsafePointer(to: &bytes) {`
`85`	`87`	`return NSUUID(uuidBytes: unsafeBitCast($0, to: UnsafePointer<UInt8>.self))`
`86`	`88`	`}`
`87`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ internal struct _CocoaArrayWrapper : RandomAccessCollection {`
`61`	`61`	`// subRange.upperBound items are stored contiguously. This is an`
`62`	`62`	`// acceptable conservative behavior, but could potentially be`
`63`	`63`	`// optimized for other cases.`
`64`		`- let contiguousCount = withUnsafeMutablePointer(&enumerationState) {`
	`64`	`+ let contiguousCount = withUnsafeMutablePointer(to: &enumerationState) {`
`65`	`65`	`self.buffer.countByEnumerating(with: $0, objects: nil, count: 0)`
`66`	`66`	`}`
`67`	`67`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ extension ${Self} {`
`56`	`56`	`let u16 = text.utf16`
`57`	`57`	`func parseNTBS(_ chars: UnsafePointer<CChar>) -> (${Self}, Int) {`
`58`	`58`	`var result: ${Self} = 0`
`59`		`- let endPtr = withUnsafeMutablePointer(&result) {`
	`59`	`+ let endPtr = withUnsafeMutablePointer(to: &result) {`
`60`	`60`	`_swift_stdlib_strto${cFuncSuffix2[bits]}_clocale(`
`61`	`61`	`chars, UnsafeMutablePointer($0))`
`62`	`62`	`}`