[AddressLowering] Move bound pattern into storage.

In a switch statement like

```
switch (x, y) {
case (.foo(let a), .bar(let b)):
...
```

both `a` and `b` have lexical lifetimes which are represented with
lexical borrow scopes.  When lowering, those lexical lifetimes need to
be preserved.

Introduce lexical `alloc_stacks` for target blocks of `switch_enum`
instructions and move the terminator result values into those
alloc_stacks.  These will naturally be marked lexical when the
begin_borrow [lexical] is removed.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -808,6 +808,19 @@ static Operand *getProjectedDefOperand(SILValue value) {
   }
 }
 
+/// If \p value is lexically borrowed, when it is lowered, it must be stored in
+/// an alloc_stack [lexical] of the same type so that its lifetime is preserved.
+static bool needsLexicalAllocStack(SILValue value) {
+  for (auto *use : value->getUses()) {
+    auto *user = use->getUser();
+    if (auto *bbi = dyn_cast<BeginBorrowInst>(user)) {
+      if (bbi->isLexical())
+        return true;
+    }
+  }
+  return false;
+}
+
 /// If \p value is a an existential or enum, then return the existential or enum
 /// operand. These operations are always rewritten by the UseRewriter and always
 /// reuse the same storage as their operand. Note that if the operation's result
@@ -834,6 +847,9 @@ static Operand *getReusedStorageOperand(SILValue value) {
     return &cast<SingleValueInstruction>(value)->getOperandRef(0);
 
   case ValueKind::SILPhiArgument: {
+    if (needsLexicalAllocStack(value)) {
+      return nullptr;
+    }
     if (auto *term = cast<SILPhiArgument>(value)->getTerminatorForResult()) {
       if (auto *switchEnum = dyn_cast<SwitchEnumInst>(term)) {
         return &switchEnum->getAllOperands()[0];
@@ -2931,20 +2947,34 @@ void UseRewriter::visitSwitchEnumInst(SwitchEnumInst * switchEnum) {
     assert(caseBB->getArguments().size() == 1);
     SILArgument *caseArg = caseBB->getArguments()[0];
 
-    assert(&switchEnum->getOperandRef(0) == getReusedStorageOperand(caseArg));
     assert(caseDecl->hasAssociatedValues() && "caseBB has a payload argument");
 
     SILBuilder caseBuilder = pass.getBuilder(caseBB->begin());
-    auto *caseAddr =
+    auto *enumDataAddr =
         caseBuilder.createUncheckedTakeEnumDataAddr(loc, enumAddr, caseDecl);
+
+    SILValue addrToLoad;
+    if (needsLexicalAllocStack(caseArg)) {
+      // This case has a variable bound to its payload.  To preserve the lexical
+      // lifetime that variable introduces, it must be moved into the
+      // alloc_stack created for it, which will subsequently be marked lexical.
+      assert(!getReusedStorageOperand(caseArg));
+      auto caseAddr = pass.valueStorageMap.getStorage(caseArg).storageAddress;
+      caseBuilder.createCopyAddr(loc, enumDataAddr, caseAddr, IsTake,
+                                 IsInitialization);
+      addrToLoad = caseAddr;
+    } else {
+      assert(&switchEnum->getOperandRef(0) == getReusedStorageOperand(caseArg));
+      addrToLoad = enumDataAddr;
+    }
     auto *caseLoad = caseBuilder.createTrivialLoadOr(
-        loc, caseAddr, LoadOwnershipQualifier::Take);
+        loc, addrToLoad, LoadOwnershipQualifier::Take);
     caseArg->replaceAllUsesWith(caseLoad);
     if (caseArg->getType().isAddressOnly(*pass.function)) {
       // Remap caseArg to the new dummy load which will be deleted during
       // deleteRewrittenInstructions.
       pass.valueStorageMap.replaceValue(caseArg, caseLoad);
-      markRewritten(caseLoad, caseAddr);
+      markRewritten(caseLoad, addrToLoad);
     }
     caseBB->eraseArgument(0);
   };

test/SILOptimizer/opaque_values_Onone.swift

@@ -19,7 +19,16 @@ struct Outer<T : Equatable> {
 
 extension Outer.Inner {
   // CHECK-LABEL: sil hidden @outer_inner_compare
-  // CHECK: switch_enum_addr {{%[^,]+}} : $*Outer<T>.Inner, case #Outer.Inner.inside!enumelt: {{bb[0-9]+}}, case #Outer.Inner.outside!enumelt: {{bb[0-9]+}}
+  // CHECK:         [[L_ADDR:%[^,]+]] = alloc_stack [lexical] $T
+  // CHECK:         [[R_ADDR:%[^,]+]] = alloc_stack [lexical] $T
+  // CHECK:         switch_enum_addr [[LHS_ADDR:%[^,]+]] : $*Outer<T>.Inner, case #Outer.Inner.inside!enumelt: [[LHS_IS_INSIDE:bb[0-9]+]], case #Outer.Inner.outside!enumelt: [[BASIC_BLOCK4:bb[0-9]+]]
+  // CHECK:       [[LHS_IS_INSIDE]]:
+  // CHECK:         [[LHS_INSIDE_ADDR:%[^,]+]] = unchecked_take_enum_data_addr [[LHS_ADDR]]
+  // CHECK:         copy_addr [take] [[LHS_INSIDE_ADDR]] to [initialization] [[L_ADDR]]
+  // CHECK:         switch_enum_addr [[RHS_ADDR:%[^,]+]] : $*Outer<T>.Inner, case #Outer.Inner.inside!enumelt: [[LHS_AND_RHS_ARE_INSIDE:bb[0-9]+]], default {{bb[0-9]+}}
+  // CHECK:       [[LHS_AND_RHS_ARE_INSIDE]]:
+  // CHECK:         [[RHS_INSIDE_ADDR:%[^,]+]] = unchecked_take_enum_data_addr [[RHS_ADDR]]
+  // CHECK:         copy_addr [take] [[RHS_INSIDE_ADDR]] to [initialization] [[R_ADDR]]
   // CHECK-LABEL: } // end sil function 'outer_inner_compare'
   @_silgen_name("outer_inner_compare")
   static func compare(_ lhs: Outer.Inner, _ rhs: Outer.Inner) -> Bool {