WIP trying to use buildGenericSignature

Author: ktoso

lib/IRGen/GenDistributed.cpp

@@ -263,31 +263,43 @@ static CanSILFunctionType getAccessorType(IRGenModule &IGM,
   // Build generic signature that includes all contextual generic parameters.
   GenericSignature signature;
   {
-    SmallVector<GenericTypeParamType *, 4> genericParams;
-    SmallVector<Requirement, 4> genericRequirements;
+    SmallVector<GenericTypeParamType *, 2> addedParameters;
+    SmallVector<Requirement, 2> addedRequirements;
 
     auto *actor = getDistributedActorOf(Target);
     assert(actor);
 
-    for (auto *genericParam : actor->getInnermostGenericParamTypes()) {
-      genericParams.push_back(genericParam);
+    unsigned targetDepth = 1;
+    unsigned targetIndex = 0;
 
-      // and also forward all requirements this generic parameter might have.
-      for (auto req : actor->getGenericRequirements()) {
-        if (req.getFirstType()->isEqual(genericParam)) {
-          genericRequirements.push_back(req);
-        }
+    if (Target->getGenericSignature()) {
+      for (auto param: Target->getGenericSignature().getGenericParams()) {
+        targetDepth = std::max(targetDepth, param->getDepth());
+        targetIndex = std::max(targetIndex, param->getIndex());
+      }
+      // Target->getGenericSignature().getInnermostGenericParams().size();
+      for (auto param: Target->getGenericSignature().getInnermostGenericParams()) {
+        targetDepth = std::max(targetDepth, param->getDepth());
+        targetIndex = std::max(targetIndex, param->getIndex());
+      }
+      if (!Target->getGenericSignature().getInnermostGenericParams().empty()) {
+        targetIndex += 1;
       }
     }
 
-    // Add a generic parameter `D` which stands for decoder type in the
-    // accessor signature - `inout D`.
-    genericParams.push_back(decoderType);
-    // Add a requirement that decoder conforms to the expected protocol.
-    genericRequirements.push_back(
-        {RequirementKind::Conformance, decoderType, decoderProtocolTy});
+    auto decoderParamTy = GenericTypeParamType::get(
+        // /*isParameterPack=*/false, /*depth=*/1, /*index=*/1, Context);
+        /*isParameterPack=*/false,
+        targetDepth,
+        targetIndex,
+        Context);
+    addedParameters.push_back(decoderParamTy);
 
-    signature = GenericSignature::get(genericParams, genericRequirements);
+    // Add a requirement that decoder conforms to the expected protocol.
+    addedRequirements.push_back(
+        {RequirementKind::Conformance, decoderParamTy, decoderProtocolTy});
+    signature = buildGenericSignature(Context, Target->getGenericSignature(),
+                                      addedParameters, addedRequirements);
   }
 
   auto accessorTy = GenericFunctionType::get(

test/Distributed/Runtime/distributed_actor_hop_to.swift

@@ -26,6 +26,7 @@ protocol LifecycleWatch: DistributedActor where ActorSystem == FakeRoundtripActo
 
 extension LifecycleWatch {
   func watch<T: Codable>(x: Int, _ y: T) async throws {
+    self.preconditionIsolated()
     print("executed: \(#function) - x = \(x), y = \(y)")
   }
 
@@ -39,15 +40,35 @@ extension LifecycleWatch {
 distributed actor Worker: LifecycleWatch {
 }
 
+extension Worker {
+  distributed actor Inside<Something> {
+    distributed func test<A: Codable>(_: A) async throws {
+      self.preconditionIsolated()
+      print("executed: \(#function)")
+    }
+    distributed func moreParams<A: Codable, B: Codable>(_: A, _: B) async throws {
+      self.preconditionIsolated()
+      print("executed: \(#function)")
+    }
+  }
+}
+
 @main struct Main {
   static func main() async {
-    let worker: any LifecycleWatch = Worker(actorSystem: DefaultDistributedActorSystem())
+    let system = DefaultDistributedActorSystem()
+    let worker: any LifecycleWatch = Worker(actorSystem: system)
     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:_:)
 
+    try! await Worker.Inside<String>(actorSystem: system).test(42)
+    // CHECK: executed: test
+
+    try! await Worker.Inside<String>(actorSystem: system).moreParams(21, 42)
+    // CHECK: executed: moreParams
+
     print("OK") // CHECK: OK
   }
 }