Revert "UnsafePointer conversion fixes."

This reverts commit fbf8f36.

A unit test failed: AutolinkExtract.import_archive.swift

But only on ubuntu 15. Speculatively revert everything because I can't
spot any particular change that would affect functionality.

Author: atrick

Foundation/Data.swift

@@ -130,7 +130,7 @@ internal final class _SwiftNSData : NSData, _SwiftNativeFoundationType {
 
  This type provides "copy-on-write" behavior, and is also bridged to the Objective-C `NSData` class. You can wrap an instance of a custom subclass of `NSData` in `struct Data` by converting it using `myData as Data`.
 
- `Data` can be initialized with an `UnsafeRawPointer` and count, an array of `UInt8` (the primitive byte type), an `UnsafeBufferPointer`,the contents of a file, or base-64 encoded data or strings. The buffer-oriented functions provide an extra measure of safety by automatically performing the size calculation, as the type is known at compile time.
+ `Data` can be initialized with an `UnsafePointer` and count, an array of `UInt8` (the primitive byte type), or an `UnsafeBufferPointer`. The buffer-oriented functions provide an extra measure of safety by automatically performing the size calculation, as the type is known at compile time.
  */
 public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, Hashable, RandomAccessCollection, MutableCollection, _MutablePairBoxing {
     /// The Objective-C bridged type of `Data`.
@@ -161,7 +161,7 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
         case none
 
         /// A custom deallocator.
-        case custom((UnsafeMutableRawPointer, Int) -> Void)
+        case custom((UnsafeMutablePointer<UInt8>, Int) -> Void)
 
         fileprivate var _deallocator : ((UnsafeMutableRawPointer, Int) -> Void)? {
             switch self {
@@ -173,7 +173,8 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
                 return nil
             case .custom(let b):
                 return { (ptr, len) in
-                    b(ptr, len)
+                    let bytePtr = ptr.bindMemory(to: UInt8.self, capacity: len)
+                    b(bytePtr, len)
                 }
             }
         }
@@ -237,7 +238,7 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
     /// - parameter bytes: A pointer to the bytes.
     /// - parameter count: The size of the bytes.
     /// - parameter deallocator: Specifies the mechanism to free the indicated buffer, or `.none`.
-    public init(bytesNoCopy bytes: UnsafeMutableRawPointer, count: Int, deallocator: Deallocator) {
+    public init(bytesNoCopy bytes: UnsafeMutablePointer<UInt8>, count: Int, deallocator: Deallocator) {
         let whichDeallocator = deallocator._deallocator
         _wrapped = _SwiftNSData(immutableObject: NSData(bytesNoCopy: bytes, length: count, deallocator: whichDeallocator))
     }
@@ -347,7 +348,7 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
         _mapUnmanaged { $0.getBytes(pointer, length: count) }
     }
 
-    private func _copyBytesHelper(to pointer: UnsafeMutableRawPointer, from range: NSRange) {
+    private func _copyBytesHelper(to pointer: UnsafeMutablePointer<UInt8>, from range: NSRange) {
         _mapUnmanaged { $0.getBytes(pointer, range: range) }
     }
 
@@ -388,7 +389,7 @@ public struct Data : ReferenceConvertible, CustomStringConvertible, Equatable, H
         guard !copyRange.isEmpty else { return 0 }
 
         let nsRange = NSMakeRange(copyRange.lowerBound, copyRange.upperBound - copyRange.lowerBound)
-        let pointer = UnsafeMutableRawPointer(buffer.baseAddress!)
+        let pointer : UnsafeMutablePointer<UInt8> = UnsafeMutablePointer<UInt8>(buffer.baseAddress!)
         _copyBytesHelper(to: pointer, from: nsRange)
         return copyRange.count
     }

Foundation/NSFileManager.swift

@@ -252,12 +252,13 @@ public class FileManager: NSObject {
         }
 
         while let entry = readdir(dir!) {
-            let entryName = withUnsafePointer(to: &entry.pointee.d_name) {
-                String(cString: UnsafeRawPointer($0).assumingMemoryBound(to: CChar.self))
-            }
-            // TODO: `entryName` should be limited in length to `entry.memory.d_namlen`.
-            if entryName != "." && entryName != ".." {
-                contents.append(entryName)
+            if let entryName = withUnsafePointer(to: &entry.pointee.d_name, { (ptr) -> String? in
+                return String(cString: UnsafePointer<Int8>(ptr))
+            }) {
+                // TODO: `entryName` should be limited in length to `entry.memory.d_namlen`.
+                if entryName != "." && entryName != ".." {
+                    contents.append(entryName)
+                }
             }
         }
 
@@ -293,27 +294,31 @@ public class FileManager: NSObject {
         var entry = readdir(dir!)
 
         while entry != nil {
-            let entryName = withUnsafePointer(to: &entry!.pointee.d_name) {
-                String(cString: UnsafeRawPointer($0).assumingMemoryBound(to: CChar.self))
-            }
-            // TODO: `entryName` should be limited in length to `entry.memory.d_namlen`.
-            if entryName != "." && entryName != ".." {
-                contents.append(entryName)
+            if let entryName = withUnsafePointer(to: &entry!.pointee.d_name, { (ptr) -> String? in
+                let int8Ptr = unsafeBitCast(ptr, to: UnsafePointer<Int8>.self)
+                return String(cString: int8Ptr)
+            }) {
+                // TODO: `entryName` should be limited in length to `entry.memory.d_namlen`.
+                if entryName != "." && entryName != ".." {
+                    contents.append(entryName)
 
-                let entryType = withUnsafePointer(to: &entry!.pointee.d_type) { (ptr) -> Int32 in
-                    return Int32(ptr.pointee)
-                }
-                #if os(OSX) || os(iOS)
-                    let tempEntryType = entryType
-                #elseif os(Linux)
-                    let tempEntryType = Int(entryType)
-                #endif
+                    if let entryType = withUnsafePointer(to: &entry!.pointee.d_type, { (ptr) -> Int32? in
+                        let int32Ptr = unsafeBitCast(ptr, to: UnsafePointer<UInt8>.self)
+                        return Int32(int32Ptr.pointee)
+                    }) {
+                        #if os(OSX) || os(iOS)
+                            let tempEntryType = entryType
+                        #elseif os(Linux)
+                            let tempEntryType = Int(entryType)
+                        #endif
 
-                if tempEntryType == DT_DIR {
-                    let subPath: String = path + "/" + entryName
+                        if tempEntryType == DT_DIR {
+                            let subPath: String = path + "/" + entryName
 
-                    let entries =  try subpathsOfDirectory(atPath: subPath)
-                    contents.append(contentsOf: entries.map({file in "\(entryName)/\(file)"}))
+                            let entries =  try subpathsOfDirectory(atPath: subPath)
+                            contents.append(contentsOf: entries.map({file in "\(entryName)/\(file)"}))
+                        }
+                    }
                 }
             }
 
@@ -463,7 +468,7 @@ public class FileManager: NSObject {
 
             let fsRep = FileManager.default().fileSystemRepresentation(withPath: path)
             let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: 2)
-            ps.initialize(to: UnsafeMutablePointer(mutating: fsRep))
+            ps.initialize(to: UnsafeMutablePointer(fsRep))
             ps.advanced(by: 1).initialize(to: nil)
             let stream = fts_open(ps, FTS_PHYSICAL | FTS_XDEV | FTS_NOCHDIR, nil)
             ps.deinitialize(count: 2)
@@ -909,7 +914,7 @@ extension FileManager {
                 if FileManager.default().fileExists(atPath: path) {
                     let fsRep = FileManager.default().fileSystemRepresentation(withPath: path)
                     let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: 2)
-                    ps.initialize(to: UnsafeMutablePointer(mutating: fsRep))
+                    ps.initialize(to: UnsafeMutablePointer(fsRep))
                     ps.advanced(by: 1).initialize(to: nil)
                     _stream = fts_open(ps, FTS_PHYSICAL | FTS_XDEV | FTS_NOCHDIR, nil)
                     ps.deinitialize(count: 2)

Foundation/NSJSONSerialization.swift

@@ -111,8 +111,7 @@ public class JSONSerialization : NSObject {
             pretty: opt.contains(.prettyPrinted),
             writer: { (str: String?) in
                 if let str = str {
-                    let count = str.lengthOfBytes(using: .utf8)
-                    result.append(UnsafeRawPointer(str.cString(using: .utf8)!).bindMemory(to: UInt8.self, capacity: count), count: count)
+                    result.append(UnsafePointer<UInt8>(str.cString(using: .utf8)!), count: str.lengthOfBytes(using: .utf8))
                 }
             }
         )
@@ -636,11 +635,11 @@ private struct JSONReader {
     func parseNumber(_ input: Index) throws -> (Any, Index)? {
         func parseTypedNumber(_ address: UnsafePointer<UInt8>, count: Int) -> (Any, IndexDistance)? {
             let temp_buffer_size = 64
-            var temp_buffer = [Int8](repeating: 0, count: temp_buffer_size)
-            return temp_buffer.withUnsafeMutableBufferPointer { (buffer: inout UnsafeMutableBufferPointer<Int8>) -> (Any, IndexDistance)? in
+            var temp_buffer = [UInt8](repeating: 0, count: temp_buffer_size)
+            return temp_buffer.withUnsafeMutableBufferPointer { (buffer: inout UnsafeMutableBufferPointer<UInt8>) -> (Any, IndexDistance)? in
                 memcpy(buffer.baseAddress!, address, min(count, temp_buffer_size - 1)) // ensure null termination
 
-                let startPointer = buffer.baseAddress!
+                let startPointer = UnsafePointer<Int8>(buffer.baseAddress!)
                 let intEndPointer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: 1)
                 defer { intEndPointer.deallocate(capacity: 1) }
                 let doubleEndPointer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>.allocate(capacity: 1)

Foundation/NSRegularExpression.swift

@@ -130,9 +130,7 @@ internal func _NSRegularExpressionMatch(_ context: UnsafeMutableRawPointer?, ran
 #endif
         matcher.block(nil, NSMatchingFlags(rawValue: opts), UnsafeMutablePointer<ObjCBool>(stop))
     } else {
-        let result = ranges!.withMemoryRebound(to: NSRange.self, capacity: count) { rangePtr in
-            TextCheckingResult.regularExpressionCheckingResultWithRanges(rangePtr, count: count, regularExpression: matcher.regex)
-        }
+        let result = TextCheckingResult.regularExpressionCheckingResultWithRanges(NSRangePointer(ranges!), count: count, regularExpression: matcher.regex)
 #if os(OSX) || os(iOS)
         let flags = NSMatchingFlags(rawValue: options.rawValue)
 #else

Foundation/NSString.swift

@@ -469,7 +469,7 @@ extension NSString {
         var numCharsBuffered = 0
         var arrayBuffer = [unichar](repeating: 0, count: 100)
         let other = str._nsObject
-        return arrayBuffer.withUnsafeMutablePointerOrAllocation(selfLen, fastpath: UnsafeMutablePointer<unichar>(mutating: _fastContents)) { (selfChars: UnsafeMutablePointer<unichar>) -> String in
+        return arrayBuffer.withUnsafeMutablePointerOrAllocation(selfLen, fastpath: UnsafeMutablePointer<unichar>(_fastContents)) { (selfChars: UnsafeMutablePointer<unichar>) -> String in
             // Now do the binary search. Note that the probe value determines the length of the substring to check.
             while true {
                 let range = NSMakeRange(0, isLiteral ? probe + 1 : NSMaxRange(rangeOfComposedCharacterSequence(at: probe))) // Extend the end of the composed char sequence
@@ -1182,12 +1182,8 @@ extension NSString {
     }
 
     public convenience init?(UTF8String nullTerminatedCString: UnsafePointer<Int8>) {
-        let count = Int(strlen(nullTerminatedCString))
-        if let str = nullTerminatedCString.withMemoryRebound(to: UInt8.self, capacity: count, {
-            let buffer = UnsafeBufferPointer<UInt8>(start: $0, count: count)
-            return String._fromCodeUnitSequence(UTF8.self, input: buffer)
-            }) as String?
-        {
+        let buffer = UnsafeBufferPointer<UInt8>(start: UnsafePointer<UInt8>(nullTerminatedCString), count: Int(strlen(nullTerminatedCString)))
+        if let str = String._fromCodeUnitSequence(UTF8.self, input: buffer) {
             self.init(str)
         } else {
             return nil

Foundation/NSURL.swift

@@ -488,9 +488,7 @@ public class NSURL: NSObject, NSSecureCoding, NSCopying {
     /* Returns the URL's path in file system representation. File system representation is a null-terminated C string with canonical UTF-8 encoding.
     */
     public func getFileSystemRepresentation(_ buffer: UnsafeMutablePointer<Int8>, maxLength maxBufferLength: Int) -> Bool {
-        return buffer.withMemoryRebound(to: UInt8.self, capacity: maxBufferLength) {
-            CFURLGetFileSystemRepresentation(_cfObject, true, $0, maxBufferLength)
-        }
+        return CFURLGetFileSystemRepresentation(_cfObject, true, UnsafeMutablePointer<UInt8>(buffer), maxBufferLength)
     }
 
     /* Returns the URL's path in file system representation. File system representation is a null-terminated C string with canonical UTF-8 encoding. The returned C string will be automatically freed just as a returned object would be released; your code should copy the representation or use getFileSystemRepresentation:maxLength: if it needs to store the representation outside of the autorelease context in which the representation is created.

Foundation/NSXMLElement.swift

@@ -74,12 +74,8 @@ public class XMLElement: XMLNode {
         @abstract Adds an attribute. Attributes with duplicate names are not added.
     */
     public func addAttribute(_ attribute: XMLNode) {
-        let name = _CFXMLNodeGetName(attribute._xmlNode)!
-        let len = strlen(name)
-        name.withMemoryRebound(to: UInt8.self, capacity: Int(len)) {
-            guard _CFXMLNodeHasProp(_xmlNode, $0) == nil else { return }
-            addChild(attribute)
-        }
+        guard _CFXMLNodeHasProp(_xmlNode, UnsafePointer<UInt8>(_CFXMLNodeGetName(attribute._xmlNode)!)) == nil else { return }
+        addChild(attribute)
     } //primitive
 
     /*!