[Distributed] Reuse fake actor systems more in tests

Author: ktoso

lib/Sema/TypeCheckDistributed.cpp

@@ -134,7 +134,7 @@ bool swift::checkDistributedActorSystemAdHocProtocolRequirements(
           "func remoteCall<Act, Err, Res>(\n"
           "    on actor: Act,\n"
           "    target: RemoteCallTarget,\n"
-          "    invocationDecoder: inout InvocationDecoder,\n"
+          "    invocation: inout InvocationEncoder,\n"
           "    throwing: Err.Type,\n"
           "    returning: Res.Type\n"
           ") async throws -> Res\n"
@@ -157,7 +157,7 @@ bool swift::checkDistributedActorSystemAdHocProtocolRequirements(
           "func remoteCallVoid<Act, Err>(\n"
           "    on actor: Act,\n"
           "    target: RemoteCallTarget,\n"
-          "    invocationDecoder: inout InvocationDecoder,\n"
+          "    invocation: inout InvocationEncoder,\n"
           "    throwing: Err.Type\n"
           ") async throws\n"
           "  where Act: DistributedActor,\n"

lib/sourcekitd.framework/Headers

@@ -122,7 +122,7 @@ public protocol DistributedActorSystem: Sendable {
 //  func remoteCall<Act, Err, Res>(
 //      on actor: Act,
 //      target: RemoteCallTarget,
-//      invocationDecoder: inout InvocationDecoder,
+//      invocation: inout InvocationEncoder,
 //      throwing: Err.Type,
 //      returning: Res.Type
 //  ) async throws -> Res
@@ -157,7 +157,7 @@ extension DistributedActorSystem {
     invocationDecoder: inout InvocationDecoder,
     handler: ResultHandler
   ) async throws where Act: DistributedActor,
-                       Act.ID == ActorID,
+                       // Act.ID == ActorID, // FIXME(distributed): can we bring this back?
                        ResultHandler: DistributedTargetInvocationResultHandler {
     // NOTE: this implementation is not the most efficient, nor final, version of this func
     // we end up demangling the name multiple times, perform more heap allocations than

lib/sourcekitd.framework/Resources

@@ -169,6 +169,7 @@ public final class FakeRoundtripActorSystem: DistributedActorSystem, @unchecked
   }
 
   private var remoteCallResult: Any? = nil
+  private var remoteCallError: Error? = nil
 
   public func remoteCall<Act, Err, Res>(
     on actor: Act,
@@ -191,16 +192,30 @@ public final class FakeRoundtripActorSystem: DistributedActorSystem, @unchecked
         fatalError("Attempted to call mock 'roundtrip' on unknown actor: \(actor.id), known: \(active.id)")
       }
 
-      let resultHandler = FakeRoundtripResultHandler { self.remoteCallResult = $0 }
+      let resultHandler = FakeRoundtripResultHandler { value in
+        self.remoteCallResult = value
+        self.remoteCallError = nil
+      } onError: { error in
+        self.remoteCallResult = nil
+        self.remoteCallError = error
+      }
       try await executeDistributedTarget(
         on: active,
         mangledTargetName: target.mangledName,
         invocationDecoder: &invocation,
         handler: resultHandler
       )
 
-      print("  << remoteCall return: \(remoteCallResult!)")
-      return remoteCallResult! as! Res
+      switch (remoteCallResult, remoteCallError) {
+      case (.some(let value), nil):
+        print("  << remoteCall return: \(value)")
+        return remoteCallResult! as! Res
+      case (nil, .some(let error)):
+        print("  << remoteCall throw: \(error)")
+        throw error
+      default:
+        fatalError("No reply!")
+      }
     }
     return try await _openExistential(targetActor, do: doIt)
   }
@@ -209,13 +224,46 @@ public final class FakeRoundtripActorSystem: DistributedActorSystem, @unchecked
     on actor: Act,
     target: RemoteCallTarget,
     invocation: inout InvocationEncoder,
-    throwing: Err.Type
+    throwing errorType: Err.Type
   ) async throws
     where Act: DistributedActor,
           Act.ID == ActorID,
           Err: Error {
-    print("remoteCallVoid: on:\(actor), target:\(target), invocation:\(invocation), throwing:\(throwing)")
-    return ()
+    print("  >> remoteCallVoid: on:\(actor)), target:\(target), invocation:\(invocation), throwing:\(String(reflecting: errorType))")
+    guard let targetActor = activeActors[actor.id] else {
+      fatalError("Attempted to call mock 'roundtrip' on: \(actor.id) without active actor")
+    }
+
+    func doIt<A: DistributedActor>(active: A) async throws {
+      guard (actor.id) == active.id as! ActorID else {
+        fatalError("Attempted to call mock 'roundtrip' on unknown actor: \(actor.id), known: \(active.id)")
+      }
+
+      let resultHandler = FakeRoundtripResultHandler { value in
+        self.remoteCallResult = value
+        self.remoteCallError = nil
+      } onError: { error in
+        self.remoteCallResult = nil
+        self.remoteCallError = error
+      }
+      try await executeDistributedTarget(
+        on: active,
+        mangledTargetName: target.mangledName,
+        invocationDecoder: &invocation,
+        handler: resultHandler
+      )
+
+      switch (remoteCallResult, remoteCallError) {
+      case (.some, nil):
+        return
+      case (nil, .some(let error)):
+        print("  << remoteCall throw: \(error)")
+        throw error
+      default:
+        fatalError("No reply!")
+      }
+    }
+    try await _openExistential(targetActor, do: doIt)
   }
 
 }
@@ -290,19 +338,22 @@ public struct FakeRoundtripInvocation: DistributedTargetInvocationEncoder, Distr
 public struct FakeRoundtripResultHandler: DistributedTargetInvocationResultHandler {
   public typealias SerializationRequirement = Codable
 
-  let store: (Any) -> Void
-  init(_ store: @escaping (Any) -> Void) {
-    self.store = store
+  let storeReturn: (any Any) -> Void
+  let storeError: (any Error) -> Void
+  init(_ storeReturn: @escaping (Any) -> Void, onError storeError: @escaping (Error) -> Void) {
+    self.storeReturn = storeReturn
+    self.storeError = storeError
   }
 
+  // FIXME(distributed): can we return void here?
   public func onReturn<Res>(value: Res) async throws {
     print(" << onReturn: \(value)")
-    store(value)
+    storeReturn(value)
   }
 
   public func onThrow<Err: Error>(error: Err) async throws {
     print(" << onThrow: \(error)")
-    store(error)
+    storeError(error)
   }
 }
 

lib/sourcekitd.framework/Versions/Current

@@ -67,7 +67,7 @@ final class FakeActorSystem: DistributedActorSystem {
   func remoteCall<Act, Err, Res>(
       on actor: Act,
       target: RemoteCallTarget,
-      invocationDecoder: InvocationDecoder,
+      invocation: InvocationDecoder,
       throwing: Err.Type,
       returning: Res.Type
   ) async throws -> Res

lib/sourcekitd.framework/sourcekitd

@@ -76,7 +76,7 @@ final class FakeActorSystem: DistributedActorSystem {
   func remoteCall<Act, Err, Res>(
     on actor: Act,
     target: RemoteCallTarget,
-    invocationDecoder: inout InvocationDecoder,
+    invocation invocationEncoder: inout InvocationEncoder,
     throwing: Err.Type,
     returning: Res.Type
   ) async throws -> Res
@@ -90,7 +90,7 @@ final class FakeActorSystem: DistributedActorSystem {
   func remoteCallVoid<Act, Err>(
     on actor: Act,
     target: RemoteCallTarget,
-    invocationDecoder: inout InvocationDecoder,
+    invocation invocationEncoder: inout InvocationEncoder,
     throwing: Err.Type
   ) async throws
     where Act: DistributedActor,
@@ -247,7 +247,7 @@ class TestDecoder: Decoder {
 // ==== Execute ----------------------------------------------------------------
 
 func test() {
-  let system = FakeActorSystem()
+  let system = DefaultDistributedActorSystem()
 
   // CHECK: assign type:DA, address:ActorAddress(address: "xxx")
   // CHECK: ready actor:DA(ActorAddress(address: "xxx"))

stdlib/public/Distributed/DistributedActorSystem.swift

@@ -95,7 +95,7 @@ final class FakeActorSystem: @unchecked Sendable, DistributedActorSystem {
   func remoteCall<Act, Err, Res>(
     on actor: Act,
     target: RemoteCallTarget,
-    invocationDecoder: inout InvocationDecoder,
+    invocation invocationEncoder: inout InvocationEncoder,
     throwing: Err.Type,
     returning: Res.Type
   ) async throws -> Res
@@ -109,7 +109,7 @@ final class FakeActorSystem: @unchecked Sendable, DistributedActorSystem {
   func remoteCallVoid<Act, Err>(
     on actor: Act,
     target: RemoteCallTarget,
-    invocationDecoder: inout InvocationDecoder,
+    invocation invocationEncoder: inout InvocationEncoder,
     throwing: Err.Type
   ) async throws
     where Act: DistributedActor,
@@ -157,7 +157,7 @@ typealias DefaultDistributedActorSystem = FakeActorSystem
 // ==== Execute ----------------------------------------------------------------
 
 func test() {
-  let system = FakeActorSystem()
+  let system = DefaultDistributedActorSystem()
 
   // no lifecycle things make sense for a normal actor, double check we didn't emit them
   print("before A")