Updated Distributed/Runtime/distributed_actor_deinit.swift to check for isolation

Author: nickolas-pohilets

test/Distributed/Runtime/distributed_actor_deinit.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking -parse-as-library) | %FileCheck %s
+// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking -parse-stdlib -parse-as-library) | %FileCheck %s
 
 // REQUIRES: executable_test
 // REQUIRES: concurrency
@@ -10,7 +10,26 @@
 // FIXME(distributed): Distributed actors currently have some issues on windows, isRemote always returns false. rdar://82593574
 // UNSUPPORTED: OS=windows-msvc
 
+import Swift
+import _Concurrency
 import Distributed
+import Dispatch
+
+@_silgen_name("swift_task_isCurrentExecutor")
+private func isCurrentExecutor(_ executor: Builtin.Executor) -> Bool
+
+func getExecutor(_ a: AnyActor) -> Builtin.Executor {
+  let pack = (a, UnsafeRawPointer?.none)
+  return unsafeBitCast(pack, to: Builtin.Executor.self)
+}
+
+func isCurrent(_ a: AnyActor) -> Bool {
+  return isCurrentExecutor(getExecutor(a))
+}
+
+func isMainThread() -> Bool {
+  isCurrentExecutor(Builtin.buildMainActorExecutorRef())
+}
 
 actor A {}
 
@@ -28,26 +47,54 @@ distributed actor DA_userDefined {
   nonisolated deinit {}
 }
 
-distributed actor DA_userDefined2 {
+distributed actor DA_userDefined_nonisolated {
   init(system: FakeActorSystem) {
     self.actorSystem = system
   }
 
   nonisolated deinit {
-    print("Deinitializing \(self.id) remote:\(__isRemoteActor(self))")
+    print("Deinitializing \(self.id) remote:\(__isRemoteActor(self)) isolated:\(isCurrent(self))")
   }
 }
 
-distributed actor DA_state {
-  var name = "Hello"
-  var age = 42
-
+distributed actor DA_userDefined_isolated {
   init(system: FakeActorSystem) {
     self.actorSystem = system
   }
 
+  deinit {
+    print("Deinitializing \(self.id) remote:\(__isRemoteActor(self)) isolated:\(isCurrent(self))")
+  }
+}
+
+distributed actor DA_state_nonisolated {
+  var name: String
+  var age: Int
+
+  init(name: String, age: Int, system: FakeActorSystem) {
+    self.name = name
+    self.age = age
+    self.actorSystem = system
+  }
+
   nonisolated deinit {
-    print("Deinitializing \(self.id) remote:\(__isRemoteActor(self))")
+    print("Deinitializing \(self.id) name=\(name) age=\(age) remote:\(__isRemoteActor(self)) isolated:\(isCurrent(self))")
+    return
+  }
+}
+
+distributed actor DA_state_isolated {
+  var name: String
+  var age: Int
+
+  init(name: String, age: Int, system: FakeActorSystem) {
+    self.name = name
+    self.age = age
+    self.actorSystem = system
+  }
+
+  deinit {
+    print("Deinitializing \(self.id) name=\(name) age=\(age) remote:\(__isRemoteActor(self)) isolated:\(isCurrent(self))")
     return
   }
 }
@@ -69,6 +116,16 @@ final class FakeActorSystem: @unchecked Sendable, DistributedActorSystem {
   typealias ResultHandler = FakeResultHandler
 
   var n = 0
+  let group: DispatchGroup
+  
+  init(group: DispatchGroup) {
+    self.group = group
+  }
+  
+  deinit {
+    print("Deinit ActorSystem: mainThread=\(isMainThread())")
+    group.leave()
+  }
 
   func resolve<Act>(id: ActorID, as actorType: Act.Type) throws -> Act?
       where Act: DistributedActor,
@@ -174,7 +231,7 @@ typealias DefaultDistributedActorSystem = FakeActorSystem
 // ==== Execute ----------------------------------------------------------------
 
 func test() {
-  let system = DefaultDistributedActorSystem()
+  let group = DispatchGroup()
 
   // no lifecycle things make sense for a normal actor, double check we didn't emit them
   print("before A")
@@ -183,46 +240,98 @@ func test() {
   // CHECK: before A
   // CHECK: after A
 
+  group.enter()
   _ = { () -> DA in
-    DA(system: system)
+    DA(system: DefaultDistributedActorSystem(group: group))
   }()
+  group.wait()
   // CHECK: assign type:DA, address:[[ADDRESS:.*]]
   // CHECK: ready actor:main.DA, address:ActorAddress(address: "[[ADDR1:addr-[0-9]]]")
   // CHECK: resign address:ActorAddress(address: "[[ADDR1]]")
+  // CHECK-NEXT: Deinit ActorSystem: mainThread=true
 
+  group.enter()
   _ = { () -> DA_userDefined in
-    DA_userDefined(system: system)
+    DA_userDefined(system: DefaultDistributedActorSystem(group: group))
   }()
+  group.wait()
   // CHECK: assign type:DA_userDefined, address:[[ADDRESS:.*]]
   // CHECK: ready actor:main.DA_userDefined, address:ActorAddress(address: "[[ADDR2:addr-[0-9]]]")
   // CHECK: resign address:ActorAddress(address: "[[ADDR2]]")
+  // CHECK-NEXT: Deinit ActorSystem: mainThread=true
 
   // resign must happen as the _last thing_ after user-deinit completed
-  _ = { () -> DA_userDefined2 in
-    DA_userDefined2(system: system)
+  group.enter()
+  _ = { () -> DA_userDefined_nonisolated in
+    DA_userDefined_nonisolated(system: DefaultDistributedActorSystem(group: group))
   }()
-  // CHECK: assign type:DA_userDefined2, address:[[ADDRESS:.*]]
-  // CHECK: ready actor:main.DA_userDefined2, address:ActorAddress(address: "[[ADDR3:addr-[0-9]]]")
-  // CHECK: Deinitializing ActorAddress(address: "[[ADDR3]]") remote:false
+  group.wait()
+  // CHECK: assign type:DA_userDefined_nonisolated, address:[[ADDRESS:.*]]
+  // CHECK: ready actor:main.DA_userDefined_nonisolated, address:ActorAddress(address: "[[ADDR3:addr-[0-9]]]")
+  // CHECK: Deinitializing ActorAddress(address: "[[ADDR3]]") remote:false isolated:false
   // CHECK-NEXT: resign address:ActorAddress(address: "[[ADDR3]]")
-
+  // CHECK-NEXT: Deinit ActorSystem: mainThread=true
+  
   // resign must happen as the _last thing_ after user-deinit completed
-  _ = { () -> DA_state in
-    DA_state(system: system)
+  group.enter()
+  _ = { () -> DA_userDefined_isolated in
+    DA_userDefined_isolated(system: DefaultDistributedActorSystem(group: group))
   }()
-  // CHECK: assign type:DA_state, address:[[ADDRESS:.*]]
-  // CHECK: ready actor:main.DA_state, address:ActorAddress(address: "[[ADDR4:addr-[0-9]]]")
-  // CHECK: Deinitializing ActorAddress(address: "[[ADDR4]]") remote:false
+  group.wait()
+  // CHECK: assign type:DA_userDefined_isolated, address:[[ADDRESS:.*]]
+  // CHECK: ready actor:main.DA_userDefined_isolated, address:ActorAddress(address: "[[ADDR4:addr-[0-9]]]")
+  // CHECK: Deinitializing ActorAddress(address: "[[ADDR4]]") remote:false isolated:true
   // CHECK-NEXT: resign address:ActorAddress(address: "[[ADDR4]]")
+  // CHECK-NEXT: Deinit ActorSystem: mainThread=false
 
+  // resign must happen as the _last thing_ after user-deinit completed
+  group.enter()
+  _ = { () -> DA_state_nonisolated in
+    DA_state_nonisolated(name: "Foo", age:37, system: DefaultDistributedActorSystem(group: group))
+  }()
+  group.wait()
+  // CHECK: assign type:DA_state_nonisolated, address:[[ADDRESS:.*]]
+  // CHECK: ready actor:main.DA_state_nonisolated, address:ActorAddress(address: "[[ADDR5:addr-[0-9]]]")
+  // CHECK: Deinitializing ActorAddress(address: "[[ADDR5]]") name=Foo age=37 remote:false isolated:false
+  // CHECK-NEXT: resign address:ActorAddress(address: "[[ADDR5]]")
+  // CHECK-NEXT: Deinit ActorSystem: mainThread=true
+  
+  // resign must happen as the _last thing_ after user-deinit completed
+  group.enter()
+  _ = { () -> DA_state_isolated in
+    DA_state_isolated(name: "Bar", age:42, system: DefaultDistributedActorSystem(group: group))
+  }()
+  group.wait()
+  // CHECK: assign type:DA_state_isolated, address:[[ADDRESS:.*]]
+  // CHECK: ready actor:main.DA_state_isolated, address:ActorAddress(address: "[[ADDR6:addr-[0-9]]]")
+  // CHECK: Deinitializing ActorAddress(address: "[[ADDR6]]") name=Bar age=42 remote:false isolated:true
+  // CHECK-NEXT: resign address:ActorAddress(address: "[[ADDR6]]")
+  // CHECK-NEXT: Deinit ActorSystem: mainThread=false
+
+  // a remote actor should not resign it's address, it was never "assigned" it
+  group.enter()
+  _ = { () -> DA_userDefined_nonisolated in
+    let address = ActorAddress(parse: "remote-1")
+    return try! DA_userDefined_nonisolated.resolve(id: address, using: DefaultDistributedActorSystem(group: group))
+  }()
+  group.wait()
+  // CHECK-NEXT: resolve type:DA_userDefined_nonisolated, address:ActorAddress(address: "remote-1")
+  // MUST NOT run deinit body for a remote distributed actor
+  // CHECK-NOT: Deinitializing ActorAddress(address: "remote-1")
+  // CHECK-NEXT: Deinit ActorSystem: mainThread=true
+  
   // a remote actor should not resign it's address, it was never "assigned" it
-  let address = ActorAddress(parse: "remote-1")
-  _ = { () -> DA_userDefined2 in
-    try! DA_userDefined2.resolve(id: address, using: system)
+  group.enter()
+  _ = { () -> DA_userDefined_isolated in
+    let address = ActorAddress(parse: "remote-2")
+    return try! DA_userDefined_isolated.resolve(id: address, using: DefaultDistributedActorSystem(group: group))
   }()
-  // CHECK-NEXT: resolve type:DA_userDefined2, address:ActorAddress(address: "[[ADDR5:remote-1]]")
+  group.wait()
+  // CHECK-NEXT: resolve type:DA_userDefined_isolated, address:ActorAddress(address: "remote-2")
   // MUST NOT run deinit body for a remote distributed actor
-  // CHECK-NOT: Deinitializing ActorAddress(address: "remote-1") remote:true
+  // CHECK-NOT: Deinitializing ActorAddress(address: "remote-2")
+  // TODO: Fix this. Remote proxies should not have isolated deinit.
+  // CHECK-NEXT: Deinit ActorSystem: mainThread=false
 
   print("DONE")
   // CHECK-NEXT: DONE