stdlib: use _withUnprotected... functions instead of Builtin.unprotectedAddressOf

Author: eeckstein

stdlib/public/core/AnyHashable.swift

@@ -159,10 +159,11 @@ public struct AnyHashable {
     }
 
     self.init(_box: _ConcreteHashableBox(false)) // Dummy value
-    let ptr = UnsafeMutablePointer<AnyHashable>(Builtin.unprotectedAddressOf(&self))
-    _makeAnyHashableUpcastingToHashableBaseType(
-      base,
-      storingResultInto: ptr)
+    _withUnprotectedUnsafeMutablePointer(to: &self) {
+      _makeAnyHashableUpcastingToHashableBaseType(
+        base,
+        storingResultInto: $0)
+    }
   }
 
   internal init<H: Hashable>(_usingDefaultRepresentationOf base: H) {

stdlib/public/core/KeyPath.swift

@@ -1951,8 +1951,9 @@ func _modifyAtWritableKeyPath_impl<Root, Value>(
       keyPath: _unsafeUncheckedDowncast(keyPath,
         to: ReferenceWritableKeyPath<Root, Value>.self))
   }
-  let ptr = UnsafePointer<Root>(Builtin.unprotectedAddressOf(&root))
-  return keyPath._projectMutableAddress(from: ptr)
+  return _withUnprotectedUnsafePointer(to: &root) {
+    keyPath._projectMutableAddress(from: $0)
+  }
 }
 
 // The release that ends the access scope is guaranteed to happen
@@ -1981,8 +1982,9 @@ func _setAtWritableKeyPath<Root, Value>(
       value: value)
   }
   // TODO: we should be able to do this more efficiently than projecting.
-  let ptr = UnsafePointer<Root>(Builtin.unprotectedAddressOf(&root))
-  let (addr, owner) = keyPath._projectMutableAddress(from: ptr)
+  let (addr, owner) = _withUnprotectedUnsafePointer(to: &root) {
+    keyPath._projectMutableAddress(from: $0)
+  }
   addr.pointee = value
   _fixLifetime(owner)
   // FIXME: this needs a deallocation barrier to ensure that the

stdlib/public/core/Random.swift

@@ -158,12 +158,9 @@ public struct SystemRandomNumberGenerator: RandomNumberGenerator, Sendable {
   @inlinable
   public mutating func next() -> UInt64 {
     var random: UInt64 = 0
-#if $BuiltinUnprotectedAddressOf
-    let ptr = UnsafeMutablePointer<UInt64>(Builtin.unprotectedAddressOf(&random))
-#else
-    let ptr = UnsafeMutablePointer<UInt64>(Builtin.addressof(&random))
-#endif
-    swift_stdlib_random(ptr, MemoryLayout<UInt64>.size)
+    _withUnprotectedUnsafeMutablePointer(to: &random) {
+      swift_stdlib_random($0, MemoryLayout<UInt64>.size)
+    }
     return random
   }
 }

stdlib/public/core/VarArgs.swift

@@ -215,15 +215,11 @@ public func _encodeBitsAsWords<T>(_ x: T) -> [Int] {
   _internalInvariant(!result.isEmpty)
   var tmp = x
   // FIXME: use UnsafeMutablePointer.assign(from:) instead of memcpy.
-#if $BuiltinUnprotectedAddressOf
-  _memcpy(dest: UnsafeMutablePointer(result._baseAddressIfContiguous!),
-          src: UnsafeMutablePointer(Builtin.unprotectedAddressOf(&tmp)),
-          size: UInt(MemoryLayout<T>.size))
-#else
-  _memcpy(dest: UnsafeMutablePointer(result._baseAddressIfContiguous!),
-          src: UnsafeMutablePointer(Builtin.addressof(&tmp)),
-          size: UInt(MemoryLayout<T>.size))
-#endif
+  _withUnprotectedUnsafeMutablePointer(to: &tmp) {
+    _memcpy(dest: UnsafeMutablePointer(result._baseAddressIfContiguous!),
+            src: $0,
+            size: UInt(MemoryLayout<T>.size))
+  }
   return result
 }