[Concurrency] Fix task-to-thread model linking.

We need to provide some of the additional functions, as stubs, for
task-to-thread model.

rdar://141348916

Author: al45tair

stdlib/public/Concurrency/Executor.swift

@@ -36,12 +36,7 @@ public protocol Executor: AnyObject, Sendable {
   func enqueue(_ job: consuming ExecutorJob)
   #endif // !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 
-  #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
-  // The functions below could have been added to a separate protocol,
-  // but doing that would then mean doing an `as?` cast in e.g.
-  // enqueueOnGlobalExecutor (in ExecutorBridge.swift), which is
-  // undesirable from a performance perspective.
-
+  #if !$Embedded
   /// `true` if this is the main executor.
   @available(SwiftStdlib 6.2, *)
   var isMainExecutor: Bool { get }
@@ -125,7 +120,7 @@ extension Executor where Self: Equatable {
 
 extension Executor {
 
-  #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+  #if !$Embedded
   // This defaults to `false` so that existing third-party Executor
   // implementations will work as expected.
   @available(SwiftStdlib 6.2, *)

stdlib/public/Concurrency/ExecutorBridge.cpp

@@ -27,6 +27,13 @@ void _swift_exit(int result) {
   exit(result);
 }
 
+#if SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+extern "C" SWIFT_CC(swift)
+SerialExecutorRef swift_getMainExecutor() {
+  return SerialExecutorRef::generic();
+}
+#endif
+
 extern "C" SWIFT_CC(swift)
 void _swift_task_checkIsolatedSwift(
   HeapObject *executor,

stdlib/public/Concurrency/ExecutorBridge.swift

@@ -21,7 +21,7 @@ import Swift
 @_silgen_name("_swift_exit")
 internal func _exit(result: CInt)
 
-#if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+#if !$Embedded
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("_swift_task_isMainExecutorSwift")
 internal func _isMainExecutor<E>(_ executor: E) -> Bool where E: SerialExecutor {
@@ -79,13 +79,20 @@ internal func _jobGetExecutorPrivateData(
   _ job: Builtin.Job
 ) -> UnsafeMutableRawPointer
 
-#if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+#if !$Embedded
+#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_getMainExecutor")
-internal func _getMainExecutor() -> any MainExecutor {
+internal func _getMainExecutor() -> any SerialExecutor {
   return MainActor.executor
 }
-#endif
+#else
+// For task-to-thread model, this is implemented in C++
+@available(SwiftStdlib 6.2, *)
+@_silgen_name("swift_getMainExecutor")
+internal func _getMainExecutor() -> any SerialExecutor
+#endif // SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+#endif // !$Embedded
 
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_dispatchMain")

stdlib/public/Concurrency/ExecutorImpl.swift

@@ -20,14 +20,16 @@
 
 import Swift
 
-#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_task_asyncMainDrainQueueImpl")
 internal func drainMainQueue() {
+  #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   try! MainActor.executor.run()
   _exit(result: 0)
+  #else
+  fatalError("swift_task_asyncMainDrainQueue() not supported with task-to-thread")
+  #endif
 }
-#endif
 
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_task_donateThreadToGlobalExecutorUntilImpl")
@@ -42,34 +44,40 @@ internal func dontateToGlobalExecutor(
   }
 }
 
-#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_task_getMainExecutorImpl")
 internal func getMainExecutor() -> UnownedSerialExecutor {
-  return unsafe UnownedSerialExecutor(MainActor.executor)
+  return unsafe _getMainExecutor().asUnownedSerialExecutor()
 }
 
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_task_enqueueMainExecutorImpl")
 internal func enqueueOnMainExecutor(job unownedJob: UnownedJob) {
+  #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   MainActor.executor.enqueue(unownedJob)
+  #else
+  fatalError("swift_task_enqueueMainExecutor() not supported for task-to-thread")
+  #endif
 }
-#endif
 
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_task_enqueueGlobalImpl")
 internal func enqueueOnGlobalExecutor(job unownedJob: UnownedJob) {
   Task.defaultExecutor.enqueue(unownedJob)
 }
 
-#if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
+#if !$Embedded
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_task_enqueueGlobalWithDelayImpl")
 internal func enqueueOnGlobalExecutor(delay: CUnsignedLongLong,
                                       job unownedJob: UnownedJob) {
+  #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   Task.defaultExecutor.asSchedulable!.enqueue(ExecutorJob(unownedJob),
                                               after: .nanoseconds(delay),
                                               clock: .continuous)
+  #else
+  fatalError("swift_task_enqueueGlobalWithDelay() not supported for task-to-thread")
+  #endif
 }
 
 @available(SwiftStdlib 6.2, *)
@@ -80,6 +88,7 @@ internal func enqueueOnGlobalExecutor(seconds: CLongLong,
                                       leewayNanoseconds: CLongLong,
                                       clock: CInt,
                                       job unownedJob: UnownedJob) {
+  #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   let delay = Duration.seconds(seconds) + Duration.nanoseconds(nanoseconds)
   let leeway = Duration.seconds(leewaySeconds) + Duration.nanoseconds(leewayNanoseconds)
   switch clock {
@@ -96,5 +105,8 @@ internal func enqueueOnGlobalExecutor(seconds: CLongLong,
     default:
       fatalError("Unknown clock ID \(clock)")
   }
+  #else
+  fatalError("swift_task_enqueueGlobalWithDeadline() not supported for task-to-thread")
+  #endif
 }
 #endif