prepare roundtrip test

Author: ktoso

stdlib/public/Concurrency/Actor.cpp

@@ -239,7 +239,7 @@ void swift::runJobInEstablishedExecutorContext(Job *job) {
     task->runInFullyEstablishedContext();
 
     assert(ActiveTask::get() == nullptr &&
-           "active task wasn't cleared before susspending?");
+           "active task wasn't cleared before suspending?");
   } else {
     // There's no extra bookkeeping to do for simple jobs besides swapping in
     // the voucher.
@@ -1726,11 +1726,7 @@ void ::swift_distributed_execute_target(
     void *argumentBuffer,
     void *resultBuffer) {
   auto *accessor = findDistributedAccessor(targetNameStart, targetNameLength);
-  if (!accessor) {
-    assert(false && "no distributed accessor accessor");
-    return;
-  }
-  fprintf(stderr, "[%s:%d] (%s) found accessor\n", __FILE__, __LINE__, __FUNCTION__);
+  assert(accessor && "no distributed accessor accessor");
 
   auto *asyncFnPtr = reinterpret_cast<
       const AsyncFunctionPointer<DistributedAccessorSignature> *>(

stdlib/public/Distributed/DistributedActorSystem.swift

@@ -124,10 +124,10 @@ public protocol DistributedActorSystem: Sendable {
 //  func remoteCall<Act, Err, Res>(
 //      on actor: Act,
 //      target: RemoteCallTarget,
-//      arguments: Invocation,
+//      invocation: Invocation,
 //      throwing: Err.Type,
 //      returning: Res.Type
-//  ) async throws -> Res.Type
+//  ) async throws -> Res
 //      where Act: DistributedActor,
 //            Act.ID == ActorID,
 //            Res: SerializationRequirement
@@ -205,8 +205,7 @@ extension DistributedActorSystem {
     guard decodedNum == paramCount else {
       throw ExecuteDistributedTargetError(
           message: """
-                   Failed to decode the expected number of params of distributed invocation target, error code: \(decodedNum)
-                   (decoded: \(decodedNum), expected params: \(paramCount)
+                   Failed to decode the expected [\(paramCount)] number of parameter types of distributed invocation target, error code: \(decodedNum); 
                    mangled name: \(mangledTargetName)
                    """)
     }
@@ -287,15 +286,16 @@ func _executeDistributedTarget(
 /// A distributed 'target' can be a `distributed func` or `distributed` computed property.
 @available(SwiftStdlib 5.6, *)
 public struct RemoteCallTarget {
-  let mangledName: String
+  public let mangledName: String
 
   // Only intended to be created by the _Distributed library.
-  internal init(mangledName: String) {
+  // TODO(distributed): make internal
+  public init(_mangledName mangledName: String) {
     self.mangledName = mangledName
   }
 
   // <module>.Base.hello(hi:)
-  var fullName: String {
+  public var fullName: String {
     fatalError("NOT IMPLEMENTED YET: \(#function)")
   }
 }

stdlib/public/runtime/MetadataLookup.cpp

@@ -1921,17 +1921,20 @@ swift_func_getParameterCount(const char *typeNameStart, size_t typeNameLength) {
   node = node->findByKind(Node::Kind::Function, /*maxDepth=*/2);
   if (!node) return -3;
 
-  node = node->findByKind(Node::Kind::Type, /*maxDepth=*/2);
-  if (!node) return -4;
-
   node = node->findByKind(Node::Kind::ArgumentTuple, /*maxDepth=*/3);
-  // Get the "deepest" Tuple from the ArgumentTuple, that's the arguments
-  while (node && node->getKind() != Node::Kind::Tuple) {
-    node = node->getFirstChild();
-  }
+  auto typeNode = node->findByKind(Node::Kind::Type, /*maxDepth=*/1);
+  if (!typeNode) return 0;
 
-  if (node) {
-    return node->getNumChildren();
+  assert(typeNode->getKind() == Node::Kind::Type);
+  if (auto paramsNode = typeNode->getFirstChild()) {
+    if (paramsNode->getKind() == Node::Kind::Tuple) {
+      return paramsNode->getNumChildren();
+    } else {
+      // it was some specific type e.g. Structure
+      return 1;
+    }
+  } else {
+    return -11;
   }
 
   return -5;
@@ -1994,17 +1997,9 @@ swift_func_getParameterTypeInfo(
   node = node->findByKind(Node::Kind::Type, /*maxDepth=*/2);
   if (!node) return -4;
 
+  auto argumentTuple = node->findByKind(Node::Kind::ArgumentTuple, /*maxDepth=*/3);
   node = node->findByKind(Node::Kind::ArgumentTuple, /*maxDepth=*/3);
-  // Get the "deepest" Tuple from the ArgumentTuple, that's the arguments
-  while (node && node->getKind() != Node::Kind::Tuple) {
-    node = node->getFirstChild();
-  }
-
-  // Only successfully return if the expected parameter count is the same
-  // as space prepared for it in the buffer.
-  if (!node || (node && node->getNumChildren() != typesLength)) {
-    return -5;
-  }
+  node = node->findByKind(Node::Kind::Type, /*maxDepth=*/1);
 
   DecodedMetadataBuilder builder(
       demangler,
@@ -2014,22 +2009,34 @@ swift_func_getParameterTypeInfo(
       [](const Metadata *, unsigned) { return nullptr; });
   TypeDecoder<DecodedMetadataBuilder> decoder(builder);
 
+  // --- Handle a single parameter:
+  if (!node) return -9;
+  if (node->getFirstChild() &&
+      node->getFirstChild()->getKind() != Node::Kind::Tuple) {
+    auto builtTypeOrError = decoder.decodeMangledType(argumentTuple);
+    if (builtTypeOrError.isError()) {
+      auto err = builtTypeOrError.getError();
+      char *errStr = err->copyErrorString();
+      err->freeErrorString(errStr);
+      return -10;
+    }
+
+    assert(typesLength == 1);
+    types[0] = builtTypeOrError.getType();
+    return 1;
+  }
+
+  // --- Handle multiple parameters:
+  node = node->findByKind(Node::Kind::Tuple, /*maxDepth=*/2);
   auto typeIdx = 0;
   // for each parameter (TupleElement), store it into the provided buffer
   for (auto tupleElement : *node) {
-    assert(tupleElement->getKind() == Node::Kind::TupleElement);
-    assert(tupleElement->getNumChildren() == 1);
-
-    auto typeNode = tupleElement->getFirstChild();
-    assert(typeNode->getKind() == Node::Kind::Type);
-
     auto builtTypeOrError = decoder.decodeMangledType(tupleElement);
     if (builtTypeOrError.isError()) {
       auto err = builtTypeOrError.getError();
       char *errStr = err->copyErrorString();
       err->freeErrorString(errStr);
-      typeIdx += 1;
-      continue;
+      return -20;
     }
 
     types[typeIdx] = builtTypeOrError.getType();

test/Distributed/Runtime/distributed_actor_remoteCall.swift

@@ -1,5 +1,5 @@
 // XXX: %target-swift-frontend -primary-file %s -emit-sil -parse-as-library -enable-experimental-distributed -disable-availability-checking | %FileCheck %s --enable-var-scope --dump-input=always
-// TODO: %target-run-simple-swift( -Xfrontend -module-name=main -Xfrontend -disable-availability-checking -Xfrontend -enable-experimental-distributed -parse-as-library) | %FileCheck %s --dump-input=always
+// RUN: %target-run-simple-swift( -Xfrontend -module-name=main -Xfrontend -disable-availability-checking -Xfrontend -enable-experimental-distributed -parse-as-library) | %FileCheck %s --dump-input=always
 
 // REQUIRES: executable_test
 // REQUIRES: concurrency