Fix type casts in Kotlin

Author: ArsenHD

utbot-framework/src/main/kotlin/org/utbot/framework/codegen/model/visitor/CgKotlinRenderer.kt

@@ -191,32 +191,50 @@ internal class CgKotlinRenderer(context: CgContext, printer: CgPrinter = CgPrint
         element.right.accept(this)
     }
 
-    override fun visit(element: CgTypeCast) {
-        print("(")
-        element.expression.accept(this)
+    /**
+     * Sometimes we can omit rendering type cast and simply render its [CgTypeCast.expression] instead.
+     * This method checks if the type cast can be omitted.
+     *
+     * For example, type cast can be omitted when a primitive wrapper is cast to its corresponding primitive (or vice versa),
+     * because in Kotlin there are no primitive types as opposed to Java.
+     *
+     * Also, sometimes we can omit type cast when the [CgTypeCast.targetType] is the same as the type of [CgTypeCast.expression].
+     */
+    private fun isCastNeeded(element: CgTypeCast): Boolean {
+        val targetType = element.targetType
+        val expressionType = element.expression.type
+
+        val isPrimitiveToWrapperCast = targetType.isPrimitiveWrapper && expressionType.isPrimitive
+        val isWrapperToPrimitiveCast = targetType.isPrimitive && expressionType.isPrimitiveWrapper
+        val isNullLiteral = element.expression == nullLiteral()
+
+        if (!isNullLiteral && element.isSafetyCast && (isPrimitiveToWrapperCast || isWrapperToPrimitiveCast)) {
+            return false
+        }
+
         // perform type cast only if target type is not equal to expression type
         // but cast from nullable to not nullable should be performed
         // TODO SAT-1445 actually this safetyCast check looks like hack workaround and possibly does not work
         //  so it should be carefully tested one day
-        if (!element.isSafetyCast || element.expression.type != element.targetType) {
-            // except for the case when a wrapper is cast to its primitive or vice versa
-
-            val isCastFromPrimitiveToWrapper = element.targetType.isPrimitiveWrapper &&
-                    element.expression.type.isPrimitive
-            val isCastFromWrapperToPrimitive = element.targetType.isPrimitive &&
-                    element.expression.type.isPrimitiveWrapper
-            val isNullLiteral = element.expression == nullLiteral()
-            if (!isNullLiteral && element.isSafetyCast && (isCastFromPrimitiveToWrapper || isCastFromWrapperToPrimitive)) {
-                return
-            }
+        return !element.isSafetyCast || expressionType != targetType
+    }
+
+    override fun visit(element: CgTypeCast) {
+        if (!isCastNeeded(element)) {
+            element.expression.accept(this)
+        } else {
+            print("(")
+
+            element.expression.accept(this)
 
             if (element.isSafetyCast) print(" as? ") else print(" as ")
             print(getKotlinClassString(element.targetType))
             renderTypeParameters(element.targetType.typeParameters)
             val initNullable = element.type.isNullable
             if (element.targetType.isNullable || initNullable) print("?")
+
+            print(")")
         }
-        print(")")
     }
 
     override fun visit(element: CgErrorWrapper) {