[Distributed] Implement RemoteCallArgument

Author: ktoso

include/swift/AST/Decl.h

@@ -3493,9 +3493,12 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Find, or potentially synthesize, the implicit 'id' property of this actor.
   VarDecl *getDistributedActorIDProperty() const;
 
-  /// Find the 'RemoteCallTarget.init(_mangledName:)' initializer function
+  /// Find the 'RemoteCallTarget.init(_:)' initializer function
   ConstructorDecl* getDistributedRemoteCallTargetInitFunction() const;
 
+  /// Find the 'RemoteCallArgument(label:name:value:)' initializer function
+  ConstructorDecl* getDistributedRemoteCallArgumentInitFunction() const;
+
   /// Collect the set of protocols to which this type should implicitly
   /// conform, such as AnyObject (for classes).
   void getImplicitProtocols(SmallVectorImpl<ProtocolDecl *> &protocols);

include/swift/AST/KnownSDKTypes.def

@@ -49,6 +49,7 @@ KNOWN_SDK_TYPE_DECL(Distributed, DistributedActorSystem, ProtocolDecl, 0)
 KNOWN_SDK_TYPE_DECL(Distributed, DistributedTargetInvocationEncoder, ProtocolDecl, 0)
 KNOWN_SDK_TYPE_DECL(Distributed, DistributedTargetInvocationDecoder, ProtocolDecl, 0)
 KNOWN_SDK_TYPE_DECL(Distributed, RemoteCallTarget, StructDecl, 0)
+KNOWN_SDK_TYPE_DECL(Distributed, RemoteCallArgument, StructDecl, 1)
 
 // String processing
 KNOWN_SDK_TYPE_DECL(StringProcessing, Regex, StructDecl, 1)

include/swift/AST/TypeCheckRequests.h

@@ -1210,7 +1210,7 @@ class GetDistributedActorSystemPropertyRequest :
     bool isCached() const { return true; }
 };
 
-/// Obtain the constructor of the RemoteCallTarget type.
+/// Obtain the constructor of the 'RemoteCallTarget' type.
 class GetDistributedRemoteCallTargetInitFunctionRequest :
     public SimpleRequest<GetDistributedRemoteCallTargetInitFunctionRequest,
                          ConstructorDecl *(NominalTypeDecl *),
@@ -1229,6 +1229,25 @@ class GetDistributedRemoteCallTargetInitFunctionRequest :
     bool isCached() const { return true; }
 };
 
+/// Obtain the constructor of the 'RemoteCallArgument' type.
+class GetDistributedRemoteCallArgumentInitFunctionRequest :
+    public SimpleRequest<GetDistributedRemoteCallArgumentInitFunctionRequest,
+                         ConstructorDecl *(NominalTypeDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  ConstructorDecl *evaluate(Evaluator &evaluator,
+                            NominalTypeDecl *nominal) const;
+
+public:
+    // Caching
+    bool isCached() const { return true; }
+};
+
 /// Obtain the 'distributed thunk' for the passed-in function.
 ///
 /// The thunk is responsible for invoking 'remoteCall' when invoked on a remote

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -145,6 +145,9 @@ SWIFT_REQUEST(TypeChecker, GetDistributedActorSystemPropertyRequest,
 SWIFT_REQUEST(TypeChecker, GetDistributedRemoteCallTargetInitFunctionRequest,
               ConstructorDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, GetDistributedRemoteCallArgumentInitFunctionRequest,
+              ConstructorDecl *(NominalTypeDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedActorInvocationDecoderRequest,
               NominalTypeDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)

lib/AST/DistributedDecl.cpp

@@ -581,6 +581,11 @@ AbstractFunctionDecl::isDistributedTargetInvocationEncoderRecordArgument() const
   auto &C = getASTContext();
   auto module = getParentModule();
 
+  auto func = dyn_cast<FuncDecl>(this);
+  if (!func) {
+    return false;
+  }
+
   // === Check base name
   if (getBaseIdentifier() != C.Id_recordArgument) {
     return false;
@@ -614,6 +619,12 @@ AbstractFunctionDecl::isDistributedTargetInvocationEncoderRecordArgument() const
       return false;
     }
 
+    // --- must be mutating, if it is defined in a struct
+    if (isa<StructDecl>(getDeclContext()) &&
+        !func->isMutating()) {
+      return false;
+    }
+
     // --- Check number of generic parameters
     auto genericParams = getGenericParams();
     unsigned int expectedGenericParamNum = 1;
@@ -635,28 +646,43 @@ AbstractFunctionDecl::isDistributedTargetInvocationEncoderRecordArgument() const
 
     // === Check all parameters
     auto params = getParameters();
-    if (params->size() != 2) {
+    if (params->size() != 1) {
       return false;
     }
 
-    // --- Check parameter: label
-    auto labelParam = params->get(0);
-    if (!labelParam->getArgumentName().is("name")) {
-      return false;
-    }
-    if (!labelParam->getInterfaceType()->isEqual(C.getStringType())) {
+  GenericTypeParamDecl *ArgumentParam = genericParams->getParams()[0];
+
+    // --- Check parameter: _ argument
+    auto argumentParam = params->get(0);
+    if (!argumentParam->getArgumentName().empty()) {
       return false;
     }
 
-    // --- Check parameter: _ argument
-    auto argumentParam = params->get(1);
-    if (!argumentParam->getArgumentName().is("")) {
+    auto argumentTy = argumentParam->getInterfaceType();
+    auto argumentInContextTy = mapTypeIntoContext(argumentTy);
+    if (argumentInContextTy->getAnyNominal() == C.getRemoteCallArgumentDecl()) {
+      auto argGenericParams = argumentInContextTy->getStructOrBoundGenericStruct()
+          ->getGenericParams()->getParams();
+      if (argGenericParams.size() != 1) {
+        return false;
+      }
+
+      // the <Value> of the RemoteCallArgument<Value>
+      auto remoteCallArgValueGenericTy =
+          mapTypeIntoContext(argGenericParams[0]->getInterfaceType())
+              ->getDesugaredType()
+              ->getMetatypeInstanceType();
+      // expected (the <Value> from the recordArgument<Value>)
+      auto expectedGenericParamTy = mapTypeIntoContext(
+          ArgumentParam->getInterfaceType()->getMetatypeInstanceType());
+
+      if (!remoteCallArgValueGenericTy->isEqual(expectedGenericParamTy)) {
+            return false;
+          }
+    } else {
       return false;
     }
 
-    // === Check generic parameters in detail
-    // --- Check: Argument: SerializationRequirement
-    GenericTypeParamDecl *ArgumentParam = genericParams->getParams()[0];
 
     auto sig = getGenericSignature();
     auto requirements = sig.getRequirements();
@@ -672,29 +698,6 @@ AbstractFunctionDecl::isDistributedTargetInvocationEncoderRecordArgument() const
     // conforms_to: Argument Encodable
     // ...
 
-    auto func = dyn_cast<FuncDecl>(this);
-    if (!func) {
-      return false;
-    }
-
-    auto resultType =
-        func->mapTypeIntoContext(argumentParam->getInterfaceType())
-            ->getDesugaredType();
-    auto resultParamType = func->mapTypeIntoContext(
-        ArgumentParam->getInterfaceType()->getMetatypeInstanceType());
-    // The result of the function must be the `Res` generic argument.
-    if (!resultType->isEqual(resultParamType)) {
-      return false;
-    }
-
-    for (auto requirementProto : requirementProtos) {
-      auto conformance =
-          module->lookupConformance(resultType, requirementProto);
-      if (conformance.isInvalid()) {
-        return false;
-      }
-    }
-
     // === Check result type: Void
     if (!func->getResultInterfaceType()->isVoid()) {
       return false;
@@ -1152,6 +1155,14 @@ NominalTypeDecl::getDistributedRemoteCallTargetInitFunction() const {
       GetDistributedRemoteCallTargetInitFunctionRequest(mutableThis), nullptr);
 }
 
+ConstructorDecl *
+NominalTypeDecl::getDistributedRemoteCallArgumentInitFunction() const {
+  auto mutableThis = const_cast<NominalTypeDecl *>(this);
+  return evaluateOrDefault(
+      getASTContext().evaluator,
+      GetDistributedRemoteCallArgumentInitFunctionRequest(mutableThis), nullptr);
+}
+
 AbstractFunctionDecl *ASTContext::getRemoteCallOnDistributedActorSystem(
     NominalTypeDecl *actorOrSystem, bool isVoidReturn) const {
   assert(actorOrSystem && "distributed actor (or system) decl must be provided");

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -270,17 +270,66 @@ deriveBodyDistributed_thunk(AbstractFunctionDecl *thunk, void *context) {
           C, recordArgumentDecl->getName());
 
       auto argumentName = param->getArgumentName().str();
-      auto recordArgArgsList = ArgumentList::forImplicitCallTo(
-          recordArgumentDeclRef->getName(),
+      LiteralExpr *argumentLabelArg;
+      if (argumentName.empty()) {
+        argumentLabelArg = new (C) NilLiteralExpr(sloc, implicit);
+      } else {
+        argumentLabelArg =
+            new (C) StringLiteralExpr(argumentName, SourceRange(), implicit);
+      }
+      auto parameterName = param->getParameterName().str();
+
+
+      // --- Prepare the RemoteCallArgument<Value> for the argument
+      auto argumentVarName = C.getIdentifier("_" + parameterName.str());
+      StructDecl *RCA = C.getRemoteCallArgumentDecl();
+      VarDecl *callArgVar =
+          new (C) VarDecl(/*isStatic=*/false, VarDecl::Introducer::Let, sloc,
+                          argumentVarName, thunk);
+      callArgVar->setImplicit();
+      callArgVar->setSynthesized();
+
+      Pattern *callArgPattern = NamedPattern::createImplicit(C, callArgVar);
+
+      auto remoteCallArgumentInitDecl =
+          RCA->getDistributedRemoteCallArgumentInitFunction();
+      auto boundRCAType = BoundGenericType::get(
+          RCA, Type(), {thunk->mapTypeIntoContext(param->getInterfaceType())});
+      auto remoteCallArgumentInitDeclRef =
+          TypeExpr::createImplicit(boundRCAType, C);
+
+      auto initCallArgArgs = ArgumentList::forImplicitCallTo(
+          DeclNameRef(remoteCallArgumentInitDecl->getEffectiveFullName()),
           {
-            // name:
-           new (C) StringLiteralExpr(argumentName, SourceRange(),
-                                     /*implicit=*/true),
-            // _ argument:
-            new (C) DeclRefExpr(
+           // label:
+           argumentLabelArg,
+           // name:
+           new (C) StringLiteralExpr(parameterName, SourceRange(), implicit),
+           // _ argument:
+           new (C) DeclRefExpr(
                ConcreteDeclRef(param), dloc, implicit,
                AccessSemantics::Ordinary,
                thunk->mapTypeIntoContext(param->getInterfaceType()))
+          },
+          C);
+
+      auto initCallArgCallExpr =
+          CallExpr::createImplicit(C, remoteCallArgumentInitDeclRef, initCallArgArgs);
+      initCallArgCallExpr->setImplicit();
+
+      auto callArgPB = PatternBindingDecl::createImplicit(
+          C, StaticSpellingKind::None, callArgPattern, initCallArgCallExpr, thunk);
+
+      remoteBranchStmts.push_back(callArgPB);
+      remoteBranchStmts.push_back(callArgVar);
+
+      /// --- Pass the argumentRepr to the recordArgument function
+      auto recordArgArgsList = ArgumentList::forImplicitCallTo(
+          recordArgumentDeclRef->getName(),
+          {
+              new (C) DeclRefExpr(
+                  ConcreteDeclRef(callArgVar), dloc, implicit,
+                  AccessSemantics::Ordinary)
           }, C);
 
       auto tryRecordArgExpr = TryExpr::createImplicit(C, sloc,

lib/Sema/TypeCheckDistributed.cpp

@@ -305,7 +305,7 @@ bool swift::checkDistributedActorSystemAdHocProtocolRequirements(
           decl->getDescriptiveKind(), decl->getName(), identifier);
       decl->diagnose(diag::note_distributed_actor_system_conformance_missing_adhoc_requirement,
                      decl->getName(), identifier,
-                     "mutating func recordArgument<Argument: SerializationRequirement>(name: String, _ argument: Argument) throws\n");
+                     "mutating func recordArgument<Value: SerializationRequirement>(_ argument: RemoteCallArgument<Value>) throws\n");
       anyMissingAdHocRequirements = true;
     }
     if (checkAdHocRequirementAccessControl(decl, Proto, recordArgumentDecl))
@@ -731,6 +731,48 @@ GetDistributedRemoteCallTargetInitFunctionRequest::evaluate(
   return nullptr;
 }
 
+ConstructorDecl*
+GetDistributedRemoteCallArgumentInitFunctionRequest::evaluate(
+    Evaluator &evaluator,
+    NominalTypeDecl *nominal) const {
+  auto &C = nominal->getASTContext();
+
+  // not via `ensureDistributedModuleLoaded` to avoid generating a warning,
+  // we won't be emitting the offending decl after all.
+  if (!C.getLoadedModule(C.Id_Distributed))
+    return nullptr;
+
+  if (!nominal->getDeclaredInterfaceType()->isEqual(
+          C.getRemoteCallArgumentType()))
+    return nullptr;
+
+  for (auto value : nominal->getMembers()) {
+    auto ctor = dyn_cast<ConstructorDecl>(value);
+    if (!ctor)
+      continue;
+
+    auto params = ctor->getParameters();
+    if (params->size() != 3)
+      return nullptr;
+
+    // --- param: label
+    if (!params->get(0)->getArgumentName().is("label"))
+      return nullptr;
+
+    // --- param: name
+    if (!params->get(1)->getArgumentName().is("name"))
+      return nullptr;
+
+    // --- param: value
+    if (params->get(2)->getArgumentName() != C.Id_value)
+      return nullptr;
+
+    return ctor;
+  }
+
+  return nullptr;
+}
+
 NominalTypeDecl *
 GetDistributedActorInvocationDecoderRequest::evaluate(Evaluator &evaluator,
                                                       NominalTypeDecl *actor) const {

stdlib/public/Distributed/DistributedActorSystem.swift

@@ -420,7 +420,9 @@ public protocol DistributedTargetInvocationEncoder {
 //  ///
 //  /// Record an argument of `Argument` type.
 //  /// This will be invoked for every argument of the target, in declaration order.
-//  mutating func recordArgument<Argument: SerializationRequirement>(_ argument: Argument) throws
+//  mutating func recordArgument<Value: SerializationRequirement>(
+//    _ argument: DistributedTargetArgument<Value>
+//  ) throws
 
   /// Record the error type of the distributed method.
   /// This method will not be invoked if the target is not throwing.
@@ -435,8 +437,47 @@ public protocol DistributedTargetInvocationEncoder {
   mutating func doneRecording() throws
 }
 
+/// Represents an argument passed to a distributed call target.
 @available(SwiftStdlib 5.7, *)
-public
+public struct RemoteCallArgument<Value> {
+  /// The "argument label" of the argument.
+  /// The label is the name visible name used in external calls made to this
+  /// target, e.g. for `func hello(label name: String)` it is `label`.
+  ///
+  /// If no label is specified (i.e. `func hi(name: String)`), the `label`,
+  /// value is empty, however `effectiveLabel` is equal to the `name`.
+  ///
+  /// In most situations, using `effectiveLabel` is more useful to identify
+  /// the user-visible name of this argument.
+  public let label: String?
+
+  /// The effective label of this argument, i.e. if no explicit `label` was set
+  /// this defaults to the `name`. This reflects the semantics of call sites of
+  /// function declarations without explicit label definitions in Swift.
+  public var effectiveLabel: String {
+    return label ?? name
+  }
+
+  /// The internal name of parameter this argument is accessible as in the
+  /// function body. It is not part of the functions API and may change without
+  /// breaking the target identifier.
+  ///
+  /// If the method did not declare an explicit `label`, it is used as the
+  /// `effectiveLabel`.
+  public let name: String
+
+  /// The value of the argument being passed to the call.
+  /// As `RemoteCallArgument` is always used in conjunction with
+  /// `recordArgument` and populated by the compiler, this Value will generally
+  /// conform to a distributed actor system's `SerializationRequirement`.
+  public let value: Value
+
+  public init(label: String?, name: String, value: Value) {
+    self.label = label
+    self.name = name
+    self.value = value
+  }
+}
 
 /// Decoder that must be provided to `executeDistributedTarget` and is used
 /// by the Swift runtime to decode arguments of the invocation.

stdlib/public/Distributed/LocalTestingDistributedActorSystem.swift

@@ -151,7 +151,7 @@ public struct LocalTestingInvocationEncoder: DistributedTargetInvocationEncoder
     fatalError("Attempted to call encoder method in a local-only actor system")
   }
 
-  public mutating func recordArgument<Argument: SerializationRequirement>(_ argument: Argument) throws {
+  public mutating func recordArgument<Value: SerializationRequirement>(_ argument: RemoteCallArgument<Value>) throws {
     fatalError("Attempted to call encoder method in a local-only actor system")
   }