[Concurrency] Don't use blocks.

We can't use blocks, because Swift doesn't support them on Linux or
Windows.  Instead, use a C function pointer, and box up the handler.

rdar://141348916

Author: al45tair

Diff for: stdlib/public/Concurrency/ExecutorBridge.cpp

@@ -84,24 +84,29 @@ void *swift_job_getExecutorPrivateData(Job *job) {
 
 #if !SWIFT_CONCURRENCY_EMBEDDED
 extern "C" SWIFT_CC(swift)
-void *swift_createDispatchEvent(void (^handler)()) {
+void *swift_createDispatchEventC(void (*handler)(void *), void *context) {
   dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_OR,
                                                     0, 0,
                                                     dispatch_get_main_queue());
-  dispatch_source_set_event_handler(source, handler);
+  dispatch_source_set_event_handler_f(source, handler);
   dispatch_activate(source);
 
   return source;
 }
 
 extern "C" SWIFT_CC(swift)
-void swift_destroyDispatchEvent(void *event) {
+void swift_destroyDispatchEventC(void *event) {
   dispatch_source_t source = (dispatch_source_t)event;
 
   dispatch_source_cancel(source);
   dispatch_release(source);
 }
 
+extern "C" SWIFT_CC(swift)
+void *swift_getDispatchEventContext(void *event) {
+  return dispatch_get_context((dispatch_source_t)event);
+}
+
 extern "C" SWIFT_CC(swift)
 void swift_signalDispatchEvent(void *event) {
   dispatch_source_t source = (dispatch_source_t)event;

Diff for: stdlib/public/Concurrency/ExecutorBridge.swift

@@ -106,12 +106,46 @@ internal func _dispatchEnqueueWithDeadline(_ global: CBool,
 internal func _dispatchAssertMainQueue()
 
 @available(SwiftStdlib 6.2, *)
-@_silgen_name("swift_createDispatchEvent")
-internal func _createDispatchEvent(handler: @convention(block) @escaping () -> ()) -> OpaquePointer
+@_silgen_name("swift_createDispatchEventC")
+internal func _createDispatchEventC(
+  handler: @convention(c) @escaping (UnsafeMutableRawPointer) -> (),
+  context: UnsafeMutableRawPointer
+) -> OpaquePointer
+
+fileprivate class DispatchEventHandlerBox {
+  var handler: () -> ()
+  init(handler: @escaping () -> ()) {
+    self.handler = handler
+  }
+}
 
 @available(SwiftStdlib 6.2, *)
-@_silgen_name("swift_destroyDispatchEvent")
-internal func _destroyDispatchEvent(_ event: OpaquePointer)
+internal func _createDispatchEvent(handler: @escaping () -> ()) -> OpaquePointer {
+  let boxed = DispatchEventHandlerBox(handler: handler)
+  let opaqueHandlerBox = Unmanaged.passRetained(boxed).toOpaque()
+  return _createDispatchEventC(
+    handler: { context in
+      let unmanaged = Unmanaged<DispatchEventHandlerBox>.fromOpaque(context)
+      unmanaged.takeUnretainedValue().handler()
+    },
+    context: opaqueHandlerBox
+  )
+}
+
+@available(SwiftStdlib 6.2, *)
+@_silgen_name("swift_destroyDispatchEventC")
+internal func _destroyDispatchEventC(_ event: OpaquePointer)
+
+@available(SwiftStdlib 6.2, *)
+@_silgen_name("swift_getDispatchEventContext")
+internal func _getDispatchEventContext(_ event: OpaquePointer) -> UnsafeMutableRawPointer
+
+@available(SwiftStdlib 6.2, *)
+internal func _destroyDispatchEvent(_ event: OpaquePointer) {
+  let context = _getDispatchEventContext(event)
+  Unmanaged<DispatchEventHandlerBox>.fromOpaque(context).release()
+  _destroyDispatchEventC(event)
+}
 
 @available(SwiftStdlib 6.2, *)
 @_silgen_name("swift_signalDispatchEvent")