[Concurrency] Add minimal placeholders for Task and UnsafeContinuation

Author: ktoso

stdlib/public/Concurrency/CMakeLists.txt

@@ -14,6 +14,7 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   Actor.swift
   PartialAsyncTask.swift
   Task.cpp
+  Task.swift
   TaskAlloc.cpp
   TaskStatus.cpp
   Mutex.cpp
@@ -36,6 +37,7 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   SWIFT_COMPILE_FLAGS
     ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}
     -parse-stdlib
+    -Xfrontend -enable-experimental-concurrency
   LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}"
   INSTALL_IN_COMPONENT stdlib
 )

stdlib/public/Concurrency/PartialAsyncTask.swift

@@ -13,6 +13,7 @@
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
 
+/// A partial task is a unit of scheduleable work.
 public struct PartialAsyncTask {
   private var context: UnsafeMutablePointer<_SwiftContext>
 

stdlib/public/Concurrency/Task.swift

@@ -0,0 +1,88 @@
+////===----------------------------------------------------------------------===//
+////
+//// This source file is part of the Swift.org open source project
+////
+//// Copyright (c) 2020 Apple Inc. and the Swift project authors
+//// Licensed under Apache License v2.0 with Runtime Library Exception
+////
+//// See https://swift.org/LICENSE.txt for license information
+//// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+////
+////===----------------------------------------------------------------------===//
+
+import Swift
+@_implementationOnly import _SwiftConcurrencyShims
+
+// ==== Task -------------------------------------------------------------------
+
+/// An asynchronous task (just "Task" hereafter) is the analogue of a thread for
+/// asynchronous functions. All asynchronous functions run as part of some task.
+///
+/// A task's execution can be seen as a series of periods where the task was
+/// running. Each such period ends at a suspension point or -- finally -- the
+/// completion of the task.
+///
+/// These partial periods towards the task's completion are `PartialAsyncTask`.
+/// Partial tasks are generally not interacted with by end-users directly,
+/// unless implementing a scheduler.
+public struct Task {
+}
+
+// ==== UnsafeContinuation -----------------------------------------------------
+
+extension Task {
+  public struct UnsafeContinuation<T> {
+    /// Return a value into the continuation 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.
+    public func resume(returning: T) {
+      fatalError("\(#function) not implemented yet.")
+    }
+  }
+
+  public struct UnsafeThrowingContinuation<T, E: Error> {
+    /// Return a value into the continuation 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.
+    public func resume(returning: T) {
+      fatalError("\(#function) not implemented yet.")
+    }
+
+    /// 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.
+    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 static func withUnsafeContinuation<T>(
+    operation: (UnsafeContinuation<T>) -> Void
+  ) async -> T {
+    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 static func withUnsafeThrowingContinuation<T>(
+    operation: (UnsafeThrowingContinuation<T, Error>) -> Void
+  ) async throws -> T {
+    fatalError("\(#function) not implemented yet.")
+  }
+}

test/Concurrency/actor_isolation.swift

@@ -7,10 +7,12 @@ var mutableGlobal: String = "can't touch this" // expected-note 2{{var declared
 func globalFunc() { }
 func acceptClosure<T>(_: () -> T) { }
 func acceptEscapingClosure<T>(_: @escaping () -> T) { }
+func acceptEscapingClosure<T>(_: (String) -> ()) async -> T? { nil }
 
 func acceptAsyncClosure<T>(_: () async -> T) { }
 func acceptEscapingAsyncClosure<T>(_: @escaping () async -> T) { }
 
+
 // ----------------------------------------------------------------------
 // Actor state isolation restrictions
 // ----------------------------------------------------------------------

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?
+}