[Distributed] Accessor must be available cross module in resilient mode

This is an important fix for libraries using @resolvable in resilient
libraries. Without the fix we're missing an accessor and this will fail
some remote calls which make use of remote calls on resolvable
protocols. This would manifest as missing accessor error thrown by the
executeDistributedTarget function.

resolves rdar://148224780

Author: ktoso

lib/IRGen/GenMeta.cpp

@@ -1083,16 +1083,14 @@ namespace {
             // Define the method descriptor.
             SILDeclRef func(entry.getFunction());
 
-            /// Distributed thunks don't need resilience.
-            if (func.isDistributedThunk()) {
-              continue;
+            /// Distributed thunks don't need method descriptors
+            if (!func.isDistributedThunk()) {
+              auto *descriptor =
+                B.getAddrOfCurrentPosition(
+                  IGM.ProtocolRequirementStructTy);
+              IGM.defineMethodDescriptor(func, Proto, descriptor,
+                                         IGM.ProtocolRequirementStructTy);
             }
-
-            auto *descriptor =
-              B.getAddrOfCurrentPosition(
-                IGM.ProtocolRequirementStructTy);
-            IGM.defineMethodDescriptor(func, Proto, descriptor,
-                                       IGM.ProtocolRequirementStructTy);
           }
         }
 

lib/IRGen/IRSymbolVisitor.cpp

@@ -108,15 +108,6 @@ class IRSymbolVisitorImpl : public SILSymbolVisitor {
 
   void addDispatchThunk(SILDeclRef declRef) override {
     auto entity = LinkEntity::forDispatchThunk(declRef);
-
-    // TODO: explain why
-    if (declRef.isDistributedThunk()) {
-      auto afd = declRef.getAbstractFunctionDecl();
-      if (afd && isa<ProtocolDecl>(afd->getDeclContext())) {
-        return;
-      }
-    }
-
     addLinkEntity(entity);
 
     if (declRef.getAbstractFunctionDecl()->hasAsync())

test/Distributed/Runtime/distributed_actor_remoteCall_accessibleFunctions.swift

@@ -0,0 +1,84 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -target %target-swift-6.0-abi-triple %S/../Inputs/FakeDistributedActorSystems.swift -plugin-path %swift-plugin-dir
+// RUN: %target-build-swift -module-name ActorsFramework -target %target-swift-6.0-abi-triple -j2 -parse-as-library -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -plugin-path %swift-plugin-dir -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: %env-SWIFT_DUMP_ACCESSIBLE_FUNCTIONS=true %target-run %t/a.out 2>&1 | %FileCheck %s --color --dump-input=always
+
+// 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
+
+// ==== Known actor system -----------------------------------------------------
+
+public struct Response: Codable, Sendable {
+  let resp: Int
+  public init(resp: Int) {
+    self.resp = resp
+  }
+}
+
+public struct Provider: Codable, Sendable {
+  let r1: Int
+  public init(r1: Int) {
+    self.r1 = r1
+  }
+}
+
+@Resolvable
+public protocol DistributedNotificationService: DistributedActor
+where ActorSystem == FakeRoundtripActorSystem {
+  distributed func getArray(a1: [Int], a2: String?) async throws -> [Response]
+}
+
+distributed actor DistributedNotificationServiceImpl: DistributedNotificationService {
+  typealias ActorSystem = FakeRoundtripActorSystem
+
+  distributed func getArray(a1: [Int], a2: String?) async throws -> [Response] {
+    []  // mock impl is enough
+  }
+}
+
+// ==== ------------------------------------------------------------------------
+
+@main struct Main {
+  static func main() async throws {
+    let roundtripSystem = FakeRoundtripActorSystem()
+
+    let real: any DistributedNotificationService = DistributedNotificationServiceImpl(
+      actorSystem: roundtripSystem)
+
+    let proxy: any DistributedNotificationService =
+      try $DistributedNotificationService.resolve(id: real.id, using: roundtripSystem)
+    _ = try await proxy.getArray(a1: [], a2: "")
+
+    // CHECK: ==== Accessible Function Records ====
+
+    // CHECK: Record name: $s15ActorsFramework30DistributedNotificationServicePAA0C001_C9ActorStubRzrlE8getArray2a12a2SayAA8ResponseVGSaySiG_SSSgtYaKFTE
+    // CHECK:  Demangled: distributed thunk (extension in ActorsFramework):ActorsFramework.DistributedNotificationService< where A: Distributed._DistributedActorStub>.getArray(a1: Swift.Array<Swift.Int>, a2: Swift.Optional<Swift.String>) async throws -> Swift.Array<ActorsFramework.Response>
+    // CHECK:  Function Ptr: [[PTR:0x.*]]
+    // CHECK:  Flags.IsDistributed: 1
+
+    // CHECK: Record name: $s15ActorsFramework34DistributedNotificationServiceImplC8getArray2a12a2SayAA8ResponseVGSaySiG_SSSgtYaKFTE
+    // CHECK:  Demangled: distributed thunk ActorsFramework.DistributedNotificationServiceImpl.getArray(a1: Swift.Array<Swift.Int>, a2: Swift.Optional<Swift.String>) async throws -> Swift.Array<ActorsFramework.Response>
+    // CHECK:  Function Ptr: [[PTR:0x.*]]
+    // CHECK:  Flags.IsDistributed: 1
+
+    // CHECK: Record name: $s15ActorsFramework31$DistributedNotificationServiceC8getArray2a12a2SayAA8ResponseVGSaySiG_SSSgtYaKFTE
+    // CHECK:  Demangled: distributed thunk ActorsFramework.$DistributedNotificationService.getArray(a1: Swift.Array<Swift.Int>, a2: Swift.Optional<Swift.String>) async throws -> Swift.Array<ActorsFramework.Response>
+    // CHECK:  Function Ptr: [[PTR:0x.*]]
+    // CHECK:  Flags.IsDistributed: 1
+
+    // CHECK: Record count: 3
+    // CHECK: ==== End of Accessible Function Records ====
+  }
+}