uncommit (from ArsenHD/support-anonymous-classes)

Author: ArsenHD

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

@@ -30,6 +30,28 @@ import kotlin.reflect.jvm.javaMethod
 
 // ClassId utils
 
+/**
+ * A type is called **non-denotable** if its name cannot be used in the source code.
+ * For example, anonymous classes **are** non-denotable types.
+ * On the other hand, [java.lang.Integer], for example, **is** denotable.
+ *
+ * This property returns the same type for denotable types,
+ * and it returns the supertype when given an anonymous class.
+ *
+ * **NOTE** that in Java there are non-denotable types other than anonymous classes.
+ * For example, null-type, intersection types, capture types.
+ * But [ClassId] cannot contain any of these (at least at the moment).
+ * So we only consider the case of anonymous classes.
+ */
+val ClassId.denotableType: ClassId
+    get() {
+        return when {
+            this.isAnonymous -> this.supertypeOfAnonymousClass
+            else -> this
+        }
+    }
+
+
 @Suppress("unused")
 val ClassId.enclosingClass: ClassId?
     get() = jClass.enclosingClass?.id

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

@@ -113,7 +113,7 @@ class TypeResolver(private val typeRegistry: TypeRegistry, private val hierarchy
                 if (numDimensions == 0) baseType else baseType.makeArrayType(numDimensions)
             }
 
-        return TypeStorage(type, concretePossibleTypes).filterInappropriateClassesForCodeGeneration()
+        return TypeStorage(type, concretePossibleTypes)//.filterInappropriateClassesForCodeGeneration()
     }
 
     private fun isInappropriateOrArrayOfMocksOrLocals(numDimensions: Int, baseType: Type?): Boolean {
@@ -183,7 +183,7 @@ class TypeResolver(private val typeRegistry: TypeRegistry, private val hierarchy
             else -> error("Unexpected type $type")
         }
 
-        return TypeStorage(type, possibleTypes).filterInappropriateClassesForCodeGeneration()
+        return TypeStorage(type, possibleTypes)//.filterInappropriateClassesForCodeGeneration()
     }
 
     /**
@@ -211,7 +211,7 @@ class TypeResolver(private val typeRegistry: TypeRegistry, private val hierarchy
                     return@forEach
                 }
                 when {
-                    sootClass.isAnonymous || sootClass.isUtMock -> unwantedTypes += it
+//                    sootClass.isAnonymous || sootClass.isUtMock -> unwantedTypes += it
                     sootClass.isArtificialEntity -> {
 //                        if (sootClass.isLambda) {
 //                            unwantedTypes += it

utbot-framework/src/main/kotlin/org/utbot/framework/assemble/AssembleModelGenerator.kt

@@ -107,9 +107,7 @@ class AssembleModelGenerator(private val methodUnderTest: UtMethod<*>) {
         }
 
         return IdentityHashMap<UtModel, UtModel>().apply {
-            models
-                .filterNot { it.classId.isAnonymous } // we cannot create an assemble model for an anonymous class instance
-                .forEach { getOrPut(it) { assembleModel(it) } }
+            models.forEach { getOrPut(it) { assembleModel(it) } }
         }
     }
 
@@ -175,6 +173,11 @@ class AssembleModelGenerator(private val methodUnderTest: UtMethod<*>) {
     private fun assembleModel(utModel: UtModel): UtModel {
         val collectedCallChain = callChain.toMutableList()
 
+        // we cannot create an assemble model for an anonymous class instance
+        if (utModel.classId.isAnonymous) {
+            return utModel
+        }
+
         val assembledModel = withCleanState {
             try {
                 when (utModel) {

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

@@ -60,6 +60,7 @@ import fj.data.Either
 import org.utbot.framework.codegen.model.tree.CgArrayInitializer
 import org.utbot.framework.codegen.model.tree.CgIsInstance
 import org.utbot.framework.plugin.api.util.classClassId
+import org.utbot.framework.plugin.api.util.denotableType
 import java.lang.reflect.Constructor
 import java.lang.reflect.Method
 import kotlin.reflect.KFunction
@@ -221,9 +222,12 @@ internal class CgStatementConstructorImpl(context: CgContext) :
         isMutable: Boolean,
         init: () -> CgExpression
     ): CgVariable {
+        // it is important that we use a denotable type for declaration, because that allows
+        // us to avoid creating `Object` variables for instances of anonymous classes,
+        // where we can instead use the supertype of the anonymous class
         val declarationOrVar: Either<CgDeclaration, CgVariable> =
             createDeclarationForNewVarAndUpdateVariableScopeOrGetExistingVariable(
-                baseType,
+                baseType.denotableType,
                 model,
                 baseName,
                 isMock,

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

@@ -49,6 +49,7 @@ import org.utbot.framework.plugin.api.UtPrimitiveModel
 import org.utbot.framework.plugin.api.WildcardTypeParameter
 import org.utbot.framework.plugin.api.util.arrayLikeName
 import org.utbot.framework.plugin.api.util.builtinStaticMethodId
+import org.utbot.framework.plugin.api.util.denotableType
 import org.utbot.framework.plugin.api.util.methodId
 import org.utbot.framework.plugin.api.util.objectArrayClassId
 import org.utbot.framework.plugin.api.util.objectClassId
@@ -250,26 +251,23 @@ internal fun CgContextOwner.importIfNeeded(method: MethodId) {
 /**
  * Casts [expression] to [targetType].
  *
- * If [targetType] is anonymous, then we cannot use it in type cast,
- * because anonymous classes cannot be accessed in the source code.
- * So, in this case we find the supertype of anonymous class and use it as the [targetType] instead.
+ * This method uses [denotableType] of the given [targetType] to ensure
+ * that we are using a denotable type in the type cast.
+ *
+ * Specifically, if we attempt to do a type cast to an anonymous class,
+ * then we will actually perform a type cast to its supertype.
+ *
+ * @see denotableType
  *
  * @param isSafetyCast shows if we should render "as?" instead of "as" in Kotlin
  */
 internal fun CgContextOwner.typeCast(
     targetType: ClassId,
     expression: CgExpression,
     isSafetyCast: Boolean = false
-//): CgTypeCast {
 ): CgExpression {
     @Suppress("NAME_SHADOWING")
-    val targetType = when {
-        targetType.isAnonymous -> targetType.supertypeOfAnonymousClass
-        else -> targetType
-    }
-//    if (targetType.simpleName.isEmpty()) {
-//        error("Cannot cast an expression to the anonymous type $targetType")
-//    }
+    val targetType = targetType.denotableType
     importIfNeeded(targetType)
     return CgTypeCast(targetType, expression, isSafetyCast)
 }