[Distributed] distributed func checks now work in protocols & dont crash

Author: ktoso

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -758,7 +758,6 @@ FuncDecl *GetDistributedThunkRequest::evaluate(
     return nullptr;
 
   auto &C = distributedTarget->getASTContext();
-  auto DC = distributedTarget->getDeclContext();
 
   if (!getConcreteReplacementForProtocolActorSystemType(distributedTarget)) {
     // Don't synthesize thunks, unless there is a *concrete* ActorSystem.
@@ -782,9 +781,6 @@ FuncDecl *GetDistributedThunkRequest::evaluate(
     if (!C.getLoadedModule(C.Id_Distributed))
       return nullptr;
 
-    auto nominal = DC->getSelfNominalTypeDecl(); // NOTE: Always from DC
-    assert(nominal);
-
     // --- Prepare the "distributed thunk" which does the "maybe remote" dance:
     return createDistributedThunkFunction(func);
   }

lib/Sema/TypeCheckAttr.cpp

@@ -5783,7 +5783,6 @@ void AttributeChecker::visitDistributedActorAttr(DistributedActorAttr *attr) {
 
     // distributed func must be declared inside an distributed actor
     auto selfTy = dc->getSelfTypeInContext();
-
     if (!selfTy->isDistributedActor()) {
       auto diagnostic = diagnoseAndRemoveAttr(
         attr, diag::distributed_actor_func_not_in_distributed_actor);

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2880,6 +2880,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     }
 
     TypeChecker::checkDeclAttributes(FD);
+    TypeChecker::checkDistributedFunc(FD);
 
     if (!checkOverrides(FD)) {
       // If a method has an 'override' keyword but does not

lib/Sema/TypeCheckDistributed.cpp

@@ -702,6 +702,13 @@ void TypeChecker::checkDistributedActor(SourceFile *SF, NominalTypeDecl *nominal
   (void)nominal->getDistributedActorIDProperty();
 }
 
+void TypeChecker::checkDistributedFunc(FuncDecl *func) {
+  if (!func->isDistributed())
+    return;
+
+  swift::checkDistributedFunction(func);
+}
+
 llvm::SmallPtrSet<ProtocolDecl *, 2>
 swift::getDistributedSerializationRequirementProtocols(
     NominalTypeDecl *nominal, ProtocolDecl *protocol) {

lib/Sema/TypeChecker.h

@@ -1104,6 +1104,9 @@ diagnosePotentialOpaqueTypeUnavailability(SourceRange ReferenceRange,
 /// Type check a 'distributed actor' declaration.
 void checkDistributedActor(SourceFile *SF, NominalTypeDecl *decl);
 
+/// Type check a single 'distributed func' declaration.
+void checkDistributedFunc(FuncDecl *func);
+
 void checkConcurrencyAvailability(SourceRange ReferenceRange,
                                   const DeclContext *ReferenceDC);
 

test/Distributed/distributed_actor_system_missing.swift

@@ -18,6 +18,7 @@ distributed actor DA {
   // Note to add the typealias is diagnosed on the protocol:
   // _Distributed.DistributedActor:3:20: note: diagnostic produced elsewhere: protocol requires nested type 'ActorSystem'; do you want to add it?
 }
+
 // When an actor declares a typealias for a system, but that system does not exist,
 // we need to fail gracefully, rather than crash trying to use the non-existing type.
 //

test/Distributed/distributed_protocols_distributed_func_serialization_requirements.swift

@@ -29,6 +29,41 @@ distributed actor SpecifyRequirement: NoSerializationRequirementYet {
   distributed func testAT() async throws -> NotCodable {
     .init()
   }
+
+}
+
+protocol ProtocolWithChecksSystem: DistributedActor
+  where ActorSystem == FakeActorSystem {
+  // expected-error@+1{{result type 'NotCodable' of distributed instance method 'testAT' does not conform to serialization requirement 'Codable'}}
+  distributed func testAT() async throws -> NotCodable
+}
+distributed actor ProtocolWithChecksSystemDA: ProtocolWithChecksSystem {
+  // expected-error@+1{{result type 'NotCodable' of distributed instance method 'testAT' does not conform to serialization requirement 'Codable'}}
+  distributed func testAT() async throws -> NotCodable { .init() }
+}
+
+protocol ProtocolWithChecksSeqReq: DistributedActor
+  where Self.SerializationRequirement == Codable {
+  // expected-error@+1{{result type 'NotCodable' of distributed instance method 'testAT' does not conform to serialization requirement 'Codable'}}
+  distributed func testAT() async throws -> NotCodable
+}
+distributed actor ProtocolWithChecksSeqReqDA_MissingSystem: ProtocolWithChecksSeqReq {
+  // expected-error@-1{{distributed actor 'ProtocolWithChecksSeqReqDA_MissingSystem' does not declare ActorSystem it can be used with.}}
+  // expected-note@-2{{you can provide a module-wide default actor system by declaring:}}
+  // expected-error@-3{{type 'ProtocolWithChecksSeqReqDA_MissingSystem' does not conform to protocol 'ProtocolWithChecksSeqReq'}}
+  //
+  // expected-error@-5{{distributed actor 'ProtocolWithChecksSeqReqDA_MissingSystem' does not declare ActorSystem it can be used with.}}
+
+  // Entire conformance is doomed, so we didn't proceed to checking the functions; that's fine
+  distributed func testAT() async throws -> NotCodable { .init() }
+}
+
+distributed actor ProtocolWithChecksSeqReqDA: ProtocolWithChecksSeqReq {
+  typealias ActorSystem = FakeActorSystem
+  // ok, since FakeActorSystem.SerializationRequirement == ProtocolWithChecksSeqReq.SerializationRequirement
+
+  // expected-error@+1{{result type 'NotCodable' of distributed instance method 'testAT' does not conform to serialization requirement 'Codable'}}
+  distributed func testAT() async throws -> NotCodable { .init() }
 }
 
 extension NoSerializationRequirementYet {