handle cases where there are conflicting super methods

Author: yigit

api/src/main/kotlin/com/google/devtools/ksp/symbol/KSFunctionDeclaration.kt

@@ -76,6 +76,10 @@ interface KSFunctionDeclaration : KSDeclaration, KSDeclarationContainer {
      * Calling `findOverridee` on `C.x` will return `B.x`.
      * Calling `findOverridee` on `C.y` will return `A.y`.
      *
+     * When there are multiple super interfaces implementing the function, the closest declaration
+     * to the current containing declaration is selected. If they are in the same level, the
+     * function of the first specified interface (in source) will be returned.
+     *
      * @return [KSFunctionDeclaration] for the original function, if overriding, otherwise null.
      * Calling [findOverridee] is expensive and should be avoided if possible.
      */

compiler-plugin/src/main/kotlin/com/google/devtools/ksp/processor/OverrideeProcessor.kt

@@ -30,9 +30,15 @@ class OverrideeProcessor: AbstractTestProcessor() {
     override fun toResult() = results
 
     override fun process(resolver: Resolver) {
-        logSubject(resolver, "Subject");
-        logSubject(resolver, "JavaSubject.Subject");
-        logSubject(resolver, "lib.Subject");
+        logSubject(resolver, "Subject")
+        logSubject(resolver, "JavaSubject.Subject")
+        logSubject(resolver, "lib.Subject")
+        logSubject(resolver, "ConflictingSubject1")
+        logSubject(resolver, "ConflictingSubject2")
+        logSubject(resolver, "ConflictingSubject3")
+        logSubject(resolver, "ConflictingSubject4")
+        logSubject(resolver, "OverrideOrder1")
+        logSubject(resolver, "OverrideOrder2")
     }
 
     private fun logSubject(resolver: Resolver, qName:String) {
@@ -73,3 +79,21 @@ class OverrideeProcessor: AbstractTestProcessor() {
         private val IGNORED_METHOD_NAMES = listOf("equals", "hashCode", "toString")
     }
 }
+
+interface MyInterface {
+    fun openFoo(): Int { return 1}
+    fun absFoo(): Unit
+}
+
+interface MyInterface2 {
+    fun absFoo(): Unit
+}
+
+abstract class MyAbstract: MyInterface {
+    override fun absFoo(): Unit {val a = 1}
+    override fun openFoo(): Int { return 2 }
+}
+
+class Subject2: MyInterface, MyAbstract() {
+    override fun absFoo(): Unit = TODO()
+}

compiler-plugin/src/main/kotlin/com/google/devtools/ksp/symbol/impl/utils.kt

@@ -287,23 +287,27 @@ internal fun DeclarationDescriptor.findPsi(): PsiElement? {
  * @see KSFunctionDeclaration.findOverridee for docs.
  */
 internal fun FunctionDescriptor.findClosestOverridee(): FunctionDescriptor? {
-    val overriddenDescriptors = this.original.overriddenDescriptors
     // When there is an intermediate class between the overridden and our function, we might receive
     // a FAKE_OVERRIDE function which is not desired as we are trying to find the actual
     // declared method.
-    // First we try to find a non-fake function and if we cannot find, then we check the overridee
-    // of the fake override.
-    overriddenDescriptors.singleOrNull {
-        it.kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE
-    }?.let {
-        // always return the original. otherwise, returned function might have type arguments
-        // substituted when the function is resolved from a `.class` file (does not happen for
-        // functions resolved from kotlin or java source code)
-        return it.original
+
+    // we also want to return the closes function declaration. That is either the closest
+    // class / interface method OR in case of equal distance (e.g. diamon dinheritance), pick the
+    // one declared first in the code.
+
+    val queue = ArrayDeque<FunctionDescriptor>()
+    queue.add(this)
+
+    while (queue.isNotEmpty()) {
+        val current = queue.removeFirst()
+        val overriddenDescriptors = current.original.overriddenDescriptors
+        overriddenDescriptors.firstOrNull {
+            it.kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE
+        }?.let {
+            return it.original
+        }
+        // if all methods are fake, add them to the queue
+        queue.addAll(overriddenDescriptors)
     }
-    // if there is no declared function, there might be a fake override and we need to find its
-    // overridee.
-    return overriddenDescriptors.singleOrNull {
-        it.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE
-    }?.findClosestOverridee()
+    return null
 }

compiler-plugin/testData/api/overridee.kt

@@ -51,6 +51,18 @@
 // Subject.openGrandBaseFun() -> GrandBase.openGrandBaseFun()
 // Subject.overriddenAbstractGrandBaseFun() -> Base.overriddenAbstractGrandBaseFun()
 // Subject.overriddenGrandBaseFun() -> Base.overriddenGrandBaseFun()
+// ConflictingSubject1:
+// ConflictingSubject1.absFoo() -> MyInterface.absFoo()
+// ConflictingSubject2:
+// ConflictingSubject2.absFoo() -> MyAbstract.absFoo()
+// ConflictingSubject3:
+// ConflictingSubject3.absFoo() -> MyInterface.absFoo()
+// ConflictingSubject4:
+// ConflictingSubject4.absFoo() -> MyInterface2.absFoo()
+// OverrideOrder1:
+// OverrideOrder1.foo() -> GrandBaseInterface2.foo()
+// OverrideOrder2:
+// OverrideOrder2.foo() -> GrandBaseInterface1.foo()
 // END
 // MODULE: lib
 // FILE: lib.kt
@@ -115,6 +127,58 @@ abstract class Subject: Base<String>() {
         fun companionMethod(): String =TODO()
     }
 }
+
+// FILE: conflictingOverrides.kt
+interface MyInterface {
+    fun absFoo(): Unit
+}
+
+interface MyInterface2 {
+    fun absFoo(): Unit
+}
+
+abstract class MyAbstract: MyInterface {
+    override fun absFoo(): Unit {val a = 1}
+}
+
+class ConflictingSubject1: MyInterface, MyAbstract() {
+    override fun absFoo(): Unit = TODO()
+}
+
+class ConflictingSubject2: MyAbstract(), MyInterface {
+    override fun absFoo(): Unit = TODO()
+}
+
+class ConflictingSubject3: MyInterface, MyInterface2 {
+    override fun absFoo(): Unit = TODO()
+}
+
+class ConflictingSubject4: MyInterface2, MyInterface {
+    override fun absFoo(): Unit = TODO()
+}
+
+// FILE: overrideOrder.kt
+interface GrandBaseInterface1 {
+    fun foo(): Unit
+}
+
+interface GrandBaseInterface2 {
+    fun foo(): Unit
+}
+
+interface BaseInterface1 : GrandBaseInterface1 {
+}
+
+interface BaseInterface2 : GrandBaseInterface2 {
+}
+
+class OverrideOrder1 : BaseInterface1, GrandBaseInterface2 {
+    override fun foo() = TODO()
+}
+class OverrideOrder2 : BaseInterface2, GrandBaseInterface1 {
+    override fun foo() = TODO()
+}
+
 // FILE: JavaSubject.java
 public class JavaSubject {
     static abstract class GrandBase {
@@ -154,4 +218,4 @@ public class JavaSubject {
             return null;
         }
     }
-}
+}