Evolution: Add some tests for @_fixed_layout classes

@_fixed_layout classes have resilient vtables now, so we can add and
re-order methods.

Removing overrides is not legal though because they are subject to
devirtualization.

Author: slavapestov

validation-test/Evolution/Inputs/class_fixed_layout_add_virtual_method.swift

@@ -0,0 +1,45 @@
+
+public func getVersion() -> Int {
+#if BEFORE
+  return 0
+#else
+  return 1
+#endif
+}
+
+#if BEFORE
+
+@_fixed_layout
+public class AddVirtualMethod {
+  public init() {}
+
+  public func firstMethod() -> Int {
+    return 1
+  }
+
+  public func secondMethod() -> Int {
+    return 2
+  }
+}
+
+#else
+
+@_fixed_layout
+public class AddVirtualMethod {
+  // Note: methods were re-ordered, new method added in the middle
+  public func secondMethod() -> Int {
+    return 2
+  }
+
+  public func thirdMethod() -> Int {
+    return 3
+  }
+
+  public func firstMethod() -> Int {
+    return 1
+  }
+
+  public init() {}
+}
+
+#endif

validation-test/Evolution/Inputs/class_fixed_layout_add_virtual_method_subclass.swift

@@ -0,0 +1,28 @@
+
+#if BEFORE
+
+@_fixed_layout
+open class AddVirtualMethod {
+  public init() {}
+
+  open func f1() -> Int {
+    return 1
+  }
+}
+
+#else
+
+@_fixed_layout
+open class AddVirtualMethod {
+  public init() {}
+
+  open func f1() -> Int {
+    return f2() + 1
+  }
+
+  open func f2() -> Int {
+    return 0
+  }
+}
+
+#endif

validation-test/Evolution/Inputs/class_fixed_layout_superclass_reorder_methods.swift

@@ -0,0 +1,48 @@
+public func getVersion() -> Int {
+#if BEFORE
+  return 0
+#else
+  return 1
+#endif
+}
+
+#if BEFORE
+@_fixed_layout
+open class Base {
+  public init() {}
+  open func firstMethod() -> Int {
+    return 1
+  }
+  open func secondMethod() -> Int {
+    return 2
+  }
+  open func callOverriddenMethods() -> Int {
+    return firstMethod() * 10 + secondMethod()
+  }
+}
+#else
+@_fixed_layout
+open class Base {
+  public init() {}
+  open func secondMethod() -> Int {
+    return 2
+  }
+  open func firstMethod() -> Int {
+    return 1
+  }
+  open func callOverriddenMethods() -> Int {
+    return firstMethod() * 10 + secondMethod()
+  }
+}
+#endif
+
+@_fixed_layout
+public class Derived : Base {
+  public override func firstMethod() -> Int {
+    return 10
+  }
+
+  public override func secondMethod() -> Int {
+    return 20
+  }
+}

validation-test/Evolution/test_class_fixed_layout_add_virtual_method.swift

@@ -0,0 +1,19 @@
+// RUN: %target-resilience-test
+// REQUIRES: executable_test
+
+import StdlibUnittest
+import class_fixed_layout_add_virtual_method
+
+
+var ClassAddVirtualMethodTest = TestSuite("ClassAddVirtualMethod")
+
+ClassAddVirtualMethodTest.test("ClassAddVirtualMethod") {
+  let c = AddVirtualMethod()
+
+  do {
+    expectEqual(1, c.firstMethod())
+    expectEqual(2, c.secondMethod())
+  }
+}
+
+runAllTests()

validation-test/Evolution/test_class_fixed_layout_add_virtual_method_subclass.swift

@@ -0,0 +1,36 @@
+// RUN: %target-resilience-test
+// REQUIRES: executable_test
+
+import StdlibUnittest
+import class_fixed_layout_add_virtual_method_subclass
+
+
+var ClassAddVirtualMethodSubclassTest = TestSuite("ClassAddVirtualMethodSubclass")
+
+class AddVirtualMethodSubclass : AddVirtualMethod {
+  func f3() -> Int {
+    return f1() + 1
+  }
+}
+
+ClassAddVirtualMethodSubclassTest.test("AddVirtualMethod") {
+  let t = AddVirtualMethodSubclass()
+
+  expectEqual(1, t.f1())
+  expectEqual(2, t.f3())
+}
+
+class AddVirtualMethodGenericSubclass<T> : AddVirtualMethod {
+  func f3(_ t: T) -> [Int : T] {
+     return [f1() : t]
+  }
+}
+
+ClassAddVirtualMethodSubclassTest.test("AddVirtualMethodGeneric") {
+  let t = AddVirtualMethodGenericSubclass<String>()
+
+  expectEqual(1, t.f1())
+  expectEqual([1 : "hi"], t.f3("hi"))
+}
+
+runAllTests()

validation-test/Evolution/test_class_fixed_layout_superclass_reorder_methods.swift

@@ -0,0 +1,53 @@
+// RUN: %target-resilience-test
+// REQUIRES: executable_test
+
+import StdlibUnittest
+import class_fixed_layout_superclass_reorder_methods
+
+
+var SuperclassReorderMethodsTest = TestSuite("SuperclassReorderMethods")
+
+SuperclassReorderMethodsTest.test("TestOverrides") {
+  class MyDerived : Base {
+    override func firstMethod() -> Int {
+      return 3
+    }
+    override func secondMethod() -> Int {
+      return 4
+    }
+  }
+
+  expectEqual(MyDerived().callOverriddenMethods(), 34)
+}
+
+SuperclassReorderMethodsTest.test("TestSuper") {
+  class MyDerived : Base {
+    override func firstMethod() -> Int {
+      return super.firstMethod() + 3
+    }
+    override func secondMethod() -> Int {
+      return super.secondMethod() + 3
+    }
+  }
+
+  expectEqual(MyDerived().callOverriddenMethods(), 45)
+}
+
+extension Derived {
+  public func firstMethodExt() -> Int {
+    return firstMethod() + super.firstMethod()
+  }
+
+  public func secondMethodExt() -> Int {
+    return secondMethod() + super.secondMethod()
+  }
+}
+
+SuperclassReorderMethodsTest.test("TestSuperExtension") {
+  let obj = Derived()
+  expectEqual(obj.firstMethodExt(), 11)
+  expectEqual(obj.secondMethodExt(), 22)
+}
+
+runAllTests()
+