[Mem2Reg] Lexical allocs create lexical borrows.

include/swift/SIL/SILCloner.h

@@ -1083,7 +1083,7 @@ void SILCloner<ImplClass>::visitBeginBorrowInst(BeginBorrowInst *Inst) {
 
   recordClonedInstruction(
       Inst, getBuilder().createBeginBorrow(getOpLocation(Inst->getLoc()),
-                                           getOpValue(Inst->getOperand()), 
+                                           getOpValue(Inst->getOperand()),
                                            Inst->isLexical()));
 }
 

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -190,11 +190,11 @@ bool isAddressOfArrayElement(SILValue addr);
 /// Move an ApplyInst's FuncRef so that it dominates the call site.
 void placeFuncRef(ApplyInst *ai, DominanceInfo *dt);
 
-/// Add an argument, \p val, to the branch-edge that is pointing into
+/// Add arguments, \p vals, to the branch-edge that is pointing into
 /// block \p Dest. Return a new instruction and do not erase the old
 /// instruction.
-TermInst *addArgumentToBranch(SILValue val, SILBasicBlock *dest,
-                              TermInst *branch);
+TermInst *addArgumentsToBranch(ArrayRef<SILValue> vals, SILBasicBlock *dest,
+                               TermInst *branch);
 
 /// Get the linkage to be used for specializations of a function with
 /// the given linkage.

lib/SILOptimizer/Transforms/AllocBoxToStack.cpp

@@ -533,11 +533,15 @@ static bool rewriteAllocBoxAsAllocStack(AllocBoxInst *ABI) {
   SILBuilderWithScope Builder(ABI);
   assert(ABI->getBoxType()->getLayout()->getFields().size() == 1
          && "rewriting multi-field box not implemented");
+  bool isLexical = ABI->getFunction()
+                       ->getModule()
+                       .getASTContext()
+                       .LangOpts.EnableExperimentalLexicalLifetimes;
   auto *ASI = Builder.createAllocStack(
       ABI->getLoc(),
       getSILBoxFieldType(TypeExpansionContext(*ABI->getFunction()),
                          ABI->getBoxType(), ABI->getModule().Types, 0),
-      ABI->getVarInfo(), ABI->hasDynamicLifetime());
+      ABI->getVarInfo(), ABI->hasDynamicLifetime(), isLexical);
 
   // Transfer a mark_uninitialized if we have one.
   SILValue StackBox = ASI;

lib/SILOptimizer/Transforms/SILSROA.cpp

@@ -202,8 +202,8 @@ createAllocas(llvm::SmallVector<AllocStackInst *, 4> &NewAllocations) {
     // TODO: Add op_fragment support for tuple type
     for (unsigned EltNo : indices(TT->getElementTypes())) {
       SILType EltTy = Type.getTupleElementType(EltNo);
-      NewAllocations.push_back(
-          B.createAllocStack(Loc, EltTy, {}, AI->hasDynamicLifetime()));
+      NewAllocations.push_back(B.createAllocStack(
+          Loc, EltTy, {}, AI->hasDynamicLifetime(), AI->isLexical()));
     }
   } else {
     assert(SD && "SD should not be null since either it or TT must be set at "
@@ -218,7 +218,7 @@ createAllocas(llvm::SmallVector<AllocStackInst *, 4> &NewAllocations) {
 
       NewAllocations.push_back(B.createAllocStack(
           Loc, Type.getFieldType(VD, M, TypeExpansionContext(B.getFunction())),
-          NewDebugVarInfo, AI->hasDynamicLifetime()));
+          NewDebugVarInfo, AI->hasDynamicLifetime(), AI->isLexical()));
     }
   }
 }

lib/SILOptimizer/Utils/InstOptUtils.cpp

@@ -864,8 +864,8 @@ void swift::placeFuncRef(ApplyInst *ai, DominanceInfo *domInfo) {
 /// Add an argument, \p val, to the branch-edge that is pointing into
 /// block \p Dest. Return a new instruction and do not erase the old
 /// instruction.
-TermInst *swift::addArgumentToBranch(SILValue val, SILBasicBlock *dest,
-                                     TermInst *branch) {
+TermInst *swift::addArgumentsToBranch(ArrayRef<SILValue> vals,
+                                      SILBasicBlock *dest, TermInst *branch) {
   SILBuilderWithScope builder(branch);
 
   if (auto *cbi = dyn_cast<CondBranchInst>(branch)) {
@@ -879,10 +879,12 @@ TermInst *swift::addArgumentToBranch(SILValue val, SILBasicBlock *dest,
       falseArgs.push_back(arg);
 
     if (dest == cbi->getTrueBB()) {
-      trueArgs.push_back(val);
+      for (auto val : vals)
+        trueArgs.push_back(val);
       assert(trueArgs.size() == dest->getNumArguments());
     } else {
-      falseArgs.push_back(val);
+      for (auto val : vals)
+        falseArgs.push_back(val);
       assert(falseArgs.size() == dest->getNumArguments());
     }
 
@@ -898,7 +900,8 @@ TermInst *swift::addArgumentToBranch(SILValue val, SILBasicBlock *dest,
     for (auto arg : bi->getArgs())
       args.push_back(arg);
 
-    args.push_back(val);
+    for (auto val : vals)
+      args.push_back(val);
     assert(args.size() == dest->getNumArguments());
     return builder.createBranch(bi->getLoc(), bi->getDestBB(), args);
   }

test/SILOptimizer/allocbox_to_stack_lifetime.sil

@@ -0,0 +1,30 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -allocbox-to-stack -enable-experimental-lexical-lifetimes | %FileCheck %s
+
+import Builtin
+
+struct Int {
+  var _value: Builtin.Int64
+}
+
+struct Bool {
+  var _value: Builtin.Int1
+}
+
+protocol Error {}
+
+// CHECK-LABEL: sil [ossa] @simple_promotion
+sil [ossa] @simple_promotion : $@convention(thin) (Int) -> Int {
+bb0(%0 : $Int):
+  %1 = alloc_box ${ var Int }
+  %1a = project_box %1 : ${ var Int }, 0
+  store %0 to [trivial] %1a : $*Int
+
+  %3 = load [trivial] %1a : $*Int
+  destroy_value %1 : ${ var Int }
+  return %3 : $Int
+// CHECK: alloc_stack [lexical]
+// CHECK-NOT: alloc_box
+// CHECK-NOT: destroy_value
+// CHECK: return
+}
+