[Distributed] Runtime: Implement _executeDistributedTarget

The implementation is as follows:

- Looks up distributed accessor by the given target name
- Extracts information required to setup async context from
  async function pointer stored in accessor record
- Allocates context and calls accessor

Author: xedin

stdlib/public/Concurrency/Actor.cpp

@@ -2016,16 +2016,63 @@ findDistributedAccessor(const char *targetNameStart, size_t targetNameLength) {
   return nullptr;
 }
 
+/// func _executeDistributedTarget(
+///    on: AnyObject,
+///    _ targetName: UnsafePointer<UInt8>,
+///    _ targetNameLength: UInt,
+///    argumentBuffer: Builtin.RawPointer,
+///    resultBuffer: Builtin.RawPointer) async throws
+using TargetExecutorSignature =
+    AsyncSignature<void(DefaultActor *, const char *, size_t, void *, void *),
+                   /*throws=*/true>;
+
+SWIFT_CC(swiftasync)
+SWIFT_RUNTIME_STDLIB_SPI
+TargetExecutorSignature::FunctionType swift_distributed_execute_target;
+
+/// Accessor takes a context, an argument buffer as a raw pointer,
+/// and a reference to an actor.
+using DistributedAccessorSignature = AsyncSignature<void(void *, HeapObject *),
+                                                    /*throws=*/true>;
+
+SWIFT_CC(swiftasync)
+static DistributedAccessorSignature::ContinuationType
+    swift_distributed_execute_target_resume;
+
+SWIFT_CC(swiftasync)
+static void ::swift_distributed_execute_target_resume(
+    SWIFT_ASYNC_CONTEXT AsyncContext *context, SWIFT_CONTEXT void *error) {
+  auto parentCtx = context->Parent;
+  auto resumeInParent =
+      reinterpret_cast<TargetExecutorSignature::ContinuationType *>(
+          parentCtx->ResumeParent);
+  swift_task_dealloc(context);
+  return resumeInParent(parentCtx, error);
+}
+
 SWIFT_CC(swiftasync)
-void swift_distributed_execute_target(
-    OpaqueValue *resultPointer,
-    SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
-    DefaultActor *actor,
-    const char *targetNameStart, size_t targetNameLength,
-    void *argumentBuffer,
-    void *resultBuffer,
-    ThrowingTaskFutureWaitContinuationFunction *resumeFn,
-    AsyncContext *callContext) {
+void ::swift_distributed_execute_target(
+    SWIFT_ASYNC_CONTEXT AsyncContext *callerContext, DefaultActor *actor,
+    const char *targetNameStart, size_t targetNameLength, void *argumentBuffer,
+    void *resultBuffer) {
   auto *accessor = findDistributedAccessor(targetNameStart, targetNameLength);
-  (void)accessor;
+
+  if (!accessor)
+    return;
+
+  auto *asyncFnPtr = reinterpret_cast<
+      const AsyncFunctionPointer<DistributedAccessorSignature> *>(accessor);
+
+  DistributedAccessorSignature::FunctionType *accessorEntry =
+      asyncFnPtr->Function.get();
+
+  AsyncContext *calleeContext = reinterpret_cast<AsyncContext *>(
+      swift_task_alloc(asyncFnPtr->ExpectedContextSize));
+
+  calleeContext->Parent = callerContext;
+  calleeContext->ResumeParent = reinterpret_cast<TaskContinuationFunction *>(
+      swift_distributed_execute_target_resume);
+
+  // TODO: Add resultBuffer as an argument to store an indirect result into.
+  accessorEntry(calleeContext, argumentBuffer, actor);
 }

stdlib/public/Distributed/DistributedActor.swift

@@ -187,6 +187,7 @@ func _distributedActorRemoteInitialize(_ actorType: Builtin.RawPointer) -> Any
 
 // ==== Remote target accesss -------------------------------------------------
 
+@available(SwiftStdlib 5.6, *)
 @_silgen_name("swift_distributed_execute_target")
 func _executeDistributedTarget(
     on: AnyObject,