withAsyncTaskCleanupHandler calls its cleanup handler twice if body throws

If the body closure given to withAsyncTaskCleanupHandler throws, its cleanup handler is called twice: once in the catch block where body is called, and then again in the task group task once the Task.sleep throws due to cancellation, which swallows the error and then continues to call the handler as well.

This results in the teardown sequence being invoked twice.

Closes #80

Author: jakepetroules

Sources/Subprocess/Configuration.swift

@@ -752,31 +752,17 @@ extension Optional where Wrapped == String {
     }
 }
 
-internal func withAsyncTaskCleanupHandler<Result>(
-    _ body: () async throws -> Result,
+internal func withAsyncTaskCleanupHandler<Success, Failure>(
+    _ body: () async throws(Failure) -> Success,
     onCleanup handler: @Sendable @escaping () async -> Void,
     isolation: isolated (any Actor)? = #isolation
-) async rethrows -> Result {
-    return try await withThrowingTaskGroup(
-        of: Void.self,
-        returning: Result.self
-    ) { group in
-        group.addTask {
-            // Keep this task sleep indefinitely until the parent task is cancelled.
-            // `Task.sleep` throws `CancellationError` when the task is canceled
-            // before the time ends. We then run the cancel handler.
-            do { while true { try await Task.sleep(nanoseconds: 1_000_000_000) } } catch {}
-            // Run task cancel handler
-            await handler()
-        }
-
-        do {
-            let result = try await body()
-            group.cancelAll()
-            return result
-        } catch {
-            await handler()
-            throw error
-        }
-    }
+) async throws(Failure) -> Success {
+    let result: Result<Success, Failure>
+    do {
+        result = try await .success(body())
+    } catch let e {
+        result = .failure(e)
+    }
+    await handler()
+    return try result.get()
 }