invoke resignIdentity in an async failable initializer

For distributed actors, their async initializers will call
actorReady prior to the end of the initializer.
If that happens, we need to resign the identity if we end
up in the failure path of the init.

Author: kavon

lib/SILGen/SILGenConstructor.cpp

@@ -822,8 +822,7 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     // For an async distributed actor init, we must `resignIdentity` before
     // the clean-ups are triggered in this failure block.
     if (isDesignatedDistActorInit && ctor->hasAsync()) {
-      // TODO: refactor emitDistributedActor_resignAddress so we can call it
-      // within this initializer.
+      emitResignIdentityCall(loc, selfClassDecl, selfArg);
     }
 
     Cleanups.emitCleanupsForReturn(ctor, IsForUnwind);
@@ -880,7 +879,8 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
   // For distributed actors, their synchronous initializers invoke "actor ready"
   // at the very end, just before returning on a successful initialization.
   // There is no need for injecting `resignIdentity` calls in such inits,
-  // because we can never call `actorReady` prematurely.
+  // even if they are failable or throwing, because we will never call
+  // `actorReady` at a point before the init can exit abnormally.
   if (isDesignatedDistActorInit && !ctor->hasAsync()) {
     RegularLocation loc(ctor);
     loc.markAutoGenerated();

lib/SILGen/SILGenDestructor.cpp

@@ -81,7 +81,14 @@ void SILGenFunction::emitDestroyingDestructor(DestructorDecl *dd) {
   /// and can remove it from its (weak) lookup tables.
   if (cd->isDistributedActor()) {
     SILBasicBlock *continueBB = createBasicBlock();
-    emitDistributedActor_resignIdentity(dd, selfValue, continueBB);
+    
+    RegularLocation loc(dd);
+    if (dd->isImplicit())
+      loc.markAutoGenerated();
+    
+    // FIXME: what should the type of management be for this?
+    auto managedSelf = ManagedValue::forBorrowedRValue(selfValue);
+    emitConditionalResignIdentityCall(loc, cd, managedSelf, continueBB);
     B.emitBlock(continueBB);
   }
 

lib/SILGen/SILGenDistributed.cpp

@@ -636,45 +636,73 @@ void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) {
   }
 }
 
-/******************************************************************************/
-/******************* DISTRIBUTED DEINIT: resignIdentity ***********************/
-/******************************************************************************/
+// MARK: transport.resignIdentity()
 
-void SILGenFunction::emitDistributedActor_resignIdentity(
-    DestructorDecl *dd, SILValue selfValue, SILBasicBlock *continueBB) {
+void SILGenFunction::emitResignIdentityCall(SILLocation loc,
+                                            ClassDecl *actorDecl,
+                                            ManagedValue actorSelf) {
   ASTContext &ctx = getASTContext();
-
-  auto cd = cast<ClassDecl>(dd->getDeclContext());
-  assert(cd->isDistributedActor() &&
-  "only distributed actors have transport lifecycle hooks in deinit");
-
-  RegularLocation Loc(dd);
-  if (dd->isImplicit())
-    Loc.markAutoGenerated();
-
-  auto selfDecl = dd->getImplicitSelfDecl();
-  auto selfManagedValue = ManagedValue::forUnmanaged(selfValue);
-  auto selfTy = selfDecl->getType();
-
+  
+  FormalEvaluationScope scope(*this);
+  
   // ==== locate: self.id
-  auto *idVarDeclRef = lookupProperty(cd, ctx.Id_id);
+  auto *idVarDeclRef = lookupProperty(actorDecl, ctx.Id_id);
   auto idRef =
-      B.createRefElementAddr(Loc, selfValue, idVarDeclRef,
-                             getLoweredType(idVarDeclRef->getType()));
-
+  B.createRefElementAddr(loc, actorSelf, idVarDeclRef,
+                         getLoweredType(idVarDeclRef->getType()));
+  
   // ==== locate: self.actorTransport
-  auto transportVarDeclRef = lookupProperty(cd, ctx.Id_actorTransport);
+  auto transportVarDeclRef = lookupProperty(actorDecl, ctx.Id_actorTransport);
   auto transportRef =
-      B.createRefElementAddr(Loc, selfValue, transportVarDeclRef,
-                             getLoweredType(transportVarDeclRef->getType()));
-
-  // locate: self.transport.resignIdentity(...)
+  B.createRefElementAddr(loc, actorSelf, transportVarDeclRef,
+                         getLoweredType(transportVarDeclRef->getType()));
+  
+  // ==== locate: self.transport.resignIdentity(...)
   auto *transportDecl = ctx.getActorTransportDecl();
   auto resignFnDecls = transportDecl->lookupDirect(ctx.Id_resignIdentity);
   assert(resignFnDecls.size() == 1);
   auto *resignFnDecl = resignFnDecls.front();
   auto resignFnRef = SILDeclRef(resignFnDecl);
+  
+  // ==== perform the call
+  auto openedTransport =
+  OpenedArchetypeType::get(transportVarDeclRef->getType());
+  auto transportAddr =
+    B.createOpenExistentialAddr(loc, /*operand=*/transportRef.getValue(),
+                                getLoweredType(openedTransport),
+                                OpenedExistentialAccess::Immutable);
+  
+  auto resignFnType =
+    SGM.M.Types.getConstantFunctionType(TypeExpansionContext::minimal(),
+                                        resignFnRef);
+  
+  auto conformance = ProtocolConformanceRef(transportDecl);
+  auto witness =
+    B.createWitnessMethod(loc, openedTransport,
+                          conformance, resignFnRef,
+                          SILType::getPrimitiveObjectType(resignFnType));
+  
+  auto subs = SubstitutionMap::getProtocolSubstitutions(transportDecl,
+                                                        openedTransport,
+                                                        conformance);
+  
+  SmallVector<SILValue, 2> params;
+  params.push_back(idRef.getValue());
+  params.push_back(transportAddr); // self for the call, as last param
+  
+  B.createApply(loc, witness, subs, params);
+}
+
+void
+SILGenFunction::emitConditionalResignIdentityCall(SILLocation loc,
+                                                  ClassDecl *actorDecl,
+                                                  ManagedValue actorSelf,
+                                                  SILBasicBlock *continueBB) {
+  assert(actorDecl->isDistributedActor() &&
+  "only distributed actors have transport lifecycle hooks in deinit");
 
+  auto selfTy = actorDecl->getDeclaredInterfaceType();
+  
   // we only transport.resignIdentity if we are a local actor,
   // and thus the address was created by transport.assignIdentity.
   auto isRemoteBB = createBasicBlock();
@@ -685,46 +713,24 @@ void SILGenFunction::emitDistributedActor_resignIdentity(
   // } else {
   //   ...
   // }
-  emitDistributedIfRemoteBranch(*this, Loc,
-                                selfManagedValue, selfTy,
+  emitDistributedIfRemoteBranch(*this, loc,
+                                actorSelf, selfTy,
                                 /*if remote*/isRemoteBB,
                                 /*if local*/isLocalBB);
 
-  // if remote
-  // === <noop>
+  // if remote, do nothing.
   {
     B.emitBlock(isRemoteBB);
-    // noop, remote actors don't do anything in their deinit
-    B.createBranch(Loc, continueBB);
+    B.createBranch(loc, continueBB);
   }
 
-  // if local
-  // === self.transport.resignIdentity(self.address)
+  // if local, resign identity.
   {
     B.emitBlock(isLocalBB);
 
-    auto openedTransport =
-        OpenedArchetypeType::get(transportVarDeclRef->getType());
-    auto transportAddr = B.createOpenExistentialAddr(
-        Loc, /*operand=*/transportRef, getLoweredType(openedTransport),
-        OpenedExistentialAccess::Immutable);
-
-    auto resignFnType = SGM.M.Types.getConstantFunctionType(
-        TypeExpansionContext::minimal(), resignFnRef);
-
-    auto witness = B.createWitnessMethod(
-        Loc, openedTransport, ProtocolConformanceRef(transportDecl),
-        resignFnRef, SILType::getPrimitiveObjectType(resignFnType));
-
-    auto subs = SubstitutionMap::getProtocolSubstitutions(
-        transportDecl, openedTransport, ProtocolConformanceRef(transportDecl));
-
-    SmallVector<SILValue, 2> params;
-    params.push_back(idRef);
-    params.push_back(transportAddr); // self for the call, as last param
-
-    B.createApply(Loc, witness, subs, params);
-    B.createBranch(Loc, continueBB);
+    emitResignIdentityCall(loc, actorDecl, actorSelf);
+    
+    B.createBranch(loc, continueBB);
   }
 }
 

lib/SILGen/SILGenFunction.h

@@ -2021,10 +2021,31 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// and is ready to receive messages.
   void emitDistributedActorReady(
       SILLocation loc, ConstructorDecl *ctor, ManagedValue actorSelf);
-
-  /// Inject distributed actor and transport interaction code into the destructor.
-  void emitDistributedActor_resignIdentity(
-      DestructorDecl *dd, SILValue selfValue, SILBasicBlock *continueBB);
+  
+  /// For a distributed actor, emits code to invoke the transport's
+  /// resignIdentity function.
+  ///
+  /// Specifically, this code emits SIL that performs the call
+  ///
+  /// \verbatim
+  ///   self.transport.resignIdentity(self.id)
+  /// \endverbatim
+  ///
+  /// using the current builder's state as the injection point.
+  ///
+  /// \param actorDecl the declaration corresponding to the actor
+  /// \param actorSelf the SIL value representing the distributed actor instance
+  void emitResignIdentityCall(SILLocation loc,
+                              ClassDecl *actorDecl, ManagedValue actorSelf);
+  
+  /// Emit code that tests whether the distributed actor is local, and if so,
+  /// resigns the distributed actor's identity.
+  /// \param continueBB the target block where execution will continue after
+  ///                   the conditional call, whether actor is local or remote.
+  void emitConditionalResignIdentityCall(SILLocation loc,
+                                         ClassDecl *actorDecl,
+                                         ManagedValue actorSelf,
+                                         SILBasicBlock *continueBB);
 
   void emitDistributedActorClassMemberDestruction(
       SILLocation cleanupLoc, ManagedValue selfValue, ClassDecl *cd,