Merge pull request #39985 from DougGregor/actor-transport-associated-type

Make the actor transport an associated type of the DistributedActor protocol

Author: ktoso

include/swift/AST/DiagnosticsSema.def

@@ -4417,6 +4417,8 @@ ERROR(actor_protocol_illegal_inheritance,none,
 ERROR(distributed_actor_protocol_illegal_inheritance,none,
       "non-distributed actor type %0 cannot conform to the 'DistributedActor' protocol",
       (DeclName))
+ERROR(broken_distributed_actor_requirement,none,
+      "DistributedActor protocol is broken: unexpected requirement", ())
 
 ERROR(unowned_executor_outside_actor,none,
       "'unownedExecutor' can only be implemented within the main "

include/swift/AST/KnownIdentifiers.def

@@ -65,6 +65,7 @@ IDENTIFIER(decode)
 IDENTIFIER(decodeIfPresent)
 IDENTIFIER(Decoder)
 IDENTIFIER(decoder)
+IDENTIFIER(DefaultActorTransport)
 IDENTIFIER_(Differentiation)
 IDENTIFIER_WITH_NAME(PatternMatchVar, "$match")
 IDENTIFIER(dynamicallyCall)
@@ -141,6 +142,7 @@ IDENTIFIER_WITH_NAME(SwiftObject, "_TtCs12_SwiftObject")
 IDENTIFIER(SwiftNativeNSObject)
 IDENTIFIER(to)
 IDENTIFIER(toRaw)
+IDENTIFIER(Transport)
 IDENTIFIER(Type)
 IDENTIFIER(type)
 IDENTIFIER(typeMismatch)

lib/SILGen/SILGenDistributed.cpp

@@ -45,22 +45,45 @@ static VarDecl* lookupProperty(NominalTypeDecl *ty, DeclName name) {
   return dyn_cast<VarDecl>(refs.front());
 }
 
+/// Emit a reference to a specific stored property of the actor.
+static SILValue emitActorPropertyReference(
+    SILGenFunction &SGF, SILLocation loc, SILValue actorSelf,
+    VarDecl *property) {
+  Type formalType = SGF.F.mapTypeIntoContext(property->getInterfaceType());
+  SILType loweredType = SGF.getLoweredType(formalType).getAddressType();
+#if false
+  if (!loweredType.isAddress()) {
+    loweredType = SILType::getPrimitiveAddressType(
+        formalType->getCanonicalType());
+  }
+#endif
+  return SGF.B.createRefElementAddr(loc, actorSelf, property, loweredType);
+}
+
 /// Perform an initializing store to the given property using the value
 /// \param actorSelf the value representing `self` for the actor instance.
 /// \param prop the property to be initialized.
 /// \param value the value to use when initializing the property.
 static void initializeProperty(SILGenFunction &SGF, SILLocation loc,
                                SILValue actorSelf,
                                VarDecl* prop, SILValue value) {
-  CanType propType = SGF.F.mapTypeIntoContext(prop->getInterfaceType())
-      ->getCanonicalType();
-  SILType loweredPropType = SGF.getLoweredType(propType);
-  auto fieldAddr = SGF.B.createRefElementAddr(loc, actorSelf, prop, loweredPropType);
+  Type formalType = SGF.F.mapTypeIntoContext(prop->getInterfaceType());
+  SILType loweredType = SGF.getLoweredType(formalType);
+
+  auto fieldAddr = emitActorPropertyReference(SGF, loc, actorSelf, prop);
 
-  if (fieldAddr->getType().isAddress())
+  if (loweredType.isAddressOnly(SGF.F)) {
     SGF.B.createCopyAddr(loc, value, fieldAddr, IsNotTake, IsInitialization);
-  else
-    SGF.B.emitStoreValueOperation(loc, value, fieldAddr, StoreOwnershipQualifier::Init);
+  } else {
+    if (value->getType().isAddress()) {
+      value = SGF.B.createTrivialLoadOr(
+          loc, value, LoadOwnershipQualifier::Copy);
+    }
+
+    value = SGF.B.emitCopyValueOperation(loc, value);
+    SGF.B.emitStoreValueOperation(
+        loc, value, fieldAddr, StoreOwnershipQualifier::Init);
+  }
 }
 
 /******************************************************************************/
@@ -355,26 +378,20 @@ void SILGenFunction::emitResignIdentityCall(SILLocation loc,
   FormalEvaluationScope scope(*this);
 
   // ==== locate: self.id
-  auto *idVarDeclRef = lookupProperty(actorDecl, ctx.Id_id);
-  CanType idType = F.mapTypeIntoContext(
-      idVarDeclRef->getInterfaceType())->getCanonicalType();
-  auto idRef = B.createRefElementAddr(loc, actorSelf, idVarDeclRef,
-                                      getLoweredType(idType));
+  auto idRef = emitActorPropertyReference(
+      *this, loc, actorSelf.getValue(), lookupProperty(actorDecl, ctx.Id_id));
 
   // ==== locate: self.actorTransport
-  auto transportVarDeclRef = lookupProperty(actorDecl, ctx.Id_actorTransport);
-  CanType transportType = F.mapTypeIntoContext(
-      transportVarDeclRef->getInterfaceType())->getCanonicalType();
-  auto transportRef =
-    B.createRefElementAddr(loc, actorSelf, transportVarDeclRef,
-                           getLoweredType(transportType));
+  auto transportRef = emitActorPropertyReference(
+      *this, loc, actorSelf.getValue(),
+      lookupProperty(actorDecl, ctx.Id_actorTransport));
 
   // Perform the call.
   emitActorTransportWitnessCall(
       B, loc, ctx.Id_resignIdentity,
-      transportRef.getValue(),
+      transportRef,
       SILType(),
-      { idRef.getValue() });
+      { idRef });
 }
 
 void

lib/SILOptimizer/Utils/DistributedActor.cpp

@@ -131,6 +131,7 @@ void emitActorTransportWitnessCall(
   if (methodSILFnTy->getSelfParameter().isFormalIndirect() &&
       !transport->getType().isAddress()) {
     auto buf = B.createAllocStack(loc, transport->getType(), None);
+    transport = B.emitCopyValueOperation(loc, transport);
     B.emitStoreValueOperation(
         loc, transport, buf, StoreOwnershipQualifier::Init);
     temporaryTransportBuffer = SILValue(buf);
@@ -169,18 +170,12 @@ void emitActorTransportWitnessCall(
   // If we had to create a buffer to pass the transport
   if (temporaryTransportBuffer) {
     emitCleanup([&](SILBuilder & builder) {
+      auto value = builder.emitLoadValueOperation(
+          loc, *temporaryTransportBuffer, LoadOwnershipQualifier::Take);
+      builder.emitDestroyValueOperation(loc, value);
       builder.createDeallocStack(loc, *temporaryTransportBuffer);
     });
   }
-
-  // If we opened an existential, then destroy the existential.
-#if false
-  if (openedExistential) {
-    emitCleanup([&](SILBuilder & builder) {
-      builder.emitDestroyAddr(loc, transport);
-    });
-  }
-#endif
 }
 
 void emitActorReadyCall(SILBuilder &B, SILLocation loc, SILValue actor,

lib/Sema/DerivedConformanceDistributedActor.cpp

@@ -61,8 +61,8 @@ static FuncDecl *deriveDistributedActor_resolve(DerivedConformance &derived) {
     return param;
   };
 
-  Type addressType = C.getAnyActorIdentityDecl()->getDeclaredInterfaceType();
-  Type transportType = getDistributedActorTransportType(decl);
+  auto addressType = C.getAnyActorIdentityDecl()->getDeclaredInterfaceType();
+  auto transportType = getDistributedActorTransportType(decl);
 
   // (_ identity: AnyActorIdentity, using transport: ActorTransport)
   auto *params = ParameterList::create(
@@ -133,10 +133,11 @@ static ValueDecl *deriveDistributedActor_actorTransport(
 
   // ```
   // nonisolated
-  // let actorTransport: ActorTransport
+  // let actorTransport: Transport
   // ```
   // (no need for @actorIndependent because it is an immutable let)
-  Type propertyType = getDistributedActorTransportType(derived.Nominal);
+  auto propertyType = getDistributedActorTransportType(derived.Nominal);
+
   VarDecl *propDecl;
   PatternBindingDecl *pbDecl;
   std::tie(propDecl, pbDecl) = derived.declareDerivedProperty(
@@ -154,6 +155,36 @@ static ValueDecl *deriveDistributedActor_actorTransport(
   return propDecl;
 }
 
+static Type deriveDistributedActor_Transport(
+    DerivedConformance &derived) {
+  assert(derived.Nominal->isDistributedActor());
+  auto &C = derived.Context;
+
+  // Look for a type DefaultActorTransport within the parent context.
+  auto defaultTransportLookup = TypeChecker::lookupUnqualified(
+      derived.getConformanceContext()->getModuleScopeContext(),
+      DeclNameRef(C.Id_DefaultActorTransport),
+      derived.ConformanceDecl->getLoc());
+  TypeDecl *defaultTransportTypeDecl = nullptr;
+  for (const auto &found : defaultTransportLookup) {
+    if (auto foundType = dyn_cast_or_null<TypeDecl>(found.getValueDecl())) {
+      if (defaultTransportTypeDecl) {
+        // Note: ambiguity, for now just fail.
+        return nullptr;
+      }
+
+      defaultTransportTypeDecl = foundType;
+      continue;
+    }
+  }
+
+  // There is no default, so fail to synthesize.
+  if (!defaultTransportTypeDecl)
+    return nullptr;
+
+  // Return the default transport type.
+  return defaultTransportTypeDecl->getDeclaredInterfaceType();
+}
 // ==== ------------------------------------------------------------------------
 
 ValueDecl *DerivedConformance::deriveDistributedActor(ValueDecl *requirement) {
@@ -174,3 +205,17 @@ ValueDecl *DerivedConformance::deriveDistributedActor(ValueDecl *requirement) {
 
   return nullptr;
 }
+
+std::pair<Type, TypeDecl *> DerivedConformance::deriveDistributedActor(
+    AssociatedTypeDecl *assocType) {
+  if (!canDeriveDistributedActor(Nominal, cast<DeclContext>(ConformanceDecl)))
+    return std::make_pair(Type(), nullptr);
+
+  if (assocType->getName() == Context.Id_Transport) {
+    return std::make_pair(deriveDistributedActor_Transport(*this), nullptr);
+  }
+
+  Context.Diags.diagnose(assocType->getLoc(),
+                         diag::broken_distributed_actor_requirement);
+  return std::make_pair(Type(), nullptr);
+}

lib/Sema/DerivedConformances.h

@@ -311,6 +311,12 @@ class DerivedConformance {
   /// \returns the derived member, which will also be added to the type.
   ValueDecl *deriveDistributedActor(ValueDecl *requirement);
 
+  /// Derive a DistributedActor associated type for a distributed actor.
+  ///
+  /// \returns the derived type member, which will also be added to the type.
+  std::pair<Type, TypeDecl *> deriveDistributedActor(
+      AssociatedTypeDecl *assocType);
+
   /// Determine if \c Actor can be derived for the given type.
   static bool canDeriveActor(DeclContext *DC, NominalTypeDecl *NTD);
 

lib/Sema/TypeCheckDistributed.cpp

@@ -184,20 +184,15 @@ void swift::checkDistributedActorConstructor(const ClassDecl *decl, ConstructorD
   if (!ctor->isDesignatedInit())
     return;
 
-  // === Designated initializers must accept exactly one ActorTransport
-  auto &C = ctor->getASTContext();
-  auto module = ctor->getParentModule();
-
+  // === Designated initializers must accept exactly one actor transport that
+  // matches the actor transport type of the actor.
   SmallVector<ParamDecl*, 2> transportParams;
   int transportParamsCount = 0;
-  auto protocolDecl = C.getProtocol(KnownProtocolKind::ActorTransport);
-  auto protocolTy = protocolDecl->getDeclaredInterfaceType();
-
+  Type transportTy = ctor->mapTypeIntoContext(
+      getDistributedActorTransportType(const_cast<ClassDecl *>(decl)));
   for (auto param : *ctor->getParameters()) {
     auto paramTy = ctor->mapTypeIntoContext(param->getInterfaceType());
-    auto conformance = TypeChecker::conformsToProtocol(paramTy, protocolDecl, module);
-
-    if (paramTy->isEqual(protocolTy) || !conformance.isInvalid()) {
+    if (paramTy->isEqual(transportTy)) {
       transportParamsCount += 1;
       transportParams.push_back(param);
     }
@@ -252,9 +247,13 @@ Type swift::getDistributedActorTransportType(NominalTypeDecl *actor) {
   assert(actor->isDistributedActor());
   auto &ctx = actor->getASTContext();
 
-  auto protocol = ctx.getProtocol(KnownProtocolKind::ActorTransport);
+  auto protocol = ctx.getProtocol(KnownProtocolKind::DistributedActor);
   if (!protocol)
     return ErrorType::get(ctx);
 
-  return protocol->getDeclaredInterfaceType();
+  // Dig out the actor transport type.
+  auto module = actor->getParentModule();
+  Type selfType = actor->getSelfInterfaceType();
+  auto conformance = module->lookupConformance(selfType, protocol);
+  return conformance.getTypeWitnessByName(selfType, ctx.Id_Transport);
 }

lib/Sema/TypeCheckProtocol.cpp

@@ -6607,6 +6607,8 @@ TypeChecker::deriveTypeWitness(DeclContext *DC,
     return std::make_pair(derived.deriveCaseIterable(AssocType), nullptr);
   case KnownProtocolKind::Differentiable:
     return derived.deriveDifferentiable(AssocType);
+  case KnownProtocolKind::DistributedActor:
+    return derived.deriveDistributedActor(AssocType);
   default:
     return std::make_pair(nullptr, nullptr);
   }

stdlib/public/Distributed/ActorTransport.swift

@@ -67,9 +67,47 @@ public protocol ActorTransport: Sendable {
   func assignIdentity<Act>(_ actorType: Act.Type) -> AnyActorIdentity
       where Act: DistributedActor
 
-  func actorReady<Act>(_ actor: Act) where Act: DistributedActor
+  func actorReady<Act>(_ actor: Act)
+      where Act: DistributedActor
 
   /// Called during actor deinit/destroy.
   func resignIdentity(_ id: AnyActorIdentity)
+}
+
+@available(SwiftStdlib 5.6, *)
+public struct AnyActorTransport: ActorTransport {
+  let transport: ActorTransport
+
+  public init<Transport: ActorTransport>(_ transport: Transport) {
+    self.transport = transport
+  }
+
+  public func decodeIdentity(from decoder: Decoder) throws -> AnyActorIdentity {
+    return try transport.decodeIdentity(from: decoder)
+  }
 
+  public func resolve<Act>(
+    _ identity: AnyActorIdentity, as actorType: Act.Type
+  ) throws -> Act? where Act: DistributedActor {
+    return try transport.resolve(identity, as: actorType)
+  }
+
+  public func assignIdentity<Act>(_ actorType: Act.Type) -> AnyActorIdentity
+      where Act: DistributedActor {
+    return transport.assignIdentity(actorType)
+  }
+
+  public func actorReady<Act>(_ actor: Act)
+      where Act: DistributedActor {
+    transport.actorReady(actor)
+  }
+
+  /// Called during actor deinit/destroy.
+  public func resignIdentity(_ id: AnyActorIdentity) {
+    transport.resignIdentity(id)
+  }
 }
+
+/// Use the existential wrapper as the default actor transport.
+@available(SwiftStdlib 5.6, *)
+public typealias DefaultActorTransport = AnyActorTransport

stdlib/public/Distributed/DistributedActor.swift

@@ -36,6 +36,9 @@ public protocol AnyActor: Sendable, AnyObject {}
 @available(SwiftStdlib 5.6, *)
 public protocol DistributedActor:
     AnyActor, Sendable, Identifiable, Hashable, Codable {
+    /// The type of transport used to communicate with actors of this type.
+    associatedtype Transport: ActorTransport
+
     /// Resolves the passed in `identity` against the `transport`, returning
     /// either a local or remote actor reference.
     ///
@@ -52,7 +55,7 @@ public protocol DistributedActor:
 //        We want to move to accepting a generic or existential identity here
 //    static func resolve<Identity>(_ identity: Identity, using transport: ActorTransport)
 //      throws -> Self where Identity: ActorIdentity
-    static func resolve(_ identity: AnyActorIdentity, using transport: ActorTransport)
+    static func resolve(_ identity: AnyActorIdentity, using transport: Transport)
       throws -> Self
 
     /// The `ActorTransport` associated with this actor.
@@ -61,7 +64,7 @@ public protocol DistributedActor:
     ///
     /// Conformance to this requirement is synthesized automatically for any
     /// `distributed actor` declaration.
-    nonisolated var actorTransport: ActorTransport { get } // TODO: rename to `transport`?
+    nonisolated var actorTransport: Transport { get } // TODO: rename to `transport`?
 
     /// Logical identity of this distributed actor.
     ///
@@ -100,9 +103,9 @@ extension CodingUserInfoKey {
 @available(SwiftStdlib 5.6, *)
 extension DistributedActor {
   nonisolated public init(from decoder: Decoder) throws {
-    guard let transport = decoder.userInfo[.actorTransportKey] as? ActorTransport else {
+    guard let transport = decoder.userInfo[.actorTransportKey] as? Transport else {
       throw DistributedActorCodingError(message:
-        "Missing ActorTransport (for key .actorTransportKey) " +
+        "Missing Transport (for key .actorTransportKey) " +
         "in Decoder.userInfo, while decoding \(Self.self).")
     }
 

test/Distributed/Runtime/distributed_actor_decode.swift

@@ -66,6 +66,9 @@ struct FakeTransport: ActorTransport {
   }
 }
 
+@available(SwiftStdlib 5.5, *)
+typealias DefaultActorTransport = FakeTransport
+
 // ==== Test Coding ------------------------------------------------------------
 
 class TestEncoder: Encoder {