From 45555d681da47e69c2363a92075162e1bf245ab8 Mon Sep 17 00:00:00 2001 From: Ivan Kylchik Date: Wed, 10 Jun 2020 19:11:58 +0300 Subject: [PATCH] Add methods from arrays classes in ir builtins map --- .../interpreter/builtins/CompileTimeUtils.kt | 18 ++--- .../builtins/IrBuiltInsMapGenerated.kt | 74 ++++++++++++++----- generators/evaluate/GenerateBuiltInsMap.kt | 67 +++++++++-------- 3 files changed, 100 insertions(+), 59 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/builtins/CompileTimeUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/builtins/CompileTimeUtils.kt index 466b29c46e8..84d925ac963 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/builtins/CompileTimeUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/builtins/CompileTimeUtils.kt @@ -14,23 +14,23 @@ data class CompileTimeFunction(val methodName: String, val args: List) @Suppress("UNCHECKED_CAST") fun unaryOperation( - methodName: String, receiverType: String, function: (T) -> Any -): Pair> { - return CompileTimeFunction(methodName, listOf(receiverType)) to function as Function1 + methodName: String, receiverType: String, function: (T) -> Any? +): Pair> { + return CompileTimeFunction(methodName, listOf(receiverType)) to function as Function1 } @Suppress("UNCHECKED_CAST") fun binaryOperation( - methodName: String, receiverType: String, parameterType: String, function: (T, E) -> Any -): Pair> { - return CompileTimeFunction(methodName, listOfNotNull(receiverType, parameterType)) to function as Function2 + methodName: String, receiverType: String, parameterType: String, function: (T, E) -> Any? +): Pair> { + return CompileTimeFunction(methodName, listOfNotNull(receiverType, parameterType)) to function as Function2 } @Suppress("UNCHECKED_CAST") fun ternaryOperation( - methodName: String, receiverType: String, firstParameterType: String, secondParameterType: String, function: (T, E, R) -> Any -): Pair> { + methodName: String, receiverType: String, firstParameterType: String, secondParameterType: String, function: (T, E, R) -> Any? +): Pair> { return CompileTimeFunction( methodName, listOfNotNull(receiverType, firstParameterType, secondParameterType) - ) to function as Function3 + ) to function as Function3 } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/builtins/IrBuiltInsMapGenerated.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/builtins/IrBuiltInsMapGenerated.kt index 75094e086e9..c3b3c1ab042 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/builtins/IrBuiltInsMapGenerated.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/builtins/IrBuiltInsMapGenerated.kt @@ -20,7 +20,7 @@ package org.jetbrains.kotlin.backend.common.interpreter.builtins /** This file is generated by org.jetbrains.kotlin.backend.common.interpreter.builtins.GenerateBuiltInsMap.generateMap(). DO NOT MODIFY MANUALLY */ -val unaryFunctions = mapOf>( +val unaryFunctions = mapOf>( unaryOperation("not", "Boolean") { a -> a.not() }, unaryOperation("toString", "Boolean") { a -> a.toString() }, unaryOperation("toByte", "Byte") { a -> a.toByte() }, @@ -94,13 +94,31 @@ val unaryFunctions = mapOf>( unaryOperation("unaryMinus", "Short") { a -> a.unaryMinus() }, unaryOperation("unaryPlus", "Short") { a -> a.unaryPlus() }, unaryOperation("length", "String") { a -> a.length }, - unaryOperation("toString", "String") { a -> a.toString() } + unaryOperation("toString", "String") { a -> a.toString() }, + unaryOperation>("size", "Array") { a -> a.size }, + unaryOperation>("iterator", "Array") { a -> a.iterator() }, + unaryOperation("size", "BooleanArray") { a -> a.size }, + unaryOperation("iterator", "BooleanArray") { a -> a.iterator() }, + unaryOperation("size", "CharArray") { a -> a.size }, + unaryOperation("iterator", "CharArray") { a -> a.iterator() }, + unaryOperation("size", "ByteArray") { a -> a.size }, + unaryOperation("iterator", "ByteArray") { a -> a.iterator() }, + unaryOperation("size", "ShortArray") { a -> a.size }, + unaryOperation("iterator", "ShortArray") { a -> a.iterator() }, + unaryOperation("size", "IntArray") { a -> a.size }, + unaryOperation("iterator", "IntArray") { a -> a.iterator() }, + unaryOperation("size", "FloatArray") { a -> a.size }, + unaryOperation("iterator", "FloatArray") { a -> a.iterator() }, + unaryOperation("size", "LongArray") { a -> a.size }, + unaryOperation("iterator", "LongArray") { a -> a.iterator() }, + unaryOperation("size", "DoubleArray") { a -> a.size }, + unaryOperation("iterator", "DoubleArray") { a -> a.iterator() } ) -val binaryFunctions = mapOf>( +val binaryFunctions = mapOf>( binaryOperation("and", "Boolean", "Boolean") { a, b -> a.and(b) }, binaryOperation("compareTo", "Boolean", "Boolean") { a, b -> a.compareTo(b) }, - binaryOperation("equals", "Boolean", "Any") { a, b -> a.equals(b) }, + binaryOperation("equals", "Boolean", "Any?") { a, b -> a.equals(b) }, binaryOperation("or", "Boolean", "Boolean") { a, b -> a.or(b) }, binaryOperation("xor", "Boolean", "Boolean") { a, b -> a.xor(b) }, binaryOperation("compareTo", "Byte", "Byte") { a, b -> a.compareTo(b) }, @@ -115,7 +133,7 @@ val binaryFunctions = mapOf>( binaryOperation("div", "Byte", "Int") { a, b -> a.div(b) }, binaryOperation("div", "Byte", "Long") { a, b -> a.div(b) }, binaryOperation("div", "Byte", "Short") { a, b -> a.div(b) }, - binaryOperation("equals", "Byte", "Any") { a, b -> a.equals(b) }, + binaryOperation("equals", "Byte", "Any?") { a, b -> a.equals(b) }, binaryOperation("minus", "Byte", "Byte") { a, b -> a.minus(b) }, binaryOperation("minus", "Byte", "Double") { a, b -> a.minus(b) }, binaryOperation("minus", "Byte", "Float") { a, b -> a.minus(b) }, @@ -145,7 +163,7 @@ val binaryFunctions = mapOf>( binaryOperation("times", "Byte", "Long") { a, b -> a.times(b) }, binaryOperation("times", "Byte", "Short") { a, b -> a.times(b) }, binaryOperation("compareTo", "Char", "Char") { a, b -> a.compareTo(b) }, - binaryOperation("equals", "Char", "Any") { a, b -> a.equals(b) }, + binaryOperation("equals", "Char", "Any?") { a, b -> a.equals(b) }, binaryOperation("minus", "Char", "Char") { a, b -> a.minus(b) }, binaryOperation("minus", "Char", "Int") { a, b -> a.minus(b) }, binaryOperation("plus", "Char", "Int") { a, b -> a.plus(b) }, @@ -161,7 +179,7 @@ val binaryFunctions = mapOf>( binaryOperation("div", "Double", "Int") { a, b -> a.div(b) }, binaryOperation("div", "Double", "Long") { a, b -> a.div(b) }, binaryOperation("div", "Double", "Short") { a, b -> a.div(b) }, - binaryOperation("equals", "Double", "Any") { a, b -> a.equals(b) }, + binaryOperation("equals", "Double", "Any?") { a, b -> a.equals(b) }, binaryOperation("minus", "Double", "Byte") { a, b -> a.minus(b) }, binaryOperation("minus", "Double", "Double") { a, b -> a.minus(b) }, binaryOperation("minus", "Double", "Float") { a, b -> a.minus(b) }, @@ -198,7 +216,7 @@ val binaryFunctions = mapOf>( binaryOperation("div", "Float", "Int") { a, b -> a.div(b) }, binaryOperation("div", "Float", "Long") { a, b -> a.div(b) }, binaryOperation("div", "Float", "Short") { a, b -> a.div(b) }, - binaryOperation("equals", "Float", "Any") { a, b -> a.equals(b) }, + binaryOperation("equals", "Float", "Any?") { a, b -> a.equals(b) }, binaryOperation("minus", "Float", "Byte") { a, b -> a.minus(b) }, binaryOperation("minus", "Float", "Double") { a, b -> a.minus(b) }, binaryOperation("minus", "Float", "Float") { a, b -> a.minus(b) }, @@ -236,7 +254,7 @@ val binaryFunctions = mapOf>( binaryOperation("div", "Int", "Int") { a, b -> a.div(b) }, binaryOperation("div", "Int", "Long") { a, b -> a.div(b) }, binaryOperation("div", "Int", "Short") { a, b -> a.div(b) }, - binaryOperation("equals", "Int", "Any") { a, b -> a.equals(b) }, + binaryOperation("equals", "Int", "Any?") { a, b -> a.equals(b) }, binaryOperation("minus", "Int", "Byte") { a, b -> a.minus(b) }, binaryOperation("minus", "Int", "Double") { a, b -> a.minus(b) }, binaryOperation("minus", "Int", "Float") { a, b -> a.minus(b) }, @@ -283,7 +301,7 @@ val binaryFunctions = mapOf>( binaryOperation("div", "Long", "Int") { a, b -> a.div(b) }, binaryOperation("div", "Long", "Long") { a, b -> a.div(b) }, binaryOperation("div", "Long", "Short") { a, b -> a.div(b) }, - binaryOperation("equals", "Long", "Any") { a, b -> a.equals(b) }, + binaryOperation("equals", "Long", "Any?") { a, b -> a.equals(b) }, binaryOperation("minus", "Long", "Byte") { a, b -> a.minus(b) }, binaryOperation("minus", "Long", "Double") { a, b -> a.minus(b) }, binaryOperation("minus", "Long", "Float") { a, b -> a.minus(b) }, @@ -329,7 +347,7 @@ val binaryFunctions = mapOf>( binaryOperation("div", "Short", "Int") { a, b -> a.div(b) }, binaryOperation("div", "Short", "Long") { a, b -> a.div(b) }, binaryOperation("div", "Short", "Short") { a, b -> a.div(b) }, - binaryOperation("equals", "Short", "Any") { a, b -> a.equals(b) }, + binaryOperation("equals", "Short", "Any?") { a, b -> a.equals(b) }, binaryOperation("minus", "Short", "Byte") { a, b -> a.minus(b) }, binaryOperation("minus", "Short", "Double") { a, b -> a.minus(b) }, binaryOperation("minus", "Short", "Float") { a, b -> a.minus(b) }, @@ -359,9 +377,18 @@ val binaryFunctions = mapOf>( binaryOperation("times", "Short", "Long") { a, b -> a.times(b) }, binaryOperation("times", "Short", "Short") { a, b -> a.times(b) }, binaryOperation("compareTo", "String", "String") { a, b -> a.compareTo(b) }, - binaryOperation("equals", "String", "Any") { a, b -> a.equals(b) }, + binaryOperation("equals", "String", "Any?") { a, b -> a.equals(b) }, binaryOperation("get", "String", "Int") { a, b -> a.get(b) }, - binaryOperation("plus", "String", "Any") { a, b -> a.plus(b) }, + binaryOperation("plus", "String", "Any?") { a, b -> a.plus(b) }, + binaryOperation, Int>("get", "Array", "Int") { a, b -> a.get(b) }, + binaryOperation("get", "BooleanArray", "Int") { a, b -> a.get(b) }, + binaryOperation("get", "CharArray", "Int") { a, b -> a.get(b) }, + binaryOperation("get", "ByteArray", "Int") { a, b -> a.get(b) }, + binaryOperation("get", "ShortArray", "Int") { a, b -> a.get(b) }, + binaryOperation("get", "IntArray", "Int") { a, b -> a.get(b) }, + binaryOperation("get", "FloatArray", "Int") { a, b -> a.get(b) }, + binaryOperation("get", "LongArray", "Int") { a, b -> a.get(b) }, + binaryOperation("get", "DoubleArray", "Int") { a, b -> a.get(b) }, binaryOperation("less", "Char", "Char") { a, b -> a < b }, binaryOperation("less", "Byte", "Byte") { a, b -> a < b }, binaryOperation("less", "Short", "Short") { a, b -> a < b }, @@ -390,14 +417,23 @@ val binaryFunctions = mapOf>( binaryOperation("greaterOrEqual", "Float", "Float") { a, b -> a >= b }, binaryOperation("greaterOrEqual", "Long", "Long") { a, b -> a >= b }, binaryOperation("greaterOrEqual", "Double", "Double") { a, b -> a >= b }, - binaryOperation("EQEQ", "Any", "Any") { a, b -> a == b }, - binaryOperation("EQEQEQ", "Any", "Any") { a, b -> a === b }, - binaryOperation("ieee754equals", "Float", "Float") { a, b -> a == b }, - binaryOperation("ieee754equals", "Double", "Double") { a, b -> a == b }, + binaryOperation("EQEQ", "Any?", "Any?") { a, b -> a == b }, + binaryOperation("EQEQEQ", "Any?", "Any?") { a, b -> a === b }, + binaryOperation("ieee754equals", "Float?", "Float?") { a, b -> a == b }, + binaryOperation("ieee754equals", "Double?", "Double?") { a, b -> a == b }, binaryOperation("ANDAND", "Boolean", "Boolean") { a, b -> a && b }, binaryOperation("OROR", "Boolean", "Boolean") { a, b -> a || b } ) -val ternaryFunctions = mapOf>( - ternaryOperation("subSequence", "String", "Int", "Int") { a, b, c -> a.subSequence(b, c) } +val ternaryFunctions = mapOf>( + ternaryOperation("subSequence", "String", "Int", "Int") { a, b, c -> a.subSequence(b, c) }, + ternaryOperation, Int, Any?>("set", "Array", "Int", "T") { a, b, c -> a.set(b, c) }, + ternaryOperation("set", "BooleanArray", "Int", "Boolean") { a, b, c -> a.set(b, c) }, + ternaryOperation("set", "CharArray", "Int", "Char") { a, b, c -> a.set(b, c) }, + ternaryOperation("set", "ByteArray", "Int", "Byte") { a, b, c -> a.set(b, c) }, + ternaryOperation("set", "ShortArray", "Int", "Short") { a, b, c -> a.set(b, c) }, + ternaryOperation("set", "IntArray", "Int", "Int") { a, b, c -> a.set(b, c) }, + ternaryOperation("set", "FloatArray", "Int", "Float") { a, b, c -> a.set(b, c) }, + ternaryOperation("set", "LongArray", "Int", "Long") { a, b, c -> a.set(b, c) }, + ternaryOperation("set", "DoubleArray", "Int", "Double") { a, b, c -> a.set(b, c) } ) diff --git a/generators/evaluate/GenerateBuiltInsMap.kt b/generators/evaluate/GenerateBuiltInsMap.kt index 7f76f88046e..0deaa2c4a34 100644 --- a/generators/evaluate/GenerateBuiltInsMap.kt +++ b/generators/evaluate/GenerateBuiltInsMap.kt @@ -9,10 +9,12 @@ import org.jetbrains.kotlin.backend.common.interpreter.builtins.compileTimeAnnot import org.jetbrains.kotlin.backend.jvm.serialization.JvmIdSignatureDescriptor import org.jetbrains.kotlin.builtins.DefaultBuiltIns import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.builtins.PrimitiveType import org.jetbrains.kotlin.config.ApiVersion import org.jetbrains.kotlin.config.LanguageVersion import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl 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.descriptors.impl.ModuleDescriptorImpl @@ -21,11 +23,9 @@ import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns import org.jetbrains.kotlin.ir.util.ConstantValueGenerator import org.jetbrains.kotlin.ir.util.SymbolTable import org.jetbrains.kotlin.ir.util.TypeTranslator -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.utils.Printer import java.io.File @@ -46,9 +46,9 @@ fun generateMap(): String { p.println("/** This file is generated by org.jetbrains.kotlin.backend.common.interpreter.builtins.GenerateBuiltInsMap.generateMap(). DO NOT MODIFY MANUALLY */") p.println() - val unaryOperationsMap = mutableMapOf>() - val binaryOperationsMap = mutableMapOf>() - val ternaryOperationsMap = mutableMapOf>() + val unaryOperationsMap = mutableMapOf>() + val binaryOperationsMap = mutableMapOf>() + val ternaryOperationsMap = mutableMapOf>() val builtIns = DefaultBuiltIns.Instance //save common built ins @@ -56,26 +56,38 @@ fun generateMap(): String { val allPrimitiveTypes = builtIns.builtInsPackageScope.getContributedDescriptors() .filter { it is ClassDescriptor && KotlinBuiltIns.isPrimitiveType(it.defaultType) } as List - for (descriptor in allPrimitiveTypes + builtIns.string) { + val arrays = listOf(builtIns.array) + PrimitiveType.values().map { builtIns.getPrimitiveArrayClassDescriptor(it) } + + for (descriptor in allPrimitiveTypes + builtIns.string + arrays) { + val typeParameters = descriptor.typeConstructor.parameters.map { it.name.asString() } + val typeParametersAsAny = if (typeParameters.isNotEmpty()) typeParameters.joinToString(prefix = "<", postfix = ">") { "Any?" } else "" val descriptorType = descriptor.defaultType @Suppress("UNCHECKED_CAST") val functions = descriptor.getMemberScope(listOf()).getContributedDescriptors() - .filter { it is CallableDescriptor && it.annotations.hasAnnotation(compileTimeAnnotation) } as List + .filter { + it is CallableDescriptor && + (it as? FunctionDescriptor)?.kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE && + (it.annotations.hasAnnotation(compileTimeAnnotation) || descriptor.annotations.hasAnnotation(compileTimeAnnotation)) + } as List for (function in functions) { - val parametersTypes = function.valueParameters.map { TypeUtils.makeNotNullable(it.type) } + listOf(descriptorType) + val operationArguments = (listOf(descriptorType) + function.valueParameters.map { it.type }).joinToString { "\"" + it + "\"" } - when (parametersTypes.size) { - 1 -> unaryOperationsMap[function] = parametersTypes - 2 -> binaryOperationsMap[function] = parametersTypes - 3 -> ternaryOperationsMap[function] = parametersTypes + val functionTypeParameters = (listOf(descriptorType.constructor.toString() + typeParametersAsAny) + + function.valueParameters.map { if (typeParameters.contains(it.type.toString())) "Any?" else it.type.toString() }) + .joinToString(prefix = "<", postfix = ">") + + when (function.valueParameters.size + 1) { // +1 for receiver + 1 -> unaryOperationsMap[function] = functionTypeParameters to operationArguments + 2 -> binaryOperationsMap[function] = functionTypeParameters to operationArguments + 3 -> ternaryOperationsMap[function] = functionTypeParameters to operationArguments else -> throw IllegalStateException("Couldn't add following method from builtins to operations map: ${function.name} in class ${descriptor.name}") } } } //save ir built ins - val binaryIrOperationsMap = mutableMapOf>() + val binaryIrOperationsMap = mutableMapOf>() val irBuiltIns = getIrBuiltIns() val irFunSymbols = (irBuiltIns.lessFunByOperandType.values + @@ -91,33 +103,30 @@ fun generateMap(): String { .filter { it.annotations.hasAnnotation(compileTimeAnnotation) } for (function in irFunSymbols) { - val parametersTypes = function.valueParameters.map { TypeUtils.makeNotNullable(it.type) } + val parametersTypes = function.valueParameters.map { it.type } + val operationArguments = parametersTypes.joinToString { "\"" + it + "\"" } + val functionTypeParameters = parametersTypes.joinToString(prefix = "<", postfix = ">") check(parametersTypes.size == 2) { "Couldn't add following method from ir builtins to operations map: ${function.name}" } - binaryIrOperationsMap[function] = parametersTypes + binaryIrOperationsMap[function] = functionTypeParameters to operationArguments } //save to file - p.println("val unaryFunctions = mapOf>(") + p.println("val unaryFunctions = mapOf>(") val unaryBody = unaryOperationsMap.entries.joinToString(",\n") { (function, parameters) -> - val receiverType = parameters.last().toString() val methodName = "${function.name}" val parentheses = if (function is FunctionDescriptor) "()" else "" - " unaryOperation<$receiverType>(\"$methodName\", \"$receiverType\") { a -> a.$methodName$parentheses }" + " unaryOperation${parameters.first}(\"$methodName\", ${parameters.second}) { a -> a.$methodName$parentheses }" } p.println(unaryBody) p.println(")") p.println() - p.println("val binaryFunctions = mapOf>(") + p.println("val binaryFunctions = mapOf>(") val binaryBody = binaryOperationsMap.entries.joinToString(",\n", postfix = ",\n") { (function, parameters) -> - val receiverType = parameters.last().toString() - val parameter = parameters.first().toString() val methodName = "${function.name}" - " binaryOperation<$receiverType, $parameter>(\"$methodName\", \"$receiverType\", \"$parameter\") { a, b -> a.$methodName(b) }" + " binaryOperation${parameters.first}(\"$methodName\", ${parameters.second}) { a, b -> a.$methodName(b) }" } + binaryIrOperationsMap.entries.joinToString(",\n") { (function, parameters) -> - val firstParameterType = parameters.last().toString() - val secondParameterType = parameters.first().toString() val methodName = "${function.name}" val methodSymbol = when (methodName) { IrBuiltIns.OperatorNames.LESS -> "<" @@ -131,19 +140,15 @@ fun generateMap(): String { IrBuiltIns.OperatorNames.OROR -> "||" else -> throw UnsupportedOperationException("Unknown ir operation \"$methodName\"") } - " binaryOperation<$firstParameterType, $secondParameterType>(\"$methodName\", \"$firstParameterType\", \"$secondParameterType\") { a, b -> a $methodSymbol b }" + " binaryOperation${parameters.first}(\"$methodName\", ${parameters.second}) { a, b -> a $methodSymbol b }" } p.println(binaryBody) p.println(")") - p.println("val ternaryFunctions = mapOf>(") + p.println("val ternaryFunctions = mapOf>(") val ternaryBody = ternaryOperationsMap.entries.joinToString(",\n") { (function, parameters) -> - val receiverType = parameters.last().toString() - val firstParameter = parameters[0].toString() - val secondParameter = parameters[1].toString() val methodName = "${function.name}" - " ternaryOperation<$receiverType, $firstParameter, $secondParameter>" + - "(\"$methodName\", \"$receiverType\", \"$firstParameter\", \"$secondParameter\") { a, b, c -> a.$methodName(b, c) }" + " ternaryOperation${parameters.first}(\"$methodName\", ${parameters.second}) { a, b, c -> a.$methodName(b, c) }" } p.println(ternaryBody) p.println(")")