Listening + IdentifiableContinuation

FlyingFox/Sources/HTTPServer+Listening.swift

@@ -47,12 +47,16 @@ extension HTTPServer {
     private func doWaitUntilListening() async throws {
         guard !isListening else { return }
         try await withIdentifiableThrowingContinuation(isolation: self) {
-            waiting[$0.id] = $0
+            appendContinuation($0)
         } onCancel: { id in
             Task { await self.cancelContinuation(with: id) }
         }
     }
 
+    private func appendContinuation(_ continuation: Continuation) {
+        waiting[continuation.id] = continuation
+    }
+
     private func cancelContinuation(with id: Continuation.ID) {
         if let continuation = waiting.removeValue(forKey: id) {
             continuation.resume(throwing: CancellationError())

FlyingFox/Tests/HTTPServerTests.swift

@@ -68,6 +68,18 @@ final class HTTPServerTests: XCTestCase {
         }
     }
 
+    func testWaitsUntilListening() async throws {
+        let server = HTTPServer.make()
+        let task = Task { try await server.waitUntilListening() }
+        try await Task.sleep(seconds: 0.1)
+
+        try await startServer(server)
+
+        await AsyncAssertNoThrow(
+            try await task.result.get()
+        )
+    }
+
     func testThrowsError_WhenSocketAlreadyListening() async throws {
         let server = HTTPServer.make(port: 42185)
         let socket = try await server.makeSocketAndListen()

FlyingSocks/Sources/SocketPool.swift

@@ -156,34 +156,25 @@ public final actor SocketPool<Queue: EventQueue>: AsyncSocketPool {
         state = .complete
         waiting.cancellAll()
         waiting = Waiting()
-        loop?.resume(throwing: CancellationError())
+        loop?.cancel()
         loop = nil
     }
 
     typealias Continuation = CancellingContinuation<Void, SocketError>
-    private var loop: IdentifiableContinuation<Void, any Swift.Error>?
+    private var loop: CancellingContinuation<Void, Never>?
     private var waiting = Waiting() {
         didSet {
             if !waiting.isEmpty, let continuation = loop {
                 continuation.resume()
-                loop = nil
             }
         }
     }
 
     private func suspendUntilContinuationsExist() async throws {
-        try await withIdentifiableThrowingContinuation(isolation: self) {
-            loop = $0
-        } onCancel: { id in
-            Task { await self.cancelLoopContinuation(with: id) }
-        }
-    }
-
-    private func cancelLoopContinuation(with id: IdentifiableContinuation<Void, any Swift.Error>.ID) {
-        if loop?.id == id {
-            loop?.resume(throwing: CancellationError())
-            loop = nil
-        }
+        let continuation = CancellingContinuation<Void, Never>()
+        loop = continuation
+        defer { loop = nil }
+        return try await continuation.value
     }
 
     private func appendContinuation(_ continuation: Continuation,