SILGen: Use the base SILDeclRef for super_method override constant info

getOverriddenVTableEntry only goes one level up in the class hierarchy,
but getConstantOverrideInfo requires that the next level up not itself be an
override.

A little bit of refactoring:

SILDeclRef::getOverriddenVTableEntry()
  -> SILDeclRef::getNextOverriddenVTableEntry()

static findOverriddenFunction()
  -> SILDeclRef::getBaseOverriddenVTableEntry()

rdar://problem/22749732

Author: bitjammer

include/swift/SIL/SILDeclRef.h

@@ -341,7 +341,11 @@ struct SILDeclRef {
   /// Return a SILDeclRef to the declaration whose vtable entry this declaration
   /// overrides. This may be different from "getOverridden" because some
   /// declarations do not always have vtable entries.
-  SILDeclRef getOverriddenVTableEntry() const;
+  SILDeclRef getNextOverriddenVTableEntry() const;
+
+  /// Return a SILDeclRef referring to the ultimate base class's declaration,
+  /// which must be used with getConstantOverrideInfo.
+  SILDeclRef getBaseOverriddenVTableEntry() const;
 
   /// True if the referenced entity is some kind of thunk.
   bool isThunk() const;

include/swift/SIL/TypeLowering.h

@@ -695,7 +695,7 @@ class TypeConverter {
   /// not override.
   CanSILFunctionType getConstantOverrideType(SILDeclRef constant) {
     // Fast path if the constant isn't overridden.
-    if (constant.getOverriddenVTableEntry().isNull())
+    if (constant.getNextOverriddenVTableEntry().isNull())
       return getConstantFunctionType(constant);
     SILDeclRef base = constant;
     while (SILDeclRef overridden = base.getOverridden())

lib/IRGen/ClassMetadataLayout.h

@@ -212,7 +212,7 @@ template <class Impl> class ClassMetadataLayout : public MetadataLayout<Impl> {
                       unsigned uncurryLevel) {
     SILDeclRef declRef(fn, kind, explosionLevel, uncurryLevel);
     // If the method overrides something, we don't need a new entry.
-    if (declRef.getOverriddenVTableEntry())
+    if (declRef.getNextOverriddenVTableEntry())
       return;
 
     // Both static and non-static functions go in the metadata.

lib/IRGen/GenMeta.cpp

@@ -4279,21 +4279,6 @@ AbstractCallee irgen::getAbstractVirtualCallee(IRGenFunction &IGF,
                         naturalUncurry, naturalUncurry, ExtraData::None);
 }
 
-/// Find the function which will actually appear in the virtual table.
-static SILDeclRef findOverriddenFunction(IRGenModule &IGM,
-                                         SILDeclRef method) {
-  // 'method' is the most final method in the hierarchy which we
-  // haven't yet found a compatible override for.  'cur' is the method
-  // we're currently looking at.  Compatibility is transitive,
-  // so we can forget our original method and just keep going up.
-
-  SILDeclRef cur = method;
-  while ((cur = cur.getOverriddenVTableEntry())) {
-    method = cur;
-  }
-  return method;
-}
-
 /// Load the correct virtual function for the given class method.
 llvm::Value *irgen::emitVirtualMethodValue(IRGenFunction &IGF,
                                            llvm::Value *base,
@@ -4305,8 +4290,7 @@ llvm::Value *irgen::emitVirtualMethodValue(IRGenFunction &IGF,
     = cast<AbstractFunctionDecl>(method.getDecl());
 
   // Find the function that's actually got an entry in the metadata.
-  SILDeclRef overridden =
-    findOverriddenFunction(IGF.IGM, method);
+  SILDeclRef overridden = method.getBaseOverriddenVTableEntry();
 
   // Find the metadata.
   llvm::Value *metadata;

lib/SIL/SILDeclRef.cpp

@@ -512,7 +512,7 @@ StringRef SILDeclRef::mangle(SmallVectorImpl<char> &buffer,
   return stream.str();
 }
 
-SILDeclRef SILDeclRef::getOverriddenVTableEntry() const {
+SILDeclRef SILDeclRef::getNextOverriddenVTableEntry() const {
   if (auto overridden = getOverridden()) {
     // If we overrode a foreign decl, a dynamic method, this is an
     // accessor for a property that overrides an ObjC decl, or if it is an
@@ -544,6 +544,19 @@ SILDeclRef SILDeclRef::getOverriddenVTableEntry() const {
   return SILDeclRef();
 }
 
+SILDeclRef SILDeclRef::getBaseOverriddenVTableEntry() const {
+  // 'method' is the most final method in the hierarchy which we
+  // haven't yet found a compatible override for.  'cur' is the method
+  // we're currently looking at.  Compatibility is transitive,
+  // so we can forget our original method and just keep going up.
+  SILDeclRef method = *this;
+  SILDeclRef cur = method;
+  while ((cur = cur.getNextOverriddenVTableEntry())) {
+    method = cur;
+  }
+  return method;
+}
+
 SILLocation SILDeclRef::getAsRegularLocation() const {
   if (hasDecl())
     return RegularLocation(getDecl());

lib/SIL/SILFunctionType.cpp

@@ -1736,7 +1736,7 @@ SILConstantInfo TypeConverter::getConstantOverrideInfo(SILDeclRef derived,
   if (found != ConstantOverrideTypes.end())
     return found->second;
 
-  assert(base.getOverriddenVTableEntry().isNull()
+  assert(base.getNextOverriddenVTableEntry().isNull()
          && "base must not be an override");
 
   auto baseInfo = getConstantInfo(base);

lib/SILAnalysis/BasicCalleeAnalysis.cpp

@@ -94,7 +94,7 @@ void CalleeCache::computeClassMethodCalleesForClass(ClassDecl *CD) {
       if (canCallUnknown)
         TheCallees.setInt(true);
 
-      Method = Method.getOverriddenVTableEntry();
+      Method = Method.getNextOverriddenVTableEntry();
     } while (Method);
   }
 }

lib/SILGen/SILGenApply.cpp

@@ -593,7 +593,7 @@ class Callee {
       constant = Constant.atUncurryLevel(level);
       constantInfo = gen.getConstantInfo(*constant);
 
-      if (SILDeclRef baseConstant = Constant.getOverriddenVTableEntry())
+      if (SILDeclRef baseConstant = Constant.getBaseOverriddenVTableEntry())
         constantInfo = gen.SGM.Types.getConstantOverrideInfo(Constant,
                                                              baseConstant);
       auto methodVal = gen.B.createSuperMethod(Loc,

lib/SILGen/SILGenType.cpp

@@ -232,7 +232,7 @@ class SILGenVTable : public Lowering::ASTVisitor<SILGenVTable> {
     // Try to find an overridden entry.
     // NB: Mutates vtableEntries in-place
     // FIXME: O(n^2)
-    if (auto overridden = member.getOverriddenVTableEntry()) {
+    if (auto overridden = member.getNextOverriddenVTableEntry()) {
       for (SILVTable::Pair &entry : vtableEntries) {
         SILDeclRef ref = overridden;
 

test/SILGen/super_method.swift

@@ -9,17 +9,25 @@ class Parent {
 class Child : Parent {}
 
 class Grandchild : Child {
-  // CHECK: sil hidden @_TFC12super_method10Grandchild16onlyInGrandchildfT_T_
+  // CHECK-LABEL: sil hidden @_TFC12super_method10Grandchild16onlyInGrandchildfT_T_
   func onlyInGrandchild() {
     // CHECK: super_method %0 : $Grandchild, #Parent.onlyInParent!1 : Parent -> () -> ()
     super.onlyInParent()
     // CHECK: function_ref super_method.Parent.finalOnlyInParent
     super.finalOnlyInParent()
   }
 
-  // CHECK: sil hidden @_TFC12super_method10Grandchild3foofT_T_
+  // CHECK-LABEL: sil hidden @_TFC12super_method10Grandchild3foofT_T_
   override func foo() {
     // CHECK: super_method %0 : $Grandchild, #Parent.foo!1 : Parent -> () -> ()
     super.foo()
   }
 }
+
+class GreatGrandchild : Grandchild {
+  // CHECK-LABEL: sil hidden @_TFC12super_method15GreatGrandchild3foofT_T_ : $@convention(method) (@guaranteed GreatGrandchild) -> ()
+  override func foo() {
+    // CHECK: super_method {{%[0-9]+}} : $GreatGrandchild, #Grandchild.foo!1 : Grandchild -> () -> () , $@convention(method) (@guaranteed Grandchild) -> ()
+    super.foo()
+  }
+}