Add an option to process methods without a body (#1719)

Author: Vassiliy-Kudryashov

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

@@ -499,6 +499,19 @@ object UtSettings : AbstractSettings(logger, defaultKeyForSettingsPath, defaultS
      * Note that values processed concretely won't be replaced with unbounded symbolic variables.
      */
     var processAllClinitSectionsConcretely by getBooleanProperty(false)
+
+    /**
+     * In cases where we don't have a body for a method, we can either throw an exception
+     * or treat this a method as a source of an unbounded symbolic variable returned as a result.
+     *
+     * If this option is set in true, instead of analysis we will return an unbounded symbolic
+     * variable with a corresponding type. Otherwise, an exception will be thrown.
+     *
+     * Default value is false since it is not a common situation when you cannot retrieve a body
+     * from a regular method. Setting this option in true might be suitable in situations when
+     * it is more important not to fall at all rather than work precisely.
+     */
+    var treatAbsentMethodsAsUnboundedValue by getBooleanProperty(false)
 }
 
 /**

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

@@ -134,6 +134,7 @@ import org.utbot.framework.plugin.api.util.utContext
 import org.utbot.framework.util.executableId
 import org.utbot.framework.util.graph
 import org.utbot.framework.plugin.api.util.isInaccessibleViaReflection
+import org.utbot.summary.ast.declaredClassName
 import java.lang.reflect.ParameterizedType
 import kotlin.collections.plus
 import kotlin.collections.plusAssign
@@ -2953,9 +2954,25 @@ class Traverser(
             declaringClass == utArrayMockClass -> utArrayMockInvoke(target, parameters)
             isUtMockForbidClassCastException -> isUtMockDisableClassCastExceptionCheckInvoke(parameters)
             else -> {
-                val graph = substitutedMethod?.jimpleBody()?.graph() ?: jimpleBody().graph()
-                pushToPathSelector(graph, target.instance, parameters, target.constraints, isLibraryMethod)
-                emptyList()
+                // Try to extract a body from substitution of our method or from the method itself.
+                // For the substitution, if it exists, we have a corresponding body and graph,
+                // but for the method itself its body might not be present in the memory.
+                // This may happen because of classloading issues (e.g. absence of required library JAR file)
+                val graph = (substitutedMethod ?: this).takeIf { it.canRetrieveBody() }?.jimpleBody()?.graph()
+
+                if (graph != null) {
+                    // If we have a graph to analyze, do it
+                    pushToPathSelector(graph, target.instance, parameters, target.constraints, isLibraryMethod)
+                    emptyList()
+                } else {
+                    // Otherwise, depending on [treatAbsentMethodsAsUnboundedValue] either throw an exception
+                    // or continue analysis with an unbounded variable as a result of the [this] method
+                    if (UtSettings.treatAbsentMethodsAsUnboundedValue) {
+                        listOf(unboundedVariable("methodWithoutBodyResult", method = this))
+                    } else {
+                        error("Cannot retrieve body for a $declaredClassName.$name method")
+                    }
+                }
             }
         }
     }