[Sema/IRGen] Extend ad-hoc requirement handling to DistributedTargetInvocationDecoder.decodeNextArgument

Author: xedin

lib/IRGen/GenProto.cpp

@@ -551,6 +551,7 @@ class EmitPolymorphicParameters : public PolymorphicConvention {
   // If we are building a protocol witness thunks for
   // `DistributedActorSystem.remoteCall` or
   // `DistributedTargetInvocationEncoder.record{Argument, ReturnType}`
+  // `DistributedTargetInvocationDecoder.decodeNextArgument`
   // requirements we need to supply witness tables associated with `Res`,
   // `Argument`, `R` generic parameters which are not expressible on the
   // protocol requirement because they come from `SerializationRequirement`
@@ -739,21 +740,23 @@ void EmitPolymorphicParameters::injectAdHocDistributedRequirements() {
 
   auto loc = Fn.getLocation();
 
-  Type genericParam;
-
   auto *funcDecl = dyn_cast_or_null<FuncDecl>(loc.getAsDeclContext());
   if (!(funcDecl && funcDecl->isGeneric()))
     return;
 
+  Type genericParam;
+
   // DistributedActorSystem.remoteCall
   if (funcDecl->isDistributedActorSystemRemoteCall(
           /*isVoidReturn=*/false)) {
     genericParam = funcDecl->getResultInterfaceType();
   }
 
   // DistributedTargetInvocationEncoder.record{Argument, ReturnType}
+  // DistributedTargetInvocationDecoder.decodeNextArgument
   if (funcDecl->isDistributedTargetInvocationEncoderRecordArgument() ||
-      funcDecl->isDistributedTargetInvocationEncoderRecordReturnType()) {
+      funcDecl->isDistributedTargetInvocationEncoderRecordReturnType() ||
+      funcDecl->isDistributedTargetInvocationDecoderDecodeNextArgument()) {
     auto *argParam = funcDecl->getGenericParams()->getParams().front();
     genericParam = argParam->getDeclaredInterfaceType();
   }

lib/Sema/CSSimplify.cpp

@@ -8599,8 +8599,10 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
           }
 
           // `DistributedTargetInvocationEncoder.record{Argument, ResultType}`
+          // `DistributedTargetInvocationDecoder.decodeNextArgument`
           if (witness->isDistributedTargetInvocationEncoderRecordArgument() ||
-              witness->isDistributedTargetInvocationEncoderRecordReturnType()) {
+              witness->isDistributedTargetInvocationEncoderRecordReturnType() ||
+              witness->isDistributedTargetInvocationDecoderDecodeNextArgument()) {
             auto genericParams = witness->getGenericParams()->getParams();
             if (GP->isEqual(genericParams.front()->getDeclaredInterfaceType()))
               return synthesizeConformance();

stdlib/public/Distributed/DistributedActorSystem.swift

@@ -890,20 +890,18 @@ public protocol DistributedTargetInvocationDecoder {
   /// - Throws: if decoding substitutions fails.
   mutating func decodeGenericSubstitutions() throws -> [Any.Type]
 
-//  /// Ad-hoc protocol requirement
-//  ///
-//  /// Attempt to decode the next argument from the underlying buffers into pre-allocated storage
-//  /// pointed at by 'pointer'.
-//  ///
-//  /// This method should throw if it has no more arguments available, if decoding the argument failed,
-//  /// or, optionally, if the argument type we're trying to decode does not match the stored type.
-//  ///
-//  /// The result of the decoding operation must be stored into the provided 'pointer' rather than
-//  /// returning a value. This pattern allows the runtime to use a heavily optimized, pre-allocated
-//  /// buffer for all the arguments and their expected types. The 'pointer' passed here is a pointer
-//  /// to a "slot" in that pre-allocated buffer. That buffer will then be passed to a thunk that
-//  /// performs the actual distributed (local) instance method invocation.
-//  mutating func decodeNextArgument<Argument: SerializationRequirement>() throws -> Argument
+  /// Attempt to decode the next argument from the underlying buffers into pre-allocated storage
+  /// pointed at by 'pointer'.
+  ///
+  /// This method should throw if it has no more arguments available, if decoding the argument failed,
+  /// or, optionally, if the argument type we're trying to decode does not match the stored type.
+  ///
+  /// The result of the decoding operation must be stored into the provided 'pointer' rather than
+  /// returning a value. This pattern allows the runtime to use a heavily optimized, pre-allocated
+  /// buffer for all the arguments and their expected types. The 'pointer' passed here is a pointer
+  /// to a "slot" in that pre-allocated buffer. That buffer will then be passed to a thunk that
+  /// performs the actual distributed (local) instance method invocation.
+  mutating func decodeNextArgument<Argument/*: SerializationRequirement*/>() throws -> Argument
 
   /// Decode the specific error type that the distributed invocation target has recorded.
   /// Currently this effectively can only ever be `Error.self`.