Merge pull request swiftlang#35392 from jckarter/checked-continuation-trap

Concurrency: Have CheckedContinuation trap on double resume.

Author: jckarter

stdlib/public/Concurrency/CheckedContinuation.swift

@@ -68,11 +68,11 @@ internal final class CheckedContinuationCanary {
 
   internal func takeContinuation<T>() -> UnsafeContinuation<T>? {
     return unsafeBitCast(_takeContinuation(),
-      to: UnsafeContinuation<T>.self)
+      to: UnsafeContinuation<T>?.self)
   }
   internal func takeThrowingContinuation<T>() -> UnsafeThrowingContinuation<T>? {
     return unsafeBitCast(_takeContinuation(),
-      to: UnsafeThrowingContinuation<T>.self)
+      to: UnsafeThrowingContinuation<T>?.self)
   }
 
   deinit {
@@ -137,12 +137,16 @@ public struct CheckedContinuation<T> {
   ///
   /// A continuation must be resumed exactly once. If the continuation has
   /// already been resumed through this object, then the attempt to resume
-  /// the continuation again will be logged, but otherwise have no effect.
+  /// the continuation again will trap.
+  ///
+  /// After `resume` enqueues the task, control is immediately returned to
+  /// the caller. The task will continue executing when its executor is
+  /// able to reschedule it.
   public func resume(returning x: __owned T) {
     if let c: UnsafeContinuation<T> = canary.takeContinuation() {
       c.resume(returning: x)
     } else {
-      logFailedCheck("SWIFT TASK CONTINUATION MISUSE: \(canary.function) tried to resume its continuation more than once, returning \(x)!\n")
+      fatalError("SWIFT TASK CONTINUATION MISUSE: \(canary.function) tried to resume its continuation more than once, returning \(x)!\n")
     }
   }
 }
@@ -207,29 +211,35 @@ public struct CheckedThrowingContinuation<T> {
   /// from its suspension point.
   ///
   /// A continuation must be resumed exactly once. If the continuation has
-  /// already been resumed through this object, whether by `resume(returning:)`
-  /// or by `resume(throwing:)`, then the attempt to resume
-  /// the continuation again will be logged, but otherwise have no effect.
+  /// already been resumed through this object, then the attempt to resume
+  /// the continuation again will trap.
+  ///
+  /// After `resume` enqueues the task, control is immediately returned to
+  /// the caller. The task will continue executing when its executor is
+  /// able to reschedule it.
   public func resume(returning x: __owned T) {
     if let c: UnsafeThrowingContinuation<T> = canary.takeThrowingContinuation() {
       c.resume(returning: x)
     } else {
-      logFailedCheck("SWIFT TASK CONTINUATION MISUSE: \(canary.function) tried to resume its continuation more than once, returning \(x)!\n")
+      fatalError("SWIFT TASK CONTINUATION MISUSE: \(canary.function) tried to resume its continuation more than once, returning \(x)!\n")
     }
   }
 
   /// Resume the task awaiting the continuation by having it throw an error
   /// from its suspension point.
   ///
   /// A continuation must be resumed exactly once. If the continuation has
-  /// already been resumed through this object, whether by `resume(returning:)`
-  /// or by `resume(throwing:)`, then the attempt to resume
-  /// the continuation again will be logged, but otherwise have no effect.
+  /// already been resumed through this object, then the attempt to resume
+  /// the continuation again will trap.
+  ///
+  /// After `resume` enqueues the task, control is immediately returned to
+  /// the caller. The task will continue executing when its executor is
+  /// able to reschedule it.
   public func resume(throwing x: __owned Error) {
     if let c: UnsafeThrowingContinuation<T> = canary.takeThrowingContinuation() {
       c.resume(throwing: x)
     } else {
-      logFailedCheck("SWIFT TASK CONTINUATION MISUSE: \(canary.function) tried to resume its continuation more than once, throwing \(x)!\n")
+      fatalError("SWIFT TASK CONTINUATION MISUSE: \(canary.function) tried to resume its continuation more than once, throwing \(x)!\n")
     }
   }
 }

test/Concurrency/Runtime/checked_continuation.swift

@@ -1,37 +1,36 @@
-// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency) 2>&1 | %FileCheck %s
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency)
 
 // REQUIRES: executable_test
 // REQUIRES: concurrency
 
 import _Concurrency
+import StdlibUnittest
 
 struct TestError: Error {}
 
-runAsyncAndBlock {
-    let x: Int = await withCheckedContinuation { c in
-        c.resume(returning: 17)
-        c.resume(returning: 38)
+var tests = TestSuite("CheckedContinuation")
+
+tests.test("trap on double resume non-throwing continuation") {
+  expectCrashLater()
+  runAsyncAndBlock {
+    let _: Int = await withCheckedContinuation { c in
+      c.resume(returning: 17)
+      c.resume(returning: 38)
     }
-    // CHECK: main tried to resume its continuation more than once, returning 38!
+  }
+}
 
+tests.test("trap on double resume throwing continuation") {
+  expectCrashLater()
+  runAsyncAndBlock {
     do {
-        let x: Int = await try withCheckedThrowingContinuation { c in
-            c.resume(throwing: TestError())
-            c.resume(returning: 679)
-            c.resume(throwing: TestError())
-        }
+      let _: Int = try await withCheckedThrowingContinuation { c in
+        c.resume(returning: 17)
+        c.resume(throwing: TestError())
+      }
     } catch {
-        // CHECK-NEXT: main tried to resume its continuation more than once, returning 679!
-        // CHECK-NEXT: main tried to resume its continuation more than once, throwing TestError()!
-    }
-    
-    _ = Task.runDetached {
-        let _: Void = await withCheckedContinuation { _ in
-            /*do nothing, leaking the task*/
-        }
-        // TODO: Whether the detached task gets a chance to run or not before
-        // the process exits is currently platform-dependent, and we don't yet
-        // have the API for yielding to the task runtime.
-        // C/HECK-NEXT: main leaked its continuation!
     }
+  }
 }
+
+runAllTests()