Switch task group child task creation over to Builtin.createAsyncTask().

Extend the behavior of `swift_task_create_common` to also encompass
adding the pending group task (when requested) and attaching it to the
group.

Author: DougGregor

include/swift/ABI/MetadataValues.h

@@ -2029,11 +2029,12 @@ class TaskCreateFlags : public FlagSet<size_t> {
     Priority       = 0,
     Priority_width = 8,
 
-    Task_IsChildTask      = 8,
-    Task_IsAsyncLetTask   = 9,
-    Task_CopyThreadLocals = 10,
-    Task_InheritContext   = 11,
-    Task_EnqueueJob       = 12,
+    Task_IsChildTask                              = 8,
+    Task_IsAsyncLetTask                           = 9,
+    Task_CopyThreadLocals                         = 10,
+    Task_InheritContext                           = 11,
+    Task_EnqueueJob                               = 12,
+    Task_AddPendingGroupTaskUnconditionally       = 13,
   };
 
   explicit constexpr TaskCreateFlags(size_t bits) : FlagSet(bits) {}
@@ -2056,6 +2057,9 @@ class TaskCreateFlags : public FlagSet<size_t> {
   FLAGSET_DEFINE_FLAG_ACCESSORS(Task_EnqueueJob,
                                 enqueueJob,
                                 setEnqueueJob)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Task_AddPendingGroupTaskUnconditionally,
+                                addPendingGroupTaskUnconditionally,
+                                setAddPendingGroupTaskUnconditionally)
 };
 
 /// Flags for schedulable jobs.

stdlib/public/Concurrency/Task.cpp

@@ -440,6 +440,12 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
     }
   }
 
+  // Add to the task group, if requested.
+  if (taskCreateFlags.addPendingGroupTaskUnconditionally()) {
+    assert(group && "Missing group");
+    swift_taskGroup_addPending(group, /*unconditionally=*/true);
+  }
+
   AsyncTask *parent = nullptr;
   if (jobFlags.task_isChildTask()) {
     parent = swift_task_getCurrent();
@@ -604,6 +610,11 @@ static AsyncTaskAndContext swift_task_create_commonImpl(
   initialContext->Flags = AsyncContextKind::Ordinary;
   initialContext->Flags.setShouldNotDeallocateInCallee(true);
 
+  // Attach to the group, if needed.
+  if (group) {
+    swift_taskGroup_attachChild(group, task);
+  }
+
   // If we're supposed to copy task locals, do so now.
   if (taskCreateFlags.copyThreadLocals()) {
     swift_task_localsCopyTo(task);

stdlib/public/Concurrency/Task.swift

@@ -496,6 +496,22 @@ struct TaskCreateFlags {
       }
     }
   }
+
+  /// Whether to add a pending group task unconditionally as part of creating
+  /// the task.
+  var addPendingGroupTaskUnconditionally: Bool {
+    get {
+      (bits & (1 << 13)) != 0
+    }
+
+    set {
+      if newValue {
+        bits = bits | 1 << 13
+      } else {
+        bits = (bits & ~(1 << 13))
+      }
+    }
+  }
 }
 
 // ==== Task Creation ----------------------------------------------------------
@@ -838,6 +854,60 @@ extension UnsafeCurrentTask: Equatable {
 
 // ==== Internal ---------------------------------------------------------------
 
+@available(SwiftStdlib 5.5, *)
+struct TaskOptionRecord {
+  // The kind of option record.
+  enum Kind: UInt8 {
+    case executor = 0
+    case taskGroup = 1
+  }
+
+  // Flags stored within an option record.
+  struct Flags {
+    var bits: Int = 0
+
+    init(kind: Kind) {
+      self.bits = 0
+      self.kind = kind
+    }
+
+    /// The kind of option record described by these flags.
+    var kind: Kind {
+      get {
+        Kind(rawValue: UInt8(bits & 0xFF))!
+      }
+
+      set {
+        bits = (bits & ~0xFF) | Int(newValue.rawValue)
+      }
+    }
+  }
+
+  var flags: Flags
+  var parent: UnsafeMutablePointer<TaskOptionRecord>? = nil
+
+  init(kind: Kind, parent: UnsafeMutablePointer<TaskOptionRecord>? = nil) {
+    self.flags = Flags(kind: kind)
+    self.parent = parent
+  }
+}
+
+@available(SwiftStdlib 5.5, *)
+extension TaskOptionRecord {
+  struct TaskGroup {
+    var base: TaskOptionRecord
+    var group: Builtin.RawPointer
+
+    init(
+      parent: UnsafeMutablePointer<TaskOptionRecord>? = nil,
+      group: Builtin.RawPointer
+    ) {
+      self.base = .init(kind: .taskGroup, parent: parent)
+      self.group = group
+    }
+  }
+}
+
 @available(SwiftStdlib 5.5, *)
 @_silgen_name("swift_task_getCurrent")
 func _getCurrentAsyncTask() -> Builtin.NativeObject?

stdlib/public/Concurrency/TaskGroup.swift

@@ -239,25 +239,16 @@ public struct TaskGroup<ChildTaskResult> {
     priority: TaskPriority? = nil,
     operation: __owned @Sendable @escaping () async -> ChildTaskResult
   ) {
-    _ = _taskGroupAddPendingTask(group: _group, unconditionally: true)
-
-    // Set up the job flags for a new task.
-    var flags = JobFlags()
-    flags.kind = .task
+    var flags = TaskCreateFlags()
     flags.priority = priority
-    flags.isFuture = true
     flags.isChildTask = true
-    flags.isGroupChildTask = true
-
-    // Create the asynchronous task future.
-    let (childTask, _) = Builtin.createAsyncTaskGroupFuture(
-      Int(flags.bits), _group, /*options*/nil, operation)
+    flags.enqueueJob = true
+    flags.addPendingGroupTaskUnconditionally = true
 
-    // Attach it to the group's task record in the current task.
-    _taskGroupAttachChild(group: _group, child: childTask)
+    var groupOption = TaskOptionRecord.TaskGroup(group: _group)
 
-    // Enqueue the resulting job.
-    _enqueueJobGlobal(Builtin.convertTaskToJob(childTask))
+    // Create the asynchronous task future.
+    _ = Builtin.createAsyncTask(flags.bits, UnsafeRawPointer(&groupOption)._rawValue, operation)
   }
 
   /// Add a child task to the group.
@@ -286,23 +277,15 @@ public struct TaskGroup<ChildTaskResult> {
       return false
     }
 
-    // Set up the job flags for a new task.
-    var flags = JobFlags()
-    flags.kind = .task
+    var flags = TaskCreateFlags()
     flags.priority = priority
-    flags.isFuture = true
     flags.isChildTask = true
-    flags.isGroupChildTask = true
+    flags.enqueueJob = true
 
-    // Create the asynchronous task future.
-    let (childTask, _) = Builtin.createAsyncTaskGroupFuture(
-      Int(flags.bits), _group, /*options*/nil, operation)
+    var groupOption = TaskOptionRecord.TaskGroup(group: _group)
 
-    // Attach it to the group's task record in the current task.
-    _taskGroupAttachChild(group: _group, child: childTask)
-
-    // Enqueue the resulting job.
-    _enqueueJobGlobal(Builtin.convertTaskToJob(childTask))
+    // Create the asynchronous task future.
+    _ = Builtin.createAsyncTask(flags.bits, UnsafeRawPointer(&groupOption)._rawValue, operation)
 
     return true
   }
@@ -473,26 +456,16 @@ public struct ThrowingTaskGroup<ChildTaskResult, Failure: Error> {
     priority: TaskPriority? = nil,
     operation: __owned @Sendable @escaping () async throws -> ChildTaskResult
   ) {
-    // we always add, so no need to check if group was cancelled
-    _ = _taskGroupAddPendingTask(group: _group, unconditionally: true)
-
-    // Set up the job flags for a new task.
-    var flags = JobFlags()
-    flags.kind = .task
+    var flags = TaskCreateFlags()
     flags.priority = priority
-    flags.isFuture = true
     flags.isChildTask = true
-    flags.isGroupChildTask = true
+    flags.enqueueJob = true
+    flags.addPendingGroupTaskUnconditionally = true
 
-    // Create the asynchronous task future.
-    let (childTask, _) = Builtin.createAsyncTaskGroupFuture(
-      Int(flags.bits), _group, /*options*/nil, operation)
+    var groupOption = TaskOptionRecord.TaskGroup(group: _group)
 
-    // Attach it to the group's task record in the current task.
-    _taskGroupAttachChild(group: _group, child: childTask)
-
-    // Enqueue the resulting job.
-    _enqueueJobGlobal(Builtin.convertTaskToJob(childTask))
+    // Create the asynchronous task future.
+    _ = Builtin.createAsyncTask(flags.bits, UnsafeRawPointer(&groupOption)._rawValue, operation)
   }
 
   /// Add a child task to the group.
@@ -521,23 +494,15 @@ public struct ThrowingTaskGroup<ChildTaskResult, Failure: Error> {
       return false
     }
 
-    // Set up the job flags for a new task.
-    var flags = JobFlags()
-    flags.kind = .task
+    var flags = TaskCreateFlags()
     flags.priority = priority
-    flags.isFuture = true
     flags.isChildTask = true
-    flags.isGroupChildTask = true
-
-    // Create the asynchronous task future.
-    let (childTask, _) = Builtin.createAsyncTaskGroupFuture(
-      Int(flags.bits), _group, /*options*/nil, operation)
+    flags.enqueueJob = true
 
-    // Attach it to the group's task record in the current task.
-    _taskGroupAttachChild(group: _group, child: childTask)
+    var groupOption = TaskOptionRecord.TaskGroup(group: _group)
 
-    // Enqueue the resulting job.
-    _enqueueJobGlobal(Builtin.convertTaskToJob(childTask))
+    // Create the asynchronous task future.
+    _ = Builtin.createAsyncTask(flags.bits, UnsafeRawPointer(&groupOption)._rawValue, operation)
 
     return true
   }
@@ -841,14 +806,6 @@ extension ThrowingTaskGroup: AsyncSequence {
 
 /// ==== -----------------------------------------------------------------------
 
-/// Attach task group child to the group group to the task.
-@available(SwiftStdlib 5.5, *)
-@_silgen_name("swift_taskGroup_attachChild")
-func _taskGroupAttachChild(
-  group: Builtin.RawPointer,
-  child: Builtin.NativeObject
-)
-
 @available(SwiftStdlib 5.5, *)
 @_silgen_name("swift_taskGroup_destroy")
 func _taskGroupDestroy(group: __owned Builtin.RawPointer)