[Concurrency] Make DispatchMainExecutor safer.

Don't shoehorn pointers into the `ExecutorEvent`; instead, keep a
table.  This does mean using a `Mutex`, sadly, but that's the price
we pay for being safe.

Also, this lets us destroy the Dispatch sources properly.

rdar://141348916

Author: al45tair

stdlib/public/Concurrency/DispatchExecutor.swift

@@ -13,6 +13,7 @@
 #if !$Embedded
 
 import Swift
+import Synchronization
 
 // We can't import Dispatch from here, sadly, because it apparently has a
 // transitive dependency on Combine (which in turn depends on _Concurrency).
@@ -24,11 +25,28 @@ import Swift
 // .. Main Executor ............................................................
 
 @available(SwiftStdlib 6.2, *)
+@safe
 public class DispatchMainExecutor: RunLoopExecutor, @unchecked Sendable {
   var threaded = false
 
+  @unsafe
+  struct EventTable {
+    var nextEvent: Int = 0
+    var events: [Int: OpaquePointer] = unsafe [:]
+  }
+
+  let eventTable = unsafe Mutex<EventTable>(EventTable())
+
   public init() {}
 
+  deinit {
+    eventTable.withLock { table in
+      for (ident, source) in table.events {
+        _destroyDispatchEvent(source)
+      }
+    }
+  }
+
   public func run() throws {
     if threaded {
       fatalError("DispatchMainExecutor does not support recursion")
@@ -88,23 +106,35 @@ extension DispatchMainExecutor: EventableExecutor {
     handler: @escaping @Sendable () -> ()
   ) -> ExecutorEvent {
     let source = unsafe _createDispatchEvent(handler: handler)
+    let eventId = unsafe eventTable.withLock { table in
+      let eventId = table.nextEvent
+      table.nextEvent += 1
+      table.events[eventId] = unsafe source
+      return eventId
+    }
 
-    // Stash the pointer in the id of the ExecutorEvent struct
-    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 = unsafe unsafeBitCast(event.id, to: OpaquePointer.self)
+    guard let source = unsafe eventTable.withLock(
+            { unsafe $0.events.removeValue(forKey: event.id) }
+          ) else {
+      return
+    }
+
     unsafe _destroyDispatchEvent(source)
   }
 
   /// Notify the executor of an event.
   public func notify(event: ExecutorEvent) {
-    // Extract the source, but don't release it
-    let source = unsafe unsafeBitCast(event.id, to: OpaquePointer.self)
+    guard let source = unsafe eventTable.withLock(
+            { unsafe $0.events[event.id] }
+          ) else {
+      return
+    }
+
     unsafe _signalDispatchEvent(source)
   }