[Distributed] Only synthesize Codable for DA where the ID is Codable (#72081)

Author: ktoso

include/swift/AST/DistributedDecl.h

@@ -37,6 +37,17 @@ Type getAssociatedTypeOfDistributedSystemOfActor(DeclContext *actorOrExtension,
 /// Find the concrete invocation decoder associated with the given actor.
 NominalTypeDecl *getDistributedActorInvocationDecoder(NominalTypeDecl *);
 
+/// Determine if this distributed actor can synthesize a `Codable` conformance.
+/// This is based on the actor's `ID` being `Codable`.
+///
+///  It is possible for the `ID` to be `Codable` but the
+/// `SerializationRequirement` used by the actor (and its actor system to not
+/// be `Codable`). In such situation the conformance is synthesized, however
+/// the user may need to provide an explicit conformance to the
+/// `SerializationRequirement` if they wanted to pass the actor to distributed
+/// methods.
+bool canSynthesizeDistributedActorCodableConformance(NominalTypeDecl *actor);
+
 /// Find `decodeNextArgument<T>(type: T.Type) -> T` method associated with
 /// invocation decoder of the given distributed actor.
 FuncDecl *getDistributedActorArgumentDecodingMethod(NominalTypeDecl *);

include/swift/AST/TypeCheckRequests.h

@@ -1054,6 +1054,24 @@ class IsDistributedActorRequest :
     bool isCached() const { return true; }
 };
 
+/// Determine whether the given class is a distributed actor.
+class CanSynthesizeDistributedActorCodableConformanceRequest :
+    public SimpleRequest<CanSynthesizeDistributedActorCodableConformanceRequest,
+        bool(NominalTypeDecl *),
+        RequestFlags::Cached> {
+public:
+    using SimpleRequest::SimpleRequest;
+
+private:
+    friend SimpleRequest;
+
+    bool evaluate(Evaluator &evaluator, NominalTypeDecl *nominal) const;
+
+public:
+    // Caching
+    bool isCached() const { return true; }
+};
+
 /// Retrieve the implicit conformance for the given distributed actor type to
 /// the Codable protocol protocol.
 ///

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -120,6 +120,9 @@ SWIFT_REQUEST(TypeChecker, IsDistributedActorRequest, bool(NominalTypeDecl *),
 SWIFT_REQUEST(TypeChecker, GetDistributedActorImplicitCodableRequest,
                NormalProtocolConformance *(NominalTypeDecl *, KnownProtocolKind),
                Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, CanSynthesizeDistributedActorCodableConformanceRequest,
+               bool (NominalTypeDecl *),
+               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedActorSystemRemoteCallFunctionRequest,
               AbstractFunctionDecl *(NominalTypeDecl *, bool),
               Cached, NoLocationInfo)

lib/AST/ConformanceLookup.cpp

@@ -26,6 +26,7 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Builtins.h"
+#include "swift/AST/DistributedDecl.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -622,7 +623,8 @@ LookupConformanceInModuleRequest::evaluate(
       }
     } else if (protocol->isSpecificProtocol(KnownProtocolKind::Encodable) ||
                protocol->isSpecificProtocol(KnownProtocolKind::Decodable)) {
-      if (nominal->isDistributedActor()) {
+      // if (nominal->isDistributedActor()) {
+      if (canSynthesizeDistributedActorCodableConformance(nominal)) {
         auto protoKind =
             protocol->isSpecificProtocol(KnownProtocolKind::Encodable)
                 ? KnownProtocolKind::Encodable

lib/AST/DistributedDecl.cpp

@@ -60,6 +60,23 @@
 
 using namespace swift;
 
+/******************************************************************************/
+/************* Implicit Distributed Actor Codable Conformance *****************/
+/******************************************************************************/
+
+bool swift::canSynthesizeDistributedActorCodableConformance(NominalTypeDecl *actor) {
+  auto &C = actor->getASTContext();
+
+  if (!actor->isDistributedActor())
+    return false;
+
+  return evaluateOrDefault(
+      C.evaluator,
+      CanSynthesizeDistributedActorCodableConformanceRequest{actor},
+      false);
+}
+
+
 /******************************************************************************/
 /************** Distributed Actor System Associated Types *********************/
 /******************************************************************************/
@@ -210,17 +227,20 @@ Type swift::getDistributedActorSystemInvocationDecoderType(NominalTypeDecl *syst
 Type swift::getDistributedSerializationRequirementType(
     NominalTypeDecl *nominal, ProtocolDecl *protocol) {
   assert(nominal);
-  assert(protocol);
   auto &ctx = nominal->getASTContext();
 
+  if (!protocol)
+    return Type();
+
   // Dig out the serialization requirement type.
   auto module = nominal->getParentModule();
   Type selfType = nominal->getSelfInterfaceType();
   auto conformance = module->lookupConformance(selfType, protocol);
   if (conformance.isInvalid())
     return Type();
 
-  return conformance.getTypeWitnessByName(selfType, ctx.Id_SerializationRequirement);
+  return conformance.getTypeWitnessByName(selfType,
+                                          ctx.Id_SerializationRequirement);
 }
 
 AbstractFunctionDecl *

lib/AST/ProtocolConformance.cpp

@@ -1284,7 +1284,7 @@ static SmallVector<ProtocolConformance *, 2> findSynthesizedConformances(
   }
 
   /// Distributed actors can synthesize Encodable/Decodable, so look for those
-  if (nominal->isDistributedActor()) {
+  if (canSynthesizeDistributedActorCodableConformance(nominal)) {
     trySynthesize(KnownProtocolKind::Encodable);
     trySynthesize(KnownProtocolKind::Decodable);
   }

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -1043,3 +1043,29 @@ NormalProtocolConformance *GetDistributedActorImplicitCodableRequest::evaluate(
   return addDistributedActorCodableConformance(classDecl,
                                                C.getProtocol(protoKind));
 }
+
+bool CanSynthesizeDistributedActorCodableConformanceRequest::evaluate(
+    Evaluator &evaluator, NominalTypeDecl *actor) const {
+
+  if (actor && !isa<ClassDecl>(actor))
+    return false;
+
+  if (!actor->isDistributedActor())
+    return false;
+
+  auto systemTy = getConcreteReplacementForProtocolActorSystemType(actor);
+  if (!systemTy)
+    return false;
+
+  if (!systemTy->getAnyNominal())
+    return false;
+
+  auto idTy = getDistributedActorSystemActorIDType(systemTy->getAnyNominal());
+  if (!idTy)
+    return false;
+
+  return TypeChecker::conformsToKnownProtocol(
+             idTy, KnownProtocolKind::Decodable, actor->getParentModule()) &&
+         TypeChecker::conformsToKnownProtocol(
+             idTy, KnownProtocolKind::Encodable, actor->getParentModule());
+}

test/Distributed/Inputs/FakeDistributedActorSystems.swift

@@ -385,6 +385,8 @@ public struct FakeInvocationEncoder : DistributedTargetInvocationEncoder {
   var returnType: Any.Type? = nil
   var errorType: Any.Type? = nil
 
+  public init() {}
+
   public mutating func recordGenericSubstitution<T>(_ type: T.Type) throws {
     print(" > encode generic sub: \(String(reflecting: type))")
     genericSubs.append(type)

test/Distributed/Runtime/distributed_actor_localSystem_generic.swift

@@ -17,14 +17,11 @@
 import Distributed
 
 @available(SwiftStdlib 6.0, *)
-distributed actor Worker<ActorSystem> where ActorSystem: DistributedActorSystem<any Codable>, ActorSystem.ActorID: Codable {
+//distributed actor Worker<ActorSystem> where ActorSystem: DistributedActorSystem<any Codable>, ActorSystem.ActorID: Codable {
+distributed actor Worker<ActorSystem> where ActorSystem: DistributedActorSystem<any Codable> {
   distributed func hi(name: String) {
     print("Hi, \(name)!")
   }
-
-  nonisolated var description: Swift.String {
-    "Worker(\(id))"
-  }
 }
 
 // ==== Execute ----------------------------------------------------------------

test/Distributed/distributed_actor_conditionally_implicitly_codable.swift

@@ -0,0 +1,116 @@
+// 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
+
+distributed actor YesVeryMuchSo {
+  typealias ActorSystem = FakeRoundtripActorSystem
+}
+func test_YesVeryMuchSo(_ actor: YesVeryMuchSo) {
+  let _: any Codable = actor // implicit conformance, ID was Codable
+
+  // unrelated protocol
+  let _: any CustomSerializationProtocol = actor // expected-error{{value of type 'YesVeryMuchSo' does not conform to specified type 'CustomSerializationProtocol'}}
+}
+
+// ==== ------------------------------------------------------------------------
+
+distributed actor SerReqNotCodable {
+  typealias ActorSystem = FakeCustomSerializationRoundtripActorSystem
+}
+func test_NotAtAll_NoImplicit(_ actor: SerReqNotCodable) {
+  let _: any Codable = actor // OK, the ID was Codable, even though SerializationRequirement was something else
+
+  // no implicit conformance
+  let _: any CustomSerializationProtocol = actor // expected-error{{value of type 'SerReqNotCodable' does not conform to specified type 'CustomSerializationProtocol'}}
+}
+
+// ==== ------------------------------------------------------------------------
+
+distributed actor NotAtAll_NothingCodable {
+  typealias ActorSystem = FakeIdIsNotCodableActorSystem
+}
+func test_NotAtAll_NoImplicit(_ actor: NotAtAll_NothingCodable) {
+  let _: any Codable = actor // expected-error{{value of type 'NotAtAll_NothingCodable' does not conform to specified type 'Decodable'}}
+
+  // no implicit conformance
+  let _: any CustomSerializationProtocol = actor // expected-error{{value of type 'NotAtAll_NothingCodable' does not conform to specified type 'CustomSerializationProtocol'}}
+}
+
+public struct NotCodableID: Sendable, Hashable {}
+
+@available(SwiftStdlib 5.7, *)
+public struct FakeIdIsNotCodableActorSystem: DistributedActorSystem, CustomStringConvertible {
+  public typealias ActorID = NotCodableID
+  public typealias InvocationDecoder = FakeInvocationDecoder
+  public typealias InvocationEncoder = FakeInvocationEncoder
+  public typealias SerializationRequirement = Codable
+  public typealias ResultHandler = FakeRoundtripResultHandler
+
+  // just so that the struct does not become "trivial"
+  let someValue: String = ""
+  let someValue2: String = ""
+  let someValue3: String = ""
+  let someValue4: String = ""
+
+  public init() {
+  }
+
+  public func resolve<Act>(id: ActorID, as actorType: Act.Type) throws -> Act?
+    where Act: DistributedActor,
+    Act.ID == ActorID  {
+    nil
+  }
+
+  public func assignID<Act>(_ actorType: Act.Type) -> ActorID
+    where Act: DistributedActor,
+    Act.ID == ActorID {
+    .init()
+  }
+
+  public func actorReady<Act>(_ actor: Act)
+    where Act: DistributedActor,
+    Act.ID == ActorID {
+  }
+
+  public func resignID(_ id: ActorID) {
+  }
+
+  public func makeInvocationEncoder() -> InvocationEncoder {
+    .init()
+  }
+
+  public func remoteCall<Act, Err, Res>(
+    on actor: Act,
+    target: RemoteCallTarget,
+    invocation invocationEncoder: inout InvocationEncoder,
+    throwing: Err.Type,
+    returning: Res.Type
+  ) async throws -> Res
+    where Act: DistributedActor,
+    Act.ID == ActorID,
+    Err: Error,
+    Res: SerializationRequirement {
+    throw ExecuteDistributedTargetError(message: "\(#function) not implemented.")
+  }
+
+  public func remoteCallVoid<Act, Err>(
+    on actor: Act,
+    target: RemoteCallTarget,
+    invocation invocationEncoder: inout InvocationEncoder,
+    throwing: Err.Type
+  ) async throws
+    where Act: DistributedActor,
+    Act.ID == ActorID,
+    Err: Error {
+    throw ExecuteDistributedTargetError(message: "\(#function) not implemented.")
+  }
+
+  public nonisolated var description: Swift.String {
+    "\(Self.self)()"
+  }
+}