Merge pull request #13718 from slavapestov/class-resilience-part-12

Class resilience part 12

Author: slavapestov

lib/IRGen/GenMeta.cpp

@@ -2952,11 +2952,6 @@ namespace {
       return B.getNextOffsetFromGlobal() - TemplateHeaderSize;
     }
 
-    /// Ignore the destructor and value witness table.
-    Size getNextOffsetFromAddressPoint() const {
-      return getNextOffsetFromTemplateHeader() - AddressPoint;
-    }
-
     template <class... T>
     void addGenericArgument(CanType type, T &&...args) {
       FillOps.push_back({type, None});
@@ -3209,7 +3204,6 @@ namespace {
 
   public:
     void noteResilientSuperclass() {
-      // FIXME: Perform sliding
       HasResilientSuperclass = true;
     }
 
@@ -3239,8 +3233,10 @@ namespace {
 
         // Otherwise, we know the offset at compile time, even if our
         // clients do not, so just emit a constant.
-        auto value = asImpl().getNextOffsetFromAddressPoint().getValue();
-        auto *init = llvm::ConstantInt::get(IGM.SizeTy, value);
+        auto &layout = IGM.getMetadataLayout(theClass);
+
+        auto value = layout.getStartOfImmediateMembers();
+        auto *init = llvm::ConstantInt::get(IGM.SizeTy, value.getValue());
 
         offsetVar->setInitializer(init);
         offsetVar->setConstant(true);
@@ -3518,13 +3514,15 @@ namespace {
       Address sizeSlot = IGF.Builder.CreateConstByteArrayGEP(
           metadataAsBytes,
           layout.getMetadataSizeOffset());
-      sizeSlot = IGF.Builder.CreateBitCast(sizeSlot, IGM.Int32Ty->getPointerTo());
+      sizeSlot = IGF.Builder.CreateBitCast(sizeSlot,
+                                           IGM.Int32Ty->getPointerTo());
       llvm::Value *size = IGF.Builder.CreateLoad(sizeSlot);
 
       Address addressPointSlot = IGF.Builder.CreateConstByteArrayGEP(
           metadataAsBytes,
           layout.getMetadataAddressPointOffset());
-      addressPointSlot = IGF.Builder.CreateBitCast(addressPointSlot, IGM.Int32Ty->getPointerTo());
+      addressPointSlot = IGF.Builder.CreateBitCast(addressPointSlot,
+                                                   IGM.Int32Ty->getPointerTo());
       llvm::Value *addressPoint = IGF.Builder.CreateLoad(addressPointSlot);
 
       size = IGF.Builder.CreateSub(size, addressPoint);
@@ -3668,10 +3666,6 @@ namespace {
       AddressPoint = B.getNextOffsetFromGlobal();
     }
 
-    Size getNextOffsetFromAddressPoint() const {
-      return B.getNextOffsetFromGlobal() - AddressPoint;
-    }
-
     void addSuperClass() {
       // If this is a root class, use SwiftObject as our formal parent.
       if (!Target->hasSuperclass()) {

lib/IRGen/MetadataLayout.cpp

@@ -271,6 +271,8 @@ ClassMetadataLayout::ClassMetadataLayout(IRGenModule &IGM, ClassDecl *decl)
       // If our superclass is resilient to us, or the class itself is resilient
       // to us, we will access metadata members relative to a base offset.
       if (forClass == Target) {
+        Layout.StartOfImmediateMembers = getNextOffset();
+
         if (Layout.HasResilientSuperclass ||
             IGM.isResilient(forClass, ResilienceExpansion::Maximal)) {
           assert(!DynamicOffsetBase);

lib/IRGen/MetadataLayout.h

@@ -177,6 +177,8 @@ class ClassMetadataLayout : public NominalMetadataLayout {
 private:
   bool HasResilientSuperclass = false;
 
+  StoredOffset StartOfImmediateMembers;
+
   StoredOffset MetadataSize;
   StoredOffset MetadataAddressPoint;
 
@@ -270,6 +272,12 @@ class ClassMetadataLayout : public NominalMetadataLayout {
 
   Offset getFieldOffsetVectorOffset(IRGenFunction &IGF) const;
 
+  /// If the start of the immediate members is statically known, this
+  /// method will return it. Otherwise, it will assert.
+  Size getStartOfImmediateMembers() const {
+    return StartOfImmediateMembers.getStaticOffset();
+  }
+
   /// The number of members to add after superclass metadata. The size of
   /// this metadata is the superclass size plus the number of immediate
   /// members in the class itself.

test/IRGen/class_resilience.swift

@@ -59,6 +59,10 @@
 
 // CHECK: @_T016class_resilience16MyResilientChildCMo = {{(protected )?}}constant [[INT]] {{60|96}}
 
+// CHECK: @_T016class_resilience24MyResilientGenericParentCMo = {{(protected )?}}constant [[INT]] {{52|80}}
+
+// CHECK: @_T016class_resilience24MyResilientConcreteChildCMo = {{(protected )?}}constant [[INT]] {{64|104}}
+
 import resilient_class
 import resilient_struct
 import resilient_enum
@@ -164,6 +168,23 @@ public class MyResilientChild : MyResilientParent {
 }
 
 
+public class MyResilientGenericParent<T> {
+  public let t: T
+
+  public init(t: T) {
+    self.t = t
+  }
+}
+
+public class MyResilientConcreteChild : MyResilientGenericParent<Int> {
+  public let x: Int
+
+  public init(x: Int) {
+    self.x = x
+    super.init(t: x)
+  }
+}
+
 extension ResilientGenericOutsideParent {
   public func genericExtensionMethod() -> A.Type {
     return A.self

validation-test/Evolution/Inputs/class_add_property_subclass.swift

@@ -0,0 +1,32 @@
+
+#if BEFORE
+
+open class AddStoredProperty {
+  public let x: Int
+
+  public init(x: Int) {
+    self.x = x
+  }
+
+  public func get() -> (Int, Int) {
+    return (x, -x)
+  }
+}
+
+#else
+
+open class AddStoredProperty {
+  public let x: Int
+  public let y: Int
+
+  public init(x: Int) {
+    self.x = x
+    self.y = -x
+  }
+
+  public func get() -> (Int, Int) {
+    return (x, y)
+  }
+}
+
+#endif

validation-test/Evolution/Inputs/class_add_virtual_method_subclass.swift

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

validation-test/Evolution/Inputs/class_insert_superclass.swift

@@ -0,0 +1,91 @@
+
+#if BEFORE
+
+open class FirstMiddle {
+  let x: String
+
+  public init(x: String) {
+    self.x = x
+  }
+
+  public func get() -> String {
+    return x
+  }
+}
+
+open class SecondMiddle {
+  let x: String
+
+  public init(x: String) {
+    self.x = x
+  }
+
+  public func get() -> String {
+    return x
+  }
+}
+
+open class GenericMiddle<T> {
+  let x: T
+
+  public init(x: T) {
+    self.x = x
+  }
+
+  public func get() -> T {
+    return x
+  }
+}
+
+#else
+
+// Insert concrete superclass
+open class Base {
+  let x: String
+
+  public init(t: String) {
+    self.x = t
+  }
+}
+
+open class FirstMiddle : Base {
+  public init(x: String) {
+    super.init(t: x)
+  }
+
+  public func get() -> String {
+    return x
+  }
+}
+
+// Insert generic superclass
+open class GenericBase<T> {
+  let x: T
+
+  public init(t: T) {
+    self.x = t
+  }
+}
+
+open class SecondMiddle : GenericBase<String> {
+  public init(x: String) {
+    super.init(t: x)
+  }
+
+  public func get() -> String {
+    return x
+  }
+}
+
+// Insert concrete superclass - class itself is generic
+open class GenericMiddle<T> : GenericBase<T> {
+  public init(x: T) {
+    super.init(t: x)
+  }
+
+  public func get() -> T {
+    return x
+  }
+}
+
+#endif

validation-test/Evolution/test_class_add_property_subclass.swift

@@ -0,0 +1,44 @@
+// RUN: %target-resilience-test
+// REQUIRES: executable_test
+
+import StdlibUnittest
+import class_add_property_subclass
+
+
+var ClassAddPropertySubclassTest = TestSuite("ClassAddPropertySubclass")
+
+class AddStoredPropertySubclass : AddStoredProperty {
+  var z: Int
+
+  init(x: Int, z: Int) {
+    self.z = z
+    super.init(x: x)
+  }
+}
+
+ClassAddPropertySubclassTest.test("AddStoredProperty") {
+  let t = AddStoredPropertySubclass(x: 1, z: 2)
+
+  expectEqual(1, t.get().0)
+  expectEqual(-1, t.get().1)
+  expectEqual(2, t.z)
+}
+
+class AddStoredPropertyGenericSubclass<T> : AddStoredProperty {
+  var z: T
+
+  init(x: Int, z: T) {
+    self.z = z
+    super.init(x: x)
+  }
+}
+
+ClassAddPropertySubclassTest.test("AddStoredPropertyGeneric") {
+  let t = AddStoredPropertyGenericSubclass(x: 1, z: "hello world")
+
+  expectEqual(1, t.get().0)
+  expectEqual(-1, t.get().1)
+  expectEqual("hello world", t.z)
+}
+
+runAllTests()

validation-test/Evolution/test_class_add_virtual_method_subclass.swift

@@ -0,0 +1,37 @@
+// RUN: %target-resilience-test
+// REQUIRES: executable_test
+
+import StdlibUnittest
+import class_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 : Strideable> : AddVirtualMethod
+    where T.Stride == Int {
+  func f3(_ t: T) -> T {
+    return t + f1()
+  }
+}
+
+ClassAddVirtualMethodSubclassTest.test("AddVirtualMethodGeneric") {
+  let t = AddVirtualMethodGenericSubclass<Int32>()
+
+  expectEqual(1, t.f1())
+  expectEqual(2, t.f3(1))
+}
+
+runAllTests()