Fix generated implementation of an inherited single abstract method

For example, UnaryOperator<T> extends Function<T, T> without overriding / defining its own `apply` method.

Author: smowton

java/kotlin-extractor/src/main/kotlin/KotlinFileExtractor.kt

@@ -654,9 +654,13 @@ open class KotlinFileExtractor(
         }
     }
 
-    fun extractFunction(f: IrFunction, parentId: Label<out DbReftype>, extractBody: Boolean, extractMethodAndParameterTypeAccesses: Boolean, typeSubstitution: TypeSubstitution?, classTypeArgsIncludingOuterClasses: List<IrTypeArgument>?, idOverride: Label<DbMethod>? = null, locOverride: Label<DbLocation>? = null): Label<out DbCallable>? {
-        if (isFake(f)) return null
+    fun extractFunction(f: IrFunction, parentId: Label<out DbReftype>, extractBody: Boolean, extractMethodAndParameterTypeAccesses: Boolean, typeSubstitution: TypeSubstitution?, classTypeArgsIncludingOuterClasses: List<IrTypeArgument>?, idOverride: Label<DbMethod>? = null, locOverride: Label<DbLocation>? = null) =
+        if (isFake(f))
+            null
+        else
+            extractNonFakeFunction(f, parentId, extractBody, extractMethodAndParameterTypeAccesses, typeSubstitution, classTypeArgsIncludingOuterClasses, idOverride, locOverride)
 
+    fun extractNonFakeFunction(f: IrFunction, parentId: Label<out DbReftype>, extractBody: Boolean, extractMethodAndParameterTypeAccesses: Boolean, typeSubstitution: TypeSubstitution?, classTypeArgsIncludingOuterClasses: List<IrTypeArgument>?, idOverride: Label<DbMethod>? = null, locOverride: Label<DbLocation>? = null): Label<out DbCallable>  {
         with("function", f) {
             DeclarationStackAdjuster(f).use {
 
@@ -3997,7 +4001,15 @@ open class KotlinFileExtractor(
 
                     fun trySub(t: IrType, context: TypeContext) = if (typeSub == null) t else typeSub(t, context, pluginContext)
 
-                    extractFunction(samMember, classId, extractBody = false, extractMethodAndParameterTypeAccesses = true, typeSub, classTypeArgs, idOverride = ids.function, locOverride = tw.getLocation(e))
+                    // Force extraction of this function even if this is a fake override --
+                    // This happens in the case where a functional interface inherits its only abstract member,
+                    // which usually we wouldn't extract, but in this case we're effectively using it as a template
+                    // for the real function we're extracting that will implement this interface, and it serves fine
+                    // for that purpose. By contrast if we looked through the fake to the underlying abstract method
+                    // we would need to compose generic type substitutions -- for example, if we're implementing
+                    // T UnaryOperator<T>.apply(T t) here, we would need to compose substitutions so we can implement
+                    // the real underlying R Function<T, R>.apply(T t).
+                    extractNonFakeFunction(samMember, classId, extractBody = false, extractMethodAndParameterTypeAccesses = true, typeSub, classTypeArgs, idOverride = ids.function, locOverride = tw.getLocation(e))
 
                     //body
                     val blockId = tw.getFreshIdLabel<DbBlock>()

java/ql/test/kotlin/library-tests/inherited-single-abstract-method/test.expected

@@ -0,0 +1,4 @@
+| test.kt:0:0:0:0 | TestKt | test.kt:3:1:3:35 | f |
+| test.kt:0:0:0:0 | TestKt | test.kt:5:1:9:1 | test |
+| test.kt:7:5:7:12 | new Function1<String,String>(...) { ... } | test.kt:7:5:7:12 | invoke |
+| test.kt:7:5:7:12 | new UnaryOperator<String>(...) { ... } | test.kt:7:5:7:12 | apply |

java/ql/test/kotlin/library-tests/inherited-single-abstract-method/test.kt

@@ -0,0 +1,9 @@
+import java.util.function.UnaryOperator
+
+fun f(x: UnaryOperator<String>) { }
+
+fun test() {
+
+  f({x -> x})
+
+}

java/ql/test/kotlin/library-tests/inherited-single-abstract-method/test.ql

@@ -0,0 +1,5 @@
+import java
+
+from ClassOrInterface ci
+where ci.fromSource()
+select ci, ci.getAMethod()