Update codegen

Author: tamarinvs19

utbot-python/src/main/kotlin/org/utbot/python/framework/codegen/model/PythonCodeGenerator.kt

@@ -143,11 +143,11 @@ class PythonCodeGenerator(
             val parameters = methodArguments.zip(arguments).map { (model, argument) ->
                 if (model is PythonTreeModel) {
                     val obj = (context.cgLanguageAssistant.getVariableConstructorBy(context) as PythonCgVariableConstructor).getOrCreateVariable(model)
-                    (obj as CgPythonTree).children.forEach { it.accept(renderer) }
+//                    (obj as CgPythonTree).children.forEach { it.accept(renderer) }
 
                     CgAssignment(
                         argument,
-                        obj.value
+                        (obj as CgPythonTree).value
                     )
                 } else {
                     CgAssignment(argument, CgLiteral(model.classId, model.toString()))

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

@@ -6,6 +6,7 @@ import org.utbot.framework.codegen.domain.models.CgAssignment
 import org.utbot.framework.codegen.domain.models.CgConstructorCall
 import org.utbot.framework.codegen.domain.models.CgExecutableCall
 import org.utbot.framework.codegen.domain.models.CgExpression
+import org.utbot.framework.codegen.domain.models.CgFieldAccess
 import org.utbot.framework.codegen.domain.models.CgMethodCall
 import org.utbot.framework.codegen.domain.models.CgStaticFieldAccess
 import org.utbot.framework.codegen.domain.models.CgThisInstance
@@ -36,7 +37,7 @@ class PythonCgCallableAccessManagerImpl(val context: CgContext) : CgCallableAcce
         CgIncompleteMethodCall(staticMethodId, CgThisInstance(pythonAnyClassId))
 
     override fun CgExpression.get(fieldId: FieldId): CgExpression {
-        TODO("Not yet implemented")
+        return CgFieldAccess(this, fieldId)
     }
 
     override fun ClassId.get(fieldId: FieldId): CgStaticFieldAccess {
@@ -55,7 +56,7 @@ class PythonCgCallableAccessManagerImpl(val context: CgContext) : CgCallableAcce
         args.forEach { arg ->
             if (arg is CgPythonTree) {
                 resolvedArgs.add(arg.value)
-                arg.children.forEach { +it }
+//                arg.children.forEach { +it }
             } else {
                 resolvedArgs.add(arg as CgExpression)
             }

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

@@ -29,8 +29,8 @@ class PythonCgVariableConstructor(context_: CgContext) : CgVariableConstructor(c
                 is PythonBoolModel -> CgLiteral(model.classId, model.value)
                 is PythonPrimitiveModel -> CgLiteral(model.classId, model.value)
                 is PythonTreeModel -> {
-                    val (value, children) = pythonBuildObject2(model.tree)
-                    CgPythonTree(model.classId, model.tree, value, children)
+                    val value = pythonBuildObject2(model.tree)
+                    CgPythonTree(model.classId, model.tree, value)
                 }
                 is PythonInitObjectModel -> constructInitObjectModel(model, baseName)
                 is PythonDictModel -> CgPythonDict(model.stores.map {
@@ -58,51 +58,45 @@ class PythonCgVariableConstructor(context_: CgContext) : CgVariableConstructor(c
         }
     }
 
-    private fun pythonBuildObject2(objectNode: PythonTree.PythonTreeNode): Pair<CgValue, List<CgStatement>> {
+    private fun pythonBuildObject2(objectNode: PythonTree.PythonTreeNode): CgValue {
         return when (objectNode) {
             is PythonTree.PrimitiveNode -> {
-                Pair(CgLiteral(objectNode.type, objectNode.repr), emptyList())
+                CgLiteral(objectNode.type, objectNode.repr)
             }
 
             is PythonTree.ListNode -> {
                 val items = objectNode.items.values.map { pythonBuildObject2(it) }
-                Pair(CgPythonList(items.map { it.first }), items.flatMap { it.second })
+                CgPythonList(items)
             }
 
             is PythonTree.TupleNode -> {
                 val items = objectNode.items.values.map { pythonBuildObject2(it) }
-                Pair(CgPythonTuple(items.map { it.first }), items.flatMap { it.second })
+                CgPythonTuple(items)
             }
 
             is PythonTree.SetNode -> {
                 val items = objectNode.items.map { pythonBuildObject2(it) }
-                Pair(CgPythonSet(items.map { it.first }.toSet()), items.flatMap { it.second })
+                CgPythonSet(items.toSet())
             }
 
             is PythonTree.DictNode -> {
                 val keys = objectNode.items.keys.map { pythonBuildObject2(it) }
                 val values = objectNode.items.values.map { pythonBuildObject2(it) }
-                Pair(CgPythonDict(
-                    keys.zip(values).map { (key, value) ->
-                        key.first to value.first
-                    }.toMap()
-                ), keys.flatMap { it.second } + values.flatMap { it.second })
+                CgPythonDict(
+                    keys.zip(values).associate { (key, value) ->
+                        key to value
+                    }
+                )
             }
 
             is PythonTree.ReduceNode -> {
                 val id = objectNode.id
-                val children = emptyList<CgStatement>().toMutableList()
                 if ((context.cgLanguageAssistant as PythonCgLanguageAssistant).memoryObjects.containsKey(id)) {
-                    return Pair(
-                        (context.cgLanguageAssistant as PythonCgLanguageAssistant).memoryObjects[id]!!,
-                        children
-                    )
+                    return (context.cgLanguageAssistant as PythonCgLanguageAssistant).memoryObjects[id]!!
                 }
 
                 val initArgs = objectNode.args.map {
-                    val buildObj = pythonBuildObject2(it)
-                    children += buildObj.second
-                    buildObj.first
+                    pythonBuildObject2(it)
                 }
                 val constructor = ConstructorId(
                     objectNode.constructor,
@@ -112,31 +106,27 @@ class PythonCgVariableConstructor(context_: CgContext) : CgVariableConstructor(c
                 val obj = newVar(objectNode.type) {
                     constructorCall
                 }
-                children.add(CgAssignment(obj, constructorCall))
+//                obj `=` constructorCall
 
                 (context.cgLanguageAssistant as PythonCgLanguageAssistant).memoryObjects[id] = obj
 
                 val state = objectNode.state.map { (key, value) ->
                     val buildObj = pythonBuildObject2(value)
-                    children.addAll(buildObj.second)
-                    key to buildObj.first
+                    key to buildObj
                 }.toMap()
                 val listitems = objectNode.listitems.map {
                     val buildObj = pythonBuildObject2(it)
-                    children.addAll(buildObj.second)
-                    buildObj.first
+                    buildObj
                 }
                 val dictitems = objectNode.dictitems.map { (key, value) ->
                     val keyObj = pythonBuildObject2(key)
                     val valueObj = pythonBuildObject2(value)
-                    children.addAll(keyObj.second)
-                    children.addAll(valueObj.second)
-                    keyObj.first to valueObj.first
+                    keyObj to valueObj
                 }
 
                 state.forEach { (key, value) ->
-                    val fieldAccess = CgFieldAccess(obj, FieldId(objectNode.type, key))
-                    children.add(CgAssignment(fieldAccess, value))
+//                    val fieldAccess = CgFieldAccess(obj, FieldId(objectNode.type, key))
+                    obj[FieldId(objectNode.type, key)] `=` value
                 }
                 listitems.forEach {
                     val methodCall = CgMethodCall(
@@ -149,18 +139,18 @@ class PythonCgVariableConstructor(context_: CgContext) : CgVariableConstructor(c
                         ),
                         listOf(it)
                     )
-                    children.add(methodCall)
+                    +methodCall
                 }
                 dictitems.forEach { (key, value) ->
                     val index = CgPythonIndex(
                         value.type as PythonClassId,
                         obj,
                         key
                     )
-                    children.add(CgAssignment(index, value))
+                    index `=` value
                 }
 
-                return Pair(obj, children)
+                return obj
             }
 
             else -> {

utbot-python/src/main/kotlin/org/utbot/python/framework/codegen/model/constructor/visitor/CgPythonRenderer.kt

@@ -509,7 +509,7 @@ internal class CgPythonRenderer(
     }
 
     override fun visit(element: CgPythonTree) {
-        element.children.forEach { it.accept(this) }
+//        element.children.forEach { it.accept(this) }
         element.value.accept(this)
     }
 

utbot-python/src/main/kotlin/org/utbot/python/framework/codegen/model/tree/CgPythonElement.kt

@@ -39,7 +39,7 @@ class CgPythonTree(
     override val type: ClassId,
     val tree: PythonTree.PythonTreeNode,
     val value: CgValue,
-    val children: List<CgStatement> = emptyList()
+//    val children: List<CgStatement> = emptyList()
 ) : CgValue, CgPythonElement
 
 class CgPythonRepr(