More resilient class layout tests

Looks like subclassing classes with resiliently-sized properties works,
as long as the subclass is @_fixed_layout, so let's ensure that's tested.

We don't want @_fixed_layout classes to be a thing though, and we still
can't handle changes to the number of stored properties in a base class,
so a couple of tests are disabled until I land some more patches.

Author: slavapestov

test/IRGen/class_resilience.swift

@@ -37,6 +37,7 @@ public class ClassWithResilientProperty {
   }
 }
 
+
 // Concrete class with non-fixed size stored property
 
 public class ClassWithResilientlySizedProperty {

test/Inputs/resilient_class.swift

@@ -1,3 +1,9 @@
+
+import resilient_struct
+
+
+// Fixed-layout, fixed-size base class
+
 @_fixed_layout
 public class OutsideParent {
   public var property: String = "OutsideParent.property"
@@ -19,6 +25,25 @@ public class OutsideParent {
   }
 }
 
+
+// Fixed-layout, resiliently-sized base class
+
+@_fixed_layout
+public class OutsideParentWithResilientProperty {
+  public let p: Point
+  public let s: Size
+  public let color: Int32
+
+  public init(p: Point, s: Size, color: Int32) {
+    self.p = p
+    self.s = s
+    self.color = color
+  }
+}
+
+
+// Resilient base class
+
 public class ResilientOutsideParent {
   public var property: String = "ResilientOutsideParent.property"
   public final var finalProperty: String = "ResilientOutsideParent.finalProperty"
@@ -40,6 +65,9 @@ public class ResilientOutsideParent {
   }
 }
 
+
+// Fixed-layout, fixed-size subclass
+
 @_fixed_layout
 public class OutsideChild : OutsideParent {
   public override func method() {
@@ -53,6 +81,9 @@ public class OutsideChild : OutsideParent {
   }
 }
 
+
+// Resilient subclass
+
 public class ResilientOutsideChild : ResilientOutsideParent {
   public override func method() {
     print("ResilientOutsideChild.method()")
@@ -65,6 +96,9 @@ public class ResilientOutsideChild : ResilientOutsideParent {
   }
 }
 
+
+// Fixed-layout, dependently-sized, generic base class
+
 @_fixed_layout
 public class GenericOutsideParent<A> {
   public var property: A
@@ -82,6 +116,9 @@ public class GenericOutsideParent<A> {
   }
 }
 
+
+// Resilient generic base class
+
 public class ResilientGenericOutsideParent<A> {
   public var property: A
   public init(property: A) {
@@ -98,6 +135,9 @@ public class ResilientGenericOutsideParent<A> {
   }
 }
 
+
+// Fixed-layout, dependently-sized, generic subclass
+
 @_fixed_layout
 public class GenericOutsideChild<A> : GenericOutsideParent<A> {
   public override init(property: A) {
@@ -116,6 +156,9 @@ public class GenericOutsideChild<A> : GenericOutsideParent<A> {
   }
 }
 
+
+// Resilient generic subclass
+
 public class ResilientGenericOutsideChild<A> : ResilientGenericOutsideParent<A> {
   public override init(property: A) {
     print("ResilientGenericOutsideGenericChild.init(a: A)")
@@ -133,6 +176,9 @@ public class ResilientGenericOutsideChild<A> : ResilientGenericOutsideParent<A>
   }
 }
 
+
+// Fixed-layout, fixed-size subclass of generic class
+
 @_fixed_layout
 public class ConcreteOutsideChild : GenericOutsideParent<String> {
   public override init(property: String) {
@@ -151,6 +197,9 @@ public class ConcreteOutsideChild : GenericOutsideParent<String> {
   }
 }
 
+
+// Resilient subclass of generic class
+
 public class ResilientConcreteOutsideChild : ResilientGenericOutsideParent<String> {
   public override init(property: String) {
     print("ResilientConcreteOutsideChild.init(property: String)")

test/Interpreter/class_resilience.swift

@@ -43,6 +43,35 @@ ResilientClassTestSuite.test("ClassWithResilientProperty") {
   expectEqual(c.color, 50)
 }
 
+
+// Generic class with resilient stored property
+
+public class GenericClassWithResilientProperty<T> {
+  public let s1: Size
+  public let t: T
+  public let s2: Size
+
+  public init(s1: Size, t: T, s2: Size) {
+    self.s1 = s1
+    self.t = t
+    self.s2 = s2
+  }
+}
+
+ResilientClassTestSuite.test("GenericClassWithResilientProperty") {
+  let c = GenericClassWithResilientProperty<Int32>(
+      s1: Size(w: 10, h: 20),
+      t: 30,
+      s2: Size(w: 40, h: 50))
+
+  expectEqual(c.s1.w, 10)
+  expectEqual(c.s1.h, 20)
+  expectEqual(c.t, 30)
+  expectEqual(c.s2.w, 40)
+  expectEqual(c.s2.h, 50)
+}
+
+
 // Concrete class with non-fixed size stored property
 
 public class ClassWithResilientlySizedProperty {
@@ -71,4 +100,125 @@ ResilientClassTestSuite.test("ClassWithResilientlySizedProperty") {
   expectEqual(c.color, 60)
 }
 
+
+// Concrete subclass of fixed-layout class with resilient stored property
+
+public class ChildOfParentWithResilientStoredProperty : ClassWithResilientProperty {
+  let enabled: Int32
+
+  public init(p: Point, s: Size, color: Int32, enabled: Int32) {
+    self.enabled = enabled
+    super.init(p: p, s: s, color: color)
+  }
+}
+
+ResilientClassTestSuite.test("ChildOfParentWithResilientStoredProperty") {
+  let c = ChildOfParentWithResilientStoredProperty(
+      p: Point(x: 10, y: 20),
+      s: Size(w: 30, h: 40),
+      color: 50,
+      enabled: 60)
+
+  expectEqual(c.p.x, 10)
+  expectEqual(c.p.y, 20)
+  expectEqual(c.s.w, 30)
+  expectEqual(c.s.h, 40)
+  expectEqual(c.color, 50)
+  expectEqual(c.enabled, 60)
+}
+
+
+// Concrete subclass of fixed-layout class with resilient stored property
+
+public class ChildOfOutsideParentWithResilientStoredProperty : OutsideParentWithResilientProperty {
+  let enabled: Int32
+
+  public init(p: Point, s: Size, color: Int32, enabled: Int32) {
+    self.enabled = enabled
+    super.init(p: p, s: s, color: color)
+  }
+}
+
+ResilientClassTestSuite.test("ChildOfOutsideParentWithResilientStoredProperty") {
+  let c = ChildOfOutsideParentWithResilientStoredProperty(
+      p: Point(x: 10, y: 20),
+      s: Size(w: 30, h: 40),
+      color: 50,
+      enabled: 60)
+
+  expectEqual(c.p.x, 10)
+  expectEqual(c.p.y, 20)
+  expectEqual(c.s.w, 30)
+  expectEqual(c.s.h, 40)
+  expectEqual(c.color, 50)
+  expectEqual(c.enabled, 60)
+}
+
+
+// Resilient class from a different resilience domain
+
+ResilientClassTestSuite.test("ResilientOutsideParent") {
+  let c = ResilientOutsideParent()
+
+  expectEqual(c.property, "ResilientOutsideParent.property")
+  expectEqual(c.finalProperty, "ResilientOutsideParent.finalProperty")
+}
+
+
+// FIXME: needs indirect metadata access
+
+#if false
+// Concrete subclass of resilient class
+
+public class ChildOfResilientOutsideParent : ResilientOutsideParent {
+  let enabled: Int32
+
+  public init(enabled: Int32) {
+    self.enabled = enabled
+    super.init()
+  }
+}
+
+ResilientClassTestSuite.test("ChildOfResilientOutsideParent") {
+  let c = ChildOfResilientOutsideParent(enabled: 60)
+
+  expectEqual(c.property, "ResilientOutsideParent.property")
+  expectEqual(c.finalProperty, "ResilientOutsideParent.finalProperty")
+  expectEqual(c.enabled, 60)
+}
+
+
+// Concrete subclass of resilient class
+
+public class ChildOfResilientOutsideParentWithResilientStoredProperty : ResilientOutsideParent {
+  public let p: Point
+  public let s: Size
+  public let color: Int32
+
+  public init(p: Point, s: Size, color: Int32) {
+    self.p = p
+    self.s = s
+    self.color = color
+    super.init()
+  }
+}
+
+ResilientClassTestSuite.test("ChildOfResilientOutsideParentWithResilientStoredProperty") {
+  let c = ChildOfResilientOutsideParentWithResilientStoredProperty(
+      p: Point(x: 10, y: 20),
+      s: Size(w: 30, h: 40),
+      color: 50)
+
+  expectEqual(c.property, "ResilientOutsideParent.property")
+  expectEqual(c.finalProperty, "ResilientOutsideParent.finalProperty")
+
+  expectEqual(c.p.x, 10)
+  expectEqual(c.p.y, 20)
+  expectEqual(c.s.w, 30)
+  expectEqual(c.s.h, 40)
+  expectEqual(c.color, 50)
+}
+#endif
+
+
 runAllTests()