do a CI test run

Author: ktoso

stdlib/public/Concurrency/TaskGroup.cpp

@@ -390,7 +390,11 @@ class TaskGroupBase : public TaskGroupTaskStatusRecord {
   virtual void enqueueCompletedTask(AsyncTask *completedTask, bool hadErrorResult) = 0;
 
   /// Resume waiting task with result from `completedTask`
-  void resumeWaitingTask(AsyncTask *completedTask, TaskGroupStatus &assumed, bool hadErrorResult, bool alreadyDecremented = false);
+  void resumeWaitingTask(AsyncTask *completedTask,
+                         TaskGroupStatus &assumed,
+                         bool hadErrorResult,
+                         bool alreadyDecremented = false,
+                         bool taskWasRetained = false);
 
   // ==== Status manipulation -------------------------------------------------
 
@@ -827,7 +831,9 @@ class DiscardingTaskGroup: public TaskGroupBase {
 
 private:
   /// Resume waiting task with specified error
-  void resumeWaitingTaskWithError(SwiftError *error, TaskGroupStatus &assumed, bool alreadyDecremented);
+  void resumeWaitingTaskWithError(SwiftError *error,
+                                  TaskGroupStatus &assumed,
+                                  bool alreadyDecremented);
 };
 
 } // end anonymous namespace
@@ -1240,11 +1246,16 @@ void DiscardingTaskGroup::offer(AsyncTask *completedTask, AsyncContext *context)
         switch (readyErrorItem.getStatus()) {
           case ReadyStatus::RawError:
             SWIFT_TASK_GROUP_DEBUG_LOG(this, "offer, complete, resume with raw error:%p", readyErrorItem.getRawError(this));
-            resumeWaitingTaskWithError(readyErrorItem.getRawError(this), assumed, alreadyDecrementedStatus);
+            resumeWaitingTaskWithError(readyErrorItem.getRawError(this), assumed,
+                                       alreadyDecrementedStatus);
             break;
           case ReadyStatus::Error:
             SWIFT_TASK_GROUP_DEBUG_LOG(this, "offer, complete, resume with errorItem.task:%p", readyErrorItem.getTask());
-            resumeWaitingTask(readyErrorItem.getTask(), assumed, /*hadErrorResult=*/true, alreadyDecrementedStatus);
+            SWIFT_TASK_GROUP_DEBUG_LOG(this, "offer, complete, expect that it was extra retained %p", readyErrorItem.getTask());
+            resumeWaitingTask(readyErrorItem.getTask(), assumed,
+                              /*hadErrorResult=*/true,
+                              alreadyDecrementedStatus,
+                              /*taskWasRetained=*/true);
             break;
           default:
             swift_Concurrency_fatalError(0,
@@ -1283,7 +1294,10 @@ void DiscardingTaskGroup::offer(AsyncTask *completedTask, AsyncContext *context)
           resumeWaitingTaskWithError(readyErrorItem.getRawError(this), assumed, alreadyDecrementedStatus);
           break;
         case ReadyStatus::Error:
-          resumeWaitingTask(readyErrorItem.getTask(), assumed, /*hadErrorResult=*/true, alreadyDecrementedStatus);
+          resumeWaitingTask(readyErrorItem.getTask(), assumed,
+                            /*hadErrorResult=*/true,
+                            alreadyDecrementedStatus,
+                            /*taskWasRetained=*/true);
           break;
         default:
           swift_Concurrency_fatalError(0,
@@ -1317,7 +1331,8 @@ void TaskGroupBase::resumeWaitingTask(
     AsyncTask *completedTask,
     TaskGroupStatus &assumed,
     bool hadErrorResult,
-    bool alreadyDecremented) {
+    bool alreadyDecremented,
+    bool taskWasRetained) {
   auto waitingTask = waitQueue.load(std::memory_order_acquire);
   assert(waitingTask && "waitingTask must not be null when attempting to resume it");
   assert(assumed.hasWaitingTask());
@@ -1384,13 +1399,21 @@ void TaskGroupBase::resumeWaitingTask(
         auto before = completedTask;
         _swift_taskGroup_detachChild(asAbstract(this), completedTask);
         SWIFT_TASK_GROUP_DEBUG_LOG(this, "completedTask %p; AFTER DETACH (count:%d)", completedTask, swift_retainCount(completedTask));
-        if (isDiscardingResults() && hadErrorResult) {
+        if (isDiscardingResults() && hadErrorResult && taskWasRetained) {
           SWIFT_TASK_GROUP_DEBUG_LOG(this, "BEFORE RELEASE error task=%p (count:%d)\n",
                   completedTask,
                   swift_retainCount(completedTask));
-//           We only used the task to keep the error in the future fragment around
+          // We only used the task to keep the error in the future fragment around
           // so now that we emitted the error and detached the task, we are free to release the task immediately.
-          swift_release(completedTask); // we need to do this if the error is a class
+          auto error = completedTask->futureFragment()->getError();
+          fprintf(stderr, "[%s:%d](%s) THE ERRROR IN RELEASING %p\n", __FILE_NAME__, __LINE__, __FUNCTION__,
+                  error);
+          swift_release(completedTask);
+//          swift_errorRelease(error);
+        } else {
+          fprintf(stderr, "[%s:%d](%s) DID NOT RELEASE %p\n", __FILE_NAME__, __LINE__, __FUNCTION__,
+                  completedTask);
+//          assert(false);
         }
 
         _swift_tsan_acquire(static_cast<Job *>(waitingTask));
@@ -1799,6 +1822,7 @@ void TaskGroupBase::waitAll(SwiftError* bodyError, AsyncTask *waitingTask,
 
 #if SWIFT_TASK_GROUP_BODY_THROWN_ERROR_WINS
     if (bodyError) {
+      // FIXME: are we ok with releases here?
       fillGroupNextErrorResult(context, bodyError);
     } else {
       fillGroupNextResult(context, result);

stdlib/public/Concurrency/TaskPrivate.h

@@ -292,6 +292,7 @@ class TaskFutureWaitAsyncContext : public AsyncContext {
     fillWithError(future->getError());
   }
   void fillWithError(SwiftError *error) {
+    fprintf(stderr, "[%s:%d](%s) FILL WITH ERROR %p\n", __FILE_NAME__, __LINE__, __FUNCTION__, error);
     errorResult = error;
     swift_errorRetain(error);
   }

stdlib/public/runtime/HeapObject.cpp

@@ -797,7 +797,7 @@ void swift::swift_unownedCheck(HeapObject *object) {
 void _swift_release_dealloc(HeapObject *object) {
 //  assert(object);
 //  if (!object->metadata) {
-    fprintf(stderr, "[%s:%d](%s) object: %p\n", __FILE_NAME__, __LINE__, __FUNCTION__, object);
+//    fprintf(stderr, "[%s:%d](%s) object: %p\n", __FILE_NAME__, __LINE__, __FUNCTION__, object);
 //  }
 //  assert(object->metadata);
   asFullMetadata(object->metadata)->destroy(object);

test/Concurrency/Runtime/async_taskgroup_discarding_dontLeak_class_error.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-leaks-swift( -Xfrontend -disable-availability-checking -parse-as-library)
+// RUN: %target-run-simple-leaks-swift( -Xfrontend -disable-availability-checking -parse-as-library) | %FileCheck %s --dump-input=always
 
 // This test uses `leaks` which is only available on apple platforms; limit it to macOS:
 // REQUIRES: OS=macosx
@@ -14,16 +14,18 @@
 // UNSUPPORTED: OS=windows-msvc
 
 import _Concurrency
+import Darwin
 
 final class ClassBoom: Error {
   let id: String
 
   init(file: String = #fileID, line: UInt = #line) {
     self.id = "\(file):\(line)"
+    fputs("INIT OF ClassBoom from \(id)", stderr)
   }
 
-  init(id: String) {
-    self.id = id
+  deinit {
+    fputs("DEINIT OF ClassBoom from \(id)", stderr)
   }
 }
 
@@ -49,6 +51,7 @@ final class ClassBoom: Error {
       }
 
       return 12
+      // CHECK: : 0 leaks
     }
   }
 }