[Concurrency] Mark expressions as unsafe.

Also fix a missing availability annotation.

rdar://141348916

Author: al45tair

stdlib/public/Concurrency/CFExecutor.swift

@@ -22,23 +22,23 @@ enum CoreFoundation {
   static let path =
     "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"
 
-  static let handle = dlopen(path, RTLD_NOLOAD)
+  static let handle = unsafe dlopen(path, RTLD_NOLOAD)
 
-  static var isPresent: Bool { return handle != nil }
+  static var isPresent: Bool { return unsafe handle != nil }
 
   static func symbol<T>(_ name: String) -> T {
-    guard let result = dlsym(handle, name) else {
+    guard let result = unsafe dlsym(handle, name) else {
       fatalError("Unable to look up \(name) in CoreFoundation")
     }
-    return unsafeBitCast(result, to: T.self)
+    return unsafe unsafeBitCast(result, to: T.self)
   }
 
   static let CFRunLoopRun: @convention(c) () -> () =
     symbol("CFRunLoopRun")
   static let CFRunLoopGetMain: @convention(c) () -> OpaquePointer =
-    symbol("CFRunLoopGetMain")
+    unsafe symbol("CFRunLoopGetMain")
   static let CFRunLoopStop: @convention(c) (OpaquePointer) -> () =
-    symbol("CFRunLoopStop")
+    unsafe symbol("CFRunLoopStop")
 }
 
 // .. Main Executor ............................................................
@@ -51,7 +51,7 @@ public final class CFMainExecutor: DispatchMainExecutor, @unchecked Sendable {
   }
 
   override public func stop() {
-    CoreFoundation.CFRunLoopStop(CoreFoundation.CFRunLoopGetMain())
+    unsafe CoreFoundation.CFRunLoopStop(CoreFoundation.CFRunLoopGetMain())
   }
 
 }

stdlib/public/Concurrency/Clock.swift

@@ -216,6 +216,7 @@ public struct ClockTraits: OptionSet {
   public static let wallTime = ClockTraits(rawValue: 1 << 2)
 }
 
+@available(SwiftStdlib 6.2, *)
 extension Clock {
   /// The traits associated with this clock instance.
   @available(SwiftStdlib 6.2, *)

stdlib/public/Concurrency/DispatchExecutor.swift

@@ -87,25 +87,25 @@ extension DispatchMainExecutor: EventableExecutor {
   public func registerEvent(
     handler: @escaping @Sendable () -> ()
   ) -> ExecutorEvent {
-    let source = _createDispatchEvent(handler: handler)
+    let source = unsafe _createDispatchEvent(handler: handler)
 
     // Stash the pointer in the id of the ExecutorEvent struct
-    let eventId = unsafeBitCast(source, to: Int.self)
+    let eventId = unsafe unsafeBitCast(source, to: Int.self)
     return ExecutorEvent(id: eventId)
   }
 
   /// Deregister the given event.
   public func deregister(event: ExecutorEvent) {
     // Extract the source and cancel it
-    let source = unsafeBitCast(event.id, to: OpaquePointer.self)
-    _destroyDispatchEvent(source)
+    let source = unsafe unsafeBitCast(event.id, to: OpaquePointer.self)
+    unsafe _destroyDispatchEvent(source)
   }
 
   /// Notify the executor of an event.
   public func notify(event: ExecutorEvent) {
     // Extract the source, but don't release it
-    let source = unsafeBitCast(event.id, to: OpaquePointer.self)
-    _signalDispatchEvent(source)
+    let source = unsafe unsafeBitCast(event.id, to: OpaquePointer.self)
+    unsafe _signalDispatchEvent(source)
   }
 
 }

stdlib/public/Concurrency/Executor.swift

@@ -418,7 +418,7 @@ public protocol TaskExecutor: Executor {
 @available(SwiftStdlib 6.0, *)
 extension TaskExecutor {
   public func asUnownedTaskExecutor() -> UnownedTaskExecutor {
-    UnownedTaskExecutor(ordinary: self)
+    unsafe UnownedTaskExecutor(ordinary: self)
   }
 }
 
@@ -648,11 +648,11 @@ extension Task where Success == Never, Failure == Never {
   @available(SwiftStdlib 6.2, *)
   @_unavailableInEmbedded
   public static var currentExecutor: (any Executor)? {
-    if let taskExecutor = _getPreferredTaskExecutor().asTaskExecutor() {
+    if let taskExecutor = unsafe _getPreferredTaskExecutor().asTaskExecutor() {
       return taskExecutor
-    } else if let activeExecutor = _getActiveExecutor().asSerialExecutor() {
+    } else if let activeExecutor = unsafe _getActiveExecutor().asSerialExecutor() {
       return activeExecutor
-    } else if let taskExecutor = _getCurrentTaskExecutor().asTaskExecutor() {
+    } else if let taskExecutor = unsafe _getCurrentTaskExecutor().asTaskExecutor() {
       return taskExecutor
     }
     return nil
@@ -717,9 +717,9 @@ public struct UnownedSerialExecutor: Sendable {
   @inlinable
   public init<E: SerialExecutor>(_ executor: __shared E) {
     if executor._isComplexEquality {
-      self.executor = Builtin.buildComplexEqualitySerialExecutorRef(executor)
+      unsafe self.executor = Builtin.buildComplexEqualitySerialExecutorRef(executor)
     } else {
-      self.executor = Builtin.buildOrdinarySerialExecutorRef(executor)
+      unsafe self.executor = Builtin.buildOrdinarySerialExecutorRef(executor)
     }
   }
 
@@ -731,12 +731,13 @@ public struct UnownedSerialExecutor: Sendable {
 
   @available(SwiftStdlib 6.2, *)
   public func asSerialExecutor() -> (any SerialExecutor)? {
-    return unsafeBitCast(executor, to: (any SerialExecutor)?.self)
+    return unsafe unsafeBitCast(executor, to: (any SerialExecutor)?.self)
   }
 }
 
 
 @available(SwiftStdlib 6.0, *)
+@unsafe
 @frozen
 public struct UnownedTaskExecutor: Sendable {
   @usableFromInline
@@ -746,28 +747,28 @@ public struct UnownedTaskExecutor: Sendable {
   /// which needs to reach for this from an @_transparent function which prevents @_spi use.
   @available(SwiftStdlib 6.0, *)
   public var _executor: Builtin.Executor {
-    self.executor
+    unsafe self.executor
   }
 
   @inlinable
   public init(_ executor: Builtin.Executor) {
-    self.executor = executor
+    unsafe self.executor = executor
   }
 
   @inlinable
   public init<E: TaskExecutor>(ordinary executor: __shared E) {
-    self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor)
+    unsafe self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor)
   }
 
   @available(SwiftStdlib 6.2, *)
   @inlinable
   public init<E: TaskExecutor>(_ executor: __shared E) {
-    self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor)
+    unsafe self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor)
   }
 
   @available(SwiftStdlib 6.2, *)
   public func asTaskExecutor() -> (any TaskExecutor)? {
-    return unsafeBitCast(executor, to: (any TaskExecutor)?.self)
+    return unsafe unsafeBitCast(executor, to: (any TaskExecutor)?.self)
   }
 }
 
@@ -869,7 +870,7 @@ internal func _task_serialExecutor_getExecutorRef<E>(_ executor: E) -> Builtin.E
 @_silgen_name("_task_taskExecutor_getTaskExecutorRef")
 internal func _task_taskExecutor_getTaskExecutorRef<E>(_ taskExecutor: E) -> Builtin.Executor
     where E: TaskExecutor {
-  return taskExecutor.asUnownedTaskExecutor().executor
+  return unsafe taskExecutor.asUnownedTaskExecutor().executor
 }
 
 // Used by the concurrency runtime

stdlib/public/Concurrency/ExecutorBridge.swift

@@ -130,11 +130,11 @@ fileprivate class DispatchEventHandlerBox {
 @available(SwiftStdlib 6.2, *)
 internal func _createDispatchEvent(handler: @escaping @Sendable () -> ()) -> OpaquePointer {
   let boxed = DispatchEventHandlerBox(handler: handler)
-  let opaqueHandlerBox = Unmanaged.passRetained(boxed).toOpaque()
-  return _createDispatchEventC(
+  let opaqueHandlerBox = unsafe Unmanaged.passRetained(boxed).toOpaque()
+  return unsafe _createDispatchEventC(
     handler: { context in
-      let unmanaged = Unmanaged<DispatchEventHandlerBox>.fromOpaque(context)
-      unmanaged.takeUnretainedValue().handler()
+      let unmanaged = unsafe Unmanaged<DispatchEventHandlerBox>.fromOpaque(context)
+      unsafe unmanaged.takeUnretainedValue().handler()
     },
     context: opaqueHandlerBox
   )
@@ -150,9 +150,9 @@ internal func _getDispatchEventContext(_ event: OpaquePointer) -> UnsafeMutableR
 
 @available(SwiftStdlib 6.2, *)
 internal func _destroyDispatchEvent(_ event: OpaquePointer) {
-  let context = _getDispatchEventContext(event)
-  Unmanaged<DispatchEventHandlerBox>.fromOpaque(context).release()
-  _destroyDispatchEventC(event)
+  let context = unsafe _getDispatchEventContext(event)
+  unsafe Unmanaged<DispatchEventHandlerBox>.fromOpaque(context).release()
+  unsafe _destroyDispatchEventC(event)
 }
 
 @available(SwiftStdlib 6.2, *)

stdlib/public/Concurrency/ExecutorImpl.swift

@@ -34,7 +34,7 @@ internal func dontateToGlobalExecutor(
   context: UnsafeMutableRawPointer
 ) {
   if let runnableExecutor = Task.defaultExecutor as? RunLoopExecutor {
-    try! runnableExecutor.run(until: { Bool(condition(context)) })
+    try! runnableExecutor.run(until: { unsafe Bool(condition(context)) })
   } else {
     fatalError("Global executor does not support thread donation")
   }
@@ -43,7 +43,7 @@ internal func dontateToGlobalExecutor(
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_task_getMainExecutorImpl")
 internal func getMainExecutor() -> UnownedSerialExecutor {
-  return UnownedSerialExecutor(MainActor.executor)
+  return unsafe UnownedSerialExecutor(MainActor.executor)
 }
 
 @available(SwiftStdlib 6.2, *)

stdlib/public/Concurrency/GlobalConcurrentExecutor.swift

@@ -62,7 +62,7 @@ internal final class _DefaultGlobalConcurrentExecutor: TaskExecutor {
     // We represent it as the `(0, 0)` ExecutorRef and it is handled properly
     // by the runtime, without having to call through to the
     // `_DefaultGlobalConcurrentExecutor` declared in Swift.
-    UnownedTaskExecutor(_getUndefinedTaskExecutor())
+    unsafe UnownedTaskExecutor(_getUndefinedTaskExecutor())
   }
 }
 

stdlib/public/Concurrency/PartialAsyncTask.swift

@@ -149,7 +149,7 @@ public struct UnownedJob: Sendable {
   @_alwaysEmitIntoClient
   @inlinable
   public func runSynchronously(on executor: UnownedTaskExecutor) {
-    _swiftJobRunOnTaskExecutor(self, executor)
+    unsafe _swiftJobRunOnTaskExecutor(self, executor)
   }
 
   /// Run this job isolated to the passed in serial executor, while executing it on the specified task executor.
@@ -324,9 +324,10 @@ public struct ExecutorJob: Sendable, ~Copyable {
   /// Returns the result of executing the closure.
   @available(SwiftStdlib 6.2, *)
   public func withUnsafeExecutorPrivateData<R>(body: (UnsafeMutableRawBufferPointer) throws -> R) rethrows -> R {
-    let base = _jobGetExecutorPrivateData(self.context)
-    let size = 2 * MemoryLayout<OpaquePointer>.stride
-    return try body(UnsafeMutableRawBufferPointer(start: base, count: size))
+    let base = unsafe _jobGetExecutorPrivateData(self.context)
+    let size = unsafe 2 * MemoryLayout<OpaquePointer>.stride
+    return unsafe try body(UnsafeMutableRawBufferPointer(start: base,
+                                                         count: size))
   }
 
   /// Kinds of schedulable jobs
@@ -418,7 +419,7 @@ extension ExecutorJob {
   @_alwaysEmitIntoClient
   @inlinable
   __consuming public func runSynchronously(on executor: UnownedTaskExecutor) {
-    _swiftJobRunOnTaskExecutor(UnownedJob(self), executor)
+    unsafe _swiftJobRunOnTaskExecutor(UnownedJob(self), executor)
   }
 
   /// Run this job isolated to the passed in serial executor, while executing it on the specified task executor.
@@ -476,44 +477,44 @@ extension ExecutorJob {
 
     /// Allocate a specified number of bytes of uninitialized memory.
     public func allocate(capacity: Int) -> UnsafeMutableRawBufferPointer {
-      let base = _jobAllocate(context, capacity)
-      return UnsafeMutableRawBufferPointer(start: base, count: capacity)
+      let base = unsafe _jobAllocate(context, capacity)
+      return unsafe UnsafeMutableRawBufferPointer(start: base, count: capacity)
     }
 
     /// Allocate uninitialized memory for a single instance of type `T`.
     public func allocate<T>(as type: T.Type) -> UnsafeMutablePointer<T> {
-      let base = _jobAllocate(context, MemoryLayout<T>.size)
-      return base.bindMemory(to: type, capacity: 1)
+      let base = unsafe _jobAllocate(context, MemoryLayout<T>.size)
+      return unsafe base.bindMemory(to: type, capacity: 1)
     }
 
     /// Allocate uninitialized memory for the specified number of
     /// instances of type `T`.
     public func allocate<T>(capacity: Int, as type: T.Type)
       -> UnsafeMutableBufferPointer<T> {
-      let base = _jobAllocate(context, MemoryLayout<T>.stride * capacity)
-      let typedBase = base.bindMemory(to: T.self, capacity: capacity)
-      return UnsafeMutableBufferPointer<T>(start: typedBase, count: capacity)
+      let base = unsafe _jobAllocate(context, MemoryLayout<T>.stride * capacity)
+      let typedBase = unsafe base.bindMemory(to: T.self, capacity: capacity)
+      return unsafe UnsafeMutableBufferPointer<T>(start: typedBase, count: capacity)
     }
 
     /// Deallocate previously allocated memory.  Note that the task
     /// allocator is stack disciplined, so if you deallocate a block of
     /// memory, all memory allocated after that block is also deallocated.
     public func deallocate(_ buffer: UnsafeMutableRawBufferPointer) {
-      _jobDeallocate(context, buffer.baseAddress!)
+      unsafe _jobDeallocate(context, buffer.baseAddress!)
     }
 
     /// Deallocate previously allocated memory.  Note that the task
     /// allocator is stack disciplined, so if you deallocate a block of
     /// memory, all memory allocated after that block is also deallocated.
     public func deallocate<T>(_ pointer: UnsafeMutablePointer<T>) {
-      _jobDeallocate(context, UnsafeMutableRawPointer(pointer))
+      unsafe _jobDeallocate(context, UnsafeMutableRawPointer(pointer))
     }
 
     /// Deallocate previously allocated memory.  Note that the task
     /// allocator is stack disciplined, so if you deallocate a block of
     /// memory, all memory allocated after that block is also deallocated.
     public func deallocate<T>(_ buffer: UnsafeMutableBufferPointer<T>) {
-      _jobDeallocate(context, UnsafeMutableRawPointer(buffer.baseAddress!))
+      unsafe _jobDeallocate(context, UnsafeMutableRawPointer(buffer.baseAddress!))
     }
 
   }

stdlib/public/Concurrency/Task+TaskExecutor.swift

@@ -146,7 +146,7 @@ public func withTaskExecutorPreference<T, Failure>(
   }
 
   let taskExecutorBuiltin: Builtin.Executor =
-      taskExecutor.asUnownedTaskExecutor().executor
+    unsafe taskExecutor.asUnownedTaskExecutor().executor
 
   let record = unsafe _pushTaskExecutorPreference(taskExecutorBuiltin)
   defer {
@@ -177,7 +177,7 @@ public func _unsafeInheritExecutor_withTaskExecutorPreference<T: Sendable>(
   }
 
   let taskExecutorBuiltin: Builtin.Executor =
-    taskExecutor.asUnownedTaskExecutor().executor
+    unsafe taskExecutor.asUnownedTaskExecutor().executor
 
   let record = unsafe _pushTaskExecutorPreference(taskExecutorBuiltin)
   defer {
@@ -458,7 +458,7 @@ extension UnsafeCurrentTask {
   @available(SwiftStdlib 6.0, *)
   public var unownedTaskExecutor: UnownedTaskExecutor? {
     let ref = _getPreferredUnownedTaskExecutor()
-    return UnownedTaskExecutor(ref)
+    return unsafe UnownedTaskExecutor(ref)
   }
 }