public struct RawByte => internal struct _RawByte

Author: gribozavr

stdlib/public/core/StringBridge.swift

@@ -162,7 +162,7 @@ extension String {
 
     // start will hold the base pointer of contiguous storage, if it
     // is found.
-    var start = UnsafeMutablePointer<RawByte>(nulTerminatedASCII)
+    var start = UnsafeMutablePointer<_RawByte>(nulTerminatedASCII)
     let isUTF16 = nulTerminatedASCII._isNull
     if (isUTF16) {
       start = UnsafeMutablePointer(_swift_stdlib_CFStringGetCharactersPtr(cfImmutableValue))

stdlib/public/core/StringBuffer.swift

@@ -18,7 +18,7 @@ struct _StringBufferIVars {
   }
 
   init(
-    usedEnd: UnsafeMutablePointer<RawByte>,
+    usedEnd: UnsafeMutablePointer<_RawByte>,
     byteCapacity: Int,
     elementWidth: Int
   ) {
@@ -30,7 +30,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: UnsafeMutablePointer<_RawByte>
 
   var capacityAndElementShift: Int
   var byteCapacity: Int {
@@ -127,12 +127,13 @@ public struct _StringBuffer {
   }
 
   /// A pointer to the start of this buffer's data area.
-  public var start: UnsafeMutablePointer<RawByte> {
+  public // @testable
+  var start: UnsafeMutablePointer<_RawByte> {
     return UnsafeMutablePointer(_storage.baseAddress)
   }
 
   /// A past-the-end pointer for this buffer's stored data.
-  var usedEnd: UnsafeMutablePointer<RawByte> {
+  var usedEnd: UnsafeMutablePointer<_RawByte> {
     get {
       return _storage.value.usedEnd
     }
@@ -146,7 +147,7 @@ public struct _StringBuffer {
   }
 
   /// A past-the-end pointer for this buffer's available storage.
-  var capacityEnd: UnsafeMutablePointer<RawByte> {
+  var capacityEnd: UnsafeMutablePointer<_RawByte> {
     return start + _storage.value.byteCapacity
   }
 
@@ -172,7 +173,7 @@ public struct _StringBuffer {
   // "grow()," below.
   @warn_unused_result
   func hasCapacity(
-    cap: Int, forSubRange r: Range<UnsafePointer<RawByte>>
+    cap: Int, forSubRange r: Range<UnsafePointer<_RawByte>>
   ) -> Bool {
     // The substring to be grown could be pointing in the middle of this
     // _StringBuffer.
@@ -191,7 +192,7 @@ public struct _StringBuffer {
   ///   to extend.
   /// - parameter newUsedCount: The desired size of the substring.
   mutating func grow(
-    bounds: Range<UnsafePointer<RawByte>>, newUsedCount: Int
+    bounds: Range<UnsafePointer<_RawByte>>, newUsedCount: Int
   ) -> Bool {
     var newUsedCount = newUsedCount
     // The substring to be grown could be pointing in the middle of this
@@ -220,8 +221,8 @@ public struct _StringBuffer {
     //  return true
     // }
     let usedEndPhysicalPtr =
-      UnsafeMutablePointer<UnsafeMutablePointer<RawByte>>(_storage._value)
-    var expected = UnsafeMutablePointer<RawByte>(bounds.endIndex)
+      UnsafeMutablePointer<UnsafeMutablePointer<_RawByte>>(_storage._value)
+    var expected = UnsafeMutablePointer<_RawByte>(bounds.endIndex)
     if _stdlib_atomicCompareExchangeStrongPtr(
       object: usedEndPhysicalPtr, expected: &expected, desired: newUsedEnd) {
       return true

stdlib/public/core/StringCore.swift

@@ -99,7 +99,7 @@ public struct _StringCore {
   func _pointerToNth(n: Int) -> OpaquePointer {
     _sanityCheck(hasContiguousStorage && n >= 0 && n <= count)
     return OpaquePointer(
-      UnsafeMutablePointer<RawByte>(_baseAddress) + (n << elementShift))
+      UnsafeMutablePointer<_RawByte>(_baseAddress) + (n << elementShift))
   }
 
   static func _copyElements(
@@ -194,7 +194,7 @@ public struct _StringCore {
   }
 
   /// Left shift amount to apply to an offset N so that when
-  /// added to a UnsafeMutablePointer<RawByte>, it traverses N elements.
+  /// added to a UnsafeMutablePointer<_RawByte>, it traverses N elements.
   var elementShift: Int {
     return Int(_countAndFlags >> (UInt._sizeInBits - 1))
   }
@@ -494,7 +494,7 @@ public struct _StringCore {
     if _fastPath(elementWidth == 1) {
       _sanityCheck(
         _pointerToNth(count)
-        == OpaquePointer(UnsafeMutablePointer<RawByte>(destination) + 1))
+        == OpaquePointer(UnsafeMutablePointer<_RawByte>(destination) + 1))
 
       UnsafeMutablePointer<UTF8.CodeUnit>(destination)[0] = UTF8.CodeUnit(u0)
     }
@@ -654,7 +654,7 @@ extension _StringCore : RangeReplaceableCollection {
     if _fastPath(!hasCocoaBuffer) {
       if _fastPath(isUniquelyReferencedNonObjC(&_owner)) {
 
-        let bounds: Range<UnsafePointer<RawByte>>
+        let bounds: Range<UnsafePointer<_RawByte>>
           = UnsafePointer(_pointerToNth(0))..<UnsafePointer(_pointerToNth(count))
 
         if _fastPath(nativeBuffer!.hasCapacity(n, forSubRange: bounds)) {

stdlib/public/core/UnsafePointer.swift.gyb

@@ -504,7 +504,8 @@ public func -= <Memory>(inout lhs: ${Self}<Memory>, rhs: Int) {
 /// any other types; it makes a decent parameter to
 /// `UnsafeMutablePointer<Memory>` when you just want to do bytewise
 /// pointer arithmetic.
-public struct RawByte {
+public // @testable
+struct _RawByte {
   let _inaccessible: UInt8
 }