[Distributed] Sema: Adjust decoding method lookup to check for covered serialization requirements

A proper `decodeNextArgument` candidate should cover all of the protocols
listed in `SerializationRequirement` associated with distributed actor it
would be used for.

Author: xedin

include/swift/AST/KnownIdentifiers.def

@@ -292,6 +292,7 @@ IDENTIFIER(using)
 IDENTIFIER(InvocationDecoder)
 IDENTIFIER(whenLocal)
 IDENTIFIER(decodeNextArgument)
+IDENTIFIER(SerializationRequirement)
 
 #undef IDENTIFIER
 #undef IDENTIFIER_

lib/Sema/TypeCheckDistributed.cpp

@@ -472,26 +472,66 @@ GetDistributedActorArgumentDecodingMethodRequest::evaluate(Evaluator &evaluator,
   auto members = TypeChecker::lookupMember(actor->getDeclContext(), decoderTy,
                                            DeclNameRef(ctx.Id_decodeNextArgument));
 
+  // typealias SerializationRequirement = any ...
+  auto serializerType = getAssociatedTypeOfDistributedSystem(
+                            actor, ctx.Id_SerializationRequirement)
+                            ->castTo<ExistentialType>()
+                            ->getConstraintType()
+                            ->getDesugaredType();
+
+  llvm::SmallPtrSet<ProtocolDecl *, 2> serializationReqs;
+  if (auto composition = serializerType->getAs<ProtocolCompositionType>()) {
+    for (auto member : composition->getMembers()) {
+      if (auto *protocol = member->getAs<ProtocolType>())
+        serializationReqs.insert(protocol->getDecl());
+    }
+  } else {
+    auto protocol = serializerType->castTo<ProtocolType>()->getDecl();
+    serializationReqs.insert(protocol);
+  }
+
   SmallVector<FuncDecl *, 2> candidates;
-  // Looking for `decodeNextArgument<Arg>() throws -> Arg`
+  // Looking for `decodeNextArgument<Arg: <SerializationReq>>() throws -> Arg`
   for (auto &member : members) {
     auto *FD = dyn_cast<FuncDecl>(member.getValueDecl());
     if (!FD || FD->hasAsync() || !FD->hasThrows())
       continue;
 
     auto *params = FD->getParameters();
+    // No arguemnts.
     if (params->size() != 0)
       continue;
 
     auto genericParamList = FD->getGenericParams();
-    if (genericParamList->size() == 1) {
-      auto paramTy = genericParamList->getParams()[0]
-                         ->getInterfaceType()
-                         ->getMetatypeInstanceType();
+    // A single generic parameter.
+    if (genericParamList->size() != 1)
+      continue;
 
-      if (FD->getResultInterfaceType()->isEqual(paramTy))
-        candidates.push_back(FD);
-    }
+    auto paramTy = genericParamList->getParams()[0]
+                       ->getInterfaceType()
+                       ->getMetatypeInstanceType();
+
+    // `decodeNextArgument` should return its generic parameter value
+    if (!FD->getResultInterfaceType()->isEqual(paramTy))
+      continue;
+
+    // Let's find out how many serialization requirements does this method cover
+    // e.g. `Codable` is two requirements - `Encodable` and `Decodable`.
+    unsigned numSerializationReqsCovered = llvm::count_if(
+        FD->getGenericRequirements(), [&](const Requirement &requirement) {
+          if (!(requirement.getFirstType()->isEqual(paramTy) &&
+                requirement.getKind() == RequirementKind::Conformance))
+            return 0;
+
+          return serializationReqs.count(requirement.getProtocolDecl()) ? 1 : 0;
+        });
+
+    // If the current method covers all of the serialization requirements,
+    // it's a match. Note that it might also have other requirements, but
+    // we let that go as long as there are no two candidates that differ
+    // only in generic requirements.
+    if (numSerializationReqsCovered == serializationReqs.size())
+      candidates.push_back(FD);
   }
 
   // Type-checker should reject any definition of invocation decoder