Use UnsafeRawPointer in StringCore.

This is another necessary step in introducing changes
for SE-0107: UnsafeRawPointer.

UnsafeRawPointer is great for bytewise pointer operations.

OpaquePointer goes away.

The _RawByte type goes away.

StringBuffer always binds memory to the correct CodeUnit
when allocating memory.

Before accessing the string, a dynamic element width check
allows us to assume the bound memory type.

Generic entry points like atomicCompareExchange no longer handle
both kinds of pointers. Normally that's good because you
should not be using generics in that case, just upcast
to raw pointer. However, with pointers-to-pointers
you can't do that.

Author: atrick

stdlib/public/SDK/GLKit/GLKit.swift.gyb

@@ -35,7 +35,7 @@ vectorElementNames = [
 public func _indexHomogeneousValue<TTT, T>(_ aggregate: UnsafePointer<TTT>,
                                            _ index: Int) -> T {
   return UnsafeRawPointer(aggregate).load(
-    fromByteOffset: index * strideof(T), as: T.self)
+    fromByteOffset: index * strideof(T.self), as: T.self)
 }
 
 %{

stdlib/public/core/Character.swift

@@ -183,7 +183,7 @@ public struct Character :
     }
     else {
       if let native = s._core.nativeBuffer,
-         native.start == UnsafeMutablePointer(s._core._baseAddress!) {
+         native.start == s._core._baseAddress! {
         _representation = .large(native._storage)
         return
       }

stdlib/public/core/Runtime.swift.gyb

@@ -20,19 +20,21 @@ import SwiftShims
 // Atomics
 //===----------------------------------------------------------------------===//
 
+public typealias _PointerToPointer = UnsafeMutablePointer<UnsafeRawPointer?>
+
 @_transparent
 public // @testable
-func _stdlib_atomicCompareExchangeStrongPtrImpl(
-  object target: UnsafeMutablePointer<UnsafeMutableRawPointer?>,
-  expected: UnsafeMutablePointer<UnsafeMutableRawPointer?>,
-  desired: UnsafeMutableRawPointer?) -> Bool {
+func _stdlib_atomicCompareExchangeStrongPtr(
+  object target: _PointerToPointer,
+  expected: _PointerToPointer,
+  desired: UnsafeRawPointer?) -> Bool {
 
   // We use Builtin.Word here because Builtin.RawPointer can't be nil.
   let (oldValue, won) = Builtin.cmpxchg_seqcst_seqcst_Word(
     target._rawValue,
     UInt(bitPattern: expected.pointee)._builtinWordValue,
     UInt(bitPattern: desired)._builtinWordValue)
-  expected.pointee = UnsafeMutableRawPointer(bitPattern: Int(oldValue))
+  expected.pointee = UnsafeRawPointer(bitPattern: Int(oldValue))
   return Bool(won)
 }
 
@@ -70,23 +72,23 @@ func _stdlib_atomicCompareExchangeStrongPtr<T>(
   object target: UnsafeMutablePointer<UnsafeMutablePointer<T>${optional}>,
   expected: UnsafeMutablePointer<UnsafeMutablePointer<T>${optional}>,
   desired: UnsafeMutablePointer<T>${optional}) -> Bool {
-  return _stdlib_atomicCompareExchangeStrongPtrImpl(
-    object: UnsafeMutablePointer(target),
-    expected: UnsafeMutablePointer(expected),
-    desired: UnsafeMutablePointer(desired))
+  return _stdlib_atomicCompareExchangeStrongPtr(
+    object: unsafeBitCast(target, to: _PointerToPointer.self),
+    expected: unsafeBitCast(expected, to: _PointerToPointer.self),
+    desired: unsafeBitCast(desired, to: Optional<UnsafeRawPointer>.self))
 }
-% end
+% end # optional
 
 @_transparent
 @discardableResult
 public // @testable
 func _stdlib_atomicInitializeARCRef(
   object target: UnsafeMutablePointer<AnyObject?>,
   desired: AnyObject) -> Bool {
-  var expected: UnsafeMutableRawPointer? = nil
+  var expected: UnsafeRawPointer? = nil
   let desiredPtr = Unmanaged.passRetained(desired).toOpaque()
-  let wonRace = _stdlib_atomicCompareExchangeStrongPtrImpl(
-    object: UnsafeMutablePointer(target),
+  let wonRace = _stdlib_atomicCompareExchangeStrongPtr(
+    object: unsafeBitCast(target, to: _PointerToPointer.self),
     expected: &expected,
     desired: desiredPtr)
   if !wonRace {

stdlib/public/core/String.swift

@@ -400,7 +400,7 @@ extension String : _ExpressibleByBuiltinUTF16StringLiteral {
   ) {
     self = String(
       _StringCore(
-        baseAddress: OpaquePointer(start),
+        baseAddress: UnsafeMutableRawPointer(start),
         count: Int(utf16CodeUnitCount),
         elementShift: 1,
         hasCocoaBuffer: false,
@@ -418,7 +418,7 @@ extension String : _ExpressibleByBuiltinStringLiteral {
     if Bool(isASCII) {
       self = String(
         _StringCore(
-          baseAddress: OpaquePointer(start),
+          baseAddress: UnsafeMutableRawPointer(start),
           count: Int(utf8CodeUnitCount),
           elementShift: 0,
           hasCocoaBuffer: false,
@@ -699,13 +699,15 @@ extension String : Hashable {
     }
 #else
     if self._core.isASCII {
-      return _swift_stdlib_unicode_hash_ascii(
-        UnsafeMutablePointer<Int8>(_core.startASCII),
-        Int32(_core.count))
+      return _core.startASCII.withMemoryRebound(
+        to: CChar.self, capacity: _core.count) {
+        _swift_stdlib_unicode_hash_ascii($0, Int32(_core.count))
+      }
     } else {
-      return _swift_stdlib_unicode_hash(
-        UnsafeMutablePointer<UInt16>(_core.startUTF16),
-        Int32(_core.count))
+      return _core.startUTF16.withMemoryRebound(
+        to: UInt16.self, capacity: _core.count) {
+        _swift_stdlib_unicode_hash($0, Int32(_core.count))
+      }
     }
 #endif
   }
@@ -821,7 +823,8 @@ internal func _nativeUnicodeLowercaseString(_ str: String) -> String {
     capacity: str._core.count, initialSize: str._core.count, elementWidth: 2)
 
   // Try to write it out to the same length.
-  let dest = UnsafeMutablePointer<UTF16.CodeUnit>(buffer.start)
+  let dest = buffer.start.bindMemory(
+    to: UTF16.CodeUnit.self, capacity: str._core.count)
   let z = _swift_stdlib_unicode_strToLower(
     dest, Int32(str._core.count),
     str._core.startUTF16, Int32(str._core.count))
@@ -831,7 +834,8 @@ internal func _nativeUnicodeLowercaseString(_ str: String) -> String {
   if correctSize != str._core.count {
     buffer = _StringBuffer(
       capacity: correctSize, initialSize: correctSize, elementWidth: 2)
-    let dest = UnsafeMutablePointer<UTF16.CodeUnit>(buffer.start)
+    let dest = buffer.start.bindMemory(
+      to: UTF16.CodeUnit.self, capacity: str._core.count)
     _swift_stdlib_unicode_strToLower(
       dest, Int32(correctSize), str._core.startUTF16, Int32(str._core.count))
   }
@@ -844,7 +848,8 @@ internal func _nativeUnicodeUppercaseString(_ str: String) -> String {
     capacity: str._core.count, initialSize: str._core.count, elementWidth: 2)
 
   // Try to write it out to the same length.
-  let dest = UnsafeMutablePointer<UTF16.CodeUnit>(buffer.start)
+  let dest = buffer.start.bindMemory(
+    to: UTF16.CodeUnit.self, capacity: str._core.count)
   let z = _swift_stdlib_unicode_strToUpper(
     dest, Int32(str._core.count),
     str._core.startUTF16, Int32(str._core.count))
@@ -854,7 +859,8 @@ internal func _nativeUnicodeUppercaseString(_ str: String) -> String {
   if correctSize != str._core.count {
     buffer = _StringBuffer(
       capacity: correctSize, initialSize: correctSize, elementWidth: 2)
-    let dest = UnsafeMutablePointer<UTF16.CodeUnit>(buffer.start)
+    let dest = buffer.start.bindMemory(
+      to: UTF16.CodeUnit.self, capacity: str._core.count)
     _swift_stdlib_unicode_strToUpper(
       dest, Int32(correctSize), str._core.startUTF16, Int32(str._core.count))
   }
@@ -904,7 +910,7 @@ extension String {
       let source = self._core.startASCII
       let buffer = _StringBuffer(
         capacity: count, initialSize: count, elementWidth: 1)
-      let dest = UnsafeMutablePointer<UInt8>(buffer.start)
+      let dest = buffer.start
       for i in 0..<count {
         // For each character in the string, we lookup if it should be shifted
         // in our ascii table, then we return 0x20 if it should, 0x0 if not.
@@ -923,7 +929,8 @@ extension String {
         // Since we are left with either 0x0 or 0x20, we can safely truncate to
         // a UInt8 and add to our ASCII value (this will not overflow numbers in
         // the ASCII range).
-        dest[i] = value &+ UInt8(truncatingBitPattern: add)
+        dest.storeBytes(of: value &+ UInt8(truncatingBitPattern: add),
+          toByteOffset: i, as: UInt8.self)
       }
       return String(_storage: buffer)
     }
@@ -953,15 +960,16 @@ extension String {
       let source = self._core.startASCII
       let buffer = _StringBuffer(
         capacity: count, initialSize: count, elementWidth: 1)
-      let dest = UnsafeMutablePointer<UInt8>(buffer.start)
+      let dest = buffer.start
       for i in 0..<count {
         // See the comment above in lowercaseString.
         let value = source[i]
         let isLower =
           _asciiLowerCaseTable >>
           UInt64(((value &- 1) & 0b0111_1111) >> 1)
         let add = (isLower & 0x1) << 5
-        dest[i] = value &- UInt8(truncatingBitPattern: add)
+        dest.storeBytes(of: value &- UInt8(truncatingBitPattern: add),
+          toByteOffset: i, as: UInt8.self)
       }
       return String(_storage: buffer)
     }

stdlib/public/core/StringBridge.swift

@@ -54,7 +54,7 @@ func _cocoaStringToSwiftString_NonASCII(
   let start = _stdlib_binary_CFStringGetCharactersPtr(cfImmutableValue)
 
   return String(_StringCore(
-    baseAddress: OpaquePointer(start),
+    baseAddress: start,
     count: length,
     elementShift: 1,
     hasCocoaBuffer: true,
@@ -81,7 +81,7 @@ internal func _cocoaStringToContiguous(
 
   _swift_stdlib_CFStringGetCharacters(
     source, _swift_shims_CFRange(location: startIndex, length: count), 
-    UnsafeMutablePointer<_swift_shims_UniChar>(buffer.start))
+    buffer.start.assumingMemoryBound(to: _swift_shims_UniChar.self))
 
   return buffer
 }
@@ -163,13 +163,13 @@ extension String {
 
     // start will hold the base pointer of contiguous storage, if it
     // is found.
-    var start: OpaquePointer?
+    var start: UnsafeMutableRawPointer?
     let isUTF16 = (nulTerminatedASCII == nil)
     if isUTF16 {
       let utf16Buf = _swift_stdlib_CFStringGetCharactersPtr(cfImmutableValue)
-      start = OpaquePointer(utf16Buf)
+      start = UnsafeMutableRawPointer(mutating: utf16Buf)
     } else {
-      start = OpaquePointer(nulTerminatedASCII)
+      start = UnsafeMutableRawPointer(mutating: nulTerminatedASCII)
     }
 
     self._core = _StringCore(

stdlib/public/core/StringBuffer.swift

@@ -19,7 +19,7 @@ struct _StringBufferIVars {
   }
 
   internal init(
-    _usedEnd: UnsafeMutablePointer<_RawByte>,
+    _usedEnd: UnsafeMutableRawPointer,
     byteCapacity: Int,
     elementWidth: Int
   ) {
@@ -31,7 +31,7 @@ struct _StringBufferIVars {
 
   // This stored property should be stored at offset zero.  We perform atomic
   // operations on it using _HeapBuffer's pointer.
-  var usedEnd: UnsafeMutablePointer<_RawByte>?
+  var usedEnd: UnsafeMutableRawPointer?
 
   var capacityAndElementShift: Int
   var byteCapacity: Int {
@@ -78,6 +78,14 @@ public struct _StringBuffer {
       _StringBufferIVars(_elementWidth: elementWidth),
       (capacity + capacityBump + divRound) >> divRound
     )
+    // This conditional branch should fold away during code gen.
+    if elementShift == 0 {
+      start.bindMemory(to: UTF8.CodeUnit.self, capacity: initialSize)
+    }
+    else {
+      start.bindMemory(to: UTF16.CodeUnit.self, capacity: initialSize)
+    }
+
     self.usedEnd = start + (initialSize << elementShift)
     _storage.value.capacityAndElementShift
       = ((_storage._capacity() - capacityBump) << 1) + elementShift
@@ -107,7 +115,7 @@ public struct _StringBuffer {
         elementWidth: isAscii ? 1 : 2)
 
     if isAscii {
-      var p = UnsafeMutablePointer<UTF8.CodeUnit>(result.start)
+      var p = result.start.assumingMemoryBound(to: UTF8.CodeUnit.self)
       let sink: (UTF32.CodeUnit) -> Void = {
         p.pointee = UTF8.CodeUnit($0)
         p += 1
@@ -137,12 +145,12 @@ public struct _StringBuffer {
 
   /// A pointer to the start of this buffer's data area.
   public // @testable
-  var start: UnsafeMutablePointer<_RawByte> {
-    return UnsafeMutablePointer(_storage.baseAddress)
+  var start: UnsafeMutableRawPointer {
+    return UnsafeMutableRawPointer(_storage.baseAddress)
   }
 
   /// A past-the-end pointer for this buffer's stored data.
-  var usedEnd: UnsafeMutablePointer<_RawByte> {
+  var usedEnd: UnsafeMutableRawPointer {
     get {
       return _storage.value.usedEnd!
     }
@@ -156,7 +164,7 @@ public struct _StringBuffer {
   }
 
   /// A past-the-end pointer for this buffer's available storage.
-  var capacityEnd: UnsafeMutablePointer<_RawByte> {
+  var capacityEnd: UnsafeMutableRawPointer {
     return start + _storage.value.byteCapacity
   }
 
@@ -181,11 +189,11 @@ public struct _StringBuffer {
   // two separate phases.  Operations with one-phase growth should use
   // "grow()," below.
   func hasCapacity(
-    _ cap: Int, forSubRange r: Range<UnsafePointer<_RawByte>>
+    _ cap: Int, forSubRange r: Range<UnsafeRawPointer>
   ) -> Bool {
     // The substring to be grown could be pointing in the middle of this
     // _StringBuffer.
-    let offset = (r.lowerBound - UnsafePointer(start)) >> elementShift
+    let offset = (r.lowerBound - UnsafeRawPointer(start)) >> elementShift
     return cap + offset <= capacity
   }
 
@@ -202,13 +210,14 @@ public struct _StringBuffer {
   @inline(__always)
   @discardableResult
   mutating func grow(
-    oldBounds bounds: Range<UnsafePointer<_RawByte>>, newUsedCount: Int
+    oldBounds bounds: Range<UnsafeRawPointer>, newUsedCount: Int
   ) -> Bool {
     var newUsedCount = newUsedCount
     // The substring to be grown could be pointing in the middle of this
     // _StringBuffer.  Adjust the size so that it covers the imaginary
     // substring from the start of the buffer to `oldUsedEnd`.
-    newUsedCount += (bounds.lowerBound - UnsafePointer(start)) >> elementShift
+    newUsedCount
+      += (bounds.lowerBound - UnsafeRawPointer(start)) >> elementShift
 
     if _slowPath(newUsedCount > capacity) {
       return false
@@ -230,11 +239,14 @@ public struct _StringBuffer {
     //  usedEnd = newUsedEnd
     //  return true
     // }
-    let usedEndPhysicalPtr =
-      UnsafeMutablePointer<UnsafeMutablePointer<_RawByte>>(_storage._value)
-    var expected = UnsafeMutablePointer<_RawByte>(bounds.upperBound)
+
+    // &StringBufferIVars.usedEnd
+    let usedEndPhysicalPtr = _PointerToPointer(_storage._value)
+    // Create a temp var to hold the exchanged `expected` value.
+    var expected : UnsafeRawPointer? = bounds.upperBound
     if _stdlib_atomicCompareExchangeStrongPtr(
-      object: usedEndPhysicalPtr, expected: &expected, desired: newUsedEnd) {
+      object: usedEndPhysicalPtr, expected: &expected,
+      desired: UnsafeRawPointer(newUsedEnd)) {
       return true
     }