[Test] Add tests for prespecialized single payload enums with layout strings

Author: drexin

test/Interpreter/Inputs/layout_string_witnesses_types.swift

@@ -477,6 +477,12 @@ public enum PrespecializedSingletonEnum<T> {
     case only(Int, T)
 }
 
+public enum PrespecializedSinglePayloadEnum<T> {
+    case empty0
+    case empty1
+    case nonEmpty(Int, T)
+}
+
 @inline(never)
 public func consume<T>(_ x: T.Type) {
     withExtendedLifetime(x) {}
@@ -489,6 +495,10 @@ public func preSpec() {
     consume(PrespecializedSingletonEnum<AnyObject>.self)
     consume(PrespecializedSingletonEnum<SimpleClass>.self)
     consume(PrespecializedSingletonEnum<Int>.self)
+
+    consume(PrespecializedSinglePayloadEnum<AnyObject>.self)
+    consume(PrespecializedSinglePayloadEnum<SimpleClass>.self)
+    consume(PrespecializedSinglePayloadEnum<Int>.self)
 }
 
 @inline(never)

test/Interpreter/layout_string_witnesses_dynamic.swift

@@ -210,6 +210,85 @@ func testPrespecializedSingletonEnumInt() {
 
 testPrespecializedSingletonEnumInt()
 
+func testPrespecializedSinglePayloadEnumAnyObject() {
+    let ptr = UnsafeMutablePointer<PrespecializedSinglePayloadEnum<AnyObject>>.allocate(capacity: 1)
+
+    do {
+        let x = PrespecializedSinglePayloadEnum<AnyObject>.nonEmpty(23, SimpleClass(x: 23))
+        testInit(ptr, to: x)
+    }
+
+    do {
+        let y = PrespecializedSinglePayloadEnum<AnyObject>.nonEmpty(32, SimpleClass(x: 32))
+
+        // CHECK-NEXT: Before deinit
+        print("Before deinit")
+
+        // CHECK-NEXT: SimpleClass deinitialized!
+        testAssign(ptr, from: y)
+    }
+
+    // CHECK-NEXT: Before deinit
+    print("Before deinit")
+
+
+    // CHECK-NEXT: SimpleClass deinitialized!
+    testDestroy(ptr)
+
+    ptr.deallocate()
+}
+
+testPrespecializedSinglePayloadEnumAnyObject()
+
+func testPrespecializedSinglePayloadEnumSimpleClass() {
+    let ptr = UnsafeMutablePointer<PrespecializedSinglePayloadEnum<SimpleClass>>.allocate(capacity: 1)
+
+    do {
+        let x = PrespecializedSinglePayloadEnum<SimpleClass>.nonEmpty(23, SimpleClass(x: 23))
+        testInit(ptr, to: x)
+    }
+
+    do {
+        let y = PrespecializedSinglePayloadEnum<SimpleClass>.nonEmpty(32, SimpleClass(x: 32))
+
+        // CHECK-NEXT: Before deinit
+        print("Before deinit")
+
+        // CHECK-NEXT: SimpleClass deinitialized!
+        testAssign(ptr, from: y)
+    }
+
+    // CHECK-NEXT: Before deinit
+    print("Before deinit")
+
+
+    // CHECK-NEXT: SimpleClass deinitialized!
+    testDestroy(ptr)
+
+    ptr.deallocate()
+}
+
+testPrespecializedSinglePayloadEnumSimpleClass()
+
+
+func testPrespecializedSinglePayloadEnumInt() {
+    let ptr = UnsafeMutablePointer<PrespecializedSinglePayloadEnum<Int>>.allocate(capacity: 1)
+
+    do {
+        let x = PrespecializedSinglePayloadEnum<Int>.nonEmpty(23, 23)
+        testInit(ptr, to: x)
+    }
+
+    do {
+        let y = PrespecializedSinglePayloadEnum<Int>.nonEmpty(32, 32)
+        testAssign(ptr, from: y)
+    }
+
+    ptr.deallocate()
+}
+
+testPrespecializedSinglePayloadEnumInt()
+
 func testGenericTuple() {
     let ptr = allocateInternalGenericPtr(of: GenericTupleWrapper<TestClass>.self)