[SILOptimizer] TypeWrappers/NFC: Add tests for convenience initializers of wrapped types

Author: xedin

test/Interpreter/Inputs/type_wrapper_defs.swift

@@ -271,3 +271,35 @@ public class UserDefinedInitWithConditionalTest<T> {
     print(self.val)
   }
 }
+
+@Wrapper
+public class ClassWithConvenienceInit<T> {
+  public var a: T?
+  public var b: String
+
+  init(a: T?, b: String) {
+    // Just to test that conditionals work properly
+    if let a {
+      self.a = a
+    } else {
+      self.a = nil
+    }
+
+    self.b = b
+  }
+
+  public convenience init() {
+    self.init(a: nil)
+    print(self.a)
+    print(self.b)
+  }
+
+  public convenience init(a: T?) {
+    self.init(a: a, b: "<placeholder>")
+    print(self.a)
+    print(self.b)
+
+    self.b = "<modified>"
+    print(self.b)
+  }
+}

test/Interpreter/type_wrappers.swift

@@ -551,3 +551,39 @@ do {
     // CHECK-NEXT: nil
   }
 }
+
+do {
+  let test1 = ClassWithConvenienceInit(a: [1, 2, 3])
+  // CHECK: in getter
+  // CHECK-NEXT: [1, 2, 3]
+  // CHECK-NEXT: in getter
+  // CHECK-NEXT: <placeholder>
+  // CHECK-NEXT: in setter => <modified>
+  // CHECK-NEXT: in getter
+  // CHECK-NEXT: <modified>
+
+  func test<T>(_ v: T) {
+    let test1 = ClassWithConvenienceInit<(Int, String, T)>()
+    test1.a = (-1, "ultimate question", v)
+    print(test1.a)
+  }
+
+  test((a: 1, b: 2.0, c: 3))
+  // -> from init(a: T?)
+  // CHECK: in getter
+  // CHECK-NEXT: nil
+  // CHECK-NEXT: in getter
+  // CHECK-NEXT: <placeholder>
+  // CHECK-NEXT: in setter => <modified>
+  // CHECK-NEXT: in getter
+  // CHECK-NEXT: <modified>
+  // -> from init()
+  // CHECK-NEXT: in getter
+  // CHECK-NEXT: nil
+  // CHECK-NEXT: in getter
+  // CHECK-NEXT: <modified>
+  // -> from test<T>(_: T)
+  // CHECK-NEXT: in setter => Optional((-1, "ultimate question", (a: 1, b: 2.0, c: 3)))
+  // CHECK-NEXT: in getter
+  // CHECK-NEXT: Optional((-1, "ultimate question", (a: 1, b: 2.0, c: 3)))
+}

test/SILOptimizer/type_wrapper_init_transform.swift

@@ -293,3 +293,40 @@ class TestConditionalInjection<T> {
     }
   }
 }
+
+/// Make sure that convenience initializers don't get _storage variable injected and don't produce any assign_by_wrapper instructions
+@Wrapper
+class ClassWithConvenienceInit<T> {
+  var a: T?
+  var b: String
+
+  init(a: T?, b: String) {
+    self.a = a
+    self.b = b
+  }
+
+  // CHECK-LABEL: sil hidden [ossa] @$s4test24ClassWithConvenienceInitC1aACyxGxSg_tcfC
+  // CHECK-NOT: {{.*}} alloc_stack [lexical] $(b: Optional<T>), var, name "_storage", implicit
+  // CHECK-NOT: assign_by_wrapper {{.*}}
+
+  convenience init(a: T? = nil) {
+    self.init(a: a, b: "<placeholder>")
+
+    // CHECK: [[A_GETTER:%.*]] = class_method [[SELF:%.*]] : $ClassWithConvenienceInit<T>, #ClassWithConvenienceInit.a!getter
+    // CHECK-NEXT: {{.*}} = apply [[A_GETTER]]<T>({{.*}})
+    _ = self.a
+    // CHECK: [[B_GETTER:%.*]] = class_method [[SELF:%.*]] : $ClassWithConvenienceInit<T>, #ClassWithConvenienceInit.b!getter
+    // CHECK-NEXT: {{.*}} = apply [[B_GETTER]]<T>({{.*}})
+    _ = self.b
+
+    // CHECK: [[A_SETTER:%.*]] = class_method [[SELF:%.*]] : $ClassWithConvenienceInit<T>, #ClassWithConvenienceInit.a!setter
+    // CHECK-NEXT: {{.*}} = apply [[A_SETTER]]<T>({{.*}})
+    self.a = a
+
+    if let a {
+      // CHECK: [[B_SETTER:%.*]] = class_method [[SELF:%.*]] : $ClassWithConvenienceInit<T>, #ClassWithConvenienceInit.b!setter
+      // CHECK-NEXT: {{.*}} = apply [[B_SETTER]]<T>({{.*}})
+      self.b = "ultimate question"
+    }
+  }
+}