Introduce a builtin and API for getting the local actor from a distributed one

Author: DougGregor

include/swift/AST/Builtins.def

@@ -1083,6 +1083,12 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(GetEnumTag, "getEnumTag", "", Special)
 /// tag's payload is already initialized with the given source.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(InjectEnumTag, "injectEnumTag", "", Special)
 
+/// distributedActorAsAnyActor: <DA: DistributedActor>(_: DA) -> any Actor
+///
+/// For a given distributed actor that is known to be local, extract an
+/// `any Actor` existential that refers to the local actor.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(DistributedActorAsAnyActor, "distributedActorAsAnyActor", "n", Special)
+
 #undef BUILTIN_MISC_OPERATION_WITH_SILGEN
 
 #undef BUILTIN_MISC_OPERATION

include/swift/SIL/FormalLinkage.h

@@ -52,6 +52,9 @@ SILLinkage
 getLinkageForProtocolConformance(const RootProtocolConformance *C,
                                  ForDefinition_t definition);
 
+/// Whether the given conformance is synthesized by the implementation.
+bool isSynthesizedConformance(const RootProtocolConformance *root);
+
 } // end swift namespace
 
 #endif

lib/AST/Builtins.cpp

@@ -1975,6 +1975,19 @@ static ValueDecl *getHopToActor(ASTContext &ctx, Identifier id) {
   return builder.build(id);
 }
 
+static ValueDecl *getDistributedActorAsAnyActor(ASTContext &ctx, Identifier id) {
+  BuiltinFunctionBuilder builder(ctx);
+  auto *distributedActorProto = ctx.getProtocol(KnownProtocolKind::DistributedActor);
+  auto *actorProto = ctx.getProtocol(KnownProtocolKind::Actor);
+
+  // Create type parameters and add conformance constraints.
+  auto actorParam = makeGenericParam();
+  builder.addParameter(actorParam);
+  builder.addConformanceRequirement(actorParam, distributedActorProto);
+  builder.setResult(makeConcrete(actorProto->getDeclaredExistentialType()));
+  return builder.build(id);
+}
+
 static ValueDecl *getPackLength(ASTContext &ctx, Identifier id) {
   BuiltinFunctionBuilder builder(ctx, /* genericParamCount */ 1,
                                  /* anyObject */ false,
@@ -3055,6 +3068,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
 
   case BuiltinValueKind::InjectEnumTag:
     return getInjectEnumTag(Context, Id);
+
+  case BuiltinValueKind::DistributedActorAsAnyActor:
+    return getDistributedActorAsAnyActor(Context, Id);
   }
 
   llvm_unreachable("bad builtin value!");

lib/AST/ProtocolConformance.cpp

@@ -321,8 +321,18 @@ bool NormalProtocolConformance::isRetroactive() const {
 }
 
 bool NormalProtocolConformance::isSynthesizedNonUnique() const {
+  // Synthesized conformance of DistributedActor to Actor.
+  if (getProtocol()->isSpecificProtocol(KnownProtocolKind::Actor)) {
+    if (auto fromProto = getDeclContext()->getSelfProtocolDecl()) {
+      if (fromProto->isSpecificProtocol(KnownProtocolKind::DistributedActor))
+        return true;
+    }
+  }
+  
+  // Check if the conformance was synthesized by the ClangImporter.
   if (auto *file = dyn_cast<FileUnit>(getDeclContext()->getModuleScopeContext()))
     return file->getKind() == FileUnitKind::ClangModule;
+
   return false;
 }
 

lib/SIL/IR/OperandOwnership.cpp

@@ -880,6 +880,7 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, TypePtrAuthDiscriminator)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, TargetOSVersionAtLeast)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, GetEnumTag)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, InjectEnumTag)
+BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, DistributedActorAsAnyActor)
 OperandOwnership OperandOwnershipBuiltinClassifier::visitCopy(BuiltinInst *bi,
                                                               StringRef) {
   if (bi->getFunction()->getConventions().useLoweredAddresses()) {

lib/SIL/IR/SIL.cpp

@@ -74,12 +74,19 @@ SILLinkage swift::getSILLinkage(FormalLinkage linkage,
   llvm_unreachable("bad formal linkage");
 }
 
+bool swift::isSynthesizedConformance(const RootProtocolConformance *root) {
+  if (auto normal = dyn_cast<NormalProtocolConformance>(root))
+    return normal->isSynthesizedNonUnique();
+
+  return false;
+}
+
+
 SILLinkage
 swift::getLinkageForProtocolConformance(const RootProtocolConformance *C,
                                         ForDefinition_t definition) {
-  // If the conformance was synthesized by the ClangImporter, give it
-  // shared linkage.
-  if (isa<ClangModuleUnit>(C->getDeclContext()->getModuleScopeContext()))
+  // If the conformance was synthesized, give it shared linkage.
+  if (isSynthesizedConformance(C))
     return SILLinkage::Shared;
 
   auto typeDecl = C->getDeclContext()->getSelfNominalTypeDecl();

lib/SIL/IR/ValueOwnership.cpp

@@ -621,6 +621,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, TaskRunInline)
 CONSTANT_OWNERSHIP_BUILTIN(None, Copy)
 CONSTANT_OWNERSHIP_BUILTIN(None, GetEnumTag)
 CONSTANT_OWNERSHIP_BUILTIN(None, InjectEnumTag)
+CONSTANT_OWNERSHIP_BUILTIN(Owned, DistributedActorAsAnyActor)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

lib/SILGen/SILGenBuiltin.cpp

@@ -25,6 +25,7 @@
 #include "swift/AST/FileUnit.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ReferenceCounting.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILUndef.h"
@@ -1886,6 +1887,63 @@ static ManagedValue emitBuiltinInjectEnumTag(SILGenFunction &SGF, SILLocation lo
   return ManagedValue::forObjectRValueWithoutOwnership(bi);
 }
 
+/// Find the extension on DistributedActor that defines __actorUnownedExecutor.
+static ExtensionDecl *findDistributedActorAsActorExtension(
+    ProtocolDecl *distributedActorProto) {
+  ASTContext &ctx = distributedActorProto->getASTContext();
+
+  auto name = ctx.getIdentifier("__actorUnownedExecutor");
+  auto results = distributedActorProto->lookupDirect(
+      name, SourceLoc(),
+      NominalTypeDecl::LookupDirectFlags::IncludeAttrImplements);
+  for (auto result : results) {
+    if (auto var = dyn_cast<VarDecl>(result)) {
+      return dyn_cast<ExtensionDecl>(var->getDeclContext());
+    }
+  }
+
+  return nullptr;
+}
+
+static ManagedValue emitBuiltinDistributedActorAsAnyActor(
+    SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
+    ArrayRef<ManagedValue> args, SGFContext C) {
+  auto &ctx = SGF.getASTContext();
+  auto distributedActor = args[0];
+
+  auto builtinDecl = cast<FuncDecl>(getBuiltinValueDecl(
+      ctx, ctx.getIdentifier("distributedActorAsAnyActor")));
+  auto genericSignature = builtinDecl->getGenericSignature();
+  auto genericParam = genericSignature.getGenericParams()[0];
+
+  auto distributedActorProto = ctx.getProtocol(KnownProtocolKind::DistributedActor);
+  auto ext = findDistributedActorAsActorExtension(distributedActorProto);
+
+  // Conformance of DistributedActor to Actor.
+  auto actorProto = ctx.getProtocol(KnownProtocolKind::Actor);
+  CanType distributedActorType = distributedActor.getType().getASTType();
+  RootProtocolConformance *daAsActorConformance = ctx.getNormalConformance(
+      Type(genericParam), actorProto, SourceLoc(), ext,
+      ProtocolConformanceState::Incomplete, /*isUnchecked=*/false,
+      /*isPreconcurrency=*/false);
+  ProtocolConformanceRef conformance(
+      actorProto,
+      ctx.getSpecializedConformance(distributedActorType, daAsActorConformance,
+                                    subs));
+  ProtocolConformanceRef conformances[1] = { conformance };
+
+  // Erase the distributed actor instance into an `any Actor` existential with
+  // the special conformance.
+  auto &distributedActorTL = SGF.getTypeLowering(distributedActorType);
+  auto &anyActorTL = SGF.getTypeLowering(actorProto->getDeclaredExistentialType());
+  return SGF.emitExistentialErasure(
+      loc, distributedActorType, distributedActorTL, anyActorTL, 
+      ctx.AllocateCopy(conformances),
+      C, [&distributedActor](SGFContext) {
+        return distributedActor;
+      });
+}
+
 llvm::Optional<SpecializedEmitter>
 SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
   // Only consider standalone declarations in the Builtin module.

lib/SILGen/SILGenLazyConformance.cpp

@@ -16,6 +16,7 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/ClangImporter/ClangModule.h"
+#include "swift/SIL/FormalLinkage.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILVisitor.h"
 
@@ -64,7 +65,7 @@ void SILGenModule::useConformance(ProtocolConformanceRef conformanceRef) {
   // If this conformance was not synthesized by the ClangImporter, we're not
   // going to be emitting it lazily either, so we can avoid doing anything
   // below.
-  if (!isa<ClangModuleUnit>(normal->getDeclContext()->getModuleScopeContext()))
+  if (!isSynthesizedConformance(normal))
     return;
 
   // If we already emitted this witness table, we don't need to track the fact

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -209,6 +209,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::AutoDiffAllocateSubcontextWithType:
     case BuiltinValueKind::AddressOfBorrowOpaque:
     case BuiltinValueKind::UnprotectedAddressOfBorrowOpaque:
+    case BuiltinValueKind::DistributedActorAsAnyActor:
       return true;
     }
   }

lib/Sema/TypeCheckAttr.cpp

@@ -3886,7 +3886,9 @@ void AttributeChecker::visitImplementsAttr(ImplementsAttr *attr) {
   // conforms to the specified protocol.
   NominalTypeDecl *NTD = DC->getSelfNominalTypeDecl();
   if (auto *OtherPD = dyn_cast<ProtocolDecl>(NTD)) {
-    if (!OtherPD->inheritsFrom(PD)) {
+    if (!OtherPD->inheritsFrom(PD) &&
+        !(OtherPD->isSpecificProtocol(KnownProtocolKind::DistributedActor) ||
+          PD->isSpecificProtocol(KnownProtocolKind::Actor))) {
       diagnose(attr->getLocation(),
                diag::implements_attr_protocol_not_conformed_to, NTD, PD)
         .highlight(attr->getProtocolTypeRepr()->getSourceRange());

lib/Serialization/Deserialization.cpp

@@ -971,7 +971,10 @@ ProtocolConformanceDeserializer::readNormalProtocolConformance(
   uint64_t offset = conformanceEntry;
   conformanceEntry = conformance;
 
-  dc->getSelfNominalTypeDecl()->registerProtocolConformance(conformance);
+  // Note: the DistributedActor -> Actor pseudo-conformance can be deserialized
+  // but must not be registered, so don't register it here.
+  if (!dc->getSelfProtocolDecl())
+    dc->getSelfNominalTypeDecl()->registerProtocolConformance(conformance);
 
   // If the conformance is complete, we're done.
   if (conformance->isComplete())

stdlib/public/Distributed/DistributedActor.swift

@@ -373,6 +373,28 @@ extension DistributedActor {
   }
 }
 
+/// Supports the operation to produce an any Actor instance from a local
+/// distributed actor
+@available(SwiftStdlib 5.7, *)
+extension DistributedActor {
+  @_alwaysEmitIntoClient
+  @_implements(Actor, unownedExecutor)
+  public nonisolated var __actorUnownedExecutor: UnownedSerialExecutor {
+    if #available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) {
+      return unownedExecutor
+    } else {
+      fatalError("FIXME: Implement default actor executor on older platforms")
+    }
+  }
+
+  /// For a local distributed actor, produce an instance of the underlying
+  /// \c Actor.
+  @backDeployed(before: SwiftStdlib 5.11)
+  public var asLocalActor: any Actor {
+    Builtin.distributedActorAsAnyActor(self)
+  }
+}
+
 /******************************************************************************/
 /************************* Runtime Functions **********************************/
 /******************************************************************************/

test/Distributed/Runtime/distributed_actor_to_actor.swift

@@ -0,0 +1,72 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems %S/../Inputs/FakeDistributedActorSystems.swift
+// RUN: %target-build-swift -module-name main %import-libdispatch -j2 -parse-as-library -Xfrontend -disable-availability-checking -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -g -o %t/a.out -enable-experimental-feature BuiltinModule
+// RUN: %target-codesign %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s --color
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: distributed
+// REQUIRES: libdispatch
+
+// rdar://76038845
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: back_deployment_runtime
+
+// FIXME(distributed): Distributed actors currently have some issues on windows rdar://82593574
+// UNSUPPORTED: OS=windows-msvc
+
+import Builtin // FIXME: Part of a hack to get the protocol conformance defined properly
+import Dispatch
+import Distributed
+import FakeDistributedActorSystems
+
+typealias DefaultDistributedActorSystem = FakeRoundtripActorSystem
+
+extension DistributedActor {
+  func f() {
+    // FIXME: Part of a hack that forces the protocol conformance for DistributedActor -> Actor to be defined
+    Builtin.distributedActorAsAnyActor(self)
+  }
+}
+
+distributed actor Worker {
+  var counter: Int = 0
+
+  distributed func test() async {
+    print("Starting on distributed actor \(self)")
+    counter = counter + 1
+    let result = await asLocalActor.doSomethingAsync {
+      incrementCounter()
+      return "\(counter)"
+    }
+    print("Distributed actor received \(result)")
+  }
+
+  func incrementCounter() {
+    counter += 1
+  }
+}
+
+extension Actor {
+  func doSomethingAsync(body: () async -> String) async -> String {
+    print("Executing on local actor \(self)")
+    let result = await body()
+    print("Got \(result) back")
+    return result + "!"
+  }
+}
+
+@main struct Main {
+  static func main() async throws {
+    let worker = Worker(actorSystem: DefaultDistributedActorSystem())
+
+    // CHECK: Starting on distributed actor [[PTR:%.*]]
+    // CHECK: Executing on local actor [[PTR]]
+    // CHECK: Got 2 back
+    // CHECK: Distributed actor received 2!
+    try await worker.test()
+
+    print("OK") // CHECK: OK
+  }
+}

test/Distributed/distributed_actor_to_actor.swift

@@ -0,0 +1,29 @@
+// RUN: %target-swift-frontend  -disable-availability-checking %s -parse-as-library -parse-stdlib -emit-sil -o - | %FileCheck %s -check-prefix=CHECK-SIL
+
+// RUN: %target-swift-frontend  -disable-availability-checking %s -parse-as-library -parse-stdlib -emit-ir -o - | %FileCheck %s -check-prefix=CHECK-IR
+
+// UNSUPPORTED: back_deploy_concurrency
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+import _Concurrency
+import Distributed
+
+// CHECK-IR: @"$sxScA11DistributedMc" = linkonce_odr hidden constant
+// CHECK-IR-SAME: i32 196808
+// CHECK-IR-SAME: $sxScA11DistributedScA15unownedExecutorScevgTW
+
+// CHECK-SIL-LABEL: sil hidden @$s021distributed_actor_to_B011getAnyActor0aF0ScA_pxYi_t11Distributed0gF0RzlF : $@convention(thin) <τ_0_0 where τ_0_0 : DistributedActor> (@guaranteed τ_0_0) -> @owned any Actor
+func getAnyActor(distributedActor: isolated some DistributedActor) -> any Actor {
+  // CHECK-SIL: [[EXISTENTIAL:%.*]] = init_existential_ref %0 : $τ_0_0 : $τ_0_0, $any Actor
+  // CHECK-SIL-NEXT: strong_retain [[EXISTENTIAL]] : $any Actor
+  // CHECK-SIL-NEXT: return [[EXISTENTIAL]] : $any Actor
+  return Builtin.distributedActorAsAnyActor(distributedActor)
+}
+
+// CHECK-IR-LABEL: define {{.*}} @"$s021distributed_actor_to_B011getAnyActor0aF0ScA_pxYi_t11Distributed0gF0RzlF
+// CHECK-IR: call ptr @swift_getWitnessTable(ptr @"$sxScA11DistributedMc", ptr %"some DistributedActor", ptr undef)
+
+// CHECK-SIL-LABEL: sil_witness_table shared <Self where Self : DistributedActor> T: Actor module Distributed {
+// CHECK-SIL-NEXT: method #Actor.unownedExecutor!getter: <Self where Self : Actor> (Self) -> () -> UnownedSerialExecutor : @$sxScA11DistributedScA15unownedExecutorScevgTW
+// CHECK-SIL-NEXT: }