Apply Fix-Its for @safe/@unsafe throughout more libraries

Author: DougGregor

stdlib/private/SwiftPrivate/IO.swift

@@ -28,7 +28,7 @@ import Android
 #elseif canImport(WASILibc)
 import WASILibc
 #endif
-let (platform_read, platform_write, platform_close) = (read, write, close)
+@unsafe let (platform_read, platform_write, platform_close) = (read, write, close)
 #endif 
 
 #if os(Windows)
@@ -121,7 +121,7 @@ public struct _FDInputStream {
     return nil
   }
 
-  public mutating func read() {
+  @safe(unchecked) public mutating func read() {
     let minFree = 128
     var bufferFree = _buffer.count - _bufferUsed
     if bufferFree < minFree {
@@ -213,7 +213,7 @@ public struct _FDOutputStream : TextOutputStream {
     self.fd = fd
   }
 
-  public mutating func write(_ string: String) {
+  @safe(unchecked) public mutating func write(_ string: String) {
     let utf8CStr = string.utf8CString
     utf8CStr.withUnsafeBufferPointer {
       (utf8CStr) -> Void in

stdlib/private/SwiftPrivate/ShardedAtomicCounter.swift

@@ -28,10 +28,10 @@ public struct _stdlib_ShardedAtomicCounter {
   // Using an array causes retains/releases, which create contention on the
   // reference count.
   // FIXME: guard every element against false sharing.
-  var _shardsPtr: UnsafeMutablePointer<Int>
+  @unsafe var _shardsPtr: UnsafeMutablePointer<Int>
   var _shardsCount: Int
 
-  public init() {
+  @safe(unchecked) public init() {
     let hardwareConcurrency = _stdlib_getHardwareConcurrency()
     let count = max(8, hardwareConcurrency * hardwareConcurrency)
     let shards = UnsafeMutablePointer<Int>.allocate(capacity: count)
@@ -42,19 +42,19 @@ public struct _stdlib_ShardedAtomicCounter {
     self._shardsCount = count
   }
 
-  public func `deinit`() {
+  @safe(unchecked) public func `deinit`() {
     self._shardsPtr.deinitialize(count: self._shardsCount)
     self._shardsPtr.deallocate()
   }
 
-  public func add(_ operand: Int, randomInt: Int) {
+  @safe(unchecked) public func add(_ operand: Int, randomInt: Int) {
     let shardIndex = Int(UInt(bitPattern: randomInt) % UInt(self._shardsCount))
     _ = _swift_stdlib_atomicFetchAddInt(
       object: self._shardsPtr + shardIndex, operand: operand)
   }
 
   // FIXME: non-atomic as a whole!
-  public func getSum() -> Int {
+  @safe(unchecked) public func getSum() -> Int {
     var result = 0
     let shards = self._shardsPtr
     let count = self._shardsCount

stdlib/private/SwiftPrivate/SwiftPrivate.swift

@@ -57,7 +57,7 @@ public func scatter<T>(_ a: [T], _ idx: [Int]) -> [T] {
   return result
 }
 
-public func withArrayOfCStrings<R>(
+@unsafe public func withArrayOfCStrings<R>(
   _ args: [String], _ body: ([UnsafeMutablePointer<CChar>?]) -> R
 ) -> R {
   let argsCounts = Array(args.map { $0.utf8.count + 1 })

stdlib/private/SwiftPrivateLibcExtras/Subprocess.swift

@@ -188,31 +188,31 @@ public func posixWaitpid(_ pid: pid_t) -> ProcessTerminationStatus {
 #if os(Linux)
 typealias _stdlib_posix_spawn_file_actions_t = posix_spawn_file_actions_t
 #else
-typealias _stdlib_posix_spawn_file_actions_t = posix_spawn_file_actions_t?
+@unsafe typealias _stdlib_posix_spawn_file_actions_t = posix_spawn_file_actions_t?
 #endif
 
-@_silgen_name("_stdlib_posix_spawn_file_actions_init")
+@unsafe @_silgen_name("_stdlib_posix_spawn_file_actions_init")
 internal func _stdlib_posix_spawn_file_actions_init(
   _ file_actions: UnsafeMutablePointer<_stdlib_posix_spawn_file_actions_t>
 ) -> CInt
 
-@_silgen_name("_stdlib_posix_spawn_file_actions_destroy")
+@unsafe @_silgen_name("_stdlib_posix_spawn_file_actions_destroy")
 internal func _stdlib_posix_spawn_file_actions_destroy(
   _ file_actions: UnsafeMutablePointer<_stdlib_posix_spawn_file_actions_t>
 ) -> CInt
 
-@_silgen_name("_stdlib_posix_spawn_file_actions_addclose")
+@unsafe @_silgen_name("_stdlib_posix_spawn_file_actions_addclose")
 internal func _stdlib_posix_spawn_file_actions_addclose(
   _ file_actions: UnsafeMutablePointer<_stdlib_posix_spawn_file_actions_t>,
   _ filedes: CInt) -> CInt
 
-@_silgen_name("_stdlib_posix_spawn_file_actions_adddup2")
+@unsafe @_silgen_name("_stdlib_posix_spawn_file_actions_adddup2")
 internal func _stdlib_posix_spawn_file_actions_adddup2(
   _ file_actions: UnsafeMutablePointer<_stdlib_posix_spawn_file_actions_t>,
   _ filedes: CInt,
   _ newfiledes: CInt) -> CInt
 
-@_silgen_name("_stdlib_posix_spawn")
+@unsafe @_silgen_name("_stdlib_posix_spawn")
 internal func _stdlib_posix_spawn(
   _ pid: UnsafeMutablePointer<pid_t>?,
   _ file: UnsafePointer<Int8>,
@@ -223,7 +223,7 @@ internal func _stdlib_posix_spawn(
 #endif
 
 /// Calls POSIX `pipe()`.
-func posixPipe() -> (readFD: CInt, writeFD: CInt) {
+@safe(unchecked) func posixPipe() -> (readFD: CInt, writeFD: CInt) {
   var fds: [CInt] = [ -1, -1 ]
   if pipe(&fds) != 0 {
     preconditionFailure("pipe() failed")
@@ -257,7 +257,7 @@ func print(_ s: String) {
 
 /// Start the same executable as a child process, redirecting its stdout and
 /// stderr.
-public func spawnChild(_ args: [String])
+@safe(unchecked) public func spawnChild(_ args: [String])
   -> (pid: pid_t, stdinFD: CInt, stdoutFD: CInt, stderrFD: CInt) {
   // The stdout, stdin, and stderr from the child process will be redirected
   // to these pipes.
@@ -450,14 +450,14 @@ internal func _make_posix_spawn_file_actions_t()
   return posix_spawn_file_actions_t()
 }
 #else
-internal func _make_posix_spawn_file_actions_t()
+@unsafe internal func _make_posix_spawn_file_actions_t()
   -> _stdlib_posix_spawn_file_actions_t {
   return nil
 }
 #endif
 #endif
 
-public func posixWaitpid(_ pid: pid_t) -> ProcessTerminationStatus {
+@safe(unchecked) public func posixWaitpid(_ pid: pid_t) -> ProcessTerminationStatus {
   var status: CInt = 0
 #if os(Cygwin)
   withUnsafeMutablePointer(to: &status) {

stdlib/private/SwiftPrivateLibcExtras/SwiftPrivateLibcExtras.swift

@@ -25,7 +25,7 @@ import WASILibc
 import CRT
 #endif
 
-public func _stdlib_mkstemps(_ template: inout String, _ suffixlen: CInt) -> CInt {
+@safe(unchecked) public func _stdlib_mkstemps(_ template: inout String, _ suffixlen: CInt) -> CInt {
 #if os(Android) || os(Haiku) || os(Windows) || os(WASI)
   preconditionFailure("mkstemps doesn't work on your platform")
 #else
@@ -78,7 +78,7 @@ public struct _stdlib_fd_set {
       ~UInt(1 << (fdInt % _stdlib_fd_set._wordBits))
   }
 
-  public mutating func zero() {
+  @safe(unchecked) public mutating func zero() {
     let count = _data.count
     return _data.withUnsafeMutableBufferPointer {
       (_data) in
@@ -90,7 +90,7 @@ public struct _stdlib_fd_set {
   }
 }
 
-public func _stdlib_select(
+@unsafe public func _stdlib_select(
   _ readfds: inout _stdlib_fd_set, _ writefds: inout _stdlib_fd_set,
   _ errorfds: inout _stdlib_fd_set, _ timeout: UnsafeMutablePointer<timeval>?
 ) -> CInt {
@@ -126,7 +126,7 @@ public func _stdlib_select(
 
 
 /// Swift-y wrapper around pipe(2)
-public func _stdlib_pipe() -> (readEnd: CInt, writeEnd: CInt, error: CInt) {
+@safe(unchecked) public func _stdlib_pipe() -> (readEnd: CInt, writeEnd: CInt, error: CInt) {
   var fds: [CInt] = [0, 0]
   let ret = fds.withUnsafeMutableBufferPointer { unsafeFds -> CInt in
 #if os(Windows)

stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift

@@ -36,7 +36,7 @@ internal class ThreadBlockContext {
   /// Execute the block, and return an `UnsafeMutablePointer` to memory
   /// allocated with `UnsafeMutablePointer.alloc` containing the result of the
   /// block.
-  func run() -> UnsafeMutableRawPointer { fatalError("abstract") }
+  @unsafe func run() -> UnsafeMutableRawPointer { fatalError("abstract") }
 }
 
 internal class ThreadBlockContextImpl<Argument, Result>: ThreadBlockContext {
@@ -49,15 +49,15 @@ internal class ThreadBlockContextImpl<Argument, Result>: ThreadBlockContext {
     super.init()
   }
 
-  override func run() -> UnsafeMutableRawPointer {
+  @unsafe override func run() -> UnsafeMutableRawPointer {
     let result = UnsafeMutablePointer<Result>.allocate(capacity: 1)
     result.initialize(to: block(arg))
     return UnsafeMutableRawPointer(result)
   }
 }
 
 /// Entry point for `pthread_create` that invokes a block context.
-internal func invokeBlockContext(
+@unsafe internal func invokeBlockContext(
   _ contextAsVoidPointer: UnsafeMutableRawPointer?
 ) -> UnsafeMutableRawPointer! {
   // The context is passed in +1; we're responsible for releasing it.
@@ -71,21 +71,21 @@ internal func invokeBlockContext(
 #if os(Windows)
 public typealias ThreadHandle = HANDLE
 #else
-public typealias ThreadHandle = pthread_t
+@unsafe public typealias ThreadHandle = pthread_t
 
 #if (os(Linux) && !canImport(Musl)) || os(Android)
 internal func _make_pthread_t() -> pthread_t {
   return pthread_t()
 }
 #else
-internal func _make_pthread_t() -> pthread_t? {
+@unsafe internal func _make_pthread_t() -> pthread_t? {
   return nil
 }
 #endif
 #endif
 
 /// Block-based wrapper for `pthread_create`.
-public func _stdlib_thread_create_block<Argument, Result>(
+@unsafe public func _stdlib_thread_create_block<Argument, Result>(
   _ start_routine: @escaping (Argument) -> Result,
   _ arg: Argument
 ) -> (CInt, ThreadHandle?) {
@@ -120,7 +120,7 @@ public func _stdlib_thread_create_block<Argument, Result>(
 }
 
 /// Block-based wrapper for `pthread_join`.
-public func _stdlib_thread_join<Result>(
+@unsafe public func _stdlib_thread_join<Result>(
   _ thread: ThreadHandle,
   _ resultType: Result.Type
 ) -> (CInt, Result?) {
@@ -160,12 +160,12 @@ public func _stdlib_thread_join<Result>(
 public class _stdlib_Barrier {
   var _threadBarrier: _stdlib_thread_barrier_t
 
-  var _threadBarrierPtr: UnsafeMutablePointer<_stdlib_thread_barrier_t> {
+  @unsafe var _threadBarrierPtr: UnsafeMutablePointer<_stdlib_thread_barrier_t> {
     return _getUnsafePointerToStoredProperties(self)
       .assumingMemoryBound(to: _stdlib_thread_barrier_t.self)
   }
 
-  public init(threadCount: Int) {
+  @safe(unchecked) public init(threadCount: Int) {
     self._threadBarrier = _stdlib_thread_barrier_t()
     let ret = _stdlib_thread_barrier_init(
       _threadBarrierPtr, CUnsignedInt(threadCount))
@@ -174,11 +174,11 @@ public class _stdlib_Barrier {
     }
   }
 
-  deinit {
+  @safe(unchecked) deinit {
     _stdlib_thread_barrier_destroy(_threadBarrierPtr)
   }
 
-  public func wait() {
+  @safe(unchecked) public func wait() {
     let ret = _stdlib_thread_barrier_wait(_threadBarrierPtr)
     if !(ret == 0 || ret == _stdlib_THREAD_BARRIER_SERIAL_THREAD) {
       fatalError("_stdlib_thread_barrier_wait() failed")

stdlib/private/SwiftPrivateThreadExtras/ThreadBarriers.swift

@@ -45,8 +45,8 @@ public struct _stdlib_thread_barrier_t {
 #elseif os(WASI)
   // pthread is currently not available on WASI
 #else
-  var mutex: UnsafeMutablePointer<pthread_mutex_t>?
-  var cond: UnsafeMutablePointer<pthread_cond_t>?
+  @unsafe var mutex: UnsafeMutablePointer<pthread_mutex_t>?
+  @unsafe var cond: UnsafeMutablePointer<pthread_cond_t>?
 #endif
 
   /// The number of threads to synchronize.
@@ -60,7 +60,7 @@ public struct _stdlib_thread_barrier_t {
   public init() {}
 }
 
-public func _stdlib_thread_barrier_init(
+@unsafe public func _stdlib_thread_barrier_init(
   _ barrier: UnsafeMutablePointer<_stdlib_thread_barrier_t>,
   _ count: CUnsignedInt
 ) -> CInt {
@@ -93,7 +93,7 @@ public func _stdlib_thread_barrier_init(
 }
 
 #if !os(Windows) && !os(WASI)
-private func _stdlib_thread_barrier_mutex_and_cond_init(_ barrier: UnsafeMutablePointer<_stdlib_thread_barrier_t>) -> CInt {
+@unsafe private func _stdlib_thread_barrier_mutex_and_cond_init(_ barrier: UnsafeMutablePointer<_stdlib_thread_barrier_t>) -> CInt {
   guard pthread_mutex_init(barrier.pointee.mutex!, nil) == 0 else {
     return -1
   }
@@ -105,7 +105,7 @@ private func _stdlib_thread_barrier_mutex_and_cond_init(_ barrier: UnsafeMutable
 }
 #endif
 
-public func _stdlib_thread_barrier_destroy(
+@unsafe public func _stdlib_thread_barrier_destroy(
   _ barrier: UnsafeMutablePointer<_stdlib_thread_barrier_t>
 ) {
 #if os(Windows)
@@ -131,7 +131,7 @@ public func _stdlib_thread_barrier_destroy(
   return
 }
 
-public func _stdlib_thread_barrier_wait(
+@unsafe public func _stdlib_thread_barrier_wait(
   _ barrier: UnsafeMutablePointer<_stdlib_thread_barrier_t>
 ) -> CInt {
 #if os(Windows)