fix missing hop in failable async actor inits

The returnsSelf check in DI was missing proper handling for failable inits.
This patch fixes that by specifically recognizing the tail-end of the success path
in a failable init, and treating that block as "returning self".

Author: kavon

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -925,6 +925,8 @@ void LifetimeChecker::injectActorHopForBlock(
   injectHopToExecutorAfter(loc, bbi, TheMemory.getUninitializedValue());
 }
 
+static bool isFailableInitReturnUseOfEnum(EnumInst *EI);
+
 void LifetimeChecker::injectActorHops() {
   auto ctor = TheMemory.getActorInitSelf();
 
@@ -947,11 +949,36 @@ void LifetimeChecker::injectActorHops() {
   // Returns true iff a block returns normally from the initializer,
   // which means that it returns `self` in some way (perhaps optional-wrapped).
   auto returnsSelf = [](SILBasicBlock &block) -> bool {
-    // This check relies on the fact that failable initializers are emitted by
-    // SILGen to perform their return in a fresh block with either:
-    //    1. No non-load uses of `self` (e.g., failing case)
-    //    2. An all-Yes in-availability. (e.g., success case)
-    return block.getTerminator()->getTermKind() == TermKind::ReturnInst;
+    auto term = block.getTerminator();
+    auto kind = term->getTermKind();
+
+    // Does this block return directly?
+    if (kind == TermKind::ReturnInst)
+      return true;
+
+
+    // Does this block return `self` wrapped in an Optional?
+    // The pattern would look like:
+    //
+    // thisBB:
+    //   ...
+    //   %x = enum $Optional<Dactor>, #Optional.some!enumelt
+    //   br exitBB(%x : $Optional<Dactor>)
+    //
+    // exitBB(%y : $Optional<Dactor>):
+    //   return %y : $Optional<Dactor>
+    //
+    if (kind == TermKind::BranchInst)
+      if (term->getNumOperands() == 1)
+        if (auto *passedVal = term->getOperand(0)->getDefiningInstruction())
+          if (auto *ei = dyn_cast<EnumInst>(passedVal))
+            if (isFailableInitReturnUseOfEnum(ei))
+              // Once we've reached this point, we know it's an Optional enum.
+              // To determine whether it's .some or .none, we can just check
+              // the number of operands.
+              return ei->getNumOperands() == 1; // is it .some ?
+
+    return false;
   };
 
   /////

test/SILOptimizer/definite_init_actor.swift

@@ -108,6 +108,22 @@ actor BoringActor {
         }
         myVar = 2
     }
+
+   // CHECK-LABEL: sil hidden @$s4test14SingleVarActorC14failable_asyncACSgSb_tYacfc : $@convention(method) @async (Bool, @owned SingleVarActor) -> @owned Optional<SingleVarActor> {
+   // CHECK: bb0({{%[0-9]+}} : $Bool, {{%[0-9]+}} : $SingleVarActor):
+   // CHECK:   cond_br {{%[0-9]+}}, [[SUCCESS_BB:bb[0-9]+]], {{bb[0-9]+}}
+   //
+   // CHECK: [[SUCCESS_BB]]:
+   // CHECK:   store {{%[0-9]+}} to {{%[0-9]+}} : $*Int
+   // CHECK:   hop_to_executor {{%[0-9]+}}
+   // CHECK:   enum $Optional<SingleVarActor>, #Optional.some!enumelt
+   //
+   // CHECK: } // end sil function '$s4test14SingleVarActorC14failable_asyncACSgSb_tYacfc'
+   init?(failable_async cond: Bool) async {
+     guard cond else { return nil }
+     myVar = 1
+   }
+
  }
 
 actor DefaultInit {