Get rid of compile time check in generator for ir builtins map

These checks are unnecessary because we use all methods from given
classes

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/builtins/IrBuiltInsMapGenerated.kt

@@ -134,8 +134,8 @@ val unaryFunctions = mapOf<CompileTimeFunction, Function1<Any?, Any?>>(
     unaryOperation<LongArray>("iterator", "LongArray") { a -> a.iterator() },
     unaryOperation<DoubleArray>("size", "DoubleArray") { a -> a.size },
     unaryOperation<DoubleArray>("iterator", "DoubleArray") { a -> a.iterator() },
-    unaryOperation<Array<Any?>>("size", "Array<T>") { a -> a.size },
-    unaryOperation<Array<Any?>>("iterator", "Array<T>") { a -> a.iterator() },
+    unaryOperation<Array<Any?>>("size", "Array") { a -> a.size },
+    unaryOperation<Array<Any?>>("iterator", "Array") { a -> a.iterator() },
     unaryOperation<Any>("hashCode", "Any") { a -> a.hashCode() },
     unaryOperation<Any>("toString", "Any") { a -> a.defaultToString() },
     unaryOperation<Any?>("CHECK_NOT_NULL", "T0?") { a -> a!! },
@@ -417,7 +417,7 @@ val binaryFunctions = mapOf<CompileTimeFunction, Function2<Any?, Any?, Any?>>(
     binaryOperation<FloatArray, Int>("get", "FloatArray", "Int") { a, b -> a.get(b) },
     binaryOperation<LongArray, Int>("get", "LongArray", "Int") { a, b -> a.get(b) },
     binaryOperation<DoubleArray, Int>("get", "DoubleArray", "Int") { a, b -> a.get(b) },
-    binaryOperation<Array<Any?>, Int>("get", "Array<T>", "Int") { a, b -> a.get(b) },
+    binaryOperation<Array<Any?>, Int>("get", "Array", "Int") { a, b -> a.get(b) },
     binaryOperation<Any, Any?>("equals", "Any", "Any?") { a, b -> a.equals(b) },
     binaryOperation<Char, Char>("less", "Char", "Char") { a, b -> a < b },
     binaryOperation<Byte, Byte>("less", "Byte", "Byte") { a, b -> a < b },
@@ -465,7 +465,7 @@ val ternaryFunctions = mapOf<CompileTimeFunction, Function3<Any?, Any?, Any?, An
     ternaryOperation<FloatArray, Int, Float>("set", "FloatArray", "Int", "Float") { a, b, c -> a.set(b, c) },
     ternaryOperation<LongArray, Int, Long>("set", "LongArray", "Int", "Long") { a, b, c -> a.set(b, c) },
     ternaryOperation<DoubleArray, Int, Double>("set", "DoubleArray", "Int", "Double") { a, b, c -> a.set(b, c) },
-    ternaryOperation<Array<Any?>, Int, Any?>("set", "Array<T>", "Int", "T") { a, b, c -> a.set(b, c) }
+    ternaryOperation<Array<Any?>, Int, Any?>("set", "Array", "Int", "T") { a, b, c -> a.set(b, c) }
 )
 
 private fun Any.defaultToString(): String {

generators/evaluate/GenerateBuiltInsMap.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.generators.evaluate
 
-import org.jetbrains.kotlin.backend.common.interpreter.builtins.compileTimeAnnotation
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.PrimitiveType
@@ -13,7 +12,9 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.types.impl.originalKotlinType
 import org.jetbrains.kotlin.utils.Printer
 import java.io.File
 
@@ -74,14 +75,12 @@ private fun getOperationMap(argumentsCount: Int): MutableMap<CallableDescriptor,
     val allPrimitiveTypes = PrimitiveType.values().map { builtIns.getBuiltInClassByFqName(it.typeFqName) }
     val arrays = PrimitiveType.values().map { builtIns.getPrimitiveArrayClassDescriptor(it) } + builtIns.array
 
-    fun CallableDescriptor.isCompileTime(classDescriptor: ClassDescriptor): Boolean {
-        val thisIsCompileTime = this.annotations.hasAnnotation(compileTimeAnnotation)
-        val classIsCompileTime = classDescriptor.annotations.hasAnnotation(compileTimeAnnotation)
+    fun CallableDescriptor.isFakeOverride(classDescriptor: ClassDescriptor): Boolean {
         val isPrimitive = KotlinBuiltIns.isPrimitiveClass(classDescriptor) || KotlinBuiltIns.isString(classDescriptor.defaultType)
         val isFakeOverridden = (this as? FunctionDescriptor)?.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE
         return when {
-            isPrimitive -> thisIsCompileTime || classIsCompileTime
-            else -> !isFakeOverridden && (thisIsCompileTime || classIsCompileTime)
+            isPrimitive -> false
+            else -> isFakeOverridden
         }
     }
 
@@ -89,16 +88,16 @@ private fun getOperationMap(argumentsCount: Int): MutableMap<CallableDescriptor,
         val classTypeParameters = classDescriptor.typeConstructor.parameters.map { it.name.asString() }
         val typeParametersReplacedToAny =
             if (classTypeParameters.isNotEmpty()) classTypeParameters.joinToString(prefix = "<", postfix = ">") { "Any?" } else ""
-        val classType = classDescriptor.defaultType
+        val classType = classDescriptor.defaultType.constructor.toString()
 
         val compileTimeFunctions = classDescriptor.unsubstitutedMemberScope.getContributedDescriptors()
             .filterIsInstance<CallableDescriptor>()
-            .filter { it.isCompileTime(classDescriptor) }
+            .filter { !it.isFakeOverride(classDescriptor) }
 
         for (function in compileTimeFunctions) {
             val operationArguments = (listOf(classType) + function.valueParameters.map { it.type }).joinToString { "\"" + it + "\"" }
 
-            val typeParametersOfFun = listOf(classType.constructor.toString() + typeParametersReplacedToAny) +
+            val typeParametersOfFun = listOf(classType + typeParametersReplacedToAny) +
                     function.valueParameters.map { if (classTypeParameters.contains(it.type.toString())) "Any?" else it.type.toString() }
 
             if (function.valueParameters.size + 1 == argumentsCount) { // +1 for receiver
@@ -110,18 +109,17 @@ private fun getOperationMap(argumentsCount: Int): MutableMap<CallableDescriptor,
     return operationMap
 }
 
-private fun getBinaryIrOperationMap(irBuiltIns: IrBuiltIns): MutableMap<CallableDescriptor, Pair<String, String>> {
-    val operationMap = mutableMapOf<CallableDescriptor, Pair<String, String>>()
+private fun getBinaryIrOperationMap(irBuiltIns: IrBuiltIns): MutableMap<IrFunction, Pair<String, String>> {
+    val operationMap = mutableMapOf<IrFunction, Pair<String, String>>()
     val irFunSymbols =
         (irBuiltIns.lessFunByOperandType.values + irBuiltIns.lessOrEqualFunByOperandType.values +
                 irBuiltIns.greaterFunByOperandType.values + irBuiltIns.greaterOrEqualFunByOperandType.values +
                 irBuiltIns.eqeqSymbol + irBuiltIns.eqeqeqSymbol + irBuiltIns.ieee754equalsFunByOperandType.values +
                 irBuiltIns.andandSymbol + irBuiltIns.ororSymbol)
-            .map { it.descriptor }
-            .filter { it.annotations.hasAnnotation(compileTimeAnnotation) }
+            .map { it.owner }
 
     for (function in irFunSymbols) {
-        val parametersTypes = function.valueParameters.map { it.type }
+        val parametersTypes = function.valueParameters.map { it.type.originalKotlinType!!.toString() }
         val operationArguments = parametersTypes.joinToString { "\"" + it + "\"" }
         val functionTypeParameters = parametersTypes.joinToString(prefix = "<", postfix = ">")
 
@@ -133,7 +131,7 @@ private fun getBinaryIrOperationMap(irBuiltIns: IrBuiltIns): MutableMap<Callable
 }
 
 private fun generateUnaryBody(unaryOperationsMap: Map<CallableDescriptor, Pair<String, String>>, irBuiltIns: IrBuiltIns): String {
-    val irNullCheck = irBuiltIns.checkNotNullSymbol.descriptor
+    val irNullCheck = irBuiltIns.checkNotNullSymbol.owner
     return unaryOperationsMap.entries.joinToString(separator = ",\n", postfix = ",\n") { (function, parameters) ->
         val methodName = "${function.name}"
         val parentheses = if (function is FunctionDescriptor) "()" else ""
@@ -142,13 +140,13 @@ private fun generateUnaryBody(unaryOperationsMap: Map<CallableDescriptor, Pair<S
             else "a.$methodName$parentheses"
         "    unaryOperation${parameters.first}(\"$methodName\", ${parameters.second}) { a -> $body }"
     } +
-            "    unaryOperation<Any?>(\"${irNullCheck.name}\", \"${irNullCheck.valueParameters.first().type}\") { a -> a!! },\n" +
+            "    unaryOperation<Any?>(\"${irNullCheck.name}\", \"${irNullCheck.valueParameters.first().type.originalKotlinType}\") { a -> a!! },\n" +
             "    unaryOperation<ExceptionState>(\"message\", \"Throwable\") { a -> a.getMessage() },\n" +
             "    unaryOperation<ExceptionState>(\"cause\", \"Throwable\") { a -> a.getCause() }"
 }
 
 private fun generateBinaryBody(
-    binaryOperationsMap: Map<CallableDescriptor, Pair<String, String>>, binaryIrOperationsMap: Map<CallableDescriptor, Pair<String, String>>
+    binaryOperationsMap: Map<CallableDescriptor, Pair<String, String>>, binaryIrOperationsMap: Map<IrFunction, Pair<String, String>>
 ): String {
     return binaryOperationsMap.entries.joinToString(separator = ",\n", postfix = ",\n") { (function, parameters) ->
         val methodName = "${function.name}"