Pavel feedback

Author: ktoso

lib/Sema/CSApply.cpp

@@ -7789,11 +7789,21 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
     apply->setArgs(args);
     cs.setType(apply, fnType->getResult());
 
-    // If this is a call to a distributed method thunk,
-    // let's mark the call as implicitly throwing/async.
+    // If this is a call to a distributed method thunk or
+    // distributed protocol requirement, let's mark the
+    // call as implicitly throwing/async.
     if (isa<SelfApplyExpr>(apply->getFn())) {
       auto *FD = dyn_cast<FuncDecl>(callee.getDecl());
-      if (FD && FD->isDistributedThunk()) {
+      auto isDistributedProtocolRequirement = [&](FuncDecl *func) {
+        if (!func->isDistributed())
+          return false;
+
+        auto *DC = func->getDeclContext();
+        return isa_and_nonnull<ProtocolDecl>(DC->getAsDecl());
+      };
+
+      if (FD &&
+          (FD->isDistributedThunk() || isDistributedProtocolRequirement(FD))) {
         apply->setImplicitlyThrows(true);
         apply->setImplicitlyAsync(ImplicitActorHopTarget::forInstanceSelf());
         apply->setUsesDistributedThunk(true);
@@ -7922,6 +7932,12 @@ bool ExprRewriter::requiresDistributedThunk(Expr *base, SourceLoc memberLoc,
   auto *memberDecl = memberRef.getDecl();
   assert(memberDecl);
 
+  auto *memberDC = memberDecl->getDeclContext();
+  // Protocol requirements are dispatched through a witness which is always
+  // a distributed thunk.
+  if (isa_and_nonnull<ProtocolDecl>(memberDC->getAsDecl()))
+    return false;
+
   if (auto *FD = dyn_cast<FuncDecl>(memberDecl)) {
     if (!(FD->isInstanceMember() && FD->isDistributed()))
       return false;

lib/Sema/TypeCheckDistributed.cpp

@@ -508,7 +508,11 @@ bool CheckDistributedFunctionRequest::evaluate(
     serializationRequirements = getDistributedSerializationRequirementProtocols(
         getDistributedActorSystemType(actor)->getAnyNominal(),
         C.getProtocol(KnownProtocolKind::DistributedActorSystem));
+  } else if (auto proto = dyn_cast<ProtocolDecl>(DC)) {
+    // FIXME: if it has a n AS defined, we can do checks based on that, otherwise, don't
+    return false;
   } else {
+    func->dump();
     llvm_unreachable("Cannot handle types other than extensions and actor "
                      "declarations in distributed function checking.");
   }

test/Distributed/Runtime/distributed_actor_func_calls_remoteCall_through_generic.swift

@@ -0,0 +1,94 @@
+// 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 --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
+
+
+typealias DefaultDistributedActorSystem = FakeRoundtripActorSystem
+
+protocol DistributedWorker: DistributedActor where ActorSystem == DefaultDistributedActorSystem {
+  associatedtype WorkItem: Sendable & Codable
+  associatedtype WorkResult: Sendable & Codable
+
+  distributed func submit(work: WorkItem) async throws -> WorkResult
+}
+
+distributed actor TheWorker: DistributedWorker {
+  typealias ActorSystem = DefaultDistributedActorSystem
+  typealias WorkItem = String
+  typealias WorkResult = String
+
+  distributed func submit(work: WorkItem) async throws -> WorkResult {
+    "\(Self.self) echo: \(work)"
+  }
+}
+
+actor WorkerPool<Worker: DistributedWorker> {
+  typealias ActorSystem = FakeRoundtripActorSystem
+  typealias WorkItem = Worker.WorkItem
+  typealias WorkResult = Worker.WorkResult
+
+  let actorSystem: ActorSystem
+  let worker: Worker
+
+  init(worker: Worker, actorSystem: ActorSystem) {
+    self.worker = worker
+    self.actorSystem = actorSystem
+  }
+
+  func submit(work: WorkItem) async throws -> WorkResult {
+    let worker = try await self.selectWorker()
+    return try await worker.submit(work: work)
+  }
+
+  func selectWorker() async throws -> Worker {
+    return self.worker
+  }
+}
+
+func test() async throws {
+  let system = DefaultDistributedActorSystem()
+
+  let w = TheWorker(actorSystem: system)
+  let remoteW = try! TheWorker.resolve(id: w.id, using: system)
+  print("remoteW is remote: \(__isRemoteActor(remoteW))")
+
+  // direct calls work ok:
+//  let reply = try await remoteW.submit(work: "Hello")
+
+  // Fails with:
+  // Cannot handle types other than extensions and actor declarations in distributed function checking.
+  // UNREACHABLE executed at /Users/ktoso/code/swift-project/swift/lib/Sema/TypeCheckDistributed.cpp:514!
+  func callWorker<W: DistributedWorker>(w: W) async throws -> String where W.WorkItem == String, W.WorkResult == String {
+    try await w.submit(work: "Hello")
+  }
+  let reply = try await callWorker(w: remoteW)
+
+//  let pool = WorkerPool<TheWorker>(worker: remoteW, actorSystem: system)
+//  let reply = try await pool.submit(work: "Hello")
+  // CHECK: >> remoteCall: on:main.TheWorker, target:main.TheWorker.submit(work:), invocation:FakeInvocationEncoder(genericSubs: [], arguments: ["Hello"], returnType: Optional(Swift.String), errorType: Optional(Swift.Error)), throwing:Swift.Error, returning:Swift.String
+
+  // CHECK: << remoteCall return: TheWorker echo: Hello
+  print("reply: \(reply)")
+  // CHECK: reply: TheWorker echo: Hello
+}
+
+@main struct Main {
+  static func main() async {
+    try! await test()
+  }
+}

test/Distributed/distributed_actor_crash.swift

@@ -0,0 +1,46 @@
+// 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-swift-frontend -typecheck -verify -disable-availability-checking -I %t 2>&1 %s
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+import Distributed
+import FakeDistributedActorSystems
+
+@available(SwiftStdlib 5.5, *)
+typealias DefaultDistributedActorSystem = FakeActorSystem
+
+import Distributed
+
+protocol DistributedWorker: DistributedActor {
+  associatedtype WorkItem: Sendable & Codable
+  associatedtype WorkResult: Sendable & Codable
+
+  distributed func submit(work: WorkItem) async throws -> WorkResult
+}
+
+distributed actor TheWorker: DistributedWorker {
+  typealias ActorSystem = FakeActorSystem
+  typealias WorkItem = String
+  typealias WorkResult = String
+
+  distributed func submit(work: WorkItem) async throws -> WorkResult {
+    work
+  }
+}
+
+distributed actor WorkerPool<Worker: DistributedWorker> {
+  typealias ActorSystem = FakeActorSystem
+  typealias WorkItem = Worker.WorkItem
+  typealias WorkResult = Worker.WorkResult
+
+  func submit(work: WorkItem) async throws -> WorkResult {
+    let worker = try await self.selectWorker()
+    return try await worker.submit(work: work)
+//    return try await TheWorker(actorSystem: actorSystem).submit(work: "X")
+  }
+
+  func selectWorker() async throws -> Worker {
+    fatalError()
+  }
+}