[AddressLowering] Storage root inherits lexical.

When a `begin_borrow [lexical]` is lowered, the lifetime that it
describes can't be shortened (or eliminated) when lowering.  In some
cases, though, there will not be an alloc_stack corresponding directly
to the value being borrowed.

In these cases, mark the whole aggregate lexical.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -2776,6 +2776,13 @@ void UseRewriter::visitBeginBorrowInst(BeginBorrowInst *borrow) {
       allocStack->setIsLexical();
       return;
     }
+    auto storage = AccessStorageWithBase::compute(address);
+    if (auto base = storage.base) {
+      if (auto *allocStack = dyn_cast<AllocStackInst>(base)) {
+        allocStack->setIsLexical();
+        return;
+      }
+    }
     // Function arguments are inherently lexical.
     if (isa<SILFunctionArgument>(address))
       return;

test/SILOptimizer/opaque_values_Onone.swift

@@ -8,3 +8,35 @@
 func generic_identity<T>(t: T) -> T {
   return t
 }
+
+
+struct Outer<T : Equatable> {
+  enum Inner {
+    case outside
+    case inside(T)
+  }
+}
+
+extension Outer.Inner {
+  // CHECK-LABEL: sil hidden @outer_inner_compare
+  // CHECK:         [[LHS_ADDR:%[^,]+]] = alloc_stack [lexical] $Outer<T>.Inner
+  // CHECK:         [[RHS_ADDR:%[^,]+]] = alloc_stack [lexical] $Outer<T>.Inner
+  // CHECK:         switch_enum_addr [[LHS_ADDR]] : $*Outer<T>.Inner, case #Outer.Inner.inside!enumelt: [[L_INSIDE:bb[0-9]+]], case #Outer.Inner.outside!enumelt: {{bb[0-9]+}}
+  // CHECK:       [[L_INSIDE]]:
+  // CHECK:         unchecked_take_enum_data_addr [[LHS_ADDR]] : $*Outer<T>.Inner, #Outer.Inner.inside!enumelt
+  // CHECK:         switch_enum_addr [[RHS_ADDR]] : $*Outer<T>.Inner, case #Outer.Inner.inside!enumelt: [[L_AND_R_INSIDE:bb[0-9]+]], default {{bb[0-9]+}}
+  // CHECK:       [[L_AND_R_INSIDE]]:
+  // CHECK:         unchecked_take_enum_data_addr [[RHS_ADDR]] : $*Outer<T>.Inner, #Outer.Inner.inside!enumelt
+  // CHECK-LABEL: } // end sil function 'outer_inner_compare'
+  @_silgen_name("outer_inner_compare")
+  static func compare(_ lhs: Outer.Inner, _ rhs: Outer.Inner) -> Bool {
+    switch (lhs, rhs) {
+    case (.inside(let l), .inside(let r)):
+      return l == r
+    case (.outside, .outside):
+      return true
+    default:
+      return false
+    }
+  }
+}