Make the actor identity type an associated type of ActorTransport

Eliminate the use of the type-erased `AnyActorIdentity` within the
distributed actor protocol by exposing the identity type of an actor
transport as an associated type, `Identity`, which is then used to
refer to all actors that have that transport.

Retain `AnyActorIdentity`, because it remains useful for type-erasing
actor transports, especially as the `Identity` type for
`AnyActorTransport`. For now, make it the default type of `Identity`:
this helps smooth over the transition from use of `AnyActorIdentity`,
but we might want to remove this to make use of the type-erased forms
always opt-in.

Author: DougGregor

lib/SILGen/SILGenDistributed.cpp

@@ -252,7 +252,6 @@ void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) {
   // ==== Prepare argument references
   // --- Parameter: identity
   SILArgument *identityArg = F.getArgument(0);
-  assert(identityArg->getType().getASTType()->isEqual(C.getAnyActorIdentityType()));
 
   // --- Parameter: transport
   SILArgument *transportArg = F.getArgument(1);

lib/Sema/DerivedConformanceDistributedActor.cpp

@@ -61,10 +61,10 @@ static FuncDecl *deriveDistributedActor_resolve(DerivedConformance &derived) {
     return param;
   };
 
-  auto addressType = C.getAnyActorIdentityDecl()->getDeclaredInterfaceType();
+  auto addressType = getDistributedActorIdentityType(decl);
   auto transportType = getDistributedActorTransportType(decl);
 
-  // (_ identity: AnyActorIdentity, using transport: ActorTransport)
+  // (_ identity: Identity, using transport: ActorTransport)
   auto *params = ParameterList::create(
       C,
       /*LParenLoc=*/SourceLoc(),
@@ -77,7 +77,7 @@ static FuncDecl *deriveDistributedActor_resolve(DerivedConformance &derived) {
   // Func name: resolve(_:using:)
   DeclName name(C, C.Id_resolve, params);
 
-  // Expected type: (Self) -> (AnyActorIdentity, ActorTransport) throws -> (Self)
+  // Expected type: (Self) -> (Identity, ActorTransport) throws -> (Self)
   auto *factoryDecl =
       FuncDecl::createImplicit(C, StaticSpellingKind::KeywordStatic,
                                name, SourceLoc(),
@@ -105,9 +105,9 @@ static ValueDecl *deriveDistributedActor_id(DerivedConformance &derived) {
 
   // ```
   // nonisolated
-  // let id: AnyActorIdentity
+  // let id: Identity
   // ```
-  auto propertyType = C.getAnyActorIdentityDecl()->getDeclaredInterfaceType();
+  auto propertyType = getDistributedActorIdentityType(derived.Nominal);
 
   VarDecl *propDecl;
   PatternBindingDecl *pbDecl;

lib/Sema/TypeCheckDistributed.cpp

@@ -257,3 +257,36 @@ Type swift::getDistributedActorTransportType(NominalTypeDecl *actor) {
   auto conformance = module->lookupConformance(selfType, protocol);
   return conformance.getTypeWitnessByName(selfType, ctx.Id_Transport);
 }
+
+Type swift::getDistributedActorIdentityType(NominalTypeDecl *actor) {
+  assert(actor->isDistributedActor());
+  auto &ctx = actor->getASTContext();
+
+  auto actorProtocol = ctx.getProtocol(KnownProtocolKind::DistributedActor);
+  if (!actorProtocol)
+    return ErrorType::get(ctx);
+
+  AssociatedTypeDecl *transportDecl =
+      actorProtocol->getAssociatedType(ctx.Id_Transport);
+  if (!transportDecl)
+    return ErrorType::get(ctx);
+
+  auto transportProtocol = ctx.getProtocol(KnownProtocolKind::ActorTransport);
+  if (!transportProtocol)
+    return ErrorType::get(ctx);
+
+  AssociatedTypeDecl *identityDecl =
+      transportProtocol->getAssociatedType(ctx.getIdentifier("Identity"));
+  if (!identityDecl)
+    return ErrorType::get(ctx);
+
+  auto module = actor->getParentModule();
+  Type selfType = actor->getSelfInterfaceType();
+  auto conformance = module->lookupConformance(selfType, actorProtocol);
+  Type dependentType = actorProtocol->getSelfInterfaceType();
+  dependentType = DependentMemberType::get(dependentType, transportDecl);
+  dependentType = DependentMemberType::get(dependentType, identityDecl);
+  return dependentType.subst(
+      SubstitutionMap::getProtocolSubstitutions(
+        actorProtocol, selfType, conformance));
+}

lib/Sema/TypeCheckDistributed.h

@@ -48,6 +48,9 @@ bool checkDistributedFunction(FuncDecl *decl, bool diagnose);
 /// Determine the distributed actor transport type for the given actor.
 Type getDistributedActorTransportType(NominalTypeDecl *actor);
 
+/// Determine the distributed actor identity type for the given actor.
+Type getDistributedActorIdentityType(NominalTypeDecl *actor);
+
 /// Diagnose a distributed func declaration in a not-distributed actor protocol.
 void diagnoseDistributedFunctionInNonDistributedActorProtocol(
   const ProtocolDecl *proto, InFlightDiagnostic &diag);

stdlib/public/Distributed/ActorTransport.swift

@@ -15,18 +15,20 @@ import _Concurrency
 
 @available(SwiftStdlib 5.6, *)
 public protocol ActorTransport: Sendable {
+  /// The identity used by actors that communicate via this transport
+  associatedtype Identity: ActorIdentity = AnyActorIdentity
 
   // ==== ---------------------------------------------------------------------
   // - MARK: Resolving actors by identity
 
-  /// Upon decoding of a `AnyActorIdentity` this function will be called
+  /// Upon decoding of an `Identity` this function will be called
   /// on the transport that is set un the Decoder's `userInfo` at decoding time.
   /// This user info is to be set by the transport, as it receives messages and
   /// attempts decoding them. This way, messages received on a specific transport
   /// (which may be representing a connection, or general transport mechanism)
   /// is able to utilize local knowledge and type information about what kind of
   /// identity to attempt to decode.
-  func decodeIdentity(from decoder: Decoder) throws -> AnyActorIdentity
+  func decodeIdentity(from decoder: Decoder) throws -> Identity
 
   /// Resolve a local or remote actor address to a real actor instance, or throw if unable to.
   /// The returned value is either a local actor or proxy to a remote actor.
@@ -48,7 +50,7 @@ public protocol ActorTransport: Sendable {
   ///
   /// Detecting liveness of such remote actors shall be offered / by transport libraries
   /// by other means, such as "watching an actor for termination" or similar.
-  func resolve<Act>(_ identity: AnyActorIdentity, as actorType: Act.Type) throws -> Act?
+  func resolve<Act>(_ identity: Identity, as actorType: Act.Type) throws -> Act?
       where Act: DistributedActor
 
   // ==== ---------------------------------------------------------------------
@@ -64,37 +66,63 @@ public protocol ActorTransport: Sendable {
   /// E.g. if an actor is created under address `addr1` then immediately invoking
   /// `transport.resolve(address: addr1, as: Greeter.self)` MUST return a reference
   /// to the same actor.
-  func assignIdentity<Act>(_ actorType: Act.Type) -> AnyActorIdentity
+  func assignIdentity<Act>(_ actorType: Act.Type) -> Identity
       where Act: DistributedActor
 
   func actorReady<Act>(_ actor: Act)
       where Act: DistributedActor
 
   /// Called during actor deinit/destroy.
-  func resignIdentity(_ id: AnyActorIdentity)
+  func resignIdentity(_ id: Identity)
+}
+
+@available(SwiftStdlib 5.6, *)
+extension ActorTransport {
+  /// Try to resolve based on a type-erased actor identity.
+  func resolve<Act>(
+    anyIdentity identity: AnyActorIdentity, as actorType: Act.Type
+  ) throws -> Act? where Act: DistributedActor {
+    return try resolve(identity.underlying as! Identity, as: actorType)
+  }
+
+  /// Try to resign based on a type-erased actor identity.
+  func resignAnyIdentity(_ id: AnyActorIdentity) {
+    resignIdentity(id.underlying as! Identity)
+  }
+
+  func decodeAnyIdentity(from decoder: Decoder) throws -> AnyActorIdentity {
+    AnyActorIdentity(try decodeIdentity(from: decoder))
+  }
+
+  func assignAnyIdentity<Act>(_ actorType: Act.Type) -> AnyActorIdentity
+      where Act: DistributedActor {
+    return AnyActorIdentity(assignIdentity(actorType))
+  }
 }
 
 @available(SwiftStdlib 5.6, *)
 public struct AnyActorTransport: ActorTransport {
+  public typealias Identity = AnyActorIdentity
+
   let transport: ActorTransport
 
   public init<Transport: ActorTransport>(_ transport: Transport) {
     self.transport = transport
   }
 
-  public func decodeIdentity(from decoder: Decoder) throws -> AnyActorIdentity {
-    return try transport.decodeIdentity(from: decoder)
+  public func decodeIdentity(from decoder: Decoder) throws -> Identity {
+    return try transport.decodeAnyIdentity(from: decoder)
   }
 
   public func resolve<Act>(
-    _ identity: AnyActorIdentity, as actorType: Act.Type
+    _ identity: Identity, as actorType: Act.Type
   ) throws -> Act? where Act: DistributedActor {
-    return try transport.resolve(identity, as: actorType)
+    return try transport.resolve(anyIdentity: identity, as: actorType)
   }
 
-  public func assignIdentity<Act>(_ actorType: Act.Type) -> AnyActorIdentity
+  public func assignIdentity<Act>(_ actorType: Act.Type) -> Identity
       where Act: DistributedActor {
-    return transport.assignIdentity(actorType)
+    return transport.assignAnyIdentity(actorType)
   }
 
   public func actorReady<Act>(_ actor: Act)
@@ -103,8 +131,8 @@ public struct AnyActorTransport: ActorTransport {
   }
 
   /// Called during actor deinit/destroy.
-  public func resignIdentity(_ id: AnyActorIdentity) {
-    transport.resignIdentity(id)
+  public func resignIdentity(_ id: Identity) {
+    transport.resignAnyIdentity(id)
   }
 }
 

stdlib/public/Distributed/DistributedActor.swift

@@ -39,6 +39,9 @@ public protocol DistributedActor:
     /// The type of transport used to communicate with actors of this type.
     associatedtype Transport: ActorTransport
 
+    /// The type of identity used by the transport.
+    typealias Identity = Transport.Identity
+
     /// Resolves the passed in `identity` against the `transport`, returning
     /// either a local or remote actor reference.
     ///
@@ -51,11 +54,7 @@ public protocol DistributedActor:
     ///
     /// - Parameter identity: identity uniquely identifying a, potentially remote, actor in the system
     /// - Parameter transport: `transport` which should be used to resolve the `identity`, and be associated with the returned actor
-// FIXME: Partially blocked on SE-309, because then we can store ActorIdentity directly
-//        We want to move to accepting a generic or existential identity here
-//    static func resolve<Identity>(_ identity: Identity, using transport: ActorTransport)
-//      throws -> Self where Identity: ActorIdentity
-    static func resolve(_ identity: AnyActorIdentity, using transport: Transport)
+    static func resolve(_ identity: Identity, using transport: Transport)
       throws -> Self
 
     /// The `ActorTransport` associated with this actor.
@@ -77,7 +76,7 @@ public protocol DistributedActor:
     ///
     /// Conformance to this requirement is synthesized automatically for any
     /// `distributed actor` declaration.
-    nonisolated var id: AnyActorIdentity { get }
+    nonisolated var id: Identity { get }
 }
 
 // ==== Hashable conformance ---------------------------------------------------
@@ -109,7 +108,7 @@ extension DistributedActor {
         "in Decoder.userInfo, while decoding \(Self.self).")
     }
 
-    let id: AnyActorIdentity = try transport.decodeIdentity(from: decoder)
+    let id: Identity = try transport.decodeIdentity(from: decoder)
     self = try Self.resolve(id, using: transport)
   }
 
@@ -151,6 +150,7 @@ public protocol ActorIdentity: Sendable, Hashable, Codable {}
 
 @available(SwiftStdlib 5.6, *)
 public struct AnyActorIdentity: ActorIdentity, @unchecked Sendable, CustomStringConvertible {
+  // FIXME: This probably shouldn't be public
   public let underlying: Any
   @usableFromInline let _hashInto: (inout Hasher) -> ()
   @usableFromInline let _equalTo: (Any) -> Bool
@@ -186,7 +186,7 @@ public struct AnyActorIdentity: ActorIdentity, @unchecked Sendable, CustomString
           "ActorTransport not available under the decoder.userInfo")
     }
 
-    self = try transport.decodeIdentity(from: decoder)
+    self = try transport.decodeAnyIdentity(from: decoder)
   }
 
   public func encode(to encoder: Encoder) throws {

test/Distributed/SIL/distributed_actor_default_deinit_sil.swift

@@ -32,7 +32,7 @@ distributed actor MyDistActor {
 // CHECK: [[LOCAL_BB]]:
 // CHECK:   [[ID_REF:%[0-9]+]] = ref_element_addr [[SELF]] : $MyDistActor, #MyDistActor.id
 // CHECK:   [[TPORT_REF:%[0-9]+]] = ref_element_addr [[SELF]] : $MyDistActor, #MyDistActor.actorTransport
-// CHECK:   [[RESIGN:%[0-9]+]] = witness_method $AnyActorTransport, #ActorTransport.resignIdentity : <Self where Self : ActorTransport> (Self) -> (AnyActorIdentity) -> ()
+// CHECK:   [[RESIGN:%[0-9]+]] = witness_method $AnyActorTransport, #ActorTransport.resignIdentity : <Self where Self : ActorTransport> (Self) -> (Self.Identity) -> ()
 // CHECK:   apply [[RESIGN]]<AnyActorTransport>([[ID_REF]], [[TPORT_REF]])
 // CHECK:   br [[CONTINUE:bb[0-9]+]]
 

test/Distributed/SIL/distributed_actor_default_init_sil.swift

@@ -22,7 +22,7 @@ distributed actor MyDistActor {
                 // *** obtain an identity ***
 // CHECK:    [[SELF_METATYPE:%[0-9]+]] = metatype $@thick MyDistActor.Type
 // CHECK:    [[ID_STACK:%[0-9+]+]] = alloc_stack $AnyActorIdentity
-// CHECK:    [[ASSIGN_ID_FN:%[0-9]+]] = witness_method $AnyActorTransport, #ActorTransport.assignIdentity : <Self where Self : ActorTransport><Act where Act : DistributedActor> (Self) -> (Act.Type) -> AnyActorIdentity
+// CHECK:    [[ASSIGN_ID_FN:%[0-9]+]] = witness_method $AnyActorTransport, #ActorTransport.assignIdentity : <Self where Self : ActorTransport><Act where Act : DistributedActor> (Self) -> (Act.Type) -> Self.Identity
 // CHECK:    = apply [[ASSIGN_ID_FN]]<AnyActorTransport, MyDistActor>([[ID_STACK]], [[SELF_METATYPE]], [[TPORT]])
                 // *** save identity ***
 // CHECK:    [[ID_FIELD:%[0-9]+]] = ref_element_addr [[SELF]] : $MyDistActor, #MyDistActor.id