[Distributed] Record generic substitution types for invocation

Author: ktoso

include/swift/AST/ASTContext.h

@@ -679,6 +679,15 @@ class ASTContext final {
   FuncDecl *getMakeInvocationEncoderOnDistributedActorSystem(
       NominalTypeDecl *actorOrSystem) const;
 
+  // Retrieve the declaration of
+  // DistributedInvocationEncoder.recordGenericSubstitution(_:).
+  //
+  // \param nominal optionally provide a 'NominalTypeDecl' from which the
+  // function decl shall be extracted. This is useful to avoid witness calls
+  // through the protocol which is looked up when nominal is null.
+  FuncDecl *getRecordGenericSubstitutionOnDistributedInvocationEncoder(
+      NominalTypeDecl *nominal) const;
+
   // Retrieve the declaration of DistributedInvocationEncoder.recordArgument(_:).
   //
   // \param nominal optionally provide a 'NominalTypeDecl' from which the
@@ -1342,6 +1351,12 @@ class ASTContext final {
   /// alternative specified via the -entry-point-function-name frontend flag.
   std::string getEntryPointFunctionName() const;
 
+  /// Find the type of SerializationRequirement on the passed nominal.
+  ///
+  /// This type exists as a typealias/associatedtype on all distributed actors,
+  /// actor systems, and related serialization types.
+  Type getDistributedSerializationRequirementType(NominalTypeDecl *);
+
   /// Find the concrete invocation decoder associated with the given actor.
   NominalTypeDecl *
   getDistributedActorInvocationDecoder(NominalTypeDecl *);

include/swift/SIL/SILFunction.h

@@ -461,6 +461,15 @@ class SILFunction
     ReplacedFunction->incrementRefCount();
   }
 
+  SILFunction *getDistributedRecordArgumentFunction() const {
+    return ReplacedFunction;
+  }
+  void setDistributedRecordArgumentFunction(SILFunction *f) {
+    if (f == nullptr)
+      return;
+    f->incrementRefCount();
+  }
+
   /// This function should only be called when SILFunctions are bulk deleted.
   void dropDynamicallyReplacedFunction() {
     if (!ReplacedFunction)

lib/AST/ASTContext.cpp

@@ -1326,6 +1326,38 @@ FuncDecl *ASTContext::getMakeInvocationEncoderOnDistributedActorSystem(
   return nullptr;
 }
 
+FuncDecl *
+ASTContext::getRecordGenericSubstitutionOnDistributedInvocationEncoder(
+    NominalTypeDecl *nominal) const {
+  for (auto result : nominal->lookupDirect(Id_recordGenericSubstitution)) {
+    auto *fd = dyn_cast<FuncDecl>(result);
+    if (!fd)
+      continue;
+    if (fd->getParameters()->size() != 1)
+      continue;
+    if (fd->hasAsync())
+      continue;
+    if (!fd->hasThrows())
+      continue;
+    // TODO(distributed): more checks
+
+    auto genericParamList = fd->getGenericParams();
+
+    // A single generic parameter.
+    if (genericParamList->size() != 1)
+      continue;
+
+    // No requirements on the generic parameter
+    if (fd->getGenericRequirements().size() != 0)
+      continue;
+
+    if (fd->getResultInterfaceType()->isVoid())
+      return fd;
+  }
+
+  return nullptr;
+}
+
 FuncDecl *ASTContext::getRecordArgumentOnDistributedInvocationEncoder(
     NominalTypeDecl *nominal) const {
   for (auto result : nominal->lookupDirect(Id_recordArgument)) {

lib/SIL/Verifier/SILVerifier.cpp

@@ -5528,6 +5528,11 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
           if (term->isFunctionExiting()) {
             require(state.Stack.empty(),
                     "return with stack allocs that haven't been deallocated");
+            if (!state.ActiveOps.empty()) {
+              for (auto op : state.ActiveOps) {
+                op->dump();
+              }
+            }
             require(state.ActiveOps.empty(),
                     "return with operations still active");
             require(!state.GotAsyncContinuation,