[Distributed] Fix when a distributed thunk is invoked, unlock tests

Author: ktoso

include/swift/AST/Expr.h

@@ -1206,7 +1206,9 @@ class DeclRefExpr : public Expr {
   /// which are cross-actor invoked, because such calls actually go over the
   /// transport/network, and may throw from this, rather than the function
   /// implementation itself..
-  bool isImplicitlyThrows() const { return Bits.DeclRefExpr.IsImplicitlyThrows; }
+  bool isImplicitlyThrows() const {
+    return Bits.DeclRefExpr.IsImplicitlyThrows;
+  }
 
   /// Set whether this reference must account for a `throw` occurring for reasons
   /// other than the function implementation itself throwing, e.g. an
@@ -4391,7 +4393,7 @@ class ApplyExpr : public Expr {
   ///
   /// where the new closure is declared to be async.
   ///
-  /// When the application is implciitly async, the result describes
+  /// When the application is implicitly async, the result describes
   /// the actor to which we need to need to hop.
   Optional<ImplicitActorHopTarget> isImplicitlyAsync() const {
     if (!Bits.ApplyExpr.ImplicitlyAsync)
@@ -4419,6 +4421,10 @@ class ApplyExpr : public Expr {
     Bits.ApplyExpr.ImplicitlyThrows = flag;
   }
 
+  /// Informs IRGen to that this expression should be applied as its distributed
+  /// thunk, rather than invoking the function directly.
+  bool shouldApplyDistributedThunk() const;
+
   ValueDecl *getCalledValue() const;
 
   static bool classof(const Expr *E) {

lib/AST/Expr.cpp

@@ -1068,6 +1068,22 @@ Type OverloadSetRefExpr::getBaseType() const {
   llvm_unreachable("Unhandled overloaded set reference expression");
 }
 
+bool ApplyExpr::shouldApplyDistributedThunk() const {
+  // only a distributed decl has a chance of needing to be invoked as a thunk
+  auto func = dyn_cast<AbstractFunctionDecl>(getCalledValue());
+  if (!func || !func->isDistributed())
+    return false;
+
+  if (implicitlyThrows())
+    return true;
+
+  auto isEffectivelyAsync = func->hasAsync() || isImplicitlyAsync();
+  if (func->hasThrows() && isEffectivelyAsync)
+    return true;
+
+  return false;
+}
+
 bool OverloadSetRefExpr::hasBaseObject() const {
   if (Type BaseTy = getBaseType())
     return !BaseTy->is<AnyMetatypeType>();

lib/SILGen/SILGenApply.cpp

@@ -1117,12 +1117,8 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
 
     // Otherwise, we have a statically-dispatched call.
     auto constant = SILDeclRef(e->getDecl());
-    if (e->getDecl()->getAttrs().hasAttribute<DistributedActorAttr>()) {
-      // we're calling a distributed function, only in cross-actor situations
-      // does this actually need to call the thunk.
-      if (!selfApply) {
-        constant = constant.asDistributed(true);
-      }
+    if (callSite && callSite->shouldApplyDistributedThunk()) {
+      constant = constant.asDistributed(true);
     } else {
       constant = constant.asForeign(
                    !isConstructorWithGeneratedAllocatorThunk(e->getDecl())

lib/Sema/TypeCheckConcurrency.cpp

@@ -2277,7 +2277,8 @@ namespace {
             } else if (func->isDistributed()) {
               tryMarkImplicitlyAsync(memberLoc, memberRef, context,
                                      ImplicitActorHopTarget::forInstanceSelf());
-                tryMarkImplicitlyThrows(memberLoc, memberRef, context);
+              tryMarkImplicitlyThrows(memberLoc, memberRef, context);
+
             } else {
               // neither static or distributed, apply full distributed isolation
               ctx.Diags.diagnose(memberLoc, diag::distributed_actor_isolated_method)

test/Distributed/Runtime/distributed_actor_dynamic_remote_func.swift

@@ -54,7 +54,7 @@ struct FakeTransport: ActorTransport {
     fatalError("not implemented:\(#function)")
   }
 
-  func resolve<Act>(_ identity: Act.ID, as actorType: Act.Type)
+  func resolve<Act>(_ identity: AnyActorIdentity, as actorType: Act.Type)
   throws -> Act?
       where Act: DistributedActor {
     return nil
@@ -95,7 +95,7 @@ func test_remote() async throws {
   let address = ActorAddress(parse: "")
   let transport = FakeTransport()
 
-  let worker = try LocalWorker(resolve: .init(address), using: transport)
+  let worker = try LocalWorkerresolve(.init(address), using: transport)
   let x = try await worker.function()
   print("call: \(x)")
   // CHECK: call: _cluster_remote_function():

test/Distributed/Runtime/distributed_actor_local.swift

@@ -49,7 +49,7 @@ struct FakeTransport: ActorTransport {
     fatalError("not implemented \(#function)")
   }
 
-  func resolve<Act>(_ identity: Act.ID, as actorType: Act.Type) throws -> Act?
+  func resolve<Act>(_ identity: AnyActorIdentity, as actorType: Act.Type) throws -> Act?
       where Act: DistributedActor {
     return nil
   }
@@ -75,7 +75,7 @@ func test_initializers() {
   let transport = FakeTransport()
 
   _ = SomeSpecificDistributedActor(transport: transport)
-  _ = try! SomeSpecificDistributedActor(resolve: .init(address), using: transport)
+  _ = try! SomeSpecificDistributedActor.resolve(.init(address), using: transport)
 }
 
 @available(SwiftStdlib 5.5, *)

test/Distributed/Runtime/distributed_actor_remote_functions.swift

@@ -11,8 +11,6 @@
 // rdar://77798215
 // UNSUPPORTED: OS=windows-msvc
 
-// REQUIRES: rdar78290608
-
 import _Distributed
 import _Concurrency
 
@@ -114,7 +112,7 @@ struct FakeTransport: ActorTransport {
     fatalError("not implemented:\(#function)")
   }
 
-  func resolve<Act>(_ identity: Act.ID, as actorType: Act.Type)
+  func resolve<Act>(_ identity: AnyActorIdentity, as actorType: Act.Type)
   throws -> Act?
       where Act: DistributedActor {
     return nil
@@ -155,21 +153,21 @@ func test_remote_invoke(address: ActorAddress, transport: ActorTransport) async
     if __isRemoteActor(actor) {
       do {
         _ = try await actor.helloThrowsTransportBoom()
-        preconditionFailure("helloThrowsTransportBoom: should have thrown")
+        print("WRONG: helloThrowsTransportBoom: should have thrown")
       } catch {
         print("\(personality) - helloThrowsTransportBoom: \(error)")
       }
     } else {
       do {
         _ = try await actor.helloThrowsImplBoom()
-        preconditionFailure("helloThrowsImplBoom: Should have thrown")
+        print("WRONG: helloThrowsImplBoom: Should have thrown")
       } catch {
         print("\(personality) - helloThrowsImplBoom: \(error)")
       }
     }
   }
 
-  let remote = try! SomeSpecificDistributedActor(resolve: .init(address), using: transport)
+  let remote = try! SomeSpecificDistributedActor.resolve(.init(address), using: transport)
   assert(__isRemoteActor(remote) == true, "should be remote")
 
   let local = SomeSpecificDistributedActor(transport: transport)

test/Distributed/Runtime/distributed_no_transport_boom.swift

@@ -36,7 +36,7 @@ struct FakeTransport: ActorTransport {
     fatalError("not implemented:\(#function)")
   }
 
-  func resolve<Act>(_ identity: Act.ID, as actorType: Act.Type)
+  func resolve<Act>(_ identity: AnyActorIdentity, as actorType: Act.Type)
   throws -> Act?
       where Act: DistributedActor {
     return nil
@@ -65,7 +65,7 @@ func test_remote() async {
   let address = ActorAddress(parse: "")
   let transport = FakeTransport()
 
-  let remote = try! SomeSpecificDistributedActor(resolve: .init(address), using: transport)
+  let remote = try! SomeSpecificDistributedActor.resolve(.init(address), using: transport)
   _ = try! await remote.hello() // let it crash!
 
   // CHECK: SOURCE_DIR/test/Distributed/Runtime/distributed_no_transport_boom.swift:18: Fatal error: Invoked remote placeholder function '_remote_hello' on remote distributed actor of type 'main.SomeSpecificDistributedActor'. Configure an appropriate 'ActorTransport' for this actor to resolve this error (e.g. by depending on some specific transport library).