[Distributed] Require that SerReq can only be used with protocols

Author: ktoso

include/swift/AST/DiagnosticsSema.def

@@ -4631,6 +4631,9 @@ ERROR(distributed_actor_func_param_not_codable,none,
 ERROR(distributed_actor_target_result_not_codable,none,
       "result type %0 of %1 %2 does not conform to serialization requirement '%3'",
       (Type, DescriptiveDeclKind, Identifier, StringRef))
+ERROR(distributed_actor_system_serialization_req_must_be_protocol,none,
+      "'SerializationRequirement' type witness %0 must be a protocol type",
+      (Type))
 ERROR(distributed_actor_remote_func_implemented_manually,none,
       "distributed instance method's %0 remote counterpart %1 cannot not be implemented manually.",
       (Identifier, Identifier))

lib/AST/DistributedDecl.cpp

@@ -271,12 +271,24 @@ swift::getDistributedSerializationRequirements(
   if (existentialRequirementTy->isAny())
     return true; // we're done here, any means there are no requirements
 
-  auto serialReqType = existentialRequirementTy->castTo<ExistentialType>()
-                           ->getConstraintType()
-                           ->getDesugaredType();
+  if (auto alias = dyn_cast<TypeAliasType>(existentialRequirementTy.getPointer())) {
+    auto ty = alias->getDesugaredType();
+    if (isa<ClassType>(ty) || isa<StructType>(ty) || isa<EnumType>(ty)) {
+      // SerializationRequirement cannot be class or struct nowadays
+      return false;
+    }
+  }
+
+  ExistentialType *serialReqType = existentialRequirementTy
+                                       ->castTo<ExistentialType>();
+  if (!serialReqType || serialReqType->hasError()) {
+    return false;
+  }
+
+  auto desugaredTy = serialReqType->getConstraintType()->getDesugaredType();
   auto flattenedRequirements =
       flattenDistributedSerializationTypeToRequiredProtocols(
-          serialReqType);
+          desugaredTy);
   for (auto p : flattenedRequirements) {
     requirementProtos.insert(p);
   }

lib/Sema/TypeCheckDistributed.cpp

@@ -431,6 +431,47 @@ static bool checkDistributedTargetResultType(
   return false;
 }
 
+bool swift::checkDistributedActorSystem(const NominalTypeDecl *system) {
+  auto nominal = const_cast<NominalTypeDecl *>(system);
+
+  // ==== Ensure the Distributed module is available,
+  // without it there's no reason to check the decl in more detail anyway.
+  if (!swift::ensureDistributedModuleLoaded(nominal))
+    return true;
+
+  auto &C = nominal->getASTContext();
+  auto DAS = C.getDistributedActorSystemDecl();
+
+  // === AssociatedTypes
+  // --- SerializationRequirement MUST be a protocol TODO(distributed): rdar://91663941
+  // we may lift this in the future and allow classes but this requires more
+  // work to enable associatedtypes to be constrained to class or protocol,
+  // which then will unlock using them as generic constraints in protocols.
+  Type requirementTy = getDistributedSerializationRequirementType(nominal, DAS);
+  requirementTy->dump();
+
+  if (auto existentialTy = requirementTy->getAs<ExistentialType>()) {
+    requirementTy = existentialTy->getConstraintType();
+  }
+
+  if (auto alias = dyn_cast<TypeAliasType>(requirementTy.getPointer())) {
+    auto concreteReqTy = alias->getDesugaredType();
+    if (auto comp = dyn_cast<ProtocolCompositionType>(concreteReqTy)) {
+      // ok, protocol composition is fine as requirement,
+      // since special case of just a single protocol
+    } else if (auto proto = dyn_cast<ProtocolType>(concreteReqTy)) {
+      // ok, protocols is exactly what we want to be used as constraints here
+    } else {
+      nominal->diagnose(diag::distributed_actor_system_serialization_req_must_be_protocol,
+                        requirementTy);
+      return true;
+    }
+  }
+
+  // all good, didn't find any errors
+  return false;
+}
+
 /// Check whether the function is a proper distributed function
 ///
 /// \returns \c true if there was a problem with adding the attribute, \c false

lib/Sema/TypeCheckDistributed.h

@@ -50,6 +50,9 @@ bool checkDistributedActorSystemAdHocProtocolRequirements(
     Type Adoptee,
     bool diagnose);
 
+/// Check 'DistributedActorSystem' implementations for additional restrictions.
+bool checkDistributedActorSystem(const NominalTypeDecl *system);
+
 /// Typecheck a distributed method declaration
 bool checkDistributedFunction(AbstractFunctionDecl *decl);
 

lib/Sema/TypeCheckProtocol.cpp

@@ -6333,6 +6333,9 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
           }
         }
       }
+    } else if (proto->isSpecificProtocol(
+                   KnownProtocolKind::DistributedActorSystem)) {
+      checkDistributedActorSystem(nominal);
     } else if (proto->isSpecificProtocol(KnownProtocolKind::Actor)) {
       if (auto classDecl = dyn_cast<ClassDecl>(nominal)) {
         if (!classDecl->isExplicitActor()) {

test/Distributed/distributed_serializationRequirement_must_be_protocol.swift

@@ -0,0 +1,125 @@
+// 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 -verify-ignore-unknown -disable-availability-checking -I %t 2>&1 %s
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+import Distributed
+import FakeDistributedActorSystems
+
+final class SomeClazz: Sendable {}
+final class SomeStruct: Sendable {}
+final class SomeEnum: Sendable {}
+
+// TODO(distributed): improve to diagnose ON the typealias rather than on the system
+// expected-error@+1{{'SerializationRequirement' type witness 'System.SerializationRequirement' (aka 'SomeClazz') must be a protocol type}}
+final class System: DistributedActorSystem {
+  // ignore those since they all fail with the SerializationRequirement being invalid:
+  // expected-error@-2{{type 'System' does not conform to protocol 'DistributedActorSystem'}}
+  // expected-note@-3{{protocol 'System' requires function 'remoteCallVoid'}}
+  // expected-error@-4{{class 'System' is missing witness for protocol requirement 'remoteCall'}}
+  // expected-note@-5{{protocol 'System' requires function 'remoteCall' with signature:}}
+  // expected-error@-6{{class 'System' is missing witness for protocol requirement 'remoteCallVoid'}}
+  typealias ActorID = String
+  typealias InvocationEncoder = ClassInvocationEncoder
+  typealias InvocationDecoder = ClassInvocationDecoder
+
+  typealias ResultHandler = DistributedTargetInvocationResultHandler
+  // expected-note@-1{{possibly intended match 'System.ResultHandler' (aka 'DistributedTargetInvocationResultHandler') does not conform to 'DistributedTargetInvocationResultHandler'}}
+
+  typealias SerializationRequirement = SomeClazz
+
+  func resolve<Act>(id: ActorID, as actorType: Act.Type)
+    throws -> Act? where Act: DistributedActor {
+    fatalError()
+  }
+
+  func assignID<Act>(_ actorType: Act.Type) -> ActorID
+    where Act: DistributedActor {
+    fatalError()
+  }
+
+  func actorReady<Act>(_ actor: Act)
+    where Act: DistributedActor,
+    Act.ID == ActorID {
+    fatalError()
+  }
+
+  func resignID(_ id: ActorID) {
+    fatalError()
+  }
+
+  func makeInvocationEncoder() -> InvocationEncoder {
+    fatalError()
+  }
+
+  func remoteCall<Act, Err, Res>(
+    on actor: Act,
+    target: RemoteCallTarget,
+    invocation: inout InvocationEncoder,
+    throwing errorType: Err.Type,
+    returning returnType: Res.Type
+  ) async throws -> Res
+    where Act: DistributedActor,
+    Act.ID == ActorID,
+    Err: Error,
+    Res: SerializationRequirement {
+    fatalError()
+  }
+
+  func remoteCallVoid<Act, Err>(
+    on actor: Act,
+    target: RemoteCallTarget,
+    invocation: inout InvocationEncoder,
+    throwing errorType: Err.Type
+  ) async throws
+    where Act: DistributedActor,
+    Act.ID == ActorID,
+    Err: Error {
+    fatalError()
+  }
+}
+
+struct ClassInvocationEncoder: DistributedTargetInvocationEncoder {
+  // expected-note@-1{{protocol 'ClassInvocationEncoder' requires function 'recordArgument' with signature:}}
+  // expected-error@-2{{struct 'ClassInvocationEncoder' is missing witness for protocol requirement 'recordArgument'}}
+  // expected-note@-3{{protocol 'ClassInvocationEncoder' requires function 'recordReturnType' with signature:}}
+  // expected-error@-4{{struct 'ClassInvocationEncoder' is missing witness for protocol requirement 'recordReturnType'}}
+  typealias SerializationRequirement = SomeClazz
+
+  public mutating func recordGenericSubstitution<T>(_ type: T.Type) throws {}
+  public mutating func recordArgument<Value: SerializationRequirement>(
+    _ argument: RemoteCallArgument<Value>) throws {}
+  public mutating func recordErrorType<E: Error>(_ type: E.Type) throws {}
+  public mutating func recordReturnType<R: SerializationRequirement>(_ type: R.Type) throws {}
+  public mutating func doneRecording() throws {}
+}
+
+final class ClassInvocationDecoder: DistributedTargetInvocationDecoder {
+  // expected-error@-1{{class 'ClassInvocationDecoder' is missing witness for protocol requirement 'decodeNextArgument'}}
+  // expected-note@-2{{protocol 'ClassInvocationDecoder' requires function 'decodeNextArgument'}}
+  typealias SerializationRequirement = SomeClazz
+
+  public func decodeGenericSubstitutions() throws -> [Any.Type] {
+    fatalError()
+  }
+
+  public func decodeNextArgument<Argument: SerializationRequirement>() throws -> Argument {
+    fatalError()
+  }
+
+  public func decodeErrorType() throws -> Any.Type? {
+    fatalError()
+  }
+
+  public func decodeReturnType() throws -> Any.Type? {
+    fatalError()
+  }
+}
+
+struct DistributedTargetInvocationResultHandler {
+  typealias SerializationRequirement = SomeClazz
+  func onReturn<Success: SomeClazz>(value: Success) async throws {}
+  func onReturnVoid() async throws {}
+  func onThrow<Err: Error>(error: Err) async throws {}
+}