Support lambda expressions

Author: ArsenHD

utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt

@@ -73,7 +73,7 @@ object UtSettings : AbstractSettings(
      * Timeout for symbolic execution
      *
      */
-    var utBotGenerationTimeoutInMillis by getLongProperty(60000L)
+    var utBotGenerationTimeoutInMillis by getLongProperty(600000L)
 
     /**
      * Random seed in path selector.
@@ -113,7 +113,7 @@ object UtSettings : AbstractSettings(
      *
      * False by default, set it to true if debug visualization is needed.
      */
-    var useDebugVisualization by getBooleanProperty(false)
+    var useDebugVisualization by getBooleanProperty(true)
 
     /**
      * Set the value to true if you want to automatically copy the path of the
@@ -136,7 +136,7 @@ object UtSettings : AbstractSettings(
      * @see <a href="CONFLUENCE:UtBot+Expression+Optimizations">
      *     UtBot Expression Optimizations</a>
      */
-    var useExpressionSimplification by getBooleanProperty(true)
+    var useExpressionSimplification by getBooleanProperty(false)
 
     /*
     * Activate or deactivate tests on comments && names/displayNames
@@ -188,7 +188,7 @@ object UtSettings : AbstractSettings(
      *
      * True by default.
      */
-    var useConcreteExecution by getBooleanProperty(true)
+    var useConcreteExecution by getBooleanProperty(false)
 
     /**
      * Enable check of full coverage for methods with code generations tests.
@@ -300,7 +300,7 @@ object UtSettings : AbstractSettings(
      *
      * False by default.
      */
-    var enableUnsatCoreCalculationForHardConstraints by getBooleanProperty(false)
+    var enableUnsatCoreCalculationForHardConstraints by getBooleanProperty(true)
 
     /**
      * Enable it to process states with unknown solver status

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
@@ -529,6 +530,35 @@ data class UtAssembleModel(
     }
 }
 
+/**
+ * Model for lambdas.
+ *
+ * Lambdas in Java represent the implementation of a single abstract method (SAM) of a functional interface.
+ * They can be used to create an instance of said functional interface, but **they are not classes**.
+ * In Java lambdas are compiled into synthetic methods of a class they are declared in.
+ * Depending on the captured variables, this method will be either static or non-static.
+ *
+ * Since lambdas are not classes we cannot use a class loader to get info about them as we can do for other models.
+ * Hence, the necessity for this specific lambda model that will be processed differently: instead of working
+ * with a class we will be working with the synthetic method that represents our lambda.
+ */
+// TODO: what about support for Kotlin lambdas (they are not exactly the same as Java's due to functional types)
+class UtLambdaModel(
+    override val id: Int?,
+    val samType: ClassId,
+    val declaringClass: ClassId,
+    val lambdaName: String,
+    val capturedValues: MutableList<UtModel> = mutableListOf(),
+) : UtReferenceModel(id, samType) {
+
+    val lambdaMethodId: MethodId
+        get() = declaringClass.jClass
+            .declaredMethods
+            .singleOrNull { it.name == lambdaName }
+            ?.executableId // synthetic lambda methods should not have overloads, so we always expect there to be only one method with the given name
+            ?: error("More than one method with name $lambdaName found in class: ${declaringClass.canonicalName}")
+}
+
 /**
  * Model for a step to obtain [UtAssembleModel].
  */
@@ -697,8 +727,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 }
@@ -1035,12 +1071,12 @@ open class MethodId(
         get() = Modifier.isPrivate(method.modifiers)
 }
 
-class ConstructorId(
+open class ConstructorId(
     override val classId: ClassId,
     override val parameters: List<ClassId>
 ) : ExecutableId() {
-    override val name: String = "<init>"
-    override val returnType: ClassId = voidClassId
+    final override val name: String = "<init>"
+    final override val returnType: ClassId = voidClassId
 
     override val isPublic: Boolean
         get() = Modifier.isPublic(constructor.modifiers)
@@ -1064,6 +1100,15 @@ class BuiltinMethodId(
     override val isPrivate: Boolean = false
 ) : MethodId(classId, name, returnType, parameters)
 
+class BuiltinConstructorId(
+    classId: ClassId,
+    parameters: List<ClassId>,
+    // by default, we assume that the builtin constructor is public
+    override val isPublic: Boolean = true,
+    override val isProtected: Boolean = false,
+    override val isPrivate: Boolean = false
+) : ConstructorId(classId, parameters)
+
 open class TypeParameters(val parameters: List<ClassId> = emptyList())
 
 class WildcardTypeParameter : TypeParameters(emptyList())

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

@@ -1,6 +1,7 @@
 package org.utbot.framework.plugin.api.util
 
 import org.utbot.framework.plugin.api.BuiltinClassId
+import org.utbot.framework.plugin.api.BuiltinConstructorId
 import org.utbot.framework.plugin.api.BuiltinMethodId
 import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.ConstructorId
@@ -30,6 +31,46 @@ 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
+        }
+    }
+
+private val isLambdaRegex = ".*(\\$)lambda_.*".toRegex()
+
+val ClassId.isLambda: Boolean
+    get() = name matches isLambdaRegex
+
+val ClassId.isFunctionalInterface: Boolean
+    get() {
+        // we cannot access jClass of a builtin type, so we have to return false
+        if (this is BuiltinClassId) return false
+        // we cannot access jClass for lambdas, but we know that it is not a functional interface anyway
+        if (this.isLambda) return false
+
+        val clazz = this.jClass
+        if (!clazz.isInterface) return false
+
+        val abstractMethods = clazz.methods.filter { java.lang.reflect.Modifier.isAbstract(it.modifiers) }
+        return abstractMethods.size == 1
+    }
+
 @Suppress("unused")
 val ClassId.enclosingClass: ClassId?
     get() = jClass.enclosingClass?.id
@@ -110,6 +151,34 @@ 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")
+        if (!isAnonymous) error("An anonymous class expected, but got $canonicalName")
+
+        val clazz = jClass
+        val superclass = clazz.superclass.id
+        val interfaces = clazz.interfaces.map { it.id }
+
+        return when {
+            // anonymous class actually inherits from Object, e.g. Object obj = new Object() { ... };
+            superclass == objectClassId && interfaces.isEmpty() -> objectClassId
+            // anonymous class implements some interface
+            superclass == objectClassId -> {
+                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
 
@@ -431,6 +500,10 @@ fun builtinMethodId(classId: BuiltinClassId, name: String, returnType: ClassId,
     return BuiltinMethodId(classId, name, returnType, arguments.toList())
 }
 
+fun builtinConstructorId(classId: BuiltinClassId, vararg arguments: ClassId): BuiltinConstructorId {
+    return BuiltinConstructorId(classId, arguments.toList())
+}
+
 fun builtinStaticMethodId(classId: ClassId, name: String, returnType: ClassId, vararg arguments: ClassId): BuiltinMethodId {
     return BuiltinMethodId(classId, name, returnType, arguments.toList(), isStatic = true)
 }

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

@@ -48,6 +48,7 @@ import kotlinx.collections.immutable.persistentHashMapOf
 import org.utbot.engine.pc.UtSolverStatusUNDEFINED
 import org.utbot.framework.plugin.api.ExecutableId
 import org.utbot.framework.plugin.api.util.executableId
+import org.utbot.framework.plugin.api.util.isLambda
 import soot.ArrayType
 import soot.PrimType
 import soot.RefLikeType
@@ -205,6 +206,9 @@ private val isAnonymousRegex = ".*\\$\\d+$".toRegex()
 val SootClass.isAnonymous
     get() = name matches isAnonymousRegex
 
+val SootClass.isLambda: Boolean
+    get() = this.id.isLambda
+
 val Type.numDimensions get() = if (this is ArrayType) numDimensions else 0
 
 /**

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

@@ -1,6 +1,7 @@
 package org.utbot.engine
 
 import org.utbot.framework.plugin.api.ClassId
+import org.utbot.framework.plugin.api.util.isFunctionalInterface
 
 /**
  * Mock strategies.
@@ -17,15 +18,24 @@ enum class MockStrategy {
     },
 
     OTHER_PACKAGES {
-        override fun eligibleToMock(classToMock: ClassId, classUnderTest: ClassId): Boolean =
-            classToMock != classUnderTest && classToMock.packageName.let {
-                it != classUnderTest.packageName && !isSystemPackage(it)
-            }
+        override fun eligibleToMock(classToMock: ClassId, classUnderTest: ClassId): Boolean {
+            if (classToMock == classUnderTest) return false
+            if (classToMock.packageName == classUnderTest.packageName) return false
+
+            // we always mock functional interfaces
+            if (classToMock.isFunctionalInterface) return true
+
+            return !isSystemPackage(classToMock.packageName)
+        }
     },
 
     OTHER_CLASSES {
-        override fun eligibleToMock(classToMock: ClassId, classUnderTest: ClassId): Boolean =
-                classToMock != classUnderTest && !isSystemPackage(classToMock.packageName)
+        override fun eligibleToMock(classToMock: ClassId, classUnderTest: ClassId): Boolean {
+            if (classToMock == classUnderTest) return false
+            // we always mock functional interfaces
+            if (classToMock.isFunctionalInterface) return true
+            return !isSystemPackage(classToMock.packageName)
+        }
     };
 
     /**

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

@@ -72,6 +72,7 @@ import kotlin.math.min
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.persistentSetOf
 import org.utbot.framework.plugin.api.SYMBOLIC_NULL_ADDR
+import org.utbot.framework.plugin.api.UtLambdaModel
 import org.utbot.framework.plugin.api.UtSandboxFailure
 import soot.ArrayType
 import soot.BooleanType
@@ -510,6 +511,13 @@ class Resolver(
         }
 
         val sootClass = actualType.sootClass
+
+        if (sootClass.isLambda) {
+            return constructLambda(concreteAddr, sootClass).also { lambda ->
+                lambda.capturedValues += collectFieldModels(addr, actualType).values
+            }
+        }
+
         val clazz = classLoader.loadClass(sootClass.name)
 
         if (clazz.isEnum) {
@@ -631,6 +639,41 @@ class Resolver(
         return constructedType.classId.jClass
     }
 
+    private fun constructLambda(addr: Address, sootClass: SootClass): UtLambdaModel {
+        val samType = sootClass.interfaces.singleOrNull()?.id
+            ?: error("Lambda must implement single interface, but ${sootClass.interfaces.size} found for ${sootClass.name}")
+
+        val declaringClass = classLoader.loadClass(sootClass.name.substringBeforeLast("\$lambda"))
+
+        // Java compiles lambdas into synthetic methods with specific names.
+        // However, Soot represents lambdas as classes.
+        // Names of these classes are the modified names of these synthetic methods.
+        // Specifically, Soot replaces some `$` signs by `_`, adds two underscores and some number
+        // to the end of the synthetic method name to form the name of a SootClass for lambda.
+        // For example, given a synthetic method `lambda$foo$1` (lambda declared in method `foo` of class `org.utbot.MyClass`),
+        // Soot will treat this lambda as a class named `org.utbot.MyClass$lambda_foo_1__5` (the last number is probably arbitrary, it's not important).
+        // Here we obtain the synthetic method name of lambda from the name of its SootClass.
+        val lambdaName = sootClass.name
+            .let { name ->
+                val start = name.lastIndexOf("\$lambda") + 1
+                val end = name.lastIndexOf("__")
+                name.substring(start, end)
+            }
+            .let {
+                val builder = StringBuilder(it)
+                builder[it.indexOfFirst { c -> c == '_' }] = '$'
+                builder[it.indexOfLast { c -> c == '_' }] = '$'
+                builder.toString()
+            }
+
+        return UtLambdaModel(
+            id = addr,
+            samType = samType,
+            declaringClass = declaringClass.id,
+            lambdaName = lambdaName
+        )
+    }
+
     private fun constructEnum(addr: Address, type: RefType, clazz: Class<*>): UtEnumConstantModel {
         val descriptor = MemoryChunkDescriptor(ENUM_ORDINAL, type, IntType.v())
         val array = findArray(descriptor, state)

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

@@ -9,7 +9,6 @@ import kotlinx.collections.immutable.toPersistentSet
 import org.utbot.common.WorkaroundReason.HACK
 import org.utbot.framework.UtSettings.ignoreStaticsFromTrustedLibraries
 import org.utbot.common.WorkaroundReason.IGNORE_STATICS_FROM_TRUSTED_LIBRARIES
-import org.utbot.common.WorkaroundReason.REMOVE_ANONYMOUS_CLASSES
 import org.utbot.common.unreachableBranch
 import org.utbot.common.withAccessibility
 import org.utbot.common.workaround
@@ -1831,7 +1830,7 @@ class Traverser(
             return fromMemory
         }
         val addr = fromMemory?.addr ?: findNewAddr()
-        val created = createObject(addr, classType, useConcreteType = false, mockInfoGenerator)
+        val created = createObject(addr, classType, useConcreteType = true, mockInfoGenerator)
         queuedSymbolicStateUpdates += MemoryUpdate(staticInstanceStorage = persistentHashMapOf(classType.id to created))
         return created
     }
@@ -3402,13 +3401,6 @@ class Traverser(
         val returnValue = (symbolicResult as? SymbolicSuccess)?.value as? ObjectValue
         if (returnValue != null) {
             queuedSymbolicStateUpdates += constructConstraintForType(returnValue, returnValue.possibleConcreteTypes).asSoftConstraint()
-
-            workaround(REMOVE_ANONYMOUS_CLASSES) {
-                val sootClass = returnValue.type.sootClass
-                if (!environment.state.isInNestedMethod() && (sootClass.isAnonymous || sootClass.isArtificialEntity)) {
-                    return
-                }
-            }
         }
 
         //fill arrays with default 0/null and other stuff