Added more tests for isolated actor deinit:

* Recursive deallocation with multiple locks held
* (UB) Escaping self triggers assertion in stdlib

Author: nickolas-pohilets

test/Concurrency/Runtime/actor_deinit_escaping_self.swift

@@ -0,0 +1,69 @@
+// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking -parse-as-library)
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: concurrency_runtime
+// UNSUPPORTED: back_deployment_runtime
+
+import _Concurrency
+@preconcurrency import Dispatch
+import StdlibUnittest
+
+actor EscapeLocked {
+  var k: Int = 1
+  
+  func increment() {
+    k += 1
+  }
+  
+  deinit {
+    let g = DispatchGroup()
+    g.enter()
+    Task.detached {
+      await self.increment()
+      g.leave()
+    }
+    let r = g.wait(timeout: .now() + .milliseconds(500))
+    expectEqual(r, .timedOut)
+    expectCrashLater(withMessage: "Assertion failed: (!oldState.getFirstJob() && \"actor has queued jobs at destruction\"), function destroy")
+  }
+}
+
+actor EscapeUnlocked {
+  let cont: UnsafeContinuation<Void, Never>
+  var k: Int = 1
+  
+  init(_ cont: UnsafeContinuation<Void, Never>) {
+    self.cont = cont
+  }
+  
+  func increment() {
+    k += 1
+  }
+  
+  deinit {
+    DispatchQueue.main.async {
+      Task.detached {
+        expectCrashLater(withMessage: "Assertion failed: (oldState.getMaxPriority() == JobPriority::Unspecified), function tryLock")
+        await self.increment()
+        self.cont.resume()
+      }
+    }
+  }
+}
+
+@main struct Main {
+  static func main() async {
+    let tests = TestSuite("EscapingSelf")
+    tests.test("escape while locked") {
+      _ = EscapeLocked()
+    }
+
+    tests.test("escape while unlocked") {
+      await withUnsafeContinuation { cont in
+        _ = EscapeUnlocked(cont)
+      }
+    }
+    await runAllTestsAsync()
+  }
+}

test/Concurrency/Runtime/actor_recursive_deinit.swift

@@ -0,0 +1,83 @@
+// RUN: %target-run-simple-swift(-Xfrontend -disable-availability-checking -parse-as-library) | %FileCheck %s
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+
+// REQUIRES: concurrency_runtime
+// UNSUPPORTED: back_deployment_runtime
+
+#if canImport(Darwin)
+import Darwin
+typealias ThreadID = pthread_t
+func getCurrentThreadID() -> ThreadID { pthread_self() }
+func equalThreadIDs(_ a: ThreadID, _ b: ThreadID) -> Bool { pthread_equal(a, b) != 0 }
+#elseif canImport(Glibc)
+import Glibc
+typealias ThreadID = pthread_t
+func getCurrentThreadID() -> ThreadID { pthread_self() }
+func equalThreadIDs(_ a: ThreadID, _ b: ThreadID) -> Bool { pthread_equal(a, b) != 0 }
+#elseif os(Windows)
+import WinSDK
+typealias ThreadID = UInt32
+func getCurrentThreadID() -> ThreadID { GetCurrentThreadId() }
+func equalThreadIDs(_ a: ThreadID, _ b: ThreadID) -> Bool { a == b }
+#endif
+
+var mainThread: ThreadID?
+func isMainThread() -> Bool {
+    return equalThreadIDs(getCurrentThreadID(), mainThread!)
+}
+
+// Look up a symbol using dlsym and cast the result to an arbitrary type.
+func lookup<T>(_ name: String) -> T {
+  let RTLD_DEFAULT = UnsafeMutableRawPointer(bitPattern: -2)
+  let result = dlsym(RTLD_DEFAULT, name)
+  return unsafeBitCast(result, to: T.self)
+}
+
+let getMainExecutor = lookup("swift_task_getMainExecutor") as @convention(thin) () -> UnownedSerialExecutor
+let isCurrentExecutor = lookup("swift_task_isCurrentExecutor") as @convention(thin) (UnownedSerialExecutor) -> Bool
+
+func getExecutor(_ a: AnyActor) -> UnownedSerialExecutor {
+  let pack = (a, UnsafeRawPointer?.none)
+  return unsafeBitCast(pack, to: UnownedSerialExecutor.self)
+}
+
+func isCurrent(_ a: AnyActor) -> Bool {
+  return isCurrentExecutor(getExecutor(a))
+}
+
+func isMainExecutor() -> Bool {
+  isCurrentExecutor(getMainExecutor())
+}
+
+actor Foo {
+    let name: String
+    let child: Foo?
+
+    init(_ name: String, _ child: Foo?) {
+        self.name = name
+        self.child = child
+    }
+
+    deinit {
+        print("DEINIT: \(name) isolated:\(isCurrent(self)) mainThread:\(isMainThread())")
+    }
+}
+
+// CHECK: DEINIT: a isolated:true mainThread:true
+// CHECK: DEINIT: b isolated:true mainThread:true
+// CHECK: DEINIT: c isolated:true mainThread:true
+// CHECK: DEINIT: d isolated:true mainThread:true
+// CHECK: DONE
+
+@main
+struct Main {
+    static func main() async {
+        mainThread = getCurrentThreadID()
+        do {
+            _ = Foo("a", Foo("b", Foo("c", Foo("d", nil))))
+        }
+        print("DONE")
+    }
+}