Avoid creating array for varargs that are only used once

Author: IlyaMuravjov

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

@@ -119,5 +119,29 @@ class UtModelDeepMapper private constructor(
          */
         fun collectAllModels(block: (collector: UtModelDeepMapper) -> Unit): Set<UtModel> =
             UtModelDeepMapper(UtModelNoopMapper).also(block).allInputtedModels
+
+        /**
+         * Creates identity deep mapper, runs [block] on it, and returns the map showing how many times each
+         * model is used (i.e. deeply counts usages of all models reachable from models passed to `counter`).
+         *
+         * @param ignoreAssembleOrigin if this flag is set to `true`, usages that occur
+         * inside of [UtAssembleModel.origin] (and origin sub-models) are ignored.
+         */
+        fun countUsages(
+            ignoreAssembleOrigin: Boolean,
+            block: (counter: UtModelDeepMapper) -> Unit
+        ) : Map<UtModel, Int> {
+            val usageCounts = mutableMapOf<UtModel, Int>()
+            block(UtModelDeepMapper(object : UtModelMapper {
+                override fun <T : UtModel> map(model: T, clazz: Class<T>): T {
+                    usageCounts[model] = (usageCounts[model] ?: 0) + 1
+                    return when {
+                        ignoreAssembleOrigin && model is UtAssembleModel -> clazz.cast(model.copy(origin = null))
+                        else -> model
+                    }
+                }
+            }))
+            return usageCounts
+        }
     }
 }

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

@@ -5,6 +5,9 @@ import org.utbot.framework.plugin.api.UtDirectGetFieldModel
 import org.utbot.framework.plugin.api.UtDirectSetFieldModel
 import org.utbot.framework.plugin.api.UtExecutableCallModel
 import org.utbot.framework.plugin.api.UtExecution
+import org.utbot.framework.plugin.api.UtExecutionFailure
+import org.utbot.framework.plugin.api.UtExecutionResult
+import org.utbot.framework.plugin.api.UtExecutionSuccess
 import org.utbot.framework.plugin.api.UtInstrumentation
 import org.utbot.framework.plugin.api.UtModel
 import org.utbot.framework.plugin.api.UtNewInstanceInstrumentation
@@ -59,6 +62,17 @@ fun UtInstrumentation.mapModels(mapper: UtModelMapper) = when (this) {
     is UtStaticMethodInstrumentation -> copy(values = values.mapModels(mapper))
 }
 
+fun UtExecutionResult.mapModels(mapper: UtModelMapper): UtExecutionResult = when (this) {
+    is UtExecutionSuccess -> copy(model = model.map(mapper))
+    is UtExecutionFailure -> this
+}
+
 fun UtExecution.mapStateBeforeModels(mapper: UtModelMapper) = copy(
     stateBefore = stateBefore.mapModels(mapper)
 )
+
+fun UtExecution.mapAllModels(mapper: UtModelMapper) = copy(
+    stateBefore = stateBefore.mapModels(mapper),
+    stateAfter = stateAfter.mapModels(mapper),
+    result = result.mapModels(mapper),
+)

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/domain/context/CgContext.kt

@@ -248,6 +248,8 @@ interface CgContextOwner {
      */
     val relevantFieldManagers: MutableList<CgAbstractClassFieldManager>
 
+    var modelToUsageCountInMethod: Map<UtModel, Int>
+
     fun block(init: () -> Unit): Block {
         val prevBlock = currentBlock
         return try {
@@ -510,6 +512,7 @@ class CgContext(
     override val hangingTestsTimeout: HangingTestsTimeout = HangingTestsTimeout(),
     override val enableTestsTimeout: Boolean = true,
     override val relevantFieldManagers: MutableList<CgAbstractClassFieldManager> = mutableListOf(),
+    override var modelToUsageCountInMethod: Map<UtModel, Int> = emptyMap(),
     override var containsReflectiveCall: Boolean = false,
 ) : CgContextOwner {
     override lateinit var statesCache: EnvironmentFieldStateCache
@@ -666,6 +669,8 @@ class CgContext(
         runtimeExceptionTestsBehaviour = this.runtimeExceptionTestsBehaviour,
         hangingTestsTimeout = this.hangingTestsTimeout,
         enableTestsTimeout = this.enableTestsTimeout,
+        relevantFieldManagers = this.relevantFieldManagers,
+        modelToUsageCountInMethod = this.modelToUsageCountInMethod,
         containsReflectiveCall = this.containsReflectiveCall,
     )
 }

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgMethodConstructor.kt

@@ -117,6 +117,8 @@ import org.utbot.framework.plugin.api.UtTimeoutException
 import org.utbot.framework.plugin.api.UtVoidModel
 import org.utbot.framework.plugin.api.isNotNull
 import org.utbot.framework.plugin.api.isNull
+import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper.Companion.countUsages
+import org.utbot.framework.plugin.api.mapper.mapAllModels
 import org.utbot.framework.plugin.api.onFailure
 import org.utbot.framework.plugin.api.onSuccess
 import org.utbot.framework.plugin.api.util.IndentUtil.TAB
@@ -1819,6 +1821,9 @@ open class CgMethodConstructor(val context: CgContext) : CgContextOwner by conte
         currentExecution = execution
         determineExecutionType()
         statesCache = EnvironmentFieldStateCache.emptyCacheFor(execution)
+        modelToUsageCountInMethod = countUsages(ignoreAssembleOrigin = true) { counter ->
+            execution.mapAllModels(counter)
+        }
         return try {
             block()
         } finally {

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/tree/CgVariableConstructor.kt

@@ -45,6 +45,7 @@ import org.utbot.framework.plugin.api.UtPrimitiveModel
 import org.utbot.framework.plugin.api.UtReferenceModel
 import org.utbot.framework.plugin.api.UtStatementCallModel
 import org.utbot.framework.plugin.api.UtVoidModel
+import org.utbot.framework.plugin.api.isNull
 import org.utbot.framework.plugin.api.util.booleanClassId
 import org.utbot.framework.plugin.api.util.booleanWrapperClassId
 import org.utbot.framework.plugin.api.util.classClassId
@@ -288,10 +289,18 @@ open class CgVariableConstructor(val context: CgContext) :
         when (statementModel) {
             is UtExecutableCallModel -> {
                 val executable = statementModel.executable
-                val paramNames = runCatching {
+                var paramNames = runCatching {
                     executable.executable.parameters.map { if (it.isNamePresent) it.name else null }
                 }.getOrNull()
-                val params = statementModel.params
+                var params = statementModel.params
+
+                if (runCatching { executable.executable.isVarArgs }.getOrDefault(false)) {
+                    convertArrayToVarArgs(statementModel.params.last())?.let { varArgs ->
+                        paramNames = paramNames?.dropLast(1)?.plus(varArgs.map { paramNames?.last()?.removeSuffix("s") })
+                        params = params.dropLast(1) + varArgs
+                    }
+                }
+
                 val caller = statementModel.instance?.let { declareOrGet(it) }
                 val args = params.mapIndexed { i, param ->
                     declareOrGet(param, name = paramNames?.getOrNull(i))
@@ -309,6 +318,16 @@ open class CgVariableConstructor(val context: CgContext) :
             }
         }
 
+    private fun convertArrayToVarArgs(array: UtModel): List<UtModel>? = when {
+        array !is UtArrayModel -> null
+        modelToUsageCountInMethod[array] != 1 -> null
+
+        // avoid ambiguity, where `null` can mean either array itself or first its element
+        array.length == 1 && array[0].isNull() -> null
+
+        else -> List(array.length) { i -> array[i] }
+    }
+
     /**
      * If executable is getter/setter that should be syntactically replaced with field access
      * (e.g., getter/setter generated by Kotlin in Kotlin code), this method returns [CgStatement]