[Distributed] Correct accessor handling of generics

ktoso · ktoso · commit e09411f5b75a · 2023-11-27T19:00:03.000+09:00
diff --git a/lib/IRGen/GenDistributed.cpp b/lib/IRGen/GenDistributed.cpp
@@ -221,7 +221,10 @@ static CanSILFunctionType getAccessorType(IRGenModule &IGM,
   // A generic parameter that represents instance of invocation decoder.
   auto *decoderType =
       GenericTypeParamType::get(/*isParameterPack=*/false,
-                                /*depth=*/1, /*index=*/0, Context);
+                                /*depth=*/0, /*index=*/0, Context);
+  auto *actorType =
+      GenericTypeParamType::get(/*isParameterPack=*/false,
+                                /*depth=*/0, /*index=*/1, Context);
 
   // decoder
   parameters.push_back(GenericFunctionType::Param(
@@ -248,14 +251,8 @@ static CanSILFunctionType getAccessorType(IRGenModule &IGM,
   // number of witness tables
   parameters.push_back(GenericFunctionType::Param(Context.getUIntType()));
 
-  // actor
-  {
-    auto targetTy = Target->getLoweredFunctionType();
-    auto actorLoc = targetTy->getParameters().back();
-
-    parameters.push_back(
-        GenericFunctionType::Param(actorLoc.getInterfaceType()));
-  }
+  // actor type
+  parameters.push_back(GenericFunctionType::Param(actorType));
 
   auto decoderProtocolTy =
       Context
@@ -268,19 +265,17 @@ static CanSILFunctionType getAccessorType(IRGenModule &IGM,
     SmallVector<GenericTypeParamType *, 4> genericParams;
     SmallVector<Requirement, 4> genericRequirements;
 
-    auto *actor = getDistributedActorOf(Target);
-    assert(actor);
-
-    for (auto *genericParam : actor->getInnermostGenericParamTypes())
-      genericParams.push_back(genericParam);
-
     // 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});
 
+    // Add a generic type for the actor type of the target.
+    // We don't have to put any requirement on it; all we need is a type here to use for the self.
+    genericParams.push_back(actorType);
+
     signature = GenericSignature::get(genericParams, genericRequirements);
   }
 
@@ -649,11 +644,8 @@ void DistributedAccessor::emit() {
   // Metadata that represents passed in the invocation decoder.
   auto *decoderType = params.claimNext();
 
-  // If the distributed thunk is declared in a protocol that conforms
-  // to `DistributedActor` protocol, there is an extract parameter that
-  // represents a type of protocol witness.
-  if (isa<ProtocolDecl>(actor))
-    (void)params.claimNext();
+  // Metadata of the distributed actor the accessor is for.
+  (void)params.claimNext();
 
   // Witness table for decoder conformance to DistributedTargetInvocationDecoder
   auto *decoderProtocolWitness = params.claimNext();
diff --git a/stdlib/public/Distributed/DistributedActor.cpp b/stdlib/public/Distributed/DistributedActor.cpp
@@ -62,7 +62,7 @@ using TargetExecutorSignature =
                         /*numWitnessTables=*/size_t,
                         /*decoderType=*/Metadata *,
                         /*decoderWitnessTable=*/void **),
-                   /*throws=*/true>;
+                        /*throws=*/true>;
 
 SWIFT_CC(swiftasync)
 SWIFT_EXPORT_FROM(swiftDistributed)
@@ -89,7 +89,7 @@ using DistributedAccessorSignature =
                         /*actor=*/HeapObject *,
                         /*decoderType=*/Metadata *,
                         /*decoderWitnessTable=*/void **),
-                   /*throws=*/true>;
+                        /*throws=*/true>;
 
 SWIFT_CC(swiftasync)
 static DistributedAccessorSignature::ContinuationType
diff --git a/test/Distributed/Runtime/distributed_actor_generic_constraint_issue_115497090.swift b/test/Distributed/Runtime/distributed_actor_generic_constraint_issue_115497090.swift
@@ -0,0 +1,56 @@
+// 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 -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
+
+import Distributed
+import FakeDistributedActorSystems
+
+import Distributed
+import FakeDistributedActorSystems
+
+typealias DefaultDistributedActorSystem = FakeActorSystem
+
+protocol SomeProtocol {
+  static var isInteger: Bool { get }
+}
+
+distributed actor TestActor<Value> where Value: Codable & Identifiable, Value.ID: SomeProtocol {
+  distributed func requirementsFromActor(value: Value) async throws {
+    self.preconditionIsolated()
+    print("OK: \(value)")
+  }
+  distributed func requirementsFromActorAndMethod(value: Value) async throws where Value: VerySpecific {
+    self.preconditionIsolated()
+    print("OK: \(value)")
+  }
+}
+
+protocol VerySpecific {}
+
+struct TheValue: Codable, Identifiable, VerySpecific {
+  let id: String
+  init() {
+    self.id = "id"
+  }
+}
+extension String: SomeProtocol {
+  static var isInteger: Bool { false }
+}
+
+@main struct Main {
+  static func main() async throws {
+    let ta: TestActor<TheValue> = TestActor(actorSystem: .init())
+    try await ta.requirementsFromActor(value: TheValue())
+    try await ta.requirementsFromActorAndMethod(value: TheValue())
+    // CHECK: OK
+  }
+}
diff --git a/test/Distributed/Runtime/distributed_actor_hop_to.swift b/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 testSecond<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).testSecond(42)
+    // CHECK: executed: test
+
+    try! await Worker.Inside<String>(actorSystem: system).moreParams(21, 42)
+    // CHECK: executed: moreParams
+
     print("OK") // CHECK: OK
   }
 }
diff --git a/test/Distributed/distributed_actor_accessor_thunks_64bit.swift b/test/Distributed/distributed_actor_accessor_thunks_64bit.swift
@@ -94,7 +94,7 @@ public distributed actor MyOtherActor {
 
 // CHECK: define hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC7simple1yySiYaKFTE"
 
-// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC7simple1yySiYaKFTETF"(ptr swiftasync %0, ptr %1, ptr %2, ptr %3, {{.*}}, ptr [[ACTOR:%.*]], ptr [[DECODER_TYPE:%.*]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]])
+// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC7simple1yySiYaKFTETF"(ptr swiftasync %0, ptr %1, ptr %2, ptr %3, {{.*}}, ptr {{(noalias)?}} [[ACTOR:%.*]], ptr [[DECODER_TYPE:%.*]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]], {{.*}})
 
 /// Read the current offset and cast an element to `Int`
 
@@ -192,7 +192,7 @@ public distributed actor MyOtherActor {
 // CHECK: define hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC7simple3ySiSSYaKFTE"
 
 /// !!! in `simple3` interesting bits are: argument value extraction (because string is exploded into N arguments) and call to distributed thunk
-// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC7simple3ySiSSYaKFTETF"(ptr swiftasync %0, ptr [[ARG_DECODER:%.*]], ptr [[ARG_TYPES:%.*]], ptr [[RESULT_BUFF:%.*]], ptr [[SUBS:%.*]], ptr [[WITNESS_TABLES:%.*]], i64 [[NUM_WITNESS_TABLES:%.*]], ptr [[ACTOR]], ptr [[DECODER_TYPE:%.*]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]])
+// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC7simple3ySiSSYaKFTETF"(ptr swiftasync %0, ptr [[ARG_DECODER:%.*]], ptr [[ARG_TYPES:%.*]], ptr [[RESULT_BUFF:%.*]], ptr [[SUBS:%.*]], ptr [[WITNESS_TABLES:%.*]], i64 [[NUM_WITNESS_TABLES:%.*]], ptr {{(noalias)?}} [[ACTOR]], ptr [[DECODER_TYPE:%.*]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]], {{.*}})
 
 
 // CHECK: [[ARG_SIZE:%.*]] = and i64 {{.*}}, -16
@@ -232,7 +232,7 @@ public distributed actor MyOtherActor {
 
 // CHECK: define hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC16single_case_enumyAA7SimpleEOAFYaKFTE"
 
-// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC16single_case_enumyAA7SimpleEOAFYaKFTETF"(ptr swiftasync %0, ptr [[ARG_DECODER:%.*]], ptr [[ARG_TYPES:%.*]], ptr [[RESULT_BUFF:%.*]], ptr [[SUBS:%.*]], ptr [[WITNESS_TABLES:%.*]], i64 [[NUM_WITNESS_TABLES:%.*]], ptr [[ACTOR]], ptr [[DECODER_TYPE]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]])
+// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC16single_case_enumyAA7SimpleEOAFYaKFTETF"(ptr swiftasync %0, ptr [[ARG_DECODER:%.*]], ptr [[ARG_TYPES:%.*]], ptr [[RESULT_BUFF:%.*]], ptr [[SUBS:%.*]], ptr [[WITNESS_TABLES:%.*]], i64 [[NUM_WITNESS_TABLES:%.*]], ptr {{(noalias)?}} [[ACTOR]], ptr [[DECODER_TYPE]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]], {{.*}})
 
 /// Let's check that the call doesn't have any arguments and returns nothing.
 
@@ -272,7 +272,7 @@ public distributed actor MyOtherActor {
 
 // CHECK: define hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC7complexyAA11LargeStructVSaySiG_AA3ObjCSSSgAFtYaKFTE"
 
-// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC7complexyAA11LargeStructVSaySiG_AA3ObjCSSSgAFtYaKFTETF"(ptr swiftasync {{.*}}, ptr [[ARG_DECODER:%.*]], ptr [[ARG_TYPES:%.*]], ptr [[RESULT_BUFF:%.*]], ptr [[SUBS:%.*]], ptr [[WITNESS_TABLES:%.*]], i64 [[NUM_WITNESS_TABLES:%.*]], ptr [[ACTOR]], ptr [[DECODER_TYPE:%.*]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]])
+// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC7complexyAA11LargeStructVSaySiG_AA3ObjCSSSgAFtYaKFTETF"(ptr swiftasync {{.*}}, ptr [[ARG_DECODER:%.*]], ptr [[ARG_TYPES:%.*]], ptr [[RESULT_BUFF:%.*]], ptr [[SUBS:%.*]], ptr [[WITNESS_TABLES:%.*]], i64 [[NUM_WITNESS_TABLES:%.*]], ptr noalias [[ACTOR]], ptr [[DECODER_TYPE:%.*]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]], {{.*}})
 
 /// First, let's check that all of the different argument types here are loaded correctly.
 
@@ -319,7 +319,7 @@ public distributed actor MyOtherActor {
 
 /// ---> Accessor for `genericArgs`
 
-// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC11genericArgsyyx_Sayq_GtYaKSeRzSERzSeR_SER_r0_lFTETF"(ptr swiftasync %0, ptr  [[ARG_DECODER:%.*]], ptr [[ARG_TYPES:%.*]], ptr [[RESULT_BUF:%.*]], ptr [[GENERIC_SUBS:%.*]], ptr [[WITNESS_TABLES:%.*]], i64 [[NUM_WITNESS_TABLES:%.*]], ptr [[ACTOR:%.*]], ptr [[DECODER_TYPE:%.*]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]])
+// CHECK: define linkonce_odr hidden swift{{(tail)?}}cc void @"$s27distributed_actor_accessors7MyActorC11genericArgsyyx_Sayq_GtYaKSeRzSERzSeR_SER_r0_lFTETF"(ptr swiftasync %0, ptr  [[ARG_DECODER:%.*]], ptr [[ARG_TYPES:%.*]], ptr [[RESULT_BUF:%.*]], ptr [[GENERIC_SUBS:%.*]], ptr [[WITNESS_TABLES:%.*]], i64 [[NUM_WITNESS_TABLES:%.*]], ptr {{(noalias)?}} [[ACTOR:%.*]], ptr [[DECODER_TYPE:%.*]], ptr [[DECODER_PROTOCOL_WITNESS:%.*]])
 
 /// ---> Load `T`
 
