[allocbox-to-stack] Fix an ossa bug in PromotedParamCloner.

For those who are unfamiliar, alloc-box-to-stack while generally not
interprocedural, will look one level into the callgraph to see if a
partial_apply that captures a box really needs to capture the box due to an
escape. If not, allocbox-to-stack clones the closure with the address inside the
box being passed instead of the box itself. This can then allow us to promote
the box from the heap to the stack.

What went wrong here is that in OSSA, this promoted param cloner drops
copy_value, destroy_value, and project_box on the given box. Both the copy_value
and destroy_value cases correctly looked through copy_values, but when porting,
the author forgot to handle project_box as well. This then caused the cloner to
assert since:

1. The project_box in the original function had a copy_value operand.

2. When we visited that copy_value, we saw it was for the box, so we dropped the
copy_value and did not add it to the cloner's Value -> op(Value) map.

3. Then when the cloner tried to create op(project_box), it tries to lookup the
value associated with the copy_value that is the project_box's operand... but we
don't have any such value due to (2). =><=.

The test change exercises this code path by adding a (project_box (copy_value))
to one of the allocbox to stack tests.

Author: gottesmm

lib/SILOptimizer/Transforms/AllocBoxToStack.cpp

@@ -818,28 +818,33 @@ PromotedParamCloner::visitStrongRetainInst(StrongRetainInst *Inst) {
   SILCloner<PromotedParamCloner>::visitStrongRetainInst(Inst);
 }
 
-void PromotedParamCloner::visitCopyValueInst(CopyValueInst *CVI) {
+void PromotedParamCloner::visitCopyValueInst(CopyValueInst *cvi) {
   // If it's a copy of a promoted parameter, just drop the instruction.
-  auto *Tmp = CVI;
-  while (auto *CopyOp = dyn_cast<CopyValueInst>(Tmp->getOperand())) {
-    Tmp = CopyOp;
+  auto *tmp = cvi;
+  while (auto *copyOp = dyn_cast<CopyValueInst>(tmp->getOperand())) {
+    tmp = copyOp;
   }
-  if (OrigPromotedParameters.count(Tmp->getOperand()))
+  if (OrigPromotedParameters.count(tmp->getOperand()))
     return;
 
-  SILCloner<PromotedParamCloner>::visitCopyValueInst(CVI);
+  SILCloner<PromotedParamCloner>::visitCopyValueInst(cvi);
 }
 
-void PromotedParamCloner::visitProjectBoxInst(ProjectBoxInst *Inst) {
-  // If it's a projection of a promoted parameter, drop the instruction.
-  // Its uses will be replaced by the promoted address.
-  if (OrigPromotedParameters.count(Inst->getOperand())) {
-    auto *origArg = cast<SILFunctionArgument>(Inst->getOperand());
-    recordFoldedValue(Inst, NewPromotedArgs[origArg->getIndex()]);
+void PromotedParamCloner::visitProjectBoxInst(ProjectBoxInst *pbi) {
+  // If it's a projection of a promoted parameter (or a copy_value of a promoted
+  // parameter), drop the instruction.  Its uses will be replaced by the
+  // promoted address.
+  SILValue box = pbi->getOperand();
+  while (auto *copyOp = dyn_cast<CopyValueInst>(box)) {
+    box = copyOp->getOperand();
+  }
+  if (OrigPromotedParameters.count(box)) {
+    auto *origArg = cast<SILFunctionArgument>(box);
+    recordFoldedValue(pbi, NewPromotedArgs[origArg->getIndex()]);
     return;
   }
 
-  SILCloner<PromotedParamCloner>::visitProjectBoxInst(Inst);
+  SILCloner<PromotedParamCloner>::visitProjectBoxInst(pbi);
 }
 
 // While cloning during specialization, make sure apply instructions do not have

test/SILOptimizer/allocbox_to_stack_ownership.sil

@@ -680,6 +680,11 @@ bb0(%0 : $Int, %1 : @owned $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>)
   %6 = function_ref @get : $@convention(method) <τ_0_0 where τ_0_0 : Count> (@in S<τ_0_0>) -> Int
   %7 = apply %6<T>(%4) : $@convention(method) <τ_0_0 where τ_0_0 : Count> (@in S<τ_0_0>) -> Int
   %8 = apply %3(%0, %7) : $@convention(thin) (Int, Int) -> Bool
+  %9 = copy_value %1 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>
+  %10 = project_box %9 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>, 0
+  copy_addr %10 to [initialization] %4 : $*S<T>
+  destroy_value %9 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>
+  destroy_addr %4 : $*S<T>
   dealloc_stack %4 : $*S<T>
   destroy_value %1 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>
 // CHECK: return