[Distributed] better test for SIL lifetime with AddressOnly types

Author: ktoso

test/Distributed/Inputs/FakeDistributedActorSystems.swift

@@ -34,6 +34,36 @@ public struct ActorAddress: Hashable, Sendable, Codable {
   }
 }
 
+/// This type is same as ActorAddress however for purposes of SIL tests we make it not-loadable.
+///
+/// By adding the `Any` we don't know the full size of the struct making the type in SIL `$*ActorAddress`
+/// when we try to store or pass it around, which triggers `isAddressOnly` guarded paths which we need to test.
+public struct NotLoadableActorAddress: Hashable, Sendable, Codable {
+  public let address: String
+  public let any: Sendable = "" // DO NOT REMOVE, this makes this struct address-only which is crucial for testing.
+
+  public init(parse address: String) {
+    self.address = address
+  }
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.singleValueContainer()
+    self.address = try container.decode(String.self)
+  }
+
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    try container.encode(self.address)
+  }
+
+  public func hash(into hasher: inout Swift.Hasher) {
+  }
+
+  public static func ==(lhs: NotLoadableActorAddress, rhs: NotLoadableActorAddress) -> Bool {
+    lhs.address == rhs.address
+  }
+}
+
 // ==== Noop Transport ---------------------------------------------------------
 
 @available(SwiftStdlib 5.7, *)
@@ -109,9 +139,81 @@ public struct FakeActorSystem: DistributedActorSystem, CustomStringConvertible {
   }
 }
 
+@available(SwiftStdlib 5.7, *)
+public struct FakeNotLoadableAddressActorSystem: DistributedActorSystem, CustomStringConvertible {
+  public typealias ActorID = NotLoadableActorAddress
+  public typealias InvocationDecoder = FakeInvocationDecoder
+  public typealias InvocationEncoder = FakeInvocationEncoder
+  public typealias SerializationRequirement = Codable
+  public typealias ResultHandler = FakeRoundtripResultHandler
+
+  // just so that the struct does not become "trivial"
+  let someValue: String = ""
+  let someValue2: String = ""
+  let someValue3: String = ""
+  let someValue4: String = ""
+
+  public init() {
+    print("Initialized new FakeActorSystem")
+  }
+
+  public func resolve<Act>(id: ActorID, as actorType: Act.Type) throws -> Act?
+      where Act: DistributedActor,
+      Act.ID == ActorID  {
+    nil
+  }
+
+  public func assignID<Act>(_ actorType: Act.Type) -> ActorID
+      where Act: DistributedActor,
+      Act.ID == ActorID {
+    NotLoadableActorAddress(parse: "xxx")
+  }
+
+  public func actorReady<Act>(_ actor: Act)
+      where Act: DistributedActor,
+            Act.ID == ActorID {
+  }
+
+  public func resignID(_ id: ActorID) {
+  }
+
+  public func makeInvocationEncoder() -> InvocationEncoder {
+    .init()
+  }
+
+  public func remoteCall<Act, Err, Res>(
+      on actor: Act,
+      target: RemoteCallTarget,
+      invocation invocationEncoder: inout InvocationEncoder,
+      throwing: Err.Type,
+      returning: Res.Type
+  ) async throws -> Res
+    where Act: DistributedActor,
+          Act.ID == ActorID,
+          Err: Error,
+          Res: SerializationRequirement {
+    throw ExecuteDistributedTargetError(message: "\(#function) not implemented.")
+  }
+
+  public func remoteCallVoid<Act, Err>(
+    on actor: Act,
+    target: RemoteCallTarget,
+    invocation invocationEncoder: inout InvocationEncoder,
+    throwing: Err.Type
+  ) async throws
+    where Act: DistributedActor,
+          Act.ID == ActorID,
+          Err: Error {
+    throw ExecuteDistributedTargetError(message: "\(#function) not implemented.")
+  }
+
+  public nonisolated var description: Swift.String {
+    "\(Self.self)()"
+  }
+}
+
 // ==== Fake Roundtrip Transport -----------------------------------------------
 
-// TODO(distributed): not thread safe...
 @available(SwiftStdlib 5.7, *)
 public final class FakeRoundtripActorSystem: DistributedActorSystem, @unchecked Sendable {
   public typealias ActorID = ActorAddress

test/Distributed/SIL/distributed_id_system_ownership_verify_sil.swift

@@ -0,0 +1,52 @@
+// 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-swift-frontend -verify -emit-sil -module-name main -disable-availability-checking -parse-as-library -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift | %FileCheck %s
+
+// 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
+
+/// This type uses a non loadable (size not known at compile time) ID which forces the actor's init SILGen
+/// to make use of the isAddressOnly handling of the ID assignments.
+///
+/// This test covers rdar://104583893 / https://github.com/apple/swift/issues/62898
+/// And used to fail with:
+///     SIL memory lifetime failure in @$s18DistributedCluster0B16EventStreamActorC11actorSystemAcA0bG0C_tcfc: memory is initialized, but shouldn't be
+typealias DefaultDistributedActorSystem = FakeNotLoadableAddressActorSystem
+
+distributed actor Greeter {
+
+  init(actorSystem: ActorSystem) {
+    self.actorSystem = actorSystem
+  }
+
+  distributed func echo(name: String) -> String {
+    return "Echo: \(name)"
+  }
+}
+
+// CHECK: sil hidden @$s4main7GreeterC7resolve2id5usingAcA23NotLoadableActorAddressV_AA04FakefgiH6SystemVtKFZ : $@convention(method) (@in_guaranteed NotLoadableActorAddress, @guaranteed FakeNotLoadableAddressActorSystem, @thick Greeter.Type) -> (@owned Greeter, @error any Error) {
+// CHECK: bb0([[ADDRESS_ARG:%[0-9]+]] : $*NotLoadableActorAddress, [[SYSTEM_ARG:%[0-9]+]] : $FakeNotLoadableAddressActorSystem, [[TYPE_ARG:%[0-9]+]] : $@thick Greeter.Type):
+// CHECK: [[TYPE:%[0-9]+]] = metatype $@thick Greeter.Type
+
+// CHECK: // makeProxyBB
+// CHECK: [[INSTANCE:%[0-9]+]] = builtin "initializeDistributedRemoteActor"([[TYPE]] : $@thick Greeter.Type) : $Greeter
+// CHECK: [[ID_PROPERTY:%[0-9]+]] = ref_element_addr [[INSTANCE]] : $Greeter, #Greeter.id
+// Note specifically that we don't [take] in the below copy_addr:
+// CHECK: copy_addr [[ADDRESS_ARG]] to [init] [[ID_PROPERTY]] : $*NotLoadableActorAddress
+
+func test() async throws {
+  let system = DefaultDistributedActorSystem()
+
+  let local = Greeter(actorSystem: system)
+  _ = try await local.echo(name: "Caplin")
+}