more tests

Author: ktoso

test/Distributed/Inputs/FakeDistributedActorSystems.swift

@@ -406,13 +406,32 @@ public struct FakeInvocationEncoder : DistributedTargetInvocationEncoder {
 
 // === decoding --------------------------------------------------------------
 
+class Guardian {
+  let type: String
+  let file: String
+  let line: UInt
+
+  init(_ type: any Any.Type, file: String = #fileID, line: UInt = #line) {
+    self.type = "\(type)"
+    self.file = file
+    self.line = line
+    print("init Guardian(\(type)) @ \(file):\(line)")
+  }
+
+  deinit {
+    print("deinit Guardian(\(type)) @ \(file):\(line)")
+  }
+}
+
 // !!! WARNING !!!
 // This is a 'final class' on purpose, to see that we retain the ad-hoc witness
 // for 'decodeNextArgument'; Do not change it to just a class!
 @available(SwiftStdlib 5.7, *)
 public final class FakeInvocationDecoder: DistributedTargetInvocationDecoder {
   public typealias SerializationRequirement = Codable
 
+  let x = Guardian(FakeInvocationDecoder.self)
+
   var genericSubs: [Any.Type] = []
   var arguments: [Any] = []
   var returnType: Any.Type? = nil
@@ -447,6 +466,8 @@ public final class FakeInvocationDecoder: DistributedTargetInvocationDecoder {
       fatalError("Cannot cast argument\(anyArgument) to expected \(Argument.self)")
     }
 
+    arguments = []
+
     print("  > decode argument: \(argument)")
     argumentIndex += 1
     return argument

test/Distributed/Runtime/distributed_actor_func_calls_decoded_args_deinit.swift

@@ -0,0 +1,60 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -disable-availability-checking %S/../Inputs/FakeDistributedActorSystems.swift
+// RUN: %target-build-swift -module-name main  -Xfrontend -disable-availability-checking -j2 -parse-as-library -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s --color --dump-input=always
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+// rdar://76038845
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: back_deployment_runtime
+
+// FIXME(distributed): Distributed actors currently have some issues on windows, isRemote always returns false. rdar://82593574
+// UNSUPPORTED: OS=windows-msvc
+
+import Distributed
+import FakeDistributedActorSystems
+
+typealias DefaultDistributedActorSystem = FakeRoundtripActorSystem
+
+final class SomeClass<T>: Sendable, Codable {
+  init() {
+    print("SomeClass: init")
+  }
+  deinit {
+    print("SomeClass: deinit")
+  }
+}
+
+struct S<T> : Codable {
+  var data: SomeClass<T>
+}
+
+distributed actor Greeter {
+  distributed func test1<T>(_: SomeClass<T>) {}
+  distributed func test2<T>(_: S<T>) {}
+}
+
+func test() async throws {
+  let system = DefaultDistributedActorSystem()
+
+  let local = Greeter(actorSystem: system)
+  let ref = try Greeter.resolve(id: local.id, using: system)
+
+  try await ref.test1(SomeClass<Int>())
+  // CHECK: SomeClass: init
+  // CHECK: SomeClass: deinit
+
+//  try await ref.test2(S(data: SomeClass<Int>()))
+  // CHECK: SomeClass: init
+  // CHECK: SomeClass: deinit
+}
+
+@main struct Main {
+  static func main() async {
+    try! await test()
+  }
+}

test/Distributed/distributed_actor_thunk_doesnt_leak_class_arguments.swift

@@ -1,5 +1,5 @@
 // RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -disable-availability-checking %S/Inputs/FakeDistributedActorSystems.swift
-// RUN: %target-swift-frontend -module-name no_to_arg_leaks -emit-irgen -disable-availability-checking -I %t 2>&1 %s | %IRGenFileCheck %s -check-prefix CHECK-%target-import-type
+// RUN: %target-swift-frontend -module-name no_to_arg_leaks -emit-irgen -disable-availability-checking -I %t 2>&1 %s | %IRGenFileCheck %s -check-prefix CHECK-%target-import-type --dump-input=always
 
 // UNSUPPORTED: back_deploy_concurrency
 // REQUIRES: concurrency