express resignIdentity in SILGen as an unwind-only clean-up

turning it into a clean-up covers both failable and throwing initializers.

resolves rdar://84535066

Author: kavon

lib/SILGen/SILGenConstructor.cpp

@@ -681,6 +681,8 @@ void SILGenFunction::emitConstructorPrologActorHop(
   }
 }
 
+// MARK: class constructor
+
 void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(ctor);
 
@@ -784,9 +786,8 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
   }
 
   // Distributed actor initializers implicitly initialize their transport and id
-  if (isDesignatedDistActorInit) {
+  if (isDesignatedDistActorInit)
     emitDistActorImplicitPropertyInits(ctor, selfArg);
-  }
 
   // Prepare the end of initializer location.
   SILLocation endOfInitLoc = RegularLocation(ctor);
@@ -818,12 +819,6 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     failureExitBB = createBasicBlock();
     failureExitArg = failureExitBB->createPhiArgument(
         resultLowering.getLoweredType(), OwnershipKind::Owned);
-    
-    // For an async distributed actor init, we must `resignIdentity` before
-    // the clean-ups are triggered in this failure block.
-    if (isDesignatedDistActorInit && ctor->hasAsync()) {
-      emitResignIdentityCall(loc, selfClassDecl, selfArg);
-    }
 
     Cleanups.emitCleanupsForReturn(ctor, IsForUnwind);
     SILValue nilResult =
@@ -878,9 +873,6 @@ 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,
-  // 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/SILGenDistributed.cpp

@@ -178,6 +178,35 @@ static void emitIdentityInit(SILGenFunction &SGF, ConstructorDecl *ctor,
   initializeProperty(SGF, loc, borrowedSelfArg.getValue(), var, temp);
 }
 
+namespace {
+/// Cleanup to resign the identity of a distributed actor if an abnormal exit happens.
+class ResignIdentity : public Cleanup {
+  ClassDecl *actorDecl;
+  SILValue self;
+public:
+  ResignIdentity(ClassDecl *actorDecl, SILValue self)
+    : actorDecl(actorDecl), self(self) {
+      assert(actorDecl->isDistributedActor());
+    }
+
+  void emit(SILGenFunction &SGF, CleanupLocation l, ForUnwind_t forUnwind) override {
+    if (forUnwind == IsForUnwind) {
+      l.markAutoGenerated();
+      SGF.emitResignIdentityCall(l, actorDecl,
+                                 ManagedValue::forUnmanaged(self));
+    }
+  }
+
+  void dump(SILGenFunction &SGF) const override {
+#ifndef NDEBUG
+    llvm::errs() << "ResignIdentity "
+                 << "State:" << getState() << " "
+                 << "Self: " << self << "\n";
+#endif
+  }
+};
+} // end anonymous namespace
+
 void SILGenFunction::emitDistActorImplicitPropertyInits(
     ConstructorDecl *ctor, ManagedValue selfArg) {
   // Only designated initializers should perform this initialization.
@@ -189,6 +218,10 @@ void SILGenFunction::emitDistActorImplicitPropertyInits(
   selfArg = selfArg.borrow(*this, loc);
   emitTransportInit(*this, ctor, loc, selfArg);
   emitIdentityInit(*this, ctor, loc, selfArg);
+
+  // register a clean-up to resign the identity upon abnormal exit
+  auto *actorDecl = cast<ClassDecl>(ctor->getParent()->getAsDecl());
+  Cleanups.pushCleanup<ResignIdentity>(actorDecl, selfArg.getValue());
 }
 
 void SILGenFunction::emitDistributedActorReady(

test/Distributed/SIL/distributed_actor_default_init_sil.swift

@@ -2,13 +2,19 @@
 // REQUIRES: concurrency
 // REQUIRES: distributed
 
+/// The convention in this test is that the Swift declaration comes before its FileCheck lines.
+
 import _Distributed
 
 /// Use the existential wrapper as the default actor transport.
 typealias DefaultActorTransport = AnyActorTransport
 
 class SomeClass {}
 
+enum Err : Error {
+  case blah
+}
+
 distributed actor MyDistActor {
   var localOnlyField: SomeClass
 
@@ -64,6 +70,8 @@ distributed actor MyDistActor {
 // CHECK:   br [[RET_BB:bb[0-9]+]]
 
 // CHECK: [[FAIL_BB]]:
+// CHECK:   [[RESIGN_FN:%[0-9]+]] = witness_method $AnyActorTransport, #ActorTransport.resignIdentity
+// CHECK:   = apply [[RESIGN_FN]]
 // CHECK:   builtin "destroyDefaultActor"
 // CHECK:   br [[RET_BB]]
 
@@ -73,6 +81,60 @@ distributed actor MyDistActor {
 
 
 
+  init?(transport_async_fail: AnyActorTransport, cond: Bool) async {
+    guard cond else { return nil }
+    self.localOnlyField = SomeClass()
+  }
+
+  // CHECK-LABEL: sil hidden{{.*}} @$s4test11MyDistActorC20transport_async_fail4condACSg12_Distributed03AnyD9TransportV_SbtYacfc : $@convention(method) @async (@in AnyActorTransport, Bool, @owned MyDistActor) -> @owned Optional<MyDistActor> {
+  // CHECK: bb0([[TPORT:%[0-9]+]] : $*AnyActorTransport, [[COND:%[0-9]+]] : $Bool, [[SELF:%[0-9]+]] : $MyDistActor):
+  // CHECK:   cond_br {{%[0-9]+}}, [[SUCCESS_BB:bb[0-9]+]], [[FAIL_BB:bb[0-9]+]]
+
+  // CHECK: [[SUCCESS_BB]]:
+  // CHECK:   hop_to_executor {{%[0-9]+}}
+  // CHECK:   [[READY_FN:%[0-9]+]] = witness_method $AnyActorTransport, #ActorTransport.actorReady
+  // CHECK:   = apply [[READY_FN]]
+  // CHECK:   br [[RET_BB:bb[0-9]+]]
+
+  // CHECK: [[FAIL_BB]]:
+  // CHECK:   [[RESIGN_FN:%[0-9]+]] = witness_method $AnyActorTransport, #ActorTransport.resignIdentity
+  // CHECK:   = apply [[RESIGN_FN]]
+  // CHECK:   builtin "destroyDefaultActor"
+  // CHECK:   br [[RET_BB]]
+
+  // CHECK: [[RET_BB]]({{%[0-9]+}} : $Optional<MyDistActor>):
+  // CHECK:   return
+  // CHECK: } // end sil function '$s4test11MyDistActorC20transport_async_fail4condACSg12_Distributed03AnyD9TransportV_SbtYacfc'
+
+
+
+  init?(transport_async_fail_throws: AnyActorTransport, cond: Bool) async throws {
+    guard cond else { throw Err.blah }
+    self.localOnlyField = SomeClass()
+  }
+
+  // CHECK-LABEL: sil hidden @$s4test11MyDistActorC27transport_async_fail_throws4condACSg12_Distributed03AnyD9TransportV_SbtYaKcfc : $@convention(method) @async (@in AnyActorTransport, Bool, @owned MyDistActor) -> (@owned Optional<MyDistActor>, @error Error) {
+  // CHECK: bb0([[TPORT:%[0-9]+]] : $*AnyActorTransport, [[COND:%[0-9]+]] : $Bool, [[SELF:%[0-9]+]] : $MyDistActor):
+  // CHECK:   cond_br {{%[0-9]+}}, [[SUCCESS_BB:bb[0-9]+]], [[FAIL_BB:bb[0-9]+]]
+
+  // CHECK: [[SUCCESS_BB]]:
+  // CHECK:   hop_to_executor {{%[0-9]+}}
+  // CHECK:   [[READY_FN:%[0-9]+]] = witness_method $AnyActorTransport, #ActorTransport.actorReady
+  // CHECK:   = apply [[READY_FN]]
+  // CHECK:   br [[RET_BB:bb[0-9]+]]
+
+  // CHECK: [[FAIL_BB]]:
+  // CHECK:   [[RESIGN_FN:%[0-9]+]] = witness_method $AnyActorTransport, #ActorTransport.resignIdentity
+  // CHECK:   = apply [[RESIGN_FN]]
+  // CHECK:   builtin "destroyDefaultActor"
+  // CHECK:   throw {{%[0-9]+}} : $Error
+
+  // CHECK: [[RET_BB]]:
+  // CHECK:   return
+  // CHECK: } // end sil function '$s4test11MyDistActorC27transport_async_fail_throws4condACSg12_Distributed03AnyD9TransportV_SbtYaKcfc'
+
+
+
   init(transport_async: AnyActorTransport, cond: Bool) async {
     if cond {
       self.localOnlyField = SomeClass()
@@ -125,5 +187,3 @@ distributed actor MyDistActor {
 
 
 }
-
-