[Distributed] Pass arguments from Invocation to HBuffer

Author: ktoso

stdlib/public/Distributed/DistributedActorSystem.swift

@@ -224,12 +224,12 @@ extension DistributedActorSystem {
       return UnsafeRawPointer(UnsafeMutablePointer<R>.allocate(capacity: 1))
     }
 
-    guard let returnType: Any.Type = _getReturnTypeInfo(mangledMethodName: mangledTargetName) else {
+    guard let returnTypeFromTypeInfo: Any.Type = _getReturnTypeInfo(mangledMethodName: mangledTargetName) else {
       throw ExecuteDistributedTargetError(
         message: "Failed to decode distributed target return type")
     }
 
-    guard let resultBuffer = _openExistential(returnType, do: allocateReturnTypeBuffer) else {
+    guard let resultBuffer = _openExistential(returnTypeFromTypeInfo, do: allocateReturnTypeBuffer) else {
       throw ExecuteDistributedTargetError(
         message: "Failed to allocate buffer for distributed target return type")
     }
@@ -239,7 +239,7 @@ extension DistributedActorSystem {
     }
 
     defer {
-      _openExistential(returnType, do: destroyReturnTypeBuffer)
+      _openExistential(returnTypeFromTypeInfo, do: destroyReturnTypeBuffer)
     }
 
     // Prepare the buffer to decode the argument values into
@@ -250,6 +250,33 @@ extension DistributedActorSystem {
     }
 
     do {
+      // Decode the invocation and pack arguments into the h-buffer
+
+      // TODO(distributed): decode the generics info
+      var argumentDecoder = invocation.makeArgumentDecoder()
+      var paramIdx = 0
+      for unsafeRawArgPointer in hargs {
+        guard paramIdx < paramCount else {
+          throw ExecuteDistributedTargetError(
+            message: "Unexpected attempt to decode more parameters than expected: \(paramIdx + 1)")
+        }
+        let paramType = paramTypes[paramIdx]
+        paramIdx += 1
+
+        // FIXME(distributed): func doDecode<Arg: SerializationRequirement>(_: Arg.Type) throws {
+        // FIXME:     but how would we call this...?
+        // FIXME:     > type 'Arg' constrained to non-protocol, non-class type 'Self.Invocation.SerializationRequirement'
+        func doDecodeArgument<Arg>(_: Arg.Type) throws {
+          let unsafeArgPointer = unsafeRawArgPointer
+            .bindMemory(to: Arg.self, capacity: 1)
+          try argumentDecoder.decodeNext(Arg.self, into: unsafeArgPointer)
+        }
+        try _openExistential(paramType, do: doDecodeArgument)
+      }
+
+       let returnType = try invocation.decodeReturnType() ?? returnTypeFromTypeInfo
+       // let errorType = try invocation.decodeErrorType() // TODO: decide how to use?
+
       // Execute the target!
       try await _executeDistributedTarget(
         on: actor,

test/Distributed/Runtime/distributed_actor_remoteCall.swift

@@ -47,10 +47,15 @@ distributed actor Greeter {
     .init(q: "question", a: 42, b: 1, c: 2.0, d: "Lorum ipsum")
   }
 
+  distributed func echo(name: String) -> String {
+    return "Echo: \(name)"
+  }
+
   distributed func enumResult() -> E {
     .bar
   }
 
+
   distributed func test(i: Int, s: String) -> String {
     return s
   }
@@ -142,25 +147,47 @@ struct FakeInvocation: DistributedTargetInvocation {
   typealias ArgumentDecoder = FakeArgumentDecoder
   typealias SerializationRequirement = Codable
 
+  var arguments: [Any] = []
+
   mutating func recordGenericSubstitution<T>(_ type: T.Type) throws {}
-  mutating func recordArgument<Argument: SerializationRequirement>(argument: Argument) throws {}
+  mutating func recordArgument<Argument: SerializationRequirement>(argument: Argument) throws {
+    arguments.append(argument)
+  }
   mutating func recordReturnType<R: SerializationRequirement>(_ type: R.Type) throws {}
   mutating func recordErrorType<E: Error>(_ type: E.Type) throws {}
   mutating func doneRecording() throws {}
 
   // === Receiving / decoding -------------------------------------------------
 
   mutating func decodeGenericSubstitutions() throws -> [Any.Type] { [] }
-  func makeArgumentDecoder() -> FakeArgumentDecoder { .init() }
+  func makeArgumentDecoder() -> FakeArgumentDecoder {
+    .init(invocation: self)
+  }
   mutating func decodeReturnType() throws -> Any.Type? { nil }
   mutating func decodeErrorType() throws -> Any.Type? { nil }
 
   struct FakeArgumentDecoder: DistributedTargetInvocationArgumentDecoder {
     typealias SerializationRequirement = Codable
+    let invocation: FakeInvocation
+    var index: Int = 0
+
     mutating func decodeNext<Argument>(
       _ argumentType: Argument.Type,
       into pointer: UnsafeMutablePointer<Argument>
-    ) throws {}
+    ) throws {
+      guard index < invocation.arguments.count else {
+        fatalError("Attempted to decode more arguments than stored! Index: \(index), args: \(invocation.arguments)")
+      }
+
+      let anyArgument = invocation.arguments[index]
+      guard let argument = anyArgument as? Argument else {
+        fatalError("Cannot cast argument\(anyArgument) to expected \(Argument.self)")
+      }
+
+      print("  > argument: \(argument)")
+      pointer.pointee = argument
+      index += 1
+    }
   }
 }
 
@@ -184,7 +211,9 @@ let emptyName = "$s4main7GreeterC5emptyyyFTE"
 let helloName = "$s4main7GreeterC5helloSSyFTE"
 let answerName = "$s4main7GreeterC6answerSiyFTE"
 let largeResultName = "$s4main7GreeterC11largeResultAA11LargeStructVyFTE"
-let enumResult = "$s4main7GreeterC10enumResultAA1EOyFTE"
+let enumResultName = "$s4main7GreeterC10enumResultAA1EOyFTE"
+
+let echoName = "$s4main7GreeterC4echo4nameS2S_tFTE"
 
 func test() async throws {
   let system = FakeActorSystem()
@@ -200,7 +229,6 @@ func test() async throws {
     invocation: &invocation,
     handler: FakeResultHandler()
   )
-
   // CHECK: RETURN: ()
 
   try await system.executeDistributedTarget(
@@ -209,7 +237,6 @@ func test() async throws {
       invocation: &invocation,
       handler: FakeResultHandler()
   )
-
   // CHECK: RETURN: Hello, World!
 
   try await system.executeDistributedTarget(
@@ -218,7 +245,6 @@ func test() async throws {
       invocation: &invocation,
       handler: FakeResultHandler()
   )
-
   // CHECK: RETURN: 42
 
   try await system.executeDistributedTarget(
@@ -227,17 +253,27 @@ func test() async throws {
       invocation: &invocation,
       handler: FakeResultHandler()
   )
-
   // CHECK: RETURN: LargeStruct(q: "question", a: 42, b: 1, c: 2.0, d: "Lorum ipsum")
 
   try await system.executeDistributedTarget(
       on: local,
-      mangledTargetName: enumResult,
+      mangledTargetName: enumResultName,
       invocation: &invocation,
       handler: FakeResultHandler()
   )
   // CHECK: RETURN: bar
 
+  var echoInvocation = system.makeInvocation()
+  try echoInvocation.recordArgument(argument: "Caplin")
+  try echoInvocation.doneRecording()
+  try await system.executeDistributedTarget(
+      on: local,
+      mangledTargetName: echoName,
+      invocation: &echoInvocation,
+      handler: FakeResultHandler()
+  )
+  // CHECK: RETURN: Echo: Caplin
+
   // CHECK-NEXT: done
   print("done")
 }