Feature unknown classes (#148)

Support unknown classes/method/fields to be resolved to some VirtualClass #147

Author: lehvolk

build.gradle.kts

@@ -9,7 +9,7 @@ val includeDokka: String? by project
 
 group = "org.jacodb"
 
-project.version = semVer ?: "1.1-SNAPSHOT"
+project.version = semVer ?: "1.2-SNAPSHOT"
 
 buildscript {
     repositories {

jacodb-analysis/src/test/kotlin/org/jacodb/analysis/impl/BaseAnalysisTest.kt

@@ -26,6 +26,7 @@ import org.jacodb.api.ext.findClass
 import org.jacodb.api.ext.methods
 import org.jacodb.impl.features.InMemoryHierarchy
 import org.jacodb.impl.features.Usages
+import org.jacodb.impl.features.classpaths.UnknownClasses
 import org.jacodb.impl.features.hierarchyExt
 import org.jacodb.testing.BaseTest
 import org.jacodb.testing.WithDB
@@ -37,7 +38,7 @@ import java.util.stream.Stream
 import kotlin.streams.asStream
 
 abstract class BaseAnalysisTest : BaseTest() {
-    companion object : WithDB(Usages, InMemoryHierarchy) {
+    companion object : WithDB(UnknownClasses, Usages, InMemoryHierarchy) {
         @JvmStatic
         fun provideClassesForJuliet(cweNum: Int, cweSpecificBans: List<String> = emptyList()): Stream<Arguments> = runBlocking {
             val cp = db.classpath(allClasspath)

jacodb-api/README.md

@@ -43,11 +43,4 @@ Call on each step of a lifecycle with respected signal.
 [BeforeIndexing]: https://jacodb.org/docs/jacodb-api/org.jacodb.api/-jc-signal/-before-indexing/index.html
 [AfterIndexing]: https://jacodb.org/docs/jacodb-api/org.jacodb.api/-jc-signal/-after-indexing/index.html
 [LocationRemoved]: https://jacodb.org/docs/jacodb-api/org.jacodb.api/-jc-signal/-location-removed/index.html
-[Drop]: https://jacodb.org/docs/jacodb-api/jacodb-api/org.jacodb.api/-jc-signal/-drop/index.html
-
-
-
-
-
-
-
+[Drop]: https://jacodb.org/docs/jacodb-api/jacodb-api/org.jacodb.api/-jc-signal/-drop/index.html

jacodb-api/src/main/kotlin/org/jacodb/api/Classes.kt

@@ -48,6 +48,7 @@ interface JcClassOrInterface : JcAnnotatedSymbol, JcAccessible {
 
     fun <T> extensionValue(key: String): T?
 
+    val lookup: JcLookup<JcField, JcMethod>
 
     val isAnnotation: Boolean
         get() {
@@ -125,7 +126,6 @@ interface JcMethod : JcSymbol, JcAnnotatedSymbol, JcAccessible {
             return name == "<clinit>"
         }
 
-
 }
 
 interface JcField : JcAnnotatedSymbol, JcAccessible {
@@ -144,4 +144,5 @@ interface JcParameter : JcAnnotated, JcAccessible {
 
 interface TypeName {
     val typeName: String
-}
+}
+

jacodb-api/src/main/kotlin/org/jacodb/api/JcClasspath.kt

@@ -83,6 +83,8 @@ interface JcClasspath : Closeable {
     suspend fun <T : JcClasspathTask> execute(task: T): T
 
     fun <T : JcClasspathTask> executeAsync(task: T): Future<T> = GlobalScope.future { execute(task) }
+
+    fun isInstalled(feature: JcClasspathFeature): Boolean
 }
 
 
@@ -205,4 +207,4 @@ interface JcMethodExtFeature : JcClasspathFeature {
     fun instList(method: JcMethod): JcInstListResult? = null
     fun rawInstList(method: JcMethod): JcRawInstListResult? = null
 
-}
+}

jacodb-api/src/main/kotlin/org/jacodb/api/JcLookup.kt

@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2022 UnitTestBot contributors (utbot.org)
+ * <p>
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ * <p>
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.jacodb.api
+
+/**
+ * lookup for fields and methods in [JcClassOrInterface] and [JcClassType]
+ */
+@JvmDefaultWithoutCompatibility
+interface JcLookup<Field : JcAccessible, Method : JcAccessible> {
+
+    fun field(name: String): Field? = field(name, null)
+    fun field(name: String, typeName: TypeName?): Field?
+    fun method(name: String, description: String): Method?
+
+    fun staticMethod(name: String, description: String): Method?
+    fun specialMethod(name: String, description: String): Method?
+}

jacodb-api/src/main/kotlin/org/jacodb/api/Types.kt

@@ -100,6 +100,9 @@ interface JcClassType : JcRefType, JcAccessible {
     val interfaces: List<JcClassType>
 
     val innerTypes: List<JcClassType>
+
+    val lookup: JcLookup<JcTypedField, JcTypedMethod>
+
 }
 
 interface JcTypeVariable : JcRefType {

jacodb-api/src/main/kotlin/org/jacodb/api/ext/JcClasses.kt

@@ -58,14 +58,7 @@ const val JAVA_OBJECT = "java.lang.Object"
  * find field by name
  */
 fun JcClassOrInterface.findFieldOrNull(name: String): JcField? {
-    return findElements(
-        allowSearchAll = true,
-        packageName = { packageName },
-        getAccessibles = { declaredFields },
-        nextHierarchy = { superClass?.let { listOf(it) } },
-    ) {
-        it.name == name
-    }
+    return lookup.field(name)
 }
 
 fun JcClassOrInterface.findDeclaredFieldOrNull(name: String): JcField? = declaredFields.singleOrNull { it.name == name }
@@ -81,28 +74,8 @@ fun JcClassOrInterface.findDeclaredMethodOrNull(name: String, desc: String? = nu
 /**
  * find method by name and description
  */
-fun JcClassOrInterface.findMethodOrNull(name: String, desc: String? = null): JcMethod? {
-    // let's find method based on strict hierarchy
-    // if method is not found then it's defined in interfaces
-    val predicate: (JcMethod) -> Boolean = {
-        it.name == name && (desc == null || it.description == desc)
-    }
-    val method = findElements(
-        packageName = { packageName },
-        getAccessibles = { declaredMethods },
-        nextHierarchy = { superClass?.let { listOf(it) } },
-        predicate = predicate
-    )
-    if (method != null) {
-        return method
-    }
-    // let's search interfaces
-    return findElements(
-        packageName = { packageName },
-        getAccessibles = { declaredMethods },
-        nextHierarchy = { interfaces },
-        predicate = predicate
-    )
+fun JcClassOrInterface.findMethodOrNull(name: String, desc: String): JcMethod? {
+    return lookup.method(name, desc)
 }
 
 /**

jacodb-api/src/main/kotlin/org/jacodb/api/ext/JcCommons.kt

@@ -18,15 +18,7 @@
 
 package org.jacodb.api.ext
 
-import org.jacodb.api.JcAccessible
-import org.jacodb.api.JcAnnotated
-import org.jacodb.api.JcAnnotation
-import org.jacodb.api.JcClassOrInterface
-import org.jacodb.api.JcClassType
-import org.jacodb.api.JcClasspath
-import org.jacodb.api.JcMethod
-import org.jacodb.api.PredefinedPrimitives
-import org.jacodb.api.throwClassNotFound
+import org.jacodb.api.*
 import java.io.Serializable
 import java.lang.Cloneable
 
@@ -98,28 +90,6 @@ internal object UnsafeHierarchyMethodComparator : Comparator<JcMethod> {
     }
 }
 
-internal fun <Container : JcAccessible, Result : JcAccessible> Container.findElements(
-    allowSearchAll: Boolean = true,
-    packageName: Container.() -> String,
-    classPackageName: String = packageName(this),
-    getAccessibles: Container.() -> List<Result>,
-    nextHierarchy: Container.() -> List<Container>?,
-    predicate: (Result) -> Boolean
-): Result? {
-    val currentPackage = packageName()
-    return getAccessibles().firstOrNull {
-        if (allowSearchAll) {
-            predicate(it)
-        } else {
-            (it.isPublic || it.isProtected || (it.isPackagePrivate && currentPackage == classPackageName)) &&
-                    predicate(it)
-        }
-    } ?: nextHierarchy()?.firstNotNullOfOrNull {
-        it.findElements(false, packageName, currentPackage, getAccessibles, nextHierarchy, predicate)
-    }
-
-}
-
 fun JcAnnotated.hasAnnotation(className: String): Boolean {
     return annotations.any { it.matches(className) }
 }

jacodb-api/src/main/kotlin/org/jacodb/api/ext/JcTypes.kt

@@ -18,14 +18,7 @@
 
 package org.jacodb.api.ext
 
-import org.jacodb.api.JcArrayType
-import org.jacodb.api.JcClassType
-import org.jacodb.api.JcPrimitiveType
-import org.jacodb.api.JcRefType
-import org.jacodb.api.JcType
-import org.jacodb.api.JcTypedField
-import org.jacodb.api.JcTypedMethod
-import org.jacodb.api.throwClassNotFound
+import org.jacodb.api.*
 import java.lang.Boolean
 import java.lang.Byte
 import java.lang.Double
@@ -166,46 +159,31 @@ fun JcType.isAssignable(declaration: JcType): kotlin.Boolean {
 
 /**
  * find field by name
+ *
+ * @param name field name
  */
 fun JcClassType.findFieldOrNull(name: String): JcTypedField? {
-    return findElements(
-        packageName = { jcClass.packageName },
-        getAccessibles = { declaredFields },
-        nextHierarchy = { listOfNotNull(superType) + interfaces},
-    ) {
-        it.name == name
-    }
+    return lookup.field(name)
 }
 
-fun JcClassType.findMethodOrNull(name: String, desc: String?): JcTypedMethod? {
-    return findMethodOrNull {
-        it.name == name && (desc == null || it.method.description == desc)
-    }
+/**
+ * find method by name and description
+ *
+ * @param name method name
+ * @param desc method description
+ */
+fun JcClassType.findMethodOrNull(name: String, desc: String): JcTypedMethod? {
+    return lookup.method(name, desc)
 }
 
 /**
  * find method by name and description
+ *
+ * This method doesn't support [org.jacodb.impl.features.classpaths.UnknownClasses] feature.
  */
-fun JcClassType.findMethodOrNull(
-    predicate: (JcTypedMethod) -> kotlin.Boolean
-): JcTypedMethod? {
+fun JcClassType.findMethodOrNull(predicate: (JcTypedMethod) -> kotlin.Boolean): JcTypedMethod? {
     // let's find method based on strict hierarchy
     // if method is not found then it's defined in interfaces
-    return findElements(
-        packageName = { jcClass.packageName },
-        getAccessibles = { declaredMethods },
-        nextHierarchy = { listOfNotNull(superType) + interfaces },
-        predicate = predicate
-    )
-//    if (method != null) {
-//        return method
-//    }
-//    // let's search interfaces
-//    return findElements(
-//        packageName = { jcClass.packageName },
-//        getAccessibles = { declaredMethods },
-//        nextHierarchy = { interfaces + superType?.interfaces.orEmpty() },
-//        predicate = predicate
-//    )
+    return methods.firstOrNull(predicate)
 }