[Distributed] Implement assigning address in SIL

Author: ktoso

include/swift/AST/DiagnosticsSema.def

@@ -4558,27 +4558,6 @@ ERROR(actor_instance_property_wrapper,none,
 ERROR(distributed_actor_func_defined_outside_of_distributed_actor,none,
       "distributed function %0 is declared outside of an distributed actor",
       (DeclName))
-ERROR(distributed_actor_local_init_explicitly_defined,none,
-      "'distributed actor' local-initializer 'init(transport:)' "
-      "cannot be implemented explicitly.",
-      ())
-ERROR(distributed_actor_init_resolve_must_not_be_user_defined,none,
-      "'distributed actor' resolve-initializer 'init(resolve:using:)' "
-      "cannot be implemented explicitly.",
-      ())
-ERROR(distributed_actor_init_user_defined_must_be_convenience,none,
-      "'distributed actor' initializer %0 must be 'convenience' initializer. "
-      "Distributed actors have an implicitly synthesized designated "
-      "'init(transport:)' local-initializer, which other initializers must delegate to",
-      (DeclName))
-ERROR(distributed_actor_init_must_delegate_to_local_init,none,
-      "'distributed actor' initializer %0 must (directly or indirectly) delegate "
-      "to 'init(transport:)'",
-      (DeclName))
-ERROR(distributed_actor_init_must_not_delegate_to_resolve_init,none,
-      "'distributed actor' initializer %0 cannot delegate to resolve-initializer "
-      "'init(resolve:using:)', as it may result resolving a storageless proxy instance",
-      (DeclName))
 ERROR(distributed_actor_local_var,none,
       "'distributed' can not be applied to local variables",
       ())

include/swift/AST/KnownProtocols.def

@@ -96,6 +96,7 @@ PROTOCOL(Differentiable)
 
 // Distributed Actors
 PROTOCOL(DistributedActor)
+PROTOCOL(ActorIdentity)
 PROTOCOL(ActorTransport)
 
 PROTOCOL(AsyncSequence)

lib/AST/ASTContext.cpp

@@ -1040,6 +1040,8 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
     M = getLoadedModule(Id_Concurrency);
     break;
   case KnownProtocolKind::DistributedActor:
+  case KnownProtocolKind::ActorTransport:
+  case KnownProtocolKind::ActorIdentity:
     M = getLoadedModule(Id_Distributed);
     break;
   default:

lib/IRGen/GenMeta.cpp

@@ -5167,6 +5167,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::Actor:
   case KnownProtocolKind::ActorTransport:
   case KnownProtocolKind::DistributedActor:
+  case KnownProtocolKind::ActorIdentity:
   case KnownProtocolKind::SerialExecutor:
   case KnownProtocolKind::Sendable:
   case KnownProtocolKind::UnsafeSendable:

lib/SILGen/SILGenConstructor.cpp

@@ -669,21 +669,6 @@ static void emitDefaultActorInitialization(
                       { self.borrow(SGF, loc).getValue() });
 }
 
-//static void emitDistributedRemoteActorInitialization(
-//    SILGenFunction &SGF, SILLocation loc,
-//    ManagedValue self,
-//    bool addressArg, bool transportArg // FIXME: make those real arguments
-//    ) {
-//  auto &ctx = SGF.getASTContext();
-//  auto builtinName = ctx.getIdentifier(
-//    getBuiltinName(BuiltinValueKind::InitializeDistributedRemoteActor));
-//  auto resultTy = SGF.SGM.Types.getEmptyTupleType();
-//
-//  FullExpr scope(SGF.Cleanups, CleanupLocation(loc));
-//  SGF.B.createBuiltin(loc, builtinName, resultTy, /*subs*/{},
-//                      { self.borrow(SGF, loc).getValue() });
-//}
-
 void SILGenFunction::emitConstructorPrologActorHop(
                                            SILLocation loc,
                                            Optional<ActorIsolation> maybeIso) {
@@ -779,11 +764,6 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     emitDefaultActorInitialization(*this, PrologueLoc, selfArg);
   }
 
-  // Distributed actor initializers implicitly initialize their transport and id
-  if (selfClassDecl->isDistributedActor() && !isDelegating) {
-    initializeDistributedActorImplicitStorageInit(ctor, selfArg);
-  }
-
   if (!ctor->hasStubImplementation()) {
     assert(selfTy.hasReferenceSemantics() &&
            "can't emit a value type ctor here");
@@ -799,6 +779,11 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     }
   }
 
+  // Distributed actor initializers implicitly initialize their transport and id
+  if (selfClassDecl->isDistributedActor() && !isDelegating) {
+    initializeDistributedActorImplicitStorageInit(ctor, selfArg);
+  }
+
   // Prepare the end of initializer location.
   SILLocation endOfInitLoc = RegularLocation(ctor);
   endOfInitLoc.pointToEnd();
@@ -865,6 +850,11 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
   // Emit the constructor body.
   emitStmt(ctor->getTypecheckedBody());
 
+  // For distributed actors, emit "actor ready" since we successfully initialized
+  if (selfClassDecl->isDistributedActor() && !isDelegating) {
+    emitDistributedActorReady(ctor, selfArg);
+  }
+
   // Emit the call to super.init() right before exiting from the initializer.
   if (NeedsBoxForSelf) {
     if (auto *SI = ctor->getSuperInitCall()) {