undo any changes in backdeploy lib, we don't do any changes there

Author: ktoso

stdlib/public/BackDeployConcurrency/TaskGroup.cpp

@@ -114,6 +114,12 @@ class TaskGroupImpl: public TaskGroupTaskStatusRecord {
     /// until a next() call eventually picks it up.
     AsyncTask *retainedTask;
 
+    bool isStorageAccessible() {
+      return status == PollStatus::Success ||
+             status == PollStatus::Error ||
+             status == PollStatus::Empty;
+    }
+
     static PollResult get(AsyncTask *asyncTask, bool hadErrorResult) {
       auto fragment = asyncTask->futureFragment();
       return PollResult{
@@ -127,15 +133,6 @@ class TaskGroupImpl: public TaskGroupTaskStatusRecord {
         /*task*/ asyncTask
       };
     }
-
-    static PollResult getEmpty(const Metadata *successType) {
-      return PollResult{
-        /*status*/ PollStatus::Success,
-        /*storage*/ nullptr,
-        /*successType*/successType,
-        /*task*/ nullptr
-      };
-    }
   };
 
   /// An item within the message queue of a group.
@@ -429,17 +426,6 @@ class TaskGroupImpl: public TaskGroupTaskStatusRecord {
   /// or a `PollStatus::MustWait` result if there are tasks in flight
   /// and the waitingTask eventually be woken up by a completion.
   PollResult poll(AsyncTask *waitingTask);
-
-  /// A `discardResults` TaskGroup is not able to wait on individual completions,
-  /// instead, it can only await on "all pending tasks have been processed".
-  ///
-  ///
-  /// If unable to complete the waiting task immediately (with an readily
-  /// available completed task), either returns an `PollStatus::Empty`
-  /// result if it is known that no pending tasks in the group,
-  /// or a `PollStatus::MustWait` result if there are tasks in flight
-  /// and the waitingTask eventually be woken up by a completion.
-  PollResult waitAll(AsyncTask *waitingTask);
 };
 
 } // end anonymous namespace
@@ -474,7 +460,7 @@ TaskGroupTaskStatusRecord *TaskGroup::getTaskRecord() {
 
 // Initializes into the preallocated _group an actual TaskGroupImpl.
 SWIFT_CC(swift)
-static void swift_taskGroup_initializeWithFlagsImpl(size_t flags, TaskGroup *group, const Metadata *T) {
+static void swift_taskGroup_initializeImpl(TaskGroup *group, const Metadata *T) {
   SWIFT_TASK_DEBUG_LOG("creating task group = %p", group);
 
   TaskGroupImpl *impl = new (group) TaskGroupImpl(T);
@@ -489,12 +475,6 @@ static void swift_taskGroup_initializeWithFlagsImpl(size_t flags, TaskGroup *gro
   if (!notCancelled) impl->statusCancel();
 }
 
-// Initializes into the preallocated _group an actual TaskGroupImpl.
-SWIFT_CC(swift)
-static void swift_taskGroup_initializeImpl(TaskGroup *group, const Metadata *T) {
-  swift_taskGroup_initializeWithFlagsImpl(0, group, T);
-}
-
 // =============================================================================
 // ==== add / attachChild ------------------------------------------------------
 
@@ -566,7 +546,7 @@ static void fillGroupNextResult(TaskFutureWaitAsyncContext *context,
   }
 
   case PollStatus::Empty: {
-    // Initialize the result as a .none Optional<Success>.
+    // Initialize the result as a nil Optional<Success>.
     const Metadata *successType = result.successType;
     OpaqueValue *destPtr = context->successResultPointer;
     successType->vw_storeEnumTagSinglePayload(destPtr, 1, 1);
@@ -575,13 +555,6 @@ static void fillGroupNextResult(TaskFutureWaitAsyncContext *context,
   }
 }
 
-static void fillGroupNextNilResult(TaskFutureWaitAsyncContext *context) {
-  /// Fill in the result value with 'nil'
-  const Metadata *successType = result.successType;
-  OpaqueValue *destPtr = context->successResultPointer;
-  successType->vw_storeEnumTagSinglePayload(destPtr, 1, 1);
-}
-
 void TaskGroupImpl::offer(AsyncTask *completedTask, AsyncContext *context) {
   assert(completedTask);
   assert(completedTask->isFuture());
@@ -598,7 +571,6 @@ void TaskGroupImpl::offer(AsyncTask *completedTask, AsyncContext *context) {
   //   W:n R:0 P:1 -> W:y R:1 P:1 // complete immediately
   //   W:n R:0 P:1 -> W:y R:1 P:3 // complete immediately, 2 more pending tasks
   auto assumed = statusAddReadyAssumeAcquire();
-  SWIFT_TASK_DEBUG_LOG("offer task %p to group(%p), tasks pending = %d", completedTask, assumed.pendingTasks());
 
   auto asyncContextPrefix = reinterpret_cast<FutureAsyncContextPrefix *>(
       reinterpret_cast<char *>(context) - sizeof(FutureAsyncContextPrefix));
@@ -668,7 +640,6 @@ void TaskGroupImpl::offer(AsyncTask *completedTask, AsyncContext *context) {
   assert(completedTask == readyItem.getTask());
   assert(readyItem.getTask()->isFuture());
   readyQueue.enqueue(readyItem);
-
   mutex.unlock(); // TODO: remove fragment lock, and use status for synchronization
   return;
 }
@@ -713,20 +684,20 @@ static void swift_taskGroup_wait_next_throwingImpl(
   waitingTask->ResumeTask = task_group_wait_resume_adapter;
   waitingTask->ResumeContext = rawContext;
 
-  auto group = asImpl(_group);
-  assert(group && "swift_taskGroup_wait_next_throwing was passed context without group!");
-
   auto context = static_cast<TaskFutureWaitAsyncContext *>(rawContext);
   context->ResumeParent =
       reinterpret_cast<TaskContinuationFunction *>(resumeFunction);
   context->Parent = callerContext;
   context->errorResult = nullptr;
   context->successResultPointer = resultPointer;
 
+  auto group = asImpl(_group);
+  assert(group && "swift_taskGroup_wait_next_throwing was passed context without group!");
+
   PollResult polled = group->poll(waitingTask);
   switch (polled.status) {
   case PollStatus::MustWait:
-    SWIFT_TASK_DEBUG_LOG("poll group = %p, tasks ready = 0, waiting task = %p",
+    SWIFT_TASK_DEBUG_LOG("poll group = %p, no ready tasks, waiting task = %p",
                          group, waitingTask);
     // The waiting task has been queued on the channel,
     // there were pending tasks so it will be woken up eventually.
@@ -746,8 +717,8 @@ static void swift_taskGroup_wait_next_throwingImpl(
 
     if (auto completedTask = polled.retainedTask) {
       // it would be null for PollStatus::Empty, then we don't need to release
-      group->detachChild(completedTask);
-      swift_release(completedTask);
+      group->detachChild(polled.retainedTask);
+      swift_release(polled.retainedTask);
     }
     return waitingTask->runInFullyEstablishedContext();
   }
@@ -783,13 +754,13 @@ PollResult TaskGroupImpl::poll(AsyncTask *waitingTask) {
 
   // ==== 2) Ready task was polled, return with it immediately -----------------
   if (assumed.readyTasks()) {
-    SWIFT_TASK_DEBUG_LOG("poll group = %p, tasks ready=%d, pending=%d",
-                         this, assumed.readyTasks(), assumed.pendingTasks());
+    SWIFT_TASK_DEBUG_LOG("poll group = %p, group has ready tasks = %d",
+                         this, assumed.readyTasks());
 
     auto assumedStatus = assumed.status;
     auto newStatus = TaskGroupImpl::GroupStatus{assumedStatus};
     if (status.compare_exchange_strong(
-        assumedStatus, newStatus.completingPendingReadyWaiting(this).status,
+        assumedStatus, newStatus.completingPendingReadyWaiting().status,
         /*success*/ std::memory_order_relaxed,
         /*failure*/ std::memory_order_acquire)) {
 
@@ -846,7 +817,7 @@ PollResult TaskGroupImpl::poll(AsyncTask *waitingTask) {
   }
 
   // ==== 3) Add to wait queue -------------------------------------------------
-  assert(assumed.readyTasks(this) == 0);
+  assert(assumed.readyTasks() == 0);
   _swift_tsan_release(static_cast<Job *>(waitingTask));
   while (true) {
     if (!hasSuspended) {
@@ -868,13 +839,15 @@ PollResult TaskGroupImpl::poll(AsyncTask *waitingTask) {
 }
 
 // =============================================================================
-// ==== Task Group status and flag checks  -------------------------------------
+// ==== isEmpty ----------------------------------------------------------------
 
 SWIFT_CC(swift)
 static bool swift_taskGroup_isEmptyImpl(TaskGroup *group) {
   return asImpl(group)->isEmpty();
 }
 
+// =============================================================================
+// ==== isCancelled ------------------------------------------------------------
 SWIFT_CC(swift)
 static bool swift_taskGroup_isCancelledImpl(TaskGroup *group) {
   return asImpl(group)->isCancelled();

test/Concurrency/Runtime/async_task_locals_prevent_illegal_use.swift renamed to test/Concurrency/Runtime/async_task_locals_prevent_illegal_use_discarding_taskgroup.swift

@@ -19,14 +19,29 @@ enum TL {
 
 // ==== ------------------------------------------------------------------------
 
-@available(SwiftStdlib 5.1, *)
-func bindAroundGroupSpawn() async {
+func bindAroundGroupAddTask() async {
   await TL.$number.withValue(1111) { // ok
     await withTaskGroup(of: Int.self) { group in
       // CHECK: error: task-local: detected illegal task-local value binding at {{.*}}illegal_use.swift:[[# @LINE + 1]]
       TL.$number.withValue(2222) { // bad!
         print("Survived, inside withValue!") // CHECK-NOT: Survived, inside withValue!
-        group.spawn {
+        group.addTask {
+          0 // don't actually perform the read, it would be unsafe.
+        }
+      }
+
+      print("Survived the illegal call!") // CHECK-NOT: Survived the illegal call!
+    }
+  }
+}
+
+func bindAroundDiscardingGroupAddTask() async {
+  await TL.$number.withValue(1111) { // ok
+    await withDiscardingTaskGroup(of: Int.self) { group in
+      // CHECK: error: task-local: detected illegal task-local value binding at {{.*}}illegal_use.swift:[[# @LINE + 1]]
+      TL.$number.withValue(2222) { // bad!
+        print("Survived, inside withValue!") // CHECK-NOT: Survived, inside withValue!
+        group.addTask {
           0 // don't actually perform the read, it would be unsafe.
         }
       }
@@ -36,9 +51,12 @@ func bindAroundGroupSpawn() async {
   }
 }
 
-@available(SwiftStdlib 5.1, *)
 @main struct Main {
   static func main() async {
-    await bindAroundGroupSpawn()
+    if CommandLine.arguments.contains("discarding-task-group") {
+      await bindAroundGroupAddTask()
+    } else {
+      await bindAroundDiscardingGroupAddTask()
+    }
   }
 }

test/Concurrency/Runtime/async_task_locals_prevent_illegal_use_taskgroup.swift

@@ -0,0 +1,62 @@
+// RUN: %target-fail-simple-swift( -Xfrontend -disable-availability-checking -parse-as-library %import-libdispatch) 2>&1 | %FileCheck %s
+//
+// // TODO: could not figure out how to use 'not --crash' it never is used with target-run-simple-swift
+// This test is intended to *crash*, so we're using target-fail-simple-swift
+// which expects the exit code of the program to be non-zero;
+// We then check stderr for the expected error message using filecheck as usual.
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: libdispatch
+// REQUIRES: concurrency_runtime
+// UNSUPPORTED: back_deployment_runtime
+
+@available(SwiftStdlib 5.1, *)
+enum TL {
+  @TaskLocal
+  static var number: Int = 2
+}
+
+// ==== ------------------------------------------------------------------------
+
+func bindAroundGroupAddTask() async {
+  await TL.$number.withValue(1111) { // ok
+    await withTaskGroup(of: Int.self) { group in
+      // CHECK: error: task-local: detected illegal task-local value binding at {{.*}}illegal_use.swift:[[# @LINE + 1]]
+      TL.$number.withValue(2222) { // bad!
+        print("Survived, inside withValue!") // CHECK-NOT: Survived, inside withValue!
+        group.addTask {
+          0 // don't actually perform the read, it would be unsafe.
+        }
+      }
+
+      print("Survived the illegal call!") // CHECK-NOT: Survived the illegal call!
+    }
+  }
+}
+
+func bindAroundDiscardingGroupAddTask() async {
+  await TL.$number.withValue(1111) { // ok
+    await withDiscardingTaskGroup(of: Int.self) { group in
+      // CHECK: error: task-local: detected illegal task-local value binding at {{.*}}illegal_use.swift:[[# @LINE + 1]]
+      TL.$number.withValue(2222) { // bad!
+        print("Survived, inside withValue!") // CHECK-NOT: Survived, inside withValue!
+        group.addTask {
+          0 // don't actually perform the read, it would be unsafe.
+        }
+      }
+
+      print("Survived the illegal call!") // CHECK-NOT: Survived the illegal call!
+    }
+  }
+}
+
+@main struct Main {
+  static func main() async {
+    if CommandLine.arguments.contains("discarding-task-group") {
+      await bindAroundGroupAddTask()
+    } else {
+      await bindAroundDiscardingGroupAddTask()
+    }
+  }
+}