Merge pull request swiftlang#36602 from ktoso/wip-task-revisions

[Concurrency] Update Task/TaskGroup APIs based on first review

Author: ktoso

include/swift/ABI/Task.h

@@ -566,7 +566,7 @@ class ContinuationAsyncContext : public AsyncContext {
 /// task.
 ///
 /// This type matches the ABI of a function `<T> () async throws -> T`, which
-/// is the type used by `Task.runDetached` and `Task.group.add` to create
+/// is the type used by `detach` and `Task.group.add` to create
 /// futures.
 class FutureAsyncContext : public AsyncContext {
 public:

include/swift/Runtime/Concurrency.h

@@ -117,6 +117,9 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 JobPriority
 swift_task_escalate(AsyncTask *task, JobPriority newPriority);
 
+// TODO: "async let wait" and "async let destroy" would be expressed
+//       similar to like TaskFutureWait;
+
 /// This matches the ABI of a closure `<T>(Builtin.NativeObject) async -> T`
 using TaskFutureWaitSignature =
     SWIFT_CC(swiftasync)
@@ -237,11 +240,12 @@ void swift_taskGroup_destroy(TaskGroup *group);
 ///
 /// \code
 /// func swift_taskGroup_addPending(
-///     group: Builtin.RawPointer
+///     group: Builtin.RawPointer,
+///     unconditionally: Bool
 /// ) -> Bool
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-bool swift_taskGroup_addPending(TaskGroup *group);
+bool swift_taskGroup_addPending(TaskGroup *group, bool unconditionally);
 
 /// Cancel all tasks in the group.
 /// This also prevents new tasks from being added.

lib/SILGen/SILGenDecl.cpp

@@ -1142,6 +1142,8 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
   auto initialization = emitPatternBindingInitialization(PBD->getPattern(idx),
                                                          JumpDest::invalid());
 
+  // TODO: need to allocate the variable, stackalloc it? pass the address to the start()
+
   // If this is an async let, create a child task to compute the initializer
   // value.
   if (PBD->isAsyncLet()) {
@@ -1157,11 +1159,35 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
            "Could not find async let autoclosure");
     bool isThrowing = init->getType()->castTo<AnyFunctionType>()->isThrowing();
 
+    // TODO: there's a builtin to make an address into a raw pointer
+    //       --- note dont need that; just have the builtin take it inout?
+    //       --- the builtin can take the address (for start())
+
+    // TODO: make a builtin start async let
+    // Builtin.startAsyncLet -- and in the builtin create the async let record
+
+    // TODO: make a builtin for end async let
+
+    // TODO: IRGen would make a local allocation for the builtins
+
+    // TODO: remember if we did an await already?
+
+    // TODO: force in typesystem that we always await; then end aysnc let does not have to be async
+    // the local let variable is actually owning the result
+    // - but since throwing we can't know; maybe we didnt await on a thing yet
+    // so we do need the tracking if we waited on a thing
+
+    // TODO: awaiting an async let should be able to take ownership
+    // that means we will not await on this async let again, maybe?
+    // it means that the async let destroy should not destroy the result anymore
+
     // Emit the closure for the child task.
     SILValue childTask;
     {
       FullExpr Scope(Cleanups, CleanupLocation(init));
       SILLocation loc(PBD);
+      // TODO: opaque object in the async context that represents the async let
+      //
       childTask = emitRunChildTask(
           loc,
           init->getType(),
@@ -1173,7 +1199,7 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
     enterDestroyCleanup(childTask);
 
     // Push a cleanup that will cancel the child task at the end of the scope.
-    enterCancelAsyncTaskCleanup(childTask);
+    enterCancelAsyncTaskCleanup(childTask); // TODO: this is "went out scope" rather than just a cancel
 
     // Save the child task so we can await it as needed.
     AsyncLetChildTasks[{PBD, idx}] = { childTask, isThrowing };

stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def

@@ -180,7 +180,8 @@ OVERRIDE_TASK_GROUP(taskGroup_cancelAll, void,
 
 OVERRIDE_TASK_GROUP(taskGroup_addPending, bool,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
-                    swift::, (TaskGroup *group), (group))
+                    swift::, (TaskGroup *group, bool unconditionally),
+                    (group, unconditionally))
 
 OVERRIDE_TASK_LOCAL(task_localValuePush, void,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),

stdlib/public/Concurrency/Task.cpp

@@ -102,7 +102,6 @@ void AsyncTask::completeFuture(AsyncContext *context) {
       reinterpret_cast<char *>(context) - sizeof(FutureAsyncContextPrefix));
   bool hadErrorResult = false;
   auto errorObject = asyncContextPrefix->errorResult;
-//   printf("asyncTask::completeFuture errorObject: %p\n", errorObject);
   fragment->getError() = errorObject;
   if (errorObject) {
     hadErrorResult = true;