Merge pull request swiftlang#22449 from gottesmm/pr-fb26d1bf402324ef5ab4eac767964caff06d3e39

[silgenpattern] Fix the box handling in the old silgenpattern enum co…

Author: gottesmm

lib/SILGen/SILGenPattern.cpp

@@ -2165,15 +2165,14 @@ void PatternMatchEmission::emitEnumElementDispatch(
           auto accessMV = ManagedValue::forUnmanaged(accessAddress);
           ManagedValue newLoadedBoxValue;
           if (accessAddress == boxedValue) {
-            newLoadedBoxValue = SGF.B.createLoadBorrow(loc, accessMV);
+            eltCMV = {SGF.B.createLoadBorrow(loc, accessMV),
+                      CastConsumptionKind::BorrowAlways};
           } else {
-            newLoadedBoxValue = SGF.B.createLoadCopy(loc, accessMV);
+            // Since we made a copy, send down TakeAlways.
+            eltCMV = {SGF.B.createLoadCopy(loc, accessMV),
+                      CastConsumptionKind::TakeAlways};
           }
-          boxedValue = newLoadedBoxValue.getUnmanagedValue();
           access.endAccess(SGF);
-
-          // Since we made a copy, send down TakeAlways.
-          eltCMV = {newLoadedBoxValue, CastConsumptionKind::TakeAlways};
         } else {
           // The boxed value may be shared, so we always have to copy it.
           eltCMV = getManagedSubobject(SGF, boxedValue, *eltTL,

test/Interpreter/indirect_enum.swift

@@ -0,0 +1,35 @@
+// RUN: %target-swiftc_driver %s -target %sanitizers-target-triple -g -sanitize=address -o %t_asan-binary
+// RUN: %target-codesign %t_asan-binary
+// RUN: env ASAN_OPTIONS=detect_leaks=0 %target-run %t_asan-binary
+// REQUIRES: executable_test
+// REQUIRES: asan_runtime
+
+// Make sure that we do not use-after-free here.
+
+class Box<T> {
+  var value: T
+  init(_ inputValue: T) { value = inputValue }
+}
+
+enum Value<U> {
+  case inline(U)
+  indirect case box(Box<U>)
+}
+
+func evaluate<U>(_ v: Value<U>) {
+  switch v {
+  case .inline:
+    return print("foo")
+  case .box(let box):
+    return print("bar \(box)")
+  }
+}
+
+func main() {
+  let v = Value.box(Box<[Int]>([1, 2, 3]))
+  evaluate(v)
+  print(v)
+}
+
+main()
+

test/SILGen/indirect_enum.swift

@@ -541,3 +541,35 @@ func dontDisableCleanupOfIndirectPayload(_ x: TrivialButIndirect) {
   guard case .Indirect(let bar) = x else { return }
 }
 // CHECK: } // end sil function '$s13indirect_enum35dontDisableCleanupOfIndirectPayloadyyAA010TrivialButG0OF'
+
+// Make sure that in these cases we do not break any ownership invariants.
+class Box<T> {
+  var value: T
+  init(_ inputValue: T) { value = inputValue }
+}
+
+enum ValueWithInlineStorage<T> {
+case inline(T)
+indirect case box(Box<T>)
+}
+
+func switchValueWithInlineStorage<U>(v: ValueWithInlineStorage<U>) {
+  switch v {
+  case .inline:
+    return
+  case .box(let box):
+    return
+  }
+}
+
+func guardValueWithInlineStorage<U>(v: ValueWithInlineStorage<U>) {
+  do {
+    guard case .inline = v else { return }
+    guard case .box(let box) = v else { return }
+  }
+
+  do {
+    if case .inline = v { return }
+    if case .box(let box) = v { return }
+  }
+}