[Distributed] More tests for primary associated types in protocols

Author: ktoso

test/Distributed/Runtime/distributed_actor_func_calls_remoteCall_through_generic.swift

@@ -20,6 +20,7 @@ import FakeDistributedActorSystems
 
 typealias DefaultDistributedActorSystem = FakeRoundtripActorSystem
 
+@available(SwiftStdlib 6.0, *)
 protocol PlainWorker {
   associatedtype WorkItem: Sendable & Codable
   associatedtype WorkResult: Sendable & Codable
@@ -28,7 +29,9 @@ protocol PlainWorker {
   func asyncThrows(work: WorkItem) async throws -> WorkResult
 }
 
-protocol DistributedWorker: DistributedActor where ActorSystem == DefaultDistributedActorSystem {
+@Resolvable
+@available(SwiftStdlib 6.0, *)
+protocol DistributedWorker<WorkItem, WorkResult>: DistributedActor where ActorSystem == DefaultDistributedActorSystem {
   associatedtype WorkItem: Sendable & Codable
   associatedtype WorkResult: Sendable & Codable
 
@@ -49,6 +52,7 @@ protocol DistributedWorker: DistributedActor where ActorSystem == DefaultDistrib
   func asyncThrowsReq_witnessDistributed_asyncThrows(work: WorkItem) async throws -> WorkResult
 }
 
+@available(SwiftStdlib 6.0, *)
 distributed actor ThePlainWorker: PlainWorker {
   typealias ActorSystem = DefaultDistributedActorSystem
   typealias WorkItem = String
@@ -59,6 +63,7 @@ distributed actor ThePlainWorker: PlainWorker {
   }
 }
 
+@available(SwiftStdlib 6.0, *)
 distributed actor TheWorker: DistributedWorker {
   typealias ActorSystem = DefaultDistributedActorSystem
   typealias WorkItem = String
@@ -105,6 +110,7 @@ distributed actor TheWorker: DistributedWorker {
 
 }
 
+@available(SwiftStdlib 6.0, *)
 func test_generic(system: DefaultDistributedActorSystem) async throws {
   let localW = TheWorker(actorSystem: system)
   let remoteW = try! TheWorker.resolve(id: localW.id, using: system)
@@ -218,6 +224,7 @@ func test_generic(system: DefaultDistributedActorSystem) async throws {
   // distributedness of those witnesses never actually is used remotely, but at
   // least check we invoke the right methods.
 
+  @available(SwiftStdlib 6.0, *)
   func call_requirement_witnessedByDistributed_sync<W: DistributedWorker>(w: W) async throws -> String where W.WorkItem == String, W.WorkResult == String {
     try await w.whenLocal { __secretlyKnownToBeLocal in
       try await __secretlyKnownToBeLocal.asyncThrowsReq_witnessDistributed_sync(work: "Hello")
@@ -231,6 +238,7 @@ func test_generic(system: DefaultDistributedActorSystem) async throws {
   }
   print("==== ----------------------------------------------------------------")
 
+  @available(SwiftStdlib 6.0, *)
   func call_requirement_witnessedByDistributed_async<W: DistributedWorker>(w: W) async throws -> String where W.WorkItem == String, W.WorkResult == String {
     try await w.whenLocal { __secretlyKnownToBeLocal in
       try await __secretlyKnownToBeLocal.asyncThrowsReq_witnessDistributed_async(work: "Hello")
@@ -244,6 +252,7 @@ func test_generic(system: DefaultDistributedActorSystem) async throws {
   }
   print("==== ----------------------------------------------------------------")
 
+  @available(SwiftStdlib 6.0, *)
   func call_requirement_witnessedByDistributed_syncThrows<W: DistributedWorker>(w: W) async throws -> String where W.WorkItem == String, W.WorkResult == String {
     try await w.whenLocal { __secretlyKnownToBeLocal in
       try await __secretlyKnownToBeLocal.asyncThrowsReq_witnessDistributed_syncThrows(work: "Hello")
@@ -257,6 +266,7 @@ func test_generic(system: DefaultDistributedActorSystem) async throws {
   }
   print("==== ----------------------------------------------------------------")
 
+  @available(SwiftStdlib 6.0, *)
   func call_requirement_witnessedByDistributed_asyncThrows<W: DistributedWorker>(w: W) async throws -> String where W.WorkItem == String, W.WorkResult == String {
     try await w.whenLocal { __secretlyKnownToBeLocal in
       try await __secretlyKnownToBeLocal.asyncThrowsReq_witnessDistributed_asyncThrows(work: "Hello")
@@ -271,6 +281,7 @@ func test_generic(system: DefaultDistributedActorSystem) async throws {
   print("==== ----------------------------------------------------------------")
 }
 
+@available(SwiftStdlib 6.0, *)
 func test_whenLocal(system: DefaultDistributedActorSystem) async throws {
   let localW = TheWorker(actorSystem: system)
   let remoteW = try! TheWorker.resolve(id: localW.id, using: system)
@@ -341,6 +352,7 @@ func test_whenLocal(system: DefaultDistributedActorSystem) async throws {
   }
 }
 
+@available(SwiftStdlib 6.0, *)
 func test_generic_plain(system: DefaultDistributedActorSystem) async throws {
   let localW = ThePlainWorker(actorSystem: system)
   let remoteW = try! ThePlainWorker.resolve(id: localW.id, using: system)
@@ -355,6 +367,7 @@ func test_generic_plain(system: DefaultDistributedActorSystem) async throws {
   }
   print("==== ----------------------------------------------------------------")
 
+  @available(SwiftStdlib 6.0, *)
   func call_plainWorker<W: PlainWorker>(w: W) async throws -> String where W.WorkItem == String, W.WorkResult == String {
     try await w.asyncThrows(work: "Hello")
   }
@@ -372,6 +385,7 @@ func test_generic_plain(system: DefaultDistributedActorSystem) async throws {
   }
 }
 
+@available(SwiftStdlib 6.0, *)
 @main struct Main {
   static func main() async {
     let system = DefaultDistributedActorSystem()

test/Distributed/Runtime/distributed_actor_remoteCall_protocol_method_in_presence_of_multiple_systems.swift

@@ -23,6 +23,19 @@ protocol GreeterProtocol: DistributedActor where ActorSystem: DistributedActorSy
   distributed func greet() -> String
 }
 
+protocol FruitProtocol: Codable {}
+struct Watermelon: FruitProtocol {}
+
+protocol AnimalProtocol: Codable {}
+struct Capybara: AnimalProtocol {}
+
+@Resolvable
+protocol FeederProtocol<Fruit, Animal>: DistributedActor where ActorSystem: DistributedActorSystem<any Codable> {
+  associatedtype Fruit: FruitProtocol
+  associatedtype Animal: AnimalProtocol
+  distributed func give(fruit: Fruit, to animal: Animal)
+}
+
 // ==== ------------------------------------------------------------------------
 
 distributed actor DAFR: GreeterProtocol {
@@ -35,9 +48,17 @@ distributed actor DAFL: GreeterProtocol {
   distributed func greet() -> String { "\(Self.self)" }
 }
 
+distributed actor Feeder: FeederProtocol {
+  typealias ActorSystem = LocalTestingDistributedActorSystem
+  distributed func give(fruit: Watermelon, to animal: Capybara) {
+    // fake impl
+  }
+}
+
 @main struct Main {
   static func main() async throws {
     let fakeRoundtripSystem = FakeRoundtripActorSystem()
+
     let fr = DAFR(actorSystem: fakeRoundtripSystem)
     let frid = fr.id
     _ = DAFL(actorSystem: .init())
@@ -46,16 +67,18 @@ distributed actor DAFL: GreeterProtocol {
 
     print("resolved on \(fakeRoundtripSystem): \(type(of: gfr))")
     // CHECK: resolved on main.FakeRoundtripActorSystem: $GreeterProtocol<FakeRoundtripActorSystem>
-
-    // CHECK: > execute distributed target: main.$GreeterProtocol.greet(), identifier: $s4main16$GreeterProtocolC5greetSSyYaKFTE
+    // CHECK-NEXT: > encode generic sub: main.$GreeterProtocol<main.FakeRoundtripActorSystem>
+    // CHECK-NEXT: > encode return type: Swift.String
+    // CHECK-NEXT: > done recording
+    // CHECK-NEXT: >> remoteCall: on:main.$GreeterProtocol<main.FakeRoundtripActorSystem>, target:main.$GreeterProtocol.greet(), invocation:FakeInvocationEncoder(genericSubs: [main.$GreeterProtocol<main.FakeRoundtripActorSystem>], arguments: [], returnType: Optional(Swift.String), errorType: nil), throwing:Swift.Never, returning:Swift.String
+    // CHECK-NEXT: > execute distributed target: main.$GreeterProtocol.greet(), identifier: $s4main16$GreeterProtocolC5greetSSyYaKFTE
+    // FIXME: was: > execute distributed target: main.$GreeterProtocol.greet(), identifier: $s4main16$GreeterProtocolC5greetSSyYaKAA0bC0RzlFTE
     // Notes:
     // - The call is made on the stub: $GreeterProtocol
     // - the record is name is 'HF' for the accessible function
 
     let got = try await gfr.greet()
     print("got: \(got)")
-
-    print("ok") // CHECK: ok
   }
 }