Hollow out swift_asyncLet_startImpl to just a swift_task_create call.

Introduce a task option record to capture the async-let storage, so
that `swift_task_create` can perform the appropriate initialization.

Author: DougGregor

include/swift/ABI/MetadataValues.h

@@ -2030,7 +2030,7 @@ class TaskCreateFlags : public FlagSet<size_t> {
     Priority_width = 8,
 
     Task_IsChildTask                              = 8,
-    Task_IsAsyncLetTask                           = 9,
+    // bit 9 is unused
     Task_CopyTaskLocals                           = 10,
     Task_InheritContext                           = 11,
     Task_EnqueueJob                               = 12,
@@ -2045,9 +2045,6 @@ class TaskCreateFlags : public FlagSet<size_t> {
   FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsChildTask,
                                 isChildTask,
                                 setIsChildTask)
-  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_IsAsyncLetTask,
-                                isAsyncLetTask,
-                                setIsAsyncLetTask)
   FLAGSET_DEFINE_FLAG_ACCESSORS(Task_CopyTaskLocals,
                                 copyTaskLocals,
                                 setCopyTaskLocals)
@@ -2148,6 +2145,8 @@ enum class TaskOptionRecordKind : uint8_t {
   Executor  = 0,
   /// Request a child task to be part of a specific task group.
   TaskGroup = 1,
+  /// Request a child task for an 'async let'.
+  AsyncLet  = 2,
 };
 
 /// Flags for cancellation records.

include/swift/ABI/TaskOptions.h

@@ -98,6 +98,24 @@ class ExecutorTaskOptionRecord : public TaskOptionRecord {
   }
 };
 
+/// Task option to specify that the created task is for an 'async let'.
+class AsyncLetTaskOptionRecord : public TaskOptionRecord {
+  AsyncLet *asyncLet;
+
+  public:
+  AsyncLetTaskOptionRecord(AsyncLet *asyncLet)
+    : TaskOptionRecord(TaskOptionRecordKind::AsyncLet),
+      asyncLet(asyncLet) {}
+
+  AsyncLet *getAsyncLet() const {
+    return asyncLet;
+  }
+
+  static bool classof(const TaskOptionRecord *record) {
+    return record->getKind() == TaskOptionRecordKind::AsyncLet;
+  }
+};
+
 } // end namespace swift
 
 #endif

stdlib/public/Concurrency/AsyncLet.cpp

@@ -16,9 +16,10 @@
 
 #include "../CompatibilityOverride/CompatibilityOverride.h"
 #include "swift/Runtime/Concurrency.h"
-#include "swift/ABI/Task.h"
 #include "swift/ABI/AsyncLet.h"
 #include "swift/ABI/Metadata.h"
+#include "swift/ABI/Task.h"
+#include "swift/ABI/TaskOptions.h"
 #include "swift/Runtime/Mutex.h"
 #include "swift/Runtime/HeapObject.h"
 #include "TaskPrivate.h"
@@ -86,6 +87,16 @@ static AsyncLetImpl *asImpl(const AsyncLet *alet) {
       const_cast<AsyncLet*>(alet));
 }
 
+void swift::asyncLet_addImpl(AsyncTask *task, AsyncLet *asyncLet) {
+  AsyncLetImpl *impl = new (asyncLet) AsyncLetImpl(task);
+
+  auto record = impl->getTaskRecord();
+  assert(impl == record && "the async-let IS the task record");
+
+  // ok, now that the group actually is initialized: attach it to the task
+  swift_task_addStatusRecord(record);
+}
+
 // =============================================================================
 // ==== start ------------------------------------------------------------------
 
@@ -95,35 +106,17 @@ static void swift_asyncLet_startImpl(AsyncLet *alet,
                                      const Metadata *futureResultType,
                                      void *closureEntryPoint,
                                      HeapObject *closureContext) {
-  AsyncTask *parent = swift_task_getCurrent();
-  assert(parent && "async-let cannot be created without parent task");
-
   auto flags = TaskCreateFlags();
-  flags.setPriority(parent->getPriority());
-  flags.setIsChildTask(true);
-  flags.setIsAsyncLetTask(true);
+  flags.setEnqueueJob(true);
+
+  AsyncLetTaskOptionRecord asyncLetOptionRecord(alet);
+  asyncLetOptionRecord.Parent = options;
 
-  auto childTaskAndContext = swift_task_create(
+  swift_task_create(
       flags.getOpaqueValue(),
-      options,
+      &asyncLetOptionRecord,
       futureResultType,
       closureEntryPoint, closureContext);
-
-  AsyncTask *childTask = childTaskAndContext.Task;
-
-  assert(childTask->isFuture());
-  assert(childTask->hasChildFragment());
-  AsyncLetImpl *impl = new (alet) AsyncLetImpl(childTask);
-
-  auto record = impl->getTaskRecord();
-  assert(impl == record && "the async-let IS the task record");
-
-  // ok, now that the group actually is initialized: attach it to the task
-  swift_task_addStatusRecord(record);
-
-  // schedule the task
-  // TODO: use the executor that may have been suggested in options
-  swift_task_enqueueGlobal(childTask);
 }
 
 // =============================================================================

stdlib/public/Concurrency/Task.cpp

@@ -398,11 +398,6 @@ task_future_wait_resume_adapter(SWIFT_ASYNC_CONTEXT AsyncContext *_context) {
 }
 
 /// Implementation of task creation.
-///
-/// If \p isAsyncLetTask is true, the \p closureContext is not heap allocated,
-/// but stack-allocated (and must not be ref-counted).
-/// Also, async-let tasks are not heap allocated, but allocated with the parent
-/// task's stack allocator.
 SWIFT_CC(swift)
 static AsyncTaskAndContext swift_task_create_commonImpl(
     size_t rawTaskCreateFlags,
@@ -414,15 +409,7 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
 
   // Propagate task-creation flags to job flags as appropriate.
   JobFlags jobFlags(JobKind::Task, taskCreateFlags.getPriority());
-
-  bool isAsyncLetTask = taskCreateFlags.isAsyncLetTask();
-  if (isAsyncLetTask) {
-    jobFlags.task_setIsAsyncLetTask(true);
-    jobFlags.task_setIsChildTask(true);
-  } else {
-    jobFlags.task_setIsChildTask(taskCreateFlags.isChildTask());
-  }
-
+  jobFlags.task_setIsChildTask(taskCreateFlags.isChildTask());
   if (futureResultType) {
     jobFlags.task_setIsFuture(true);
     assert(initialContextSize >= sizeof(FutureAsyncContext));
@@ -431,6 +418,7 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
   // Collect the options we know about.
   ExecutorRef executor = ExecutorRef::generic();
   TaskGroup *group = nullptr;
+  AsyncLet *asyncLet = nullptr;
   for (auto option = options; option; option = option->getParent()) {
     switch (option->getKind()) {
     case TaskOptionRecordKind::Executor:
@@ -442,6 +430,13 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
       assert(group && "Missing group");
       jobFlags.task_setIsGroupChildTask(true);
       break;
+
+    case TaskOptionRecordKind::AsyncLet:
+      asyncLet = cast<AsyncLetTaskOptionRecord>(option)->getAsyncLet();
+      assert(asyncLet && "Missing async let storage");
+      jobFlags.task_setIsAsyncLetTask(true);
+      jobFlags.task_setIsChildTask(true);
+      break;
     }
   }
 
@@ -489,7 +484,7 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
   constexpr unsigned initialSlabSize = 512;
 
   void *allocation = nullptr;
-  if (isAsyncLetTask) {
+  if (asyncLet) {
     assert(parent);
     allocation = _swift_task_alloc_specific(parent,
                                         amountToAllocate + initialSlabSize);
@@ -536,7 +531,7 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
   // Initialize the task so that resuming it will run the given
   // function on the initial context.
   AsyncTask *task = nullptr;
-  if (isAsyncLetTask) {
+  if (asyncLet) {
     // Initialize the refcount bits to "immortal", so that
     // ARC operations don't have any effect on the task.
     task = new(allocation) AsyncTask(&taskHeapMetadata,
@@ -580,7 +575,7 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
 #endif
 
   // Initialize the task-local allocator.
-  if (isAsyncLetTask) {
+  if (asyncLet) {
     initialContext->ResumeParent = reinterpret_cast<TaskContinuationFunction *>(
                                                    &completeTask);
     assert(parent);
@@ -627,6 +622,11 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
     swift_task_localsCopyTo(task);
   }
 
+  // Push the async let task status record.
+  if (asyncLet) {
+    asyncLet_addImpl(task, asyncLet);
+  }
+
   // If we're supposed to enqueue the task, do so now.
   if (taskCreateFlags.enqueueJob()) {
     swift_retain(task);

stdlib/public/Concurrency/Task.swift

@@ -794,8 +794,9 @@ extension UnsafeCurrentTask: Equatable {
 struct TaskOptionRecord {
   // The kind of option record.
   enum Kind: UInt8 {
-    case executor = 0
+    case executor  = 0
     case taskGroup = 1
+    case asyncLet  = 2
   }
 
   // Flags stored within an option record.

stdlib/public/Concurrency/TaskPrivate.h

@@ -74,6 +74,9 @@ void _swift_task_dealloc_specific(AsyncTask *task, void *ptr);
 /// related to the active task.
 void runJobInEstablishedExecutorContext(Job *job);
 
+/// Initialize the async let storage for the given async-let child task.
+void asyncLet_addImpl(AsyncTask *task, AsyncLet *asyncLet);
+
 /// Clear the active task reference for the current thread.
 AsyncTask *_swift_task_clearCurrent();