Generics in Kotlin codegen (#88)

Refactored imports to support kotlin builtins (List, Map, e.t.c).
Added generics propagation using callables.
Added filling generics with Any? and *.
Reworked Kotlin type render.
Fixed assemble model generation in concrete.
Fixed bug with backticks.

Author: nikitavlaev

utbot-core/src/main/kotlin/org/utbot/common/HackUtil.kt

@@ -67,4 +67,14 @@ enum class WorkaroundReason {
      * requires thorough [investigation](https://github.com/UnitTestBot/UTBotJava/issues/716).
      */
     IGNORE_STATICS_FROM_TRUSTED_LIBRARIES,
+
+    /**
+     * Special handling of collection constructors from other collections (for generics processing)
+     */
+    COLLECTION_CONSTRUCTOR_FROM_COLLECTION,
+
+    /**
+     * Assume that in calls to methods in modification chain always require the same type parameters as class has
+     */
+    MODIFICATION_CHAIN_GENERICS_FROM_CLASS,
 }

utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt

@@ -28,6 +28,7 @@ import org.utbot.framework.plugin.api.util.isPrimitive
 import org.utbot.framework.plugin.api.util.jClass
 import org.utbot.framework.plugin.api.util.longClassId
 import org.utbot.framework.plugin.api.util.method
+import org.utbot.framework.plugin.api.util.objectClassId
 import org.utbot.framework.plugin.api.util.primitiveTypeJvmNameOrNull
 import org.utbot.framework.plugin.api.util.safeJField
 import org.utbot.framework.plugin.api.util.shortClassId
@@ -56,6 +57,7 @@ import kotlin.jvm.internal.CallableReference
 import kotlin.reflect.KCallable
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
+import kotlin.reflect.KType
 import kotlin.reflect.full.instanceParameter
 import kotlin.reflect.jvm.javaConstructor
 import kotlin.reflect.jvm.javaType
@@ -760,8 +762,10 @@ open class ClassId @JvmOverloads constructor(
     open val allConstructors: Sequence<ConstructorId>
         get() = jClass.declaredConstructors.asSequence().map { it.executableId }
 
-    open val typeParameters: TypeParameters
-        get() = TypeParameters()
+    /**
+     * This might cause problems in case of reusing the same [ClassId] for different models.
+     */
+    open val typeParameters: TypeParameters = TypeParameters()
 
     open val outerClass: Class<*>?
         get() = jClass.enclosingClass
@@ -904,6 +908,19 @@ open class FieldId(val declaringClass: ClassId, val name: String) {
     open val type: ClassId
         get() = strategy.type
 
+    // required to store and update type parameters
+    // TODO check if by lazy works correctly in newer Kotlin (https://stackoverflow.com/questions/47638464/kotlin-lazy-var-throwing-classcastexception-kotlin-uninitialized-value)
+    // val fixedType: ClassId by lazy { type }
+    private var hiddenFixedType: ClassId? = null
+
+    val fixedType: ClassId
+        get() {
+            if (hiddenFixedType == null) {
+                hiddenFixedType = type
+            }
+            return hiddenFixedType!!
+        }
+
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
         if (javaClass != other?.javaClass) return false
@@ -979,6 +996,11 @@ sealed class ExecutableId : StatementId() {
     abstract val isProtected: Boolean
     abstract val isPrivate: Boolean
 
+    /**
+     * This might cause problems in case of reusing the same [ExecutableId] for different models.
+     */
+    val typeParameters: TypeParameters = TypeParameters()
+
     val isPackagePrivate: Boolean
         get() = !(isPublic || isProtected || isPrivate)
 
@@ -1064,9 +1086,31 @@ class BuiltinMethodId(
     override val isPrivate: Boolean = false
 ) : MethodId(classId, name, returnType, parameters)
 
-open class TypeParameters(val parameters: List<ClassId> = emptyList())
+open class TypeParameters(var parameters: List<ClassId> = emptyList()) {
+    fun copyFromClassId(classId: ClassId) {
+        parameters = classId.typeParameters.parameters
+    }
+
+    fun fromType(type: KType) {
+        if (type.arguments.isEmpty()) return
+
+        parameters = type.arguments.map {
+            when (val clazz = it.type?.classifier) {
+                is KClass<*> -> {
+                    val classId = clazz.id
+                    it.type?.let { t ->
+                        classId.typeParameters.fromType(t)
+                    } ?: error("")
+
+                    classId
+                }
+                else -> objectClassId
+            }
+        }
+    }
+}
 
-class WildcardTypeParameter : TypeParameters(emptyList())
+object WildcardTypeParameter: ClassId("org.utbot.framework.plugin.api.WildcardTypeParameter")
 
 interface CodeGenerationSettingItem {
     val displayName: String

utbot-framework/src/main/kotlin/org/utbot/engine/UtBotSymbolicEngine.kt

@@ -146,7 +146,8 @@ private fun pathSelector(graph: InterProceduralUnitGraph, typeRegistry: TypeRegi
 
 class UtBotSymbolicEngine(
     private val controller: EngineController,
-    private val methodUnderTest: UtMethod<*>,
+    /** methodUnderTest is internal to use in [org.utbot.framework.plugin.api.TestFlow.processGenerics]. **/
+    internal val methodUnderTest: UtMethod<*>,
     classpath: String,
     dependencyPaths: String,
     mockStrategy: MockStrategy = NO_MOCKS,

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/Domain.kt

@@ -37,19 +37,26 @@ data class TestClassFile(val packageName: String, val imports: List<Import>, val
 
 sealed class Import(internal val order: Int) : Comparable<Import> {
     abstract val qualifiedName: String
+    abstract val classId: ClassId
 
     override fun compareTo(other: Import) = importComparator.compare(this, other)
 }
 
 private val importComparator = compareBy<Import> { it.order }.thenBy { it.qualifiedName }
 
-data class StaticImport(val qualifierClass: String, val memberName: String) : Import(1) {
-    override val qualifiedName: String = "$qualifierClass.$memberName"
+data class StaticImport(val methodId: MethodId) : Import(1) {
+    override val qualifiedName: String = "${methodId.classId.canonicalName}.${methodId.name}"
+    override val classId: ClassId
+        get() = methodId.classId
 }
 
-data class RegularImport(val packageName: String, val className: String) : Import(2) {
-    override val qualifiedName: String
-        get() = if (packageName.isNotEmpty()) "$packageName.$className" else className
+data class RegularImport(override val classId: ClassId) : Import(2) {
+    override val qualifiedName: String =
+        if (classId.packageName.isNotEmpty()) {
+            "${classId.packageName}.${classId.simpleNameWithEnclosings}"
+        } else {
+            classId.simpleNameWithEnclosings
+        }
 
     // TODO: check without equals() and hashCode()
     override fun equals(other: Any?): Boolean {
@@ -58,15 +65,14 @@ data class RegularImport(val packageName: String, val className: String) : Impor
 
         other as RegularImport
 
-        if (packageName != other.packageName) return false
-        if (className != other.className) return false
+        if (classId != other.classId) return false
 
         return true
     }
 
     override fun hashCode(): Int {
-        var result = packageName.hashCode()
-        result = 31 * result + className.hashCode()
+        var result = classId.hashCode()
+        result = 31 * result + qualifiedName.hashCode()
         return result
     }
 }

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/name/CgNameGenerator.kt

@@ -148,8 +148,9 @@ internal class CgNameGeneratorImpl(private val context: CgContext)
     private fun createNameFromKeyword(baseName: String): String = when(codegenLanguage) {
         CodegenLanguage.JAVA -> nextIndexedVarName(baseName)
         CodegenLanguage.KOTLIN -> {
+            val backticksBaseName = "`$baseName`"
             // use backticks for first variable with keyword name and use indexed names for all next such variables
-            if (baseName !in existingVariableNames) "`$baseName`" else nextIndexedVarName(baseName)
+            if (backticksBaseName !in existingVariableNames) backticksBaseName else nextIndexedVarName(baseName)
         }
     }
 

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgCallableAccessManager.kt

@@ -101,8 +101,9 @@ internal class CgCallableAccessManagerImpl(val context: CgContext) : CgCallableA
     override operator fun ConstructorId.invoke(vararg args: Any?): CgExecutableCall {
         val resolvedArgs = args.resolve()
         val constructorCall = if (this canBeCalledWith resolvedArgs) {
-            CgConstructorCall(this, resolvedArgs.guardedForDirectCallOf(this))
+            CgConstructorCall(this, resolvedArgs.guardedForDirectCallOf(this), typeParameters)
         } else {
+            // TODO typeParameters?
             callWithReflection(resolvedArgs)
         }
         newConstructorCall(this)
@@ -112,8 +113,9 @@ internal class CgCallableAccessManagerImpl(val context: CgContext) : CgCallableA
     override operator fun CgIncompleteMethodCall.invoke(vararg args: Any?): CgMethodCall {
         val resolvedArgs = args.resolve()
         val methodCall = if (method.canBeCalledWith(caller, resolvedArgs)) {
-            CgMethodCall(caller, method, resolvedArgs.guardedForDirectCallOf(method))
+            CgMethodCall(caller, method, resolvedArgs.guardedForDirectCallOf(method), method.typeParameters)
         } else {
+            // TODO typeParams?
             method.callWithReflection(caller, resolvedArgs)
         }
         newMethodCall(method)

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/tree/CgMethodConstructor.kt

@@ -218,7 +218,7 @@ internal class CgMethodConstructor(val context: CgContext) : CgContextOwner by c
 
             // prevValue is nullable if not accessible because of getStaticFieldValue(..) : Any?
             val prevValue = newVar(
-                CgClassId(field.type, isNullable = !fieldAccessible),
+                CgClassId(field.fixedType, typeParameters = field.fixedType.typeParameters, isNullable = !fieldAccessible),
                 "prev${field.name.capitalize()}"
             ) {
                 if (fieldAccessible) {

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/constructor/util/ConstructorUtils.kt

@@ -47,6 +47,7 @@ import org.utbot.framework.plugin.api.UtModel
 import org.utbot.framework.plugin.api.UtNullModel
 import org.utbot.framework.plugin.api.UtPrimitiveModel
 import org.utbot.framework.plugin.api.WildcardTypeParameter
+import org.utbot.framework.plugin.api.TypeParameters
 import org.utbot.framework.plugin.api.util.arrayLikeName
 import org.utbot.framework.plugin.api.util.builtinStaticMethodId
 import org.utbot.framework.plugin.api.util.methodId
@@ -129,7 +130,7 @@ internal data class CgFieldState(val variable: CgVariable, val model: UtModel)
 
 data class ExpressionWithType(val type: ClassId, val expression: CgExpression)
 
-val classCgClassId = CgClassId(Class::class.id, typeParameters = WildcardTypeParameter(), isNullable = false)
+val classCgClassId = CgClassId(Class::class.id, TypeParameters(listOf(WildcardTypeParameter)), isNullable = false)
 
 /**
  * A [MethodId] to add an item into [ArrayList].
@@ -241,7 +242,7 @@ internal fun CgContextOwner.importIfNeeded(method: MethodId) {
         .takeIf { currentExecutable != method }
         ?.let {
             importedStaticMethods += method
-            collectedImports += StaticImport(method.classId.canonicalName, method.name)
+            collectedImports += StaticImport(method)
         }
 }
 
@@ -394,7 +395,7 @@ internal operator fun UtArrayModel.get(index: Int): UtModel = stores[index] ?: c
 internal fun ClassId.utilMethodId(name: String, returnType: ClassId, vararg arguments: ClassId): MethodId =
     BuiltinMethodId(this, name, returnType, arguments.toList())
 
-fun ClassId.toImport(): RegularImport = RegularImport(packageName, simpleNameWithEnclosings)
+fun ClassId.toImport(): RegularImport = RegularImport(this)
 
 // Immutable collections utils
 

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/visitor/CgAbstractRenderer.kt

@@ -692,6 +692,8 @@ internal abstract class CgAbstractRenderer(val context: CgContext, val printer:
 
     override fun toString(): String = printer.toString()
 
+    // Reorder imports to keep alphabetic and logical order if their names are post-processed by renderer
+    protected abstract fun <T: Import> reorderImports(imports: List<T>): List<T>
     protected abstract fun renderRegularImport(regularImport: RegularImport)
     protected abstract fun renderStaticImport(staticImport: StaticImport)
 
@@ -718,8 +720,8 @@ internal abstract class CgAbstractRenderer(val context: CgContext, val printer:
 
     protected abstract fun renderExceptionCatchVariable(exception: CgVariable)
 
-    protected fun getEscapedImportRendering(import: Import): String =
-        import.qualifiedName
+    protected fun getEscapedImportRendering(importName: String): String =
+        importName
             .split(".")
             .joinToString(".") { it.escapeNamePossibleKeyword() }
 
@@ -809,8 +811,8 @@ internal abstract class CgAbstractRenderer(val context: CgContext, val printer:
     }
 
     private fun renderClassFileImports(element: CgTestClassFile) {
-        val regularImports = element.imports.filterIsInstance<RegularImport>()
-        val staticImports = element.imports.filterIsInstance<StaticImport>()
+        val regularImports = reorderImports(element.imports.filterIsInstance<RegularImport>())
+        val staticImports = reorderImports(element.imports.filterIsInstance<StaticImport>())
 
         for (import in regularImports) {
             renderRegularImport(import)

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/visitor/CgJavaRenderer.kt

@@ -1,6 +1,7 @@
 package org.utbot.framework.codegen.model.visitor
 
 import org.apache.commons.text.StringEscapeUtils
+import org.utbot.framework.codegen.Import
 import org.utbot.framework.codegen.RegularImport
 import org.utbot.framework.codegen.StaticImport
 import org.utbot.framework.codegen.model.constructor.context.CgContext
@@ -198,13 +199,15 @@ internal class CgJavaRenderer(context: CgContext, printer: CgPrinter = CgPrinter
         renderExecutableCallArguments(element)
     }
 
+    override fun <T : Import> reorderImports(imports: List<T>): List<T> = imports
+
     override fun renderRegularImport(regularImport: RegularImport) {
-        val escapedImport = getEscapedImportRendering(regularImport)
+        val escapedImport = getEscapedImportRendering(regularImport.qualifiedName)
         println("import $escapedImport$statementEnding")
     }
 
     override fun renderStaticImport(staticImport: StaticImport) {
-        val escapedImport = getEscapedImportRendering(staticImport)
+        val escapedImport = getEscapedImportRendering(staticImport.qualifiedName)
         println("import static $escapedImport$statementEnding")
     }