SILGen: Use vtable thunk abstraction for super_method instructions

The constant provided to the callee for super methods reference the
backing implementation, but the vtable entry may point to a thunk with
different abstraction when using mixed concrete and generic classes in
the hierarchy. The SIL devirtualizer expects super method references to
match what's in the vtable.

Also update the verifier for SuperMethodInst types - before it required
that the types be the same, but they may not be for the same reasons noted
above. Instead, do a similar check as for ClassMethodInst.

https://bugs.swift.org/browse/SR-134

Author: bitjammer

lib/SIL/Verifier.cpp

@@ -1686,8 +1686,9 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   }
 
   void checkSuperMethodInst(SuperMethodInst *CMI) {
-    require(CMI->getType() == TC.getConstantType(CMI->getMember()),
-            "result type of super_method must match type of method");
+    auto overrideTy = TC.getConstantOverrideType(CMI->getMember());
+    requireSameType(CMI->getType(), SILType::getPrimitiveObjectType(overrideTy),
+                    "result type of super_method must match abstracted type of method");
     auto methodType = requireObjectType(SILFunctionType, CMI,
                                         "result of super_method");
     require(!methodType->getExtInfo().hasContext(),

lib/SILGen/SILGenApply.cpp

@@ -593,13 +593,15 @@ class Callee {
       constant = Constant.atUncurryLevel(level);
       constantInfo = gen.getConstantInfo(*constant);
 
-      SILValue methodVal = gen.B.createSuperMethod(Loc,
-                                                   SelfValue,
-                                                   *constant,
-                                                   constantInfo.getSILType(),
-                                                   /*volatile*/
-                                                     constant->isForeign);
-
+      if (SILDeclRef baseConstant = Constant.getOverriddenVTableEntry())
+        constantInfo = gen.SGM.Types.getConstantOverrideInfo(Constant,
+                                                             baseConstant);
+      auto methodVal = gen.B.createSuperMethod(Loc,
+                                               SelfValue,
+                                               *constant,
+                                               constantInfo.getSILType(),
+                                               /*volatile*/
+                                                 constant->isForeign);
       mv = ManagedValue::forUnmanaged(methodVal);
       break;
     }

test/IRGen/concrete_inherits_generic_base.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -module-name foo -emit-ir %s | FileCheck %s
+// RUN: %target-swift-frontend -use-native-super-method -module-name foo -emit-ir %s | FileCheck %s
 
 // -- Classes with generic bases can't go in the @objc_classes list, since
 //    they need runtime initialization before they're valid.

test/SILPasses/super_method.swift

@@ -28,3 +28,65 @@ class Grandchild : Child {
     super.foo()
   }
 }
+
+class GenericParent<A> {
+  let a: A
+  init(a: A) {
+    self.a = a
+  }
+
+  func onlyInParent() {}
+
+  @inline(never)
+  final func finalOnlyInParent() {}
+
+  @inline(never)
+  func method() {}
+
+  @inline(never)
+  class func classMethod() {}
+}
+
+class GenericChild<A> : GenericParent<A> {}
+
+class GenericGrandchild<A> : GenericChild<A> {
+  // CHECK-LABEL: sil hidden @_TFC12super_method17GenericGrandchild16onlyInGrandchildfT_T_ : $@convention(method) <A> (@guaranteed GenericGrandchild<A>) -> ()
+  func onlyInGrandchild() {
+    // CHECK: super_method {{%[0-9+]}} : $GenericGrandchild<A>, #GenericParent.onlyInParent!1 : <A> GenericParent<A> -> () -> () , $@convention(method) <τ_0_0> (@guaranteed GenericParent<τ_0_0>) -> ()
+    super.onlyInParent()
+    // CHECK: function_ref @_TFC12super_method13GenericParent17finalOnlyInParentfT_T_ : $@convention(method) <τ_0_0> (@guaranteed GenericParent<τ_0_0>) -> ()
+    super.finalOnlyInParent()
+  }
+  // CHECK-LABEL: sil hidden @_TFC12super_method17GenericGrandchild6methodfT_T_ : $@convention(method) <A> (@guaranteed GenericGrandchild<A>) -> ()
+  override func method() {
+    // CHECK: super_method {{%[0-9]+}} : $GenericGrandchild<A>, #GenericParent.method!1 : <A> GenericParent<A> -> () -> () , $@convention(method) <τ_0_0> (@guaranteed GenericParent<τ_0_0>) -> ()
+    super.method()
+  }
+}
+
+class ConcreteChild : GenericParent<String> {
+  // CHECK-LABEL: sil hidden @_TFC12super_method13ConcreteChildcfT1aSS_S0_ : $@convention(method) (@owned String, @owned ConcreteChild) -> @owned ConcreteChild
+  override init(a: String) {
+    // CHECK-NOT: super_method {{%[0-9]+}} : $ConcreteChild, #GenericParent.init!initializer.1
+    // CHECK: [[INIT_FN_REF:%[0-9]+]] = function_ref @_TFC12super_method13GenericParentcfT1ax_GS0_x_ : $@convention(method) <τ_0_0> (@in τ_0_0, @owned GenericParent<τ_0_0>) -> @owned GenericParent<τ_0_0> // user: %10
+    // CHECK-NEXT: apply [[INIT_FN_REF]]
+    super.init(a: a)
+  }
+}
+
+class ConcreteGrandchild : ConcreteChild {
+  // CHECK-LABEL: sil hidden @_TFC12super_method18ConcreteGrandchild16onlyInGrandchildfT_T_ : $@convention(method) (@guaranteed ConcreteGrandchild) -> ()
+  func onlyInGrandchild() {
+    // CHECK-NOT: super_method {{%[0-9]+}} : $ConcreteGrandchild, #GenericParent.onlyInParent!1
+    // CHECK: function_ref @_TFC12super_method13GenericParent12onlyInParentfT_T_ : $@convention(method) <τ_0_0> (@guaranteed GenericParent<τ_0_0>) -> ()
+    super.onlyInParent()
+    // CHECK: function_ref @_TFC12super_method13GenericParent17finalOnlyInParentfT_T_ : $@convention(method) <τ_0_0> (@guaranteed GenericParent<τ_0_0>) -> ()
+    super.finalOnlyInParent()
+  }
+  // CHECK-LABEL: sil hidden @_TFC12super_method18ConcreteGrandchild6methodfT_T_ : $@convention(method) (@guaranteed ConcreteGrandchild) -> ()
+  override func method() {
+    // CHECK-NOT: super_method {{%[0-9]+}} : $ConcreteGrandchild, #GenericParent.method!1
+    // CHECK: function_ref @_TFC12super_method13GenericParent6methodfT_T_ : $@convention(method) <τ_0_0> (@guaranteed GenericParent<τ_0_0>) -> ()
+    super.method()
+  }
+}