Remove _Continuation protocol and duplicate the relevant code.

Author: grynspan

stdlib/public/Concurrency/CMakeLists.txt

@@ -37,7 +37,6 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   Actor.cpp
   Actor.swift
   CheckedContinuation.swift
-  ContinuationProtocol.swift
   GlobalExecutor.cpp
   AsyncIteratorProtocol.swift
   AsyncSequence.swift

stdlib/public/Concurrency/CheckedContinuation.swift

@@ -95,7 +95,7 @@ internal final class CheckedContinuationCanary {
 /// of `withCheckedContinuation` or `withCheckedThrowingContinuation` should be
 /// enough to obtain the extra checking without further source modification in
 /// most circumstances.
-public struct CheckedContinuation<T, E: Error>: _Continuation {
+public struct CheckedContinuation<T, E: Error> {
   private let canary: CheckedContinuationCanary
 
   /// Initialize a `CheckedContinuation` wrapper around an
@@ -119,6 +119,18 @@ public struct CheckedContinuation<T, E: Error>: _Continuation {
       function: function)
   }
 
+  /// Resume the task awaiting the continuation by having it return normally
+  /// from its suspension point.
+  ///
+  /// - Parameter value: The value to return from the continuation.
+  ///
+  /// 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 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, E> = canary.takeContinuation() {
       c.resume(returning: x)
@@ -127,6 +139,18 @@ public struct CheckedContinuation<T, E: Error>: _Continuation {
     }
   }
 
+  /// Resume the task awaiting the continuation by having it throw an error
+  /// from its suspension point.
+  ///
+  /// - Parameter error: The error to throw from the continuation.
+  ///
+  /// 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 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 E) {
     if let c: UnsafeContinuation<T, E> = canary.takeContinuation() {
       c.resume(throwing: x)
@@ -136,6 +160,71 @@ public struct CheckedContinuation<T, E: Error>: _Continuation {
   }
 }
 
+extension CheckedContinuation {
+  /// Resume the task awaiting the continuation by having it either
+  /// return normally or throw an error based on the state of the given
+  /// `Result` value.
+  ///
+  /// - Parameter result: A value to either return or throw from the
+  ///   continuation.
+  ///
+  /// 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 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.
+  @_alwaysEmitIntoClient
+  public func resume<Er: Error>(with result: Result<T, Er>) where E == Error {
+    switch result {
+      case .success(let val):
+        self.resume(returning: val)
+      case .failure(let err):
+        self.resume(throwing: err)
+    }
+  }
+
+  /// Resume the task awaiting the continuation by having it either
+  /// return normally or throw an error based on the state of the given
+  /// `Result` value.
+  ///
+  /// - Parameter result: A value to either return or throw from the
+  ///   continuation.
+  ///
+  /// 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 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.
+  @_alwaysEmitIntoClient
+  public func resume(with result: Result<T, E>) {
+    switch result {
+      case .success(let val):
+        self.resume(returning: val)
+      case .failure(let err):
+        self.resume(throwing: err)
+    }
+  }
+
+  /// Resume the task awaiting the continuation by having it return normally
+  /// from its suspension point.
+  ///
+  /// 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 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.
+  @_alwaysEmitIntoClient
+  public func resume() where T == Void {
+    self.resume(returning: ())
+  }
+}
+
 public func withCheckedContinuation<T>(
     function: String = #function,
     _ body: (CheckedContinuation<T, Never>) -> Void

stdlib/public/Concurrency/ContinuationProtocol.swift

@@ -22,7 +22,7 @@ public struct PartialAsyncTask {
 }
 
 @frozen
-public struct UnsafeContinuation<T, E: Error>: _Continuation {
+public struct UnsafeContinuation<T, E: Error> {
   @usableFromInline internal var context: Builtin.RawUnsafeContinuation
 
   @_alwaysEmitIntoClient
@@ -34,6 +34,18 @@ public struct UnsafeContinuation<T, E: Error>: _Continuation {
   @_silgen_name("swift_continuation_resume")
   internal func _resume(returning value: __owned T)
 
+  /// Resume the task awaiting the continuation by having it return normally
+  /// from its suspension point.
+  ///
+  /// - Parameter value: The value to return from the continuation.
+  ///
+  /// 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 result in undefined behavior.
+  ///
+  /// 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.
   @_alwaysEmitIntoClient
   public func resume(returning value: __owned T) where E == Never {
     self._resume(returning: value)
@@ -43,6 +55,18 @@ public struct UnsafeContinuation<T, E: Error>: _Continuation {
   @_silgen_name("swift_continuation_throwingResume")
   internal func _resume(returningToThrowingFunction: __owned T)
 
+  /// Resume the task awaiting the continuation by having it return normally
+  /// from its suspension point.
+  ///
+  /// - Parameter value: The value to return from the continuation.
+  ///
+  /// 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 result in undefined behavior.
+  ///
+  /// 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.
   @_alwaysEmitIntoClient
   public func resume(returning value: __owned T) {
     self._resume(returningToThrowingFunction: value)
@@ -52,12 +76,89 @@ public struct UnsafeContinuation<T, E: Error>: _Continuation {
   @_silgen_name("swift_continuation_throwingResumeWithError")
   internal func _resume(throwing: __owned Error)
 
+  /// Resume the task awaiting the continuation by having it throw an error
+  /// from its suspension point.
+  ///
+  /// - Parameter error: The error to throw from the continuation.
+  ///
+  /// 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 result in undefined behavior.
+  ///
+  /// 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.
   @_alwaysEmitIntoClient
   public func resume(throwing error: __owned E) {
     self._resume(throwing: error)
   }
 }
 
+extension UnsafeContinuation {
+  /// Resume the task awaiting the continuation by having it either
+  /// return normally or throw an error based on the state of the given
+  /// `Result` value.
+  ///
+  /// - Parameter result: A value to either return or throw from the
+  ///   continuation.
+  ///
+  /// 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 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.
+  @_alwaysEmitIntoClient
+  public func resume<Er: Error>(with result: Result<T, Er>) where E == Error {
+    switch result {
+      case .success(let val):
+        self.resume(returning: val)
+      case .failure(let err):
+        self.resume(throwing: err)
+    }
+  }
+
+  /// Resume the task awaiting the continuation by having it either
+  /// return normally or throw an error based on the state of the given
+  /// `Result` value.
+  ///
+  /// - Parameter result: A value to either return or throw from the
+  ///   continuation.
+  ///
+  /// 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 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.
+  @_alwaysEmitIntoClient
+  public func resume(with result: Result<T, E>) {
+    switch result {
+      case .success(let val):
+        self.resume(returning: val)
+      case .failure(let err):
+        self.resume(throwing: err)
+    }
+  }
+
+  /// Resume the task awaiting the continuation by having it return normally
+  /// from its suspension point.
+  ///
+  /// 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 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.
+  @_alwaysEmitIntoClient
+  public func resume() where T == Void {
+    self.resume(returning: ())
+  }
+}
+
 #if _runtime(_ObjC)
 
 // Intrinsics used by SILGen to resume or fail continuations.