Support anonymous classes (#760)

Support anonymous classes

Author: ArsenHD

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

@@ -31,6 +31,7 @@ import org.utbot.framework.plugin.api.util.method
 import org.utbot.framework.plugin.api.util.primitiveTypeJvmNameOrNull
 import org.utbot.framework.plugin.api.util.safeJField
 import org.utbot.framework.plugin.api.util.shortClassId
+import org.utbot.framework.plugin.api.util.supertypeOfAnonymousClass
 import org.utbot.framework.plugin.api.util.toReferenceTypeBytecodeSignature
 import org.utbot.framework.plugin.api.util.voidClassId
 import soot.ArrayType
@@ -679,8 +680,14 @@ open class ClassId @JvmOverloads constructor(
  */
  val prettifiedName: String
  get() {
- val className = jClass.canonicalName ?: name // Explicit jClass reference to get null instead of exception
- return className
+ val baseName = when {
+ // anonymous classes have empty simpleName and their canonicalName is null,
+ // so we create a specific name for them
+ isAnonymous -> "Anonymous${supertypeOfAnonymousClass.prettifiedName}"
+ // in other cases where canonical name is still null, we use ClassId.name instead
+ else -> jClass.canonicalName ?: name // Explicit jClass reference to get null instead of exception
+ }
+ return baseName
  .substringAfterLast(".")
  .replace(Regex("[^a-zA-Z0-9]"), "")
  .let { if (this.isArray) it + "Array" else it }

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

@@ -31,6 +31,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
@@ -111,6 +133,37 @@ infix fun ClassId.isSubtypeOf(type: ClassId): Boolean {
 
 infix fun ClassId.isNotSubtypeOf(type: ClassId): Boolean = !(this isSubtypeOf type)
 
+/**
+ * - Anonymous class that extends a class will have this class as its superclass and no interfaces.
+ * - Anonymous class that implements an interface, will have the only interface
+ * and [java.lang.Object] as its superclass.
+ *
+ * @return [ClassId] of a type that the given anonymous class inherits
+ */
+val ClassId.supertypeOfAnonymousClass: ClassId
+ get() {
+ if (this is BuiltinClassId) error("Cannot obtain info about supertypes of BuiltinClassId $canonicalName")
+ require(isAnonymous) { "An anonymous class expected, but got $canonicalName" }
+
+ val clazz = jClass
+ val superclass = clazz.superclass.id
+ val interfaces = clazz.interfaces.map { it.id }
+
+ return when (superclass) {
+ objectClassId -> {
+ // anonymous class actually inherits from Object, e.g. Object obj = new Object() { ... };
+ if (interfaces.isEmpty()) {
+ objectClassId
+ } else {
+ // anonymous class implements some interface
+ interfaces.singleOrNull() ?: error("Anonymous class can have no more than one interface")
+ }
+ }
+ // anonymous class inherits from some class other than java.lang.Object
+ else -> superclass
+ }
+ }
+
 val ClassId.kClass: KClass<*>
  get() = jClass.kotlin
 

utbot-framework-test/src/test/kotlin/org/utbot/examples/objects/AnonymousClassesExampleTest.kt

@@ -1,7 +1,7 @@
 package org.utbot.examples.objects
 
+import org.utbot.tests.infrastructure.Full
 import org.utbot.tests.infrastructure.UtValueTestCaseChecker
-import org.utbot.tests.infrastructure.DoNotCalculate
 import org.utbot.tests.infrastructure.isException
 import org.junit.jupiter.api.Test
 import org.utbot.testcheckers.eq
@@ -11,37 +11,43 @@ class AnonymousClassesExampleTest : UtValueTestCaseChecker(testClass = Anonymous
  fun testAnonymousClassAsParam() {
  checkWithException(
  AnonymousClassesExample::anonymousClassAsParam,
- eq(2),
+ eq(3),
  { abstractAnonymousClass, r -> abstractAnonymousClass == null && r.isException<NullPointerException>() },
  { abstractAnonymousClass, r -> abstractAnonymousClass != null && r.getOrNull() == 0 },
- coverage = DoNotCalculate
+ { abstractAnonymousClass, r -> abstractAnonymousClass != null && abstractAnonymousClass::class.java.isAnonymousClass && r.getOrNull() == 42 },
+ coverage = Full
  )
  }
 
  @Test
  fun testNonFinalAnonymousStatic() {
- check(
+ checkStaticsAndException(
  AnonymousClassesExample::nonFinalAnonymousStatic,
- eq(0), // we remove all anonymous classes in statics
- coverage = DoNotCalculate
+ eq(3),
+ { statics, r -> statics.values.single().value == null && r.isException<NullPointerException>() },
+ { _, r -> r.getOrNull() == 0 },
+ { _, r -> r.getOrNull() == 42 },
+ coverage = Full
  )
  }
 
  @Test
  fun testAnonymousClassAsStatic() {
  check(
  AnonymousClassesExample::anonymousClassAsStatic,
- eq(0), // we remove all anonymous classes in statics
- coverage = DoNotCalculate
+ eq(1),
+ { r -> r == 42 },
+ coverage = Full
  )
  }
 
  @Test
  fun testAnonymousClassAsResult() {
  check(
  AnonymousClassesExample::anonymousClassAsResult,
- eq(0), // we remove anonymous classes from the params and the result
- coverage = DoNotCalculate
+ eq(1),
+ { abstractAnonymousClass -> abstractAnonymousClass != null && abstractAnonymousClass::class.java.isAnonymousClass },
+ coverage = Full
  )
  }
 }

utbot-framework-test/src/test/kotlin/org/utbot/framework/assemble/AssembleModelGeneratorTests.kt

@@ -58,6 +58,8 @@ import org.utbot.framework.util.SootUtils
 import org.utbot.framework.util.instanceCounter
 import org.utbot.framework.util.modelIdCounter
 import kotlin.reflect.full.functions
+import org.utbot.examples.assemble.*
+import org.utbot.framework.codegen.model.constructor.util.arrayTypeOf
 
 /**
  * Test classes must be located in the same folder as [AssembleTestUtils] class.
@@ -1117,7 +1119,7 @@ class AssembleModelGeneratorTests {
  testClassId,
  "array" to UtArrayModel(
  modelIdCounter.incrementAndGet(),
- ClassId("[L${innerClassId.canonicalName}", innerClassId),
+ arrayTypeOf(innerClassId),
  length = 3,
  UtNullModel(innerClassId),
  mutableMapOf(
@@ -1187,11 +1189,11 @@ class AssembleModelGeneratorTests {
  val testClassId = ArrayOfComplexArrays::class.id
  val innerClassId = PrimitiveFields::class.id
 
- val innerArrayClassId = ClassId("[L${innerClassId.canonicalName}", innerClassId)
+ val innerArrayClassId = arrayTypeOf(innerClassId)
 
  val arrayOfArraysModel = UtArrayModel(
  modelIdCounter.incrementAndGet(),
- ClassId("[Lorg.utbot.examples.assemble.ComplexArray", testClassId),
+ arrayTypeOf(testClassId),
  length = 2,
  UtNullModel(innerArrayClassId),
  mutableMapOf(

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

@@ -3405,9 +3405,18 @@ class Traverser(
  if (returnValue != null) {
  queuedSymbolicStateUpdates += constructConstraintForType(returnValue, returnValue.possibleConcreteTypes).asSoftConstraint()
 
+ // We only remove anonymous classes if there are regular classes available.
+ // If there are no other options, then we do use anonymous classes.
  workaround(REMOVE_ANONYMOUS_CLASSES) {
  val sootClass = returnValue.type.sootClass
- if (!environment.state.isInNestedMethod() && (sootClass.isAnonymous || sootClass.isArtificialEntity)) {
+ val isInNestedMethod = environment.state.isInNestedMethod()
+
+ if (!isInNestedMethod && sootClass.isArtificialEntity) {
+ return
+ }
+
+ val onlyAnonymousTypesAvailable = returnValue.typeStorage.possibleConcreteTypes.all { (it as? RefType)?.sootClass?.isAnonymous == true }
+ if (!isInNestedMethod && sootClass.isAnonymous && !onlyAnonymousTypesAvailable) {
  return
  }
  }

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

@@ -1,7 +1,6 @@
 package org.utbot.engine
 
 import org.utbot.common.WorkaroundReason
-import org.utbot.common.heuristic
 import org.utbot.common.workaround
 import org.utbot.engine.pc.UtAddrExpression
 import org.utbot.engine.pc.UtBoolExpression
@@ -187,11 +186,9 @@ class TypeResolver(private val typeRegistry: TypeRegistry, private val hierarchy
  }
 
  /**
- * Remove anonymous and artificial types from the [TypeStorage] if [TypeStorage.possibleConcreteTypes]
- * contains non-anonymous and non-artificial types.
- * However, if the typeStorage contains only artificial and anonymous types, it becomes much more complicated.
- * If leastCommonType of the typeStorage is an artificialEntity, result will contain both artificial and anonymous
- * types, otherwise only anonymous types. It is required for some classes, e.g., `forEach__145`.
+ * Where possible, remove types that are not currently supported by code generation.
+ * For example, we filter out artificial entities (lambdas are an example of them)
+ * if the least common type is **not** artificial itself.
  */
  private fun TypeStorage.filterInappropriateClassesForCodeGeneration(): TypeStorage {
  val unwantedTypes = mutableSetOf<Type>()
@@ -200,19 +197,17 @@ class TypeResolver(private val typeRegistry: TypeRegistry, private val hierarchy
  val leastCommonSootClass = (leastCommonType as? RefType)?.sootClass
  val keepArtificialEntities = leastCommonSootClass?.isArtificialEntity == true
 
- heuristic(WorkaroundReason.REMOVE_ANONYMOUS_CLASSES) {
- possibleConcreteTypes.forEach {
- val sootClass = (it.baseType as? RefType)?.sootClass ?: run {
- // All not RefType should be included in the concreteTypes, e.g., arrays
- concreteTypes += it
- return@forEach
- }
- when {
- sootClass.isAnonymous || sootClass.isUtMock -> unwantedTypes += it
- sootClass.isArtificialEntity -> if (keepArtificialEntities) concreteTypes += it else Unit
- workaround(WorkaroundReason.HACK) { leastCommonSootClass == OBJECT_TYPE && sootClass.isOverridden } -> Unit
- else -> concreteTypes += it
- }
+ possibleConcreteTypes.forEach {
+ val sootClass = (it.baseType as? RefType)?.sootClass ?: run {
+ // All not RefType should be included in the concreteTypes, e.g., arrays
+ concreteTypes += it
+ return@forEach
+ }
+ when {
+ sootClass.isUtMock -> unwantedTypes += it
+ sootClass.isArtificialEntity -> if (keepArtificialEntities) concreteTypes += it else Unit
+ workaround(WorkaroundReason.HACK) { leastCommonSootClass == OBJECT_TYPE && sootClass.isOverridden } -> Unit
+ else -> concreteTypes += it
  }
  }
 

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

@@ -4,10 +4,8 @@ import mu.KotlinLogging
 import org.utbot.analytics.EngineAnalyticsContext
 import org.utbot.analytics.FeatureProcessor
 import org.utbot.analytics.Predictors
-import org.utbot.common.WorkaroundReason.REMOVE_ANONYMOUS_CLASSES
 import org.utbot.common.bracket
 import org.utbot.common.debug
-import org.utbot.common.workaround
 import org.utbot.engine.MockStrategy.NO_MOCKS
 import org.utbot.engine.pc.UtArraySelectExpression
 import org.utbot.engine.pc.UtBoolExpression
@@ -60,6 +58,8 @@ import org.utbot.framework.plugin.api.UtNullModel
 import org.utbot.framework.plugin.api.UtOverflowFailure
 import org.utbot.framework.plugin.api.UtResult
 import org.utbot.framework.plugin.api.UtSymbolicExecution
+import org.utbot.framework.util.graph
+import org.utbot.framework.plugin.api.util.executableId
 import org.utbot.framework.plugin.api.util.isStatic
 import org.utbot.framework.plugin.api.onSuccess
 import org.utbot.framework.plugin.api.util.description
@@ -469,15 +469,6 @@ class UtBotSymbolicEngine(
  // in case an exception occurred from the concrete execution
  concreteExecutionResult ?: return@forEach
 
- workaround(REMOVE_ANONYMOUS_CLASSES) {
- concreteExecutionResult.result.onSuccess {
- if (it.classId.isAnonymous) {
- logger.debug("Anonymous class found as a concrete result, symbolic one will be returned")
- return@flow
- }
- }
- }
-
  val coveredInstructions = concreteExecutionResult.coverage.coveredInstructions
  if (coveredInstructions.isNotEmpty()) {
  val coverageKey = coveredInstructionTracker.add(coveredInstructions)
@@ -586,16 +577,6 @@ class UtBotSymbolicEngine(
  instrumentation
  )
 
- workaround(REMOVE_ANONYMOUS_CLASSES) {
- concreteExecutionResult.result.onSuccess {
- if (it.classId.isAnonymous) {
- logger.debug("Anonymous class found as a concrete result, symbolic one will be returned")
- emit(symbolicUtExecution)
- return
- }
- }
- }
-
  val concolicUtExecution = symbolicUtExecution.copy(
  stateAfter = concreteExecutionResult.stateAfter,
  result = concreteExecutionResult.result,

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

@@ -171,6 +171,11 @@ class AssembleModelGenerator(private val methodPackageName: String) {
  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/tree/CgVariableConstructor.kt

@@ -55,6 +55,7 @@ import org.utbot.framework.plugin.api.util.intClassId
 import org.utbot.framework.plugin.api.util.isArray
 import org.utbot.framework.plugin.api.util.isPrimitiveWrapperOrString
 import org.utbot.framework.plugin.api.util.stringClassId
+import org.utbot.framework.plugin.api.util.supertypeOfAnonymousClass
 import org.utbot.framework.plugin.api.util.wrapperByPrimitive
 import java.lang.reflect.Field
 import java.lang.reflect.Modifier
@@ -119,7 +120,9 @@ internal class CgVariableConstructor(val context: CgContext) :
  val obj = if (model.isMock) {
  mockFrameworkManager.createMockFor(model, baseName)
  } else {
- newVar(model.classId, baseName) { utilsClassId[createInstance](model.classId.name) }
+ val modelType = model.classId
+ val variableType = if (modelType.isAnonymous) modelType.supertypeOfAnonymousClass else modelType
+ newVar(variableType, baseName) { utilsClassId[createInstance](model.classId.name) }
  }
 
  valueByModelId[model.id] = obj

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

@@ -70,6 +70,7 @@ import org.utbot.framework.plugin.api.util.constructorClassId
 import org.utbot.framework.plugin.api.util.fieldClassId
 import org.utbot.framework.plugin.api.util.isPrimitive
 import org.utbot.framework.plugin.api.util.methodClassId
+import org.utbot.framework.plugin.api.util.denotableType
 import java.lang.reflect.Constructor
 import java.lang.reflect.Method
 import kotlin.reflect.KFunction
@@ -244,9 +245,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,
@@ -558,8 +562,8 @@ internal class CgStatementConstructorImpl(context: CgContext) :
  val isGetFieldUtilMethod = (expression is CgMethodCall && expression.executableId.isGetFieldUtilMethod)
  val shouldCastBeSafety = expression == nullLiteral() || isGetFieldUtilMethod
 
- type = baseType
  expr = typeCast(baseType, expression, shouldCastBeSafety)
+ type = expr.type
  }
  expression.type isNotSubtypeOf baseType && !typeAccessible -> {
  type = if (expression.type.isArray) objectArrayClassId else objectClassId