workaround for #59356 while still implementing the witness feature

Author: ktoso

test/Distributed/Runtime/distributed_actor_local_only_witness_and_call.swift

@@ -0,0 +1,71 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -disable-availability-checking %S/../Inputs/FakeDistributedActorSystems.swift
+// RUN: %target-build-swift -module-name main -Xfrontend -enable-experimental-distributed -Xfrontend -disable-availability-checking -j2 -parse-as-library -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s --color
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+// rdar://76038845
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: back_deployment_runtime
+
+// FIXME(distributed): Distributed actors currently have some issues on windows, isRemote always returns false. rdar://82593574
+// UNSUPPORTED: OS=windows-msvc
+
+
+import Distributed
+import FakeDistributedActorSystems
+
+typealias DefaultDistributedActorSystem = FakeRoundtripActorSystem
+
+protocol LifecycleWatch: DistributedActor where ActorSystem == FakeRoundtripActorSystem {
+  func terminated(actor id: ID) async
+}
+
+extension LifecycleWatch {
+  func watch<T: Codable>(x: Int, _ y: T) async throws {
+    // nothing here
+    print("executed: \(#function) - x = \(x), y = \(y)")
+  }
+
+  distributed func test<T: Codable & Sendable>(x: Int, _ y: T) async throws {
+    print("executed: \(#function)")
+    try await self.watch(x: x, y)
+    print("done executed: \(#function)")
+  }
+}
+
+distributed actor Worker: LifecycleWatch {
+  func terminated(actor id: ID) async {
+    print("terminated (on \(self.id)): \(id)")
+  }
+}
+
+@main struct Main {
+  static func main() async {
+    let worker: any LifecycleWatch = Worker(actorSystem: DefaultDistributedActorSystem())
+    try! await worker.test(x: 42, "on protocol")
+
+    // CHECK: executed: test(x:_:)
+    // CHECK: executed: watch(x:_:) - x = 42, y = on protocol
+    // CHECK: done executed: test(x:_:)
+
+    // FIXME: Actor isolation getting with generics is pending implementation #59356
+    do {
+      let terminatedID = Worker.ID(parse: "<terminated-id>")
+      let __secretlyKnownToBeLocal = worker
+      await __secretlyKnownToBeLocal.terminated(actor: terminatedID)
+
+      // FIXME: Once the above fixme is solved, use this real code instead:
+      //    _ = await worker.whenLocal { __secretlyKnownToBeLocal in
+      //      let terminatedID = Worker.ID(parse: "<terminated-id>")
+      //      return await __secretlyKnownToBeLocal.terminated(actor: terminatedID)
+      //    }
+    }
+    // CHECK: terminated (on ActorAddress(address: "<unique-id>")): ActorAddress(address: "<terminated-id>")
+
+    print("OK") // CHECK: OK
+  }
+}

test/Distributed/distributed_protocol_isolation.swift

@@ -178,9 +178,7 @@ protocol TerminationWatchingA {
 }
 
 protocol TerminationWatchingDA: DistributedActor {
-  func terminated(da: String) async
-  // expected-note@-1{{distributed actor-isolated instance method 'terminated(da:)' declared here}}
-  // expected-note@-2{{distributed actor-isolated instance method 'terminated(da:)' declared here}}
+  func terminated(da: String) async // expected-note 3 {{distributed actor-isolated instance method 'terminated(da:)' declared here}}
 }
 
 actor A_TerminationWatchingA: TerminationWatchingA {
@@ -212,21 +210,26 @@ func test_watchingDA<WDA: TerminationWatchingDA>(da: WDA) async throws {
   // expected-error@-1{{only 'distributed' instance methods can be called on a potentially remote distributed actor}}
   // expected-warning@-2{{no calls to throwing functions occur within 'try' expression}}
 
-//  // FIXME: pending fix of closure isolation checking with actors #59356
-//  await da.whenLocal { __secretlyKnownToBeLocal in
-//    await __secretlyKnownToBeLocal.terminated(da: "local calls are okey!") // OK
-//  }
+  let __secretlyKnownToBeLocal = da
+  await __secretlyKnownToBeLocal.terminated(da: "local calls are okey!") // OK // FIXME(#59356): (the __secretlyKnown is a hack, but the whenLocal crashes now on pending isolation getting with generic actors for closures)
+  // FIXME: pending fix of closure isolation checking with actors #59356
+  // await da.whenLocal { __secretlyKnownToBeLocal in
+  //   await __secretlyKnownToBeLocal.terminated(da: "local calls are okey!") // OK
+  // }
 }
 
 func test_watchingDA_erased(da: DA_TerminationWatchingDA) async throws {
-  let wda: TerminationWatchingDA = da
-  try await wda.terminated(wda: "the terminated func is not distributed")
+  let wda: any TerminationWatchingDA = da
+  try await wda.terminated(da: "the terminated func is not distributed")
   // expected-error@-1{{only 'distributed' instance methods can be called on a potentially remote distributed actor}}
   // expected-warning@-2{{no calls to throwing functions occur within 'try' expression}}
 
-  await wda.whenLocal { __secretlyKnownToBeLocal in
-    await __secretlyKnownToBeLocal.terminated(da: "local calls are okey!") // OK
-  }
+  let __secretlyKnownToBeLocal = wda
+  await __secretlyKnownToBeLocal.terminated(da: "local calls are okey!") // OK // OK // FIXME(#59356): (the __secretlyKnown is a hack, but the whenLocal crashes now on pending isolation getting with generic actors for closures)
+  // FIXME: pending fix of closure isolation checking with actors #59356
+  // await wda.whenLocal { __secretlyKnownToBeLocal in
+  //   await __secretlyKnownToBeLocal.terminated(da: "local calls are okey!") // OK
+  // }
 }
 
 func test_watchingDA_any(da: any TerminationWatchingDA) async throws {