add some simple compilation tests

Author: ktoso

stdlib/public/Concurrency/Task.swift

@@ -39,7 +39,7 @@ extension Task {
     ///
     /// This is appropriate when the caller is something "busy", like an event
     /// loop, and doesn't want to be potentially delayed by arbitrary work.
-    func resume(returning: T) {
+    public func resume(returning: T) {
       fatalError("\(#function) not implemented yet.")
     }
   }
@@ -52,26 +52,26 @@ extension Task {
     ///
     /// This is appropriate when the caller is something "busy", like an event
     /// loop, and doesn't want to be potentially delayed by arbitrary work.
-    func resume(returning: T) {
+    public func resume(returning: T) {
       fatalError("\(#function) not implemented yet.")
     }
 
-    /// Resume the continuation with an error value and make the task schedulable.
+    /// Resume the continuation with an error and make the task schedulable.
     ///
     /// The task will never run synchronously, even if the task does not
     /// need to be resumed on a specific executor.
     ///
     /// This is appropriate when the caller is something "busy", like an event
     /// loop, and doesn't want to be potentially delayed by arbitrary work.
-    func resume(throwing: E) {
+    public func resume(throwing: E) {
       fatalError("\(#function) not implemented yet.")
     }
   }
 
   /// The operation functions must resume the continuation *exactly once*.
   ///
   /// The continuation will not begin executing until the operation function returns.
-  public func withUnsafeContinuation<T>(
+  public static func withUnsafeContinuation<T>(
     operation: (UnsafeContinuation<T>) -> Void
   ) async -> T {
     fatalError("\(#function) not implemented yet.")
@@ -80,7 +80,9 @@ extension Task {
   /// The operation functions must resume the continuation *exactly once*.
   ///
   /// The continuation will not begin executing until the operation function returns.
-  public func withUnsafeThrowingContinuation<T>(operation: (UnsafeThrowingContinuation<T, Error>) -> Void) async throws -> T {
+  public static func withUnsafeThrowingContinuation<T>(
+    operation: (UnsafeThrowingContinuation<T, Error>) -> Void
+  ) async throws -> T {
     fatalError("\(#function) not implemented yet.")
   }
 }

test/Concurrency/async_tasks.swift

@@ -0,0 +1,39 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-concurrency
+// REQUIRES: concurrency
+
+func someAsyncFunc() async -> String { "" }
+struct MyError: Error {}
+
+// non-async function with "weird shape" representing some API that has not adopted
+// swift concurrency yet, but we want to call it from an async function and make it
+// play nice with the rest of the system.
+func someManyCallbacksFunction(
+  calledSometimes: () -> (),
+  otherwiseThisIsCalled: () -> (),
+  calledOnError: (Error) -> ()
+) { }
+
+func test_unsafeContinuations() async {
+  // the closure should not allow async operations;
+  // after all: if you have async code, just call it directly, without the unsafe continuation
+  let _: String = Task.withUnsafeContinuation { continuation in // expected-error{{cannot convert value of type '(_) async -> ()' to expected argument type '(Task.UnsafeContinuation<String>) -> Void'}}
+    let s = await someAsyncFunc() // rdar://70610141 for getting a better error message here
+    continuation.resume(returning: s)
+  }
+
+  let _: String = await Task.withUnsafeContinuation { continuation in
+    continuation.resume(returning: "")
+  }
+}
+
+func test_unsafeThrowingContinuations() async {
+  let _: String = try await Task.withUnsafeThrowingContinuation { continuation in
+    continuation.resume(returning: "")
+  }
+
+  let _: String = try await Task.withUnsafeThrowingContinuation { continuation in
+    continuation.resume(throwing: MyError())
+  }
+
+  // TODO: Potentially could offer some warnings if we know that a continuation was resumed or escaped at all in a closure?
+}