Merge pull request #59288 from DougGregor/back-deploy-concurrency-task-leak

Author: DougGregor

stdlib/public/BackDeployConcurrency/Actor.h

@@ -14,8 +14,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_ABI_ACTOR_H
-#define SWIFT_ABI_ACTOR_H
+#ifndef SWIFT_ABI_ACTOR_BACKDEPLOYED_H
+#define SWIFT_ABI_ACTOR_BACKDEPLOYED_H
 
 #include "swift/ABI/HeapObject.h"
 #include "swift/ABI/MetadataValues.h"
@@ -31,11 +31,21 @@ class alignas(Alignment_DefaultActor) DefaultActor : public HeapObject {
   // destructor does not destroy the actor instance; you must call
   // swift_defaultActor_{initialize,destroy} yourself.
   constexpr DefaultActor(const HeapMetadata *metadata)
-    : HeapObject(metadata), PrivateData{} {}
+    : HeapObject(metadata), PrivateData{} {
+    initHeapObject();
+  }
 
   constexpr DefaultActor(const HeapMetadata *metadata,
                          InlineRefCounts::Immortal_t immortal)
-    : HeapObject(metadata, immortal), PrivateData{} {}
+    : HeapObject(metadata, immortal), PrivateData{} {
+    // By a lucky coincidence, the modern bit pattern for immortal objects also
+    // sets the immortal bit for older runtimes, so we don't need an immortal
+    // equivalent to initHeapObject().
+  }
+
+  void initHeapObject() {
+    _swift_instantiateInertHeapObject(this, metadata);
+  }
 
   void *PrivateData[NumWords_DefaultActor];
 };

stdlib/public/BackDeployConcurrency/Task.h

@@ -95,6 +95,7 @@ class alignas(2 * alignof(void*)) Job :
   Job(JobFlags flags, JobInvokeFunction *invoke,
       const HeapMetadata *metadata = &jobHeapMetadata)
       : HeapObject(metadata), Flags(flags), RunJob(invoke) {
+    initHeapObject();
     Voucher = voucher_copy();
     assert(!isAsyncTask() && "wrong constructor for a task");
   }
@@ -103,6 +104,7 @@ class alignas(2 * alignof(void*)) Job :
       const HeapMetadata *metadata = &jobHeapMetadata,
       bool captureCurrentVoucher = true)
       : HeapObject(metadata), Flags(flags), ResumeTask(invoke) {
+    initHeapObject();
     if (captureCurrentVoucher)
       Voucher = voucher_copy();
     assert(isAsyncTask() && "wrong constructor for a non-task job");
@@ -114,11 +116,18 @@ class alignas(2 * alignof(void*)) Job :
       const HeapMetadata *metadata, InlineRefCounts::Immortal_t immortal,
       bool captureCurrentVoucher = true)
       : HeapObject(metadata, immortal), Flags(flags), ResumeTask(invoke) {
+    // By a lucky coincidence, the modern bit pattern for immortal objects also
+    // sets the immortal bit for older runtimes, so we don't need an immortal
+    // equivalent to initHeapObject().
     if (captureCurrentVoucher)
       Voucher = voucher_copy();
     assert(isAsyncTask() && "wrong constructor for a non-task job");
   }
 
+  void initHeapObject() {
+    _swift_instantiateInertHeapObject(this, metadata);
+  }
+
   ~Job() { swift_voucher_release(Voucher); }
 
   bool isAsyncTask() const {

test/Concurrency/Runtime/task_destruction.swift

@@ -0,0 +1,34 @@
+// RUN: %target-run-simple-swift(-parse-as-library -Xfrontend -disable-availability-checking) | %FileCheck %s
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: concurrency_runtime
+
+// UNSUPPORTED: back_deployment_runtime
+
+class C {}
+
+@_silgen_name("exit")
+func exit(_ code : UInt32) -> Never
+
+@main
+enum Main {
+  static func main() async {
+    weak var weakRef: C?
+    do {
+      let c = C()
+      let t = Task.detached { return c }
+      weakRef = c
+    }
+    Task.detached {
+      try await Task.sleep(nanoseconds: 10_000_000_000)
+      print("Fail!")
+      exit(1)
+    }
+    
+    while weakRef != nil {
+      await Task.yield()
+    }
+    // CHECK: Success
+    print("Success!")
+  }
+}