Got rid of varargs processing stuff

Author: Damtev

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

@@ -1,55 +1,22 @@
 package org.utbot.common
 
-import java.lang.reflect.Array
 import java.lang.reflect.InvocationTargetException
 import java.lang.reflect.Method
 import kotlin.reflect.KClass
 
 val Class<*>.nameOfPackage: String get() = `package`?.name?:""
 
+/**
+ * Invokes [this] method of passed [obj] instance (null for static methods) with the passed [args] arguments.
+ * NOTE: vararg parameters must be passed as an array of the corresponding type.
+ */
 fun Method.invokeCatching(obj: Any?, args: List<Any?>) = try {
-    val invocation = if (isVarArgs) {
-        // In java only last parameter could be vararg
-        val firstNonVarargParametersCount = parameterCount - 1
-
-        val varargArray = constructVarargParameterArray(firstNonVarargParametersCount, args)
-
-        if (firstNonVarargParametersCount == 0) {
-            // Only vararg parameter, just pass only it as an array
-            invoke(obj, varargArray)
-        } else {
-            // Pass first non vararg parameters as vararg, and the vararg parameter as an array
-            val firstNonVarargParameters = args.take(firstNonVarargParametersCount)
-
-            invoke(obj, *firstNonVarargParameters.toTypedArray(), varargArray)
-        }
-    } else {
-        invoke(obj, *args.toTypedArray())
-    }
+    val invocation = invoke(obj, *args.toTypedArray())
 
     Result.success(invocation)
 } catch (e: InvocationTargetException) {
     Result.failure<Nothing>(e.targetException)
 }
 
-// https://stackoverflow.com/a/59857242
-private fun Method.constructVarargParameterArray(firstNonVarargParametersCount: Int, args: List<Any?>): Any {
-    val varargCount = args.size - firstNonVarargParametersCount
-    val varargElements = args.drop(firstNonVarargParametersCount)
-
-    val varargElementType = parameterTypes.last().componentType
-    requireNotNull(varargElementType) {
-        "Vararg parameter of method $this was expected to be array but ${parameterTypes.last()} found"
-    }
-
-    val varargArray = Array.newInstance(parameterTypes.last().componentType, varargCount)
-
-    varargElements.forEachIndexed { index, value ->
-        Array.set(varargArray, index, value)
-    }
-
-    return varargArray
-}
-
 val KClass<*>.allNestedClasses: List<KClass<*>>
     get() = listOf(this) + nestedClasses.flatMap { it.allNestedClasses }

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

@@ -484,17 +484,8 @@ internal class CgCallableAccessManagerImpl(val context: CgContext) : CgCallableA
         executable: ExecutableId,
         args: List<CgExpression>,
         ambiguousOverloads: List<ExecutableId>
-    ): List<CgExpression> {
-        val parametersCount = executable.parameters.size
-
-        val (nonVarargParameters, varargParameters) = if (executable.isVarArgs) {
-            // Vararg is always the last parameter
-            args.take(parametersCount - 1) to args.drop(parametersCount - 1)
-        } else {
-            args to emptyList()
-        }
-
-        val castedNonVarargs = nonVarargParameters.withIndex().map { (i ,arg) ->
+    ): List<CgExpression> =
+        args.withIndex().map { (i ,arg) ->
             val targetType = executable.parameters[i]
 
             // always cast nulls
@@ -511,33 +502,6 @@ internal class CgCallableAccessManagerImpl(val context: CgContext) : CgCallableA
             if (ancestors.isNotEmpty()) typeCast(targetType, arg) else arg
         }
 
-        if (varargParameters.isEmpty()) {
-            return castedNonVarargs
-        }
-
-        // Vararg exist, create an array for them without inner casts
-
-        val varargClassId = executable.parameters.last()
-        val varargElementClassId = varargClassId.elementClassId
-            ?: error("Vararg parameter of $executable has to be an array but ${executable.parameters.last()} found")
-
-        // Use a simple array initializer here since this situation is pretty rare
-        val initializer = arrayInitializer(
-            arrayType = varargClassId,
-            elementType = varargElementClassId,
-            values = varargParameters
-        )
-
-        val arrayForVarargs = variableConstructor.newVar(
-            baseType = varargElementClassId,
-            baseName = "varargParameters"
-        ) {
-            initializer
-        }
-
-        return castedNonVarargs + arrayForVarargs
-    }
-
     /**
      * Receives a list of [CgExpression].
      * Transforms it into a list of [CgExpression] where:

utbot-framework/src/main/kotlin/org/utbot/framework/concrete/StreamConstructors.kt

@@ -2,26 +2,38 @@ package org.utbot.framework.concrete
 
 import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.MethodId
+import org.utbot.framework.plugin.api.UtArrayModel
 import org.utbot.framework.plugin.api.UtAssembleModel
 import org.utbot.framework.plugin.api.UtExecutableCallModel
+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.UtStatementModel
+import org.utbot.framework.plugin.api.util.defaultValueModel
 import org.utbot.framework.plugin.api.util.doubleArrayClassId
 import org.utbot.framework.plugin.api.util.doubleStreamClassId
 import org.utbot.framework.plugin.api.util.intArrayClassId
 import org.utbot.framework.plugin.api.util.intStreamClassId
+import org.utbot.framework.plugin.api.util.isPrimitiveWrapper
 import org.utbot.framework.plugin.api.util.longArrayClassId
 import org.utbot.framework.plugin.api.util.longStreamClassId
 import org.utbot.framework.plugin.api.util.methodId
 import org.utbot.framework.plugin.api.util.objectArrayClassId
 import org.utbot.framework.plugin.api.util.streamClassId
+import org.utbot.framework.util.modelIdCounter
 import org.utbot.framework.util.valueToClassId
 
 /**
  * Max number of elements in any concrete stream.
  */
 private const val STREAM_ELEMENTS_LIMIT: Int = 1_000_000
 
-internal abstract class AbstractStreamConstructor(private val streamClassId: ClassId, elementsClassId: ClassId) : UtAssembleModelConstructorBase() {
+internal abstract class AbstractStreamConstructor(private val streamClassId: ClassId, private val elementsClassId: ClassId) : UtAssembleModelConstructorBase() {
+    private val singleElementClassId: ClassId = elementsClassId.elementClassId
+        ?: error("Stream $streamClassId elements have to be an array but $elementsClassId found")
+
+    private val elementDefaultValueModel: UtModel = singleElementClassId.defaultValueModel()
+
     override fun provideInstantiationCall(
         internalConstructor: UtModelConstructorInterface,
         value: Any,
@@ -46,10 +58,18 @@ internal abstract class AbstractStreamConstructor(private val streamClassId: Cla
             )
         }
 
+        val varargModelsArray = UtArrayModel(
+            id = modelIdCounter.incrementAndGet(),
+            classId = elementsClassId,
+            length = models.size,
+            constModel = elementDefaultValueModel,
+            stores = models.mapIndexed { i, model -> i to model.wrapperModelToPrimitiveModel() }.toMap(mutableMapOf())
+        )
+
         return UtExecutableCallModel(
             instance = null,
             executable = ofMethodId,
-            params = models
+            params = listOf(varargModelsArray)
         )
     }
 
@@ -71,6 +91,30 @@ internal abstract class AbstractStreamConstructor(private val streamClassId: Cla
         returnType = this.streamClassId,
         arguments = arrayOf(elementsClassId) // vararg
     )
+
+    /**
+     * Transforms [this] to [UtPrimitiveModel] if it is an [UtAssembleModel] for the corresponding wrapper
+     * (primitive int and wrapper Integer, etc.), and throws an error otherwise.
+     */
+    private fun UtModel.wrapperModelToPrimitiveModel(): UtModel {
+        if (!classId.isPrimitiveWrapper) {
+            // We do not need to transform classes other than primitive wrappers
+            return this
+        }
+
+        require(this !is UtNullModel) {
+            "Unexpected null value in wrapper for primitive stream ${this@AbstractStreamConstructor}"
+        }
+
+        require(this is UtAssembleModel) {
+            "Unexpected not wrapper assemble model $this for value in wrapper " +
+                    "for primitive stream ${this@AbstractStreamConstructor.streamClassId}"
+        }
+
+        return (instantiationCall.params.firstOrNull() as? UtPrimitiveModel)
+            ?: error("No primitive value parameter for wrapper constructor $instantiationCall in model $this " +
+                    "in wrapper for primitive stream ${this@AbstractStreamConstructor.streamClassId}")
+    }
 }
 
 internal class BaseStreamConstructor : AbstractStreamConstructor(streamClassId, objectArrayClassId)