From fcdb8866d2aa04cb9f69773ca874b2a541c2088a Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Fri, 11 Jun 2021 16:27:09 -0700 Subject: [PATCH] FIR: rewrite evaluator to use eval utils in frontend.common --- compiler/fir/evaluate/build.gradle.kts | 3 +- .../FirCompileTimeConstantEvaluator.kt | 186 ++++++------ .../fir/evaluate/FirOperationsMapGenerated.kt | 286 ------------------ .../evaluate/GenerateFirOperationsMap.kt | 126 -------- generators/evaluate/GenerateOperationsMap.kt | 26 +- .../evaluate/OperationsMapGeneratorsUtil.kt | 48 --- .../evaluate/GenerateFirOperationsMapTest.kt | 18 -- 7 files changed, 122 insertions(+), 571 deletions(-) delete mode 100644 compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirOperationsMapGenerated.kt delete mode 100644 generators/evaluate/GenerateFirOperationsMap.kt delete mode 100644 generators/evaluate/OperationsMapGeneratorsUtil.kt delete mode 100644 generators/tests/org/jetbrains/kotlin/generators/evaluate/GenerateFirOperationsMapTest.kt diff --git a/compiler/fir/evaluate/build.gradle.kts b/compiler/fir/evaluate/build.gradle.kts index bbe82714bb1..853d7e5bb7a 100644 --- a/compiler/fir/evaluate/build.gradle.kts +++ b/compiler/fir/evaluate/build.gradle.kts @@ -4,7 +4,8 @@ plugins { } dependencies { - compile(project(":compiler:fir:tree")) + implementation(project(":compiler:fir:tree")) + implementation(project(":compiler:frontend.common")) compileOnly(intellijCoreDep()) { includeJars("intellij-core", rootProject = rootProject) } } diff --git a/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirCompileTimeConstantEvaluator.kt b/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirCompileTimeConstantEvaluator.kt index f6a7cd6a4bc..d31014b1002 100644 --- a/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirCompileTimeConstantEvaluator.kt +++ b/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirCompileTimeConstantEvaluator.kt @@ -13,8 +13,10 @@ import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.types.* -import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef -import org.jetbrains.kotlin.fir.types.impl.FirImplicitIntTypeRef +import org.jetbrains.kotlin.fir.types.impl.* +import org.jetbrains.kotlin.resolve.constants.evaluate.CompileTimeType +import org.jetbrains.kotlin.resolve.constants.evaluate.evalBinaryOp +import org.jetbrains.kotlin.resolve.constants.evaluate.evalUnaryOp import org.jetbrains.kotlin.types.ConstantValueKind /** @@ -31,48 +33,24 @@ class FirCompileTimeConstantEvaluator { else -> null } + // TODO: Rework to handle nested expressions + // This is no longer used during FIR2IR where an inner expression is recursively rewritten to ConstExpression if possible. + // Maybe rewrite this to a recursive version with caching either here or in provider. private fun evaluate(functionCall: FirFunctionCall): FirConstExpression<*>? { - if (!functionCall.isNumericOperatorCall) { - return null - } val function = functionCall.getOriginalFunction()!! as FirSimpleFunction - @Suppress("UNCHECKED_CAST") - val opr1 = functionCall.explicitReceiver!! as FirConstExpression - if (function.name.asString() in unaryOperatorNames) { - opr1.evaluate(function)?.let { - return it.adjustType(functionCall.typeRef) - } - return null - } - assert(function.name.asString() in binaryOperatorNames) { - "Inconsistency in isNumericOperatorCall and operator names: ${function.name.asString()}." + val opr1 = functionCall.explicitReceiver as? FirConstExpression<*> ?: return null + opr1.evaluate(function)?.let { + return it.adjustType(functionCall.typeRef) } - @Suppress("UNCHECKED_CAST") - val opr2 = functionCall.argument as FirConstExpression + val opr2 = functionCall.argument as? FirConstExpression<*> ?: return null opr1.evaluate(function, opr2)?.let { return it.adjustType(functionCall.typeRef) } return null } - private val FirFunctionCall.isNumericOperatorCall: Boolean - get() { - val function = getOriginalFunction() ?: return false - return typeRef.toConstantValueKind() != null && - // LHS is const expression with numeric constant value. - explicitReceiver != null && explicitReceiver!!.isNumericConst && - function is FirSimpleFunction && - // Either unary operator (which doesn't need RHS) or RHS is also const expression with numeric constant value. - ((function.name.asString() in unaryOperatorNames && arguments.isEmpty()) || - (function.name.asString() in binaryOperatorNames && arguments.size == 1 && argument.isNumericConst)) - } - - private val FirExpression.isNumericConst: Boolean - get() = - this is FirConstExpression<*> && typedValue is Number - private fun FirConstExpression<*>.adjustType(expectedType: FirTypeRef): FirConstExpression<*> { val expectedKind = expectedType.toConstantValueKind() // Note that the resolved type for the const expression is not always matched with the const kind. For example, @@ -84,7 +62,7 @@ class FirCompileTimeConstantEvaluator { // After computing the compile time constant, we need to adjust its type here. val expression = if (expectedKind != null && expectedKind != kind && value is Number) { - val typeAdjustedValue = expectedKind.convert(value as Number)!! + val typeAdjustedValue = expectedKind.convertToNumber(value as Number)!! expectedKind.toConstExpression(source, typeAdjustedValue) } else { this @@ -92,60 +70,79 @@ class FirCompileTimeConstantEvaluator { // Lastly, we should preserve the resolved type of the original function call. return expression.apply { replaceTypeRef(expectedType) + } ?: this + } + + private fun ConstantValueKind.toCompileTimeType(): CompileTimeType { + return when (this) { + ConstantValueKind.Byte -> CompileTimeType.BYTE + ConstantValueKind.Short -> CompileTimeType.SHORT + ConstantValueKind.Int -> CompileTimeType.INT + ConstantValueKind.Long -> CompileTimeType.LONG + ConstantValueKind.Double -> CompileTimeType.DOUBLE + ConstantValueKind.Float -> CompileTimeType.FLOAT + ConstantValueKind.Char -> CompileTimeType.CHAR + ConstantValueKind.Boolean -> CompileTimeType.BOOLEAN + ConstantValueKind.String -> CompileTimeType.STRING + + else -> CompileTimeType.ANY } } // Unary operators - private fun FirConstExpression.evaluate(function: FirSimpleFunction): FirConstExpression? { - val f = unaryOperations[UnaryOperationKey(kind, function.name.asString())] ?: return null - // TODO: need some systematic check, e.g., integer overflow - return try { - val r = f(typedValue) - r.toConstantValueKind()!!.toConstExpression(source, r) - } catch (e: Exception) { - null + private fun FirConstExpression<*>.evaluate(function: FirSimpleFunction): FirConstExpression<*>? { + if (value == null) return null + return evalUnaryOp( + function.name.asString(), + kind.toCompileTimeType(), + value!! + )?.let { + it.toConstantValueKind()?.toConstExpression(source, it) } } // Binary operators - private fun FirConstExpression.evaluate( + private fun FirConstExpression<*>.evaluate( function: FirSimpleFunction, - other: FirConstExpression - ): FirConstExpression? { - val f = binaryOperations[BinaryOperationKey(kind, other.kind, function.name.asString())] ?: return null - // TODO: need some systematic check, e.g., div by zero (1 / 0 v.s. 1 / 0.f) - return try { - val r = f(typedValue, other.typedValue) - r.toConstantValueKind()!!.toConstExpression(source, r) - } catch (e: Exception) { - null + other: FirConstExpression<*> + ): FirConstExpression<*>? { + if (value == null || other.value == null) return null + return evalBinaryOp( + function.name.asString(), + kind.toCompileTimeType(), + value!!, + other.kind.toCompileTimeType(), + other.value!! + )?.let { + it.toConstantValueKind()?.toConstExpression(source, it) } } ////// KINDS - private fun FirTypeRef.toConstantValueKind(): ConstantValueKind? = + private fun FirTypeRef.toConstantValueKind(): ConstantValueKind<*>? = when (this) { !is FirResolvedTypeRef -> null !is FirImplicitBuiltinTypeRef -> type.toConstantValueKind() + + is FirImplicitByteTypeRef -> ConstantValueKind.Byte + is FirImplicitDoubleTypeRef -> ConstantValueKind.Double + is FirImplicitFloatTypeRef -> ConstantValueKind.Float is FirImplicitIntTypeRef -> ConstantValueKind.Int + is FirImplicitLongTypeRef -> ConstantValueKind.Long + is FirImplicitShortTypeRef -> ConstantValueKind.Short + + is FirImplicitCharTypeRef -> ConstantValueKind.Char + is FirImplicitStringTypeRef -> ConstantValueKind.String + is FirImplicitBooleanTypeRef -> ConstantValueKind.Boolean + else -> null } - private fun ConeKotlinType.toConstantValueKind(): ConstantValueKind? = + private fun ConeKotlinType.toConstantValueKind(): ConstantValueKind<*>? = when (this) { is ConeKotlinErrorType -> null - is ConeLookupTagBasedType -> { - when (lookupTag.name.asString()) { - "Byte" -> ConstantValueKind.Byte - "Double" -> ConstantValueKind.Double - "Float" -> ConstantValueKind.Float - "Int" -> ConstantValueKind.Int - "Long" -> ConstantValueKind.Long - "Short" -> ConstantValueKind.Short - else -> null - } - } + is ConeLookupTagBasedType -> lookupTag.name.asString().toConstantValueKind() is ConeFlexibleType -> upperBound.toConstantValueKind() is ConeCapturedType -> lowerType?.toConstantValueKind() ?: constructor.supertypes!!.first().toConstantValueKind() is ConeDefinitelyNotNullType -> original.toConstantValueKind() @@ -154,7 +151,23 @@ class FirCompileTimeConstantEvaluator { is ConeIntegerLiteralType -> null } - private fun T.toConstantValueKind(): ConstantValueKind? = + private fun String.toConstantValueKind(): ConstantValueKind<*>? = + when (this) { + "Byte" -> ConstantValueKind.Byte + "Double" -> ConstantValueKind.Double + "Float" -> ConstantValueKind.Float + "Int" -> ConstantValueKind.Int + "Long" -> ConstantValueKind.Long + "Short" -> ConstantValueKind.Short + + "Char" -> ConstantValueKind.Char + "String" -> ConstantValueKind.String + "Boolean" -> ConstantValueKind.Boolean + + else -> null + } + + private fun T.toConstantValueKind(): ConstantValueKind<*>? = when (this) { is Byte -> ConstantValueKind.Byte is Double -> ConstantValueKind.Double @@ -162,10 +175,15 @@ class FirCompileTimeConstantEvaluator { is Int -> ConstantValueKind.Int is Long -> ConstantValueKind.Long is Short -> ConstantValueKind.Short + + is Char -> ConstantValueKind.Char + is String -> ConstantValueKind.String + is Boolean -> ConstantValueKind.Boolean + else -> null } - private fun ConstantValueKind<*>.convert(value: Number?): Number? { + private fun ConstantValueKind<*>.convertToNumber(value: Number?): Number? { if (value == null) { return null } @@ -180,30 +198,16 @@ class FirCompileTimeConstantEvaluator { } } - private fun ConstantValueKind.toConstExpression(source: FirSourceElement?, value: Number): FirConstExpression = - @Suppress("UNCHECKED_CAST") - buildConstExpression(source, this, value as T) -} + private fun ConstantValueKind?.toConstExpression(source: FirSourceElement?, value: Any): FirConstExpression? = + if (this == null) null else + @Suppress("UNCHECKED_CAST") + buildConstExpression(source, this, value as T) -val FirConstExpression.typedValue: T - @Suppress("UNCHECKED_CAST") - get() = - (value as? Long)?.let { - when (kind) { - ConstantValueKind.Byte -> it.toByte() - ConstantValueKind.Short -> it.toShort() - ConstantValueKind.Int -> it.toInt() - ConstantValueKind.Float -> it.toFloat() - ConstantValueKind.Double -> it.toDouble() - else -> it - } - } as T ?: value - -fun FirFunctionCall.getOriginalFunction(): FirCallableDeclaration<*>? { - val symbol: AbstractFirBasedSymbol<*>? = when (val reference = calleeReference) { - is FirResolvedNamedReference -> reference.resolvedSymbol - // is FirNamedReferenceWithCandidate -> reference.candidateSymbol - else -> null + private fun FirFunctionCall.getOriginalFunction(): FirCallableDeclaration<*>? { + val symbol: AbstractFirBasedSymbol<*>? = when (val reference = calleeReference) { + is FirResolvedNamedReference -> reference.resolvedSymbol + else -> null + } + return symbol?.fir as? FirCallableDeclaration<*> } - return symbol?.fir as? FirCallableDeclaration<*> } diff --git a/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirOperationsMapGenerated.kt b/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirOperationsMapGenerated.kt deleted file mode 100644 index 7df35e7c21c..00000000000 --- a/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirOperationsMapGenerated.kt +++ /dev/null @@ -1,286 +0,0 @@ -/* - * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ -@file:Suppress("DEPRECATION", "DEPRECATION_ERROR") - -package org.jetbrains.kotlin.fir.evaluate - -import org.jetbrains.kotlin.types.ConstantValueKind - -/** This file is generated by org.jetbrains.kotlin.generators.evaluate:generateFirMap(). DO NOT MODIFY MANUALLY */ - -internal data class UnaryOperationKey(val opr: ConstantValueKind, val opName: String) -internal data class BinaryOperationKey(val opr1: ConstantValueKind, val opr2: ConstantValueKind, val opName: String) - -@Suppress("UNCHECKED_CAST") -private fun unaryOperation( - t: ConstantValueKind, - opName: String, - operation: Function1 -) = UnaryOperationKey(t, opName) to operation as Function1 - -@Suppress("UNCHECKED_CAST") -private fun binaryOperation( - t: ConstantValueKind, - u: ConstantValueKind, - opName: String, - operation: Function2 -) = BinaryOperationKey(t, u, opName) to operation as Function2 - -internal val unaryOperations: HashMap, Function1> = hashMapOf( - unaryOperation(ConstantValueKind.Byte, "dec", { a -> a.dec() }), - unaryOperation(ConstantValueKind.Byte, "hashCode", { a -> a.hashCode() }), - unaryOperation(ConstantValueKind.Byte, "inc", { a -> a.inc() }), - unaryOperation(ConstantValueKind.Byte, "toByte", { a -> a.toByte() }), - unaryOperation(ConstantValueKind.Byte, "toDouble", { a -> a.toDouble() }), - unaryOperation(ConstantValueKind.Byte, "toFloat", { a -> a.toFloat() }), - unaryOperation(ConstantValueKind.Byte, "toInt", { a -> a.toInt() }), - unaryOperation(ConstantValueKind.Byte, "toLong", { a -> a.toLong() }), - unaryOperation(ConstantValueKind.Byte, "toShort", { a -> a.toShort() }), - unaryOperation(ConstantValueKind.Byte, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(ConstantValueKind.Byte, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(ConstantValueKind.Double, "dec", { a -> a.dec() }), - unaryOperation(ConstantValueKind.Double, "hashCode", { a -> a.hashCode() }), - unaryOperation(ConstantValueKind.Double, "inc", { a -> a.inc() }), - unaryOperation(ConstantValueKind.Double, "toByte", { a -> a.toByte() }), - unaryOperation(ConstantValueKind.Double, "toDouble", { a -> a.toDouble() }), - unaryOperation(ConstantValueKind.Double, "toFloat", { a -> a.toFloat() }), - unaryOperation(ConstantValueKind.Double, "toInt", { a -> a.toInt() }), - unaryOperation(ConstantValueKind.Double, "toLong", { a -> a.toLong() }), - unaryOperation(ConstantValueKind.Double, "toShort", { a -> a.toShort() }), - unaryOperation(ConstantValueKind.Double, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(ConstantValueKind.Double, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(ConstantValueKind.Float, "dec", { a -> a.dec() }), - unaryOperation(ConstantValueKind.Float, "hashCode", { a -> a.hashCode() }), - unaryOperation(ConstantValueKind.Float, "inc", { a -> a.inc() }), - unaryOperation(ConstantValueKind.Float, "toByte", { a -> a.toByte() }), - unaryOperation(ConstantValueKind.Float, "toDouble", { a -> a.toDouble() }), - unaryOperation(ConstantValueKind.Float, "toFloat", { a -> a.toFloat() }), - unaryOperation(ConstantValueKind.Float, "toInt", { a -> a.toInt() }), - unaryOperation(ConstantValueKind.Float, "toLong", { a -> a.toLong() }), - unaryOperation(ConstantValueKind.Float, "toShort", { a -> a.toShort() }), - unaryOperation(ConstantValueKind.Float, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(ConstantValueKind.Float, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(ConstantValueKind.Int, "dec", { a -> a.dec() }), - unaryOperation(ConstantValueKind.Int, "hashCode", { a -> a.hashCode() }), - unaryOperation(ConstantValueKind.Int, "inc", { a -> a.inc() }), - unaryOperation(ConstantValueKind.Int, "inv", { a -> a.inv() }), - unaryOperation(ConstantValueKind.Int, "toByte", { a -> a.toByte() }), - unaryOperation(ConstantValueKind.Int, "toDouble", { a -> a.toDouble() }), - unaryOperation(ConstantValueKind.Int, "toFloat", { a -> a.toFloat() }), - unaryOperation(ConstantValueKind.Int, "toInt", { a -> a.toInt() }), - unaryOperation(ConstantValueKind.Int, "toLong", { a -> a.toLong() }), - unaryOperation(ConstantValueKind.Int, "toShort", { a -> a.toShort() }), - unaryOperation(ConstantValueKind.Int, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(ConstantValueKind.Int, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(ConstantValueKind.Long, "dec", { a -> a.dec() }), - unaryOperation(ConstantValueKind.Long, "hashCode", { a -> a.hashCode() }), - unaryOperation(ConstantValueKind.Long, "inc", { a -> a.inc() }), - unaryOperation(ConstantValueKind.Long, "inv", { a -> a.inv() }), - unaryOperation(ConstantValueKind.Long, "toByte", { a -> a.toByte() }), - unaryOperation(ConstantValueKind.Long, "toDouble", { a -> a.toDouble() }), - unaryOperation(ConstantValueKind.Long, "toFloat", { a -> a.toFloat() }), - unaryOperation(ConstantValueKind.Long, "toInt", { a -> a.toInt() }), - unaryOperation(ConstantValueKind.Long, "toLong", { a -> a.toLong() }), - unaryOperation(ConstantValueKind.Long, "toShort", { a -> a.toShort() }), - unaryOperation(ConstantValueKind.Long, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(ConstantValueKind.Long, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(ConstantValueKind.Short, "dec", { a -> a.dec() }), - unaryOperation(ConstantValueKind.Short, "hashCode", { a -> a.hashCode() }), - unaryOperation(ConstantValueKind.Short, "inc", { a -> a.inc() }), - unaryOperation(ConstantValueKind.Short, "toByte", { a -> a.toByte() }), - unaryOperation(ConstantValueKind.Short, "toDouble", { a -> a.toDouble() }), - unaryOperation(ConstantValueKind.Short, "toFloat", { a -> a.toFloat() }), - unaryOperation(ConstantValueKind.Short, "toInt", { a -> a.toInt() }), - unaryOperation(ConstantValueKind.Short, "toLong", { a -> a.toLong() }), - unaryOperation(ConstantValueKind.Short, "toShort", { a -> a.toShort() }), - unaryOperation(ConstantValueKind.Short, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(ConstantValueKind.Short, "unaryPlus", { a -> a.unaryPlus() }), -) - -internal val binaryOperations: HashMap, Function2> = hashMapOf( - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(ConstantValueKind.Short, ConstantValueKind.Short, "times", { a, b -> a.times(b) }), -) - -internal val unaryOperatorNames = unaryOperations.map { it.key.opName }.toHashSet() -internal val binaryOperatorNames = binaryOperations.map { it.key.opName }.toHashSet() diff --git a/generators/evaluate/GenerateFirOperationsMap.kt b/generators/evaluate/GenerateFirOperationsMap.kt deleted file mode 100644 index 11b850aa03d..00000000000 --- a/generators/evaluate/GenerateFirOperationsMap.kt +++ /dev/null @@ -1,126 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.generators.evaluate - -import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.utils.Printer -import java.io.File - -val FIR_DEST_FILE: File = File("compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirOperationsMapGenerated.kt") -private val EXCLUDED_FUNCTIONS: List = listOf( - "not", "toChar", "toString", - "and", "or", "xor", "shl", "shr", "ushr", - "compareTo", "equals", - "rangeTo", "subSequence" -) -private val EXCLUDED_TYPES: List = listOf("Boolean", "Char", "String") - -fun main() { - GeneratorsFileUtil.writeFileIfContentChanged(FIR_DEST_FILE, generateFirMap()) -} - -fun generateFirMap(): String { - val sb = StringBuilder() - val p = Printer(sb) - p.println(File("license/COPYRIGHT_HEADER.txt").readText()) - p.println("@file:Suppress(\"DEPRECATION\", \"DEPRECATION_ERROR\")") - - p.println( - """ - |package org.jetbrains.kotlin.fir.evaluate - | - |import org.jetbrains.kotlin.types.ConstantValueKind - | - |/** This file is generated by org.jetbrains.kotlin.generators.evaluate:generateFirMap(). DO NOT MODIFY MANUALLY */ - | - |internal data class UnaryOperationKey(val opr: ConstantValueKind, val opName: String) - |internal data class BinaryOperationKey(val opr1: ConstantValueKind, val opr2: ConstantValueKind, val opName: String) - | - |@Suppress("UNCHECKED_CAST") - |private fun unaryOperation( - | t: ConstantValueKind, - | opName: String, - | operation: Function1 - |) = UnaryOperationKey(t, opName) to operation as Function1 - | - |@Suppress("UNCHECKED_CAST") - |private fun binaryOperation( - | t: ConstantValueKind, - | u: ConstantValueKind, - | opName: String, - | operation: Function2 - |) = BinaryOperationKey(t, u, opName) to operation as Function2 - """.trimMargin() - ) - p.println() - - val unaryOperationsMap = arrayListOf, Boolean>>() - val binaryOperationsMap = arrayListOf>>() - populateOperationsMap(unaryOperationsMap, binaryOperationsMap, EXCLUDED_FUNCTIONS) - - p.println("internal val unaryOperations: HashMap, Function1> = hashMapOf(") - p.pushIndent() - p.renderUnaryOperations(unaryOperationsMap) - p.popIndent() - p.println(")") - p.println() - - p.println("internal val binaryOperations: HashMap, Function2> = hashMapOf(") - p.pushIndent() - p.renderBinaryOperations(binaryOperationsMap) - p.popIndent() - p.println(")") - p.println() - - p.println( - """ - |internal val unaryOperatorNames = unaryOperations.map { it.key.opName }.toHashSet() - |internal val binaryOperatorNames = binaryOperations.map { it.key.opName }.toHashSet() - """.trimMargin() - ) - - return sb.toString() -} - -private fun Printer.renderUnaryOperations(unaryOperationsMap: List, Boolean>>) { - val unaryOperationsMapIterator = unaryOperationsMap.iterator() - while (unaryOperationsMapIterator.hasNext()) { - val (funcName, parameters, isFunction) = unaryOperationsMapIterator.next() - if (parameters.first().constructor.declarationDescriptor!!.name.asString() in EXCLUDED_TYPES) { - continue - } - val parenthesesOrBlank = if (isFunction) "()" else "" - this.println( - "unaryOperation(", - parameters.joinToString(", ") { it.asString() }, - ", ", - "\"$funcName\"", - ", { a -> a.$funcName$parenthesesOrBlank })", - if (unaryOperationsMapIterator.hasNext()) "," else "" - ) - } -} - -private fun Printer.renderBinaryOperations(binaryOperationsMap: List>>) { - val binaryOperationsMapIterator = binaryOperationsMap.iterator() - while (binaryOperationsMapIterator.hasNext()) { - val (funcName, parameters) = binaryOperationsMapIterator.next() - if (parameters.first().constructor.declarationDescriptor!!.name.asString() in EXCLUDED_TYPES) { - continue - } - this.println( - "binaryOperation(", - parameters.joinToString(", ") { it.asString() }, - ", ", - "\"$funcName\"", - ", { a, b -> a.$funcName(b) })", - if (binaryOperationsMapIterator.hasNext()) "," else "" - ) - } -} - -private fun KotlinType.asString(): String = "ConstantValueKind." + constructor.declarationDescriptor!!.name.asString() diff --git a/generators/evaluate/GenerateOperationsMap.kt b/generators/evaluate/GenerateOperationsMap.kt index 5e4207a485b..8de7a050c63 100644 --- a/generators/evaluate/GenerateOperationsMap.kt +++ b/generators/evaluate/GenerateOperationsMap.kt @@ -7,9 +7,12 @@ package org.jetbrains.kotlin.generators.evaluate import org.jetbrains.kotlin.builtins.DefaultBuiltIns import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.typeUtil.makeNotNullable import org.jetbrains.kotlin.utils.Printer import java.io.File @@ -37,7 +40,6 @@ fun generate(): String { val unaryOperationsMap = arrayListOf, Boolean>>() val binaryOperationsMap = arrayListOf>>() - populateOperationsMap(unaryOperationsMap, binaryOperationsMap, EXCLUDED_FUNCTIONS) val builtIns = DefaultBuiltIns.Instance @@ -48,6 +50,24 @@ fun generate(): String { val integerTypes = allPrimitiveTypes.map { it.defaultType }.filter { it.isIntegerType() } val fpTypes = allPrimitiveTypes.map { it.defaultType }.filter { it.isFpType() } + for (descriptor in allPrimitiveTypes + builtIns.string) { + @Suppress("UNCHECKED_CAST") + val functions = descriptor.getMemberScope(listOf()).getContributedDescriptors() + .filter { it is CallableDescriptor && !EXCLUDED_FUNCTIONS.contains(it.getName().asString()) } as List + + for (function in functions) { + val parametersTypes = function.getParametersTypes() + + when (parametersTypes.size) { + 1 -> unaryOperationsMap.add(Triple(function.name.asString(), parametersTypes, function is FunctionDescriptor)) + 2 -> binaryOperationsMap.add(function.name.asString() to parametersTypes) + else -> throw IllegalStateException( + "Couldn't add following method from builtins to operations map: ${function.name} in class ${descriptor.name}" + ) + } + } + } + unaryOperationsMap.add(Triple("code", listOf(builtIns.charType), false)) for (type in integerTypes) { @@ -165,6 +185,10 @@ private fun KotlinType.isIntegerType(): Boolean = private fun KotlinType.isFpType(): Boolean = KotlinBuiltIns.isDouble(this) || KotlinBuiltIns.isFloat(this) +private fun CallableDescriptor.getParametersTypes(): List = + listOf((containingDeclaration as ClassDescriptor).defaultType) + + valueParameters.map { it.type.makeNotNullable() } + private fun KotlinType.asString(): String = typeName.uppercase() private val KotlinType.typeName: String diff --git a/generators/evaluate/OperationsMapGeneratorsUtil.kt b/generators/evaluate/OperationsMapGeneratorsUtil.kt deleted file mode 100644 index c955c4778da..00000000000 --- a/generators/evaluate/OperationsMapGeneratorsUtil.kt +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.generators.evaluate - -import org.jetbrains.kotlin.builtins.DefaultBuiltIns -import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.descriptors.CallableDescriptor -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.FunctionDescriptor -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.typeUtil.makeNotNullable - -internal fun populateOperationsMap( - unaryOperationsMap: ArrayList, Boolean>>, - binaryOperationsMap: ArrayList>>, - excludedFunctions: List -) { - val builtIns = DefaultBuiltIns.Instance - - @Suppress("UNCHECKED_CAST") - val allPrimitiveTypes = builtIns.builtInsPackageScope.getContributedDescriptors() - .filter { it is ClassDescriptor && KotlinBuiltIns.isPrimitiveType(it.defaultType) } as List - - for (descriptor in allPrimitiveTypes + builtIns.string) { - @Suppress("UNCHECKED_CAST") - val functions = descriptor.getMemberScope(listOf()).getContributedDescriptors() - .filter { it is CallableDescriptor && !excludedFunctions.contains(it.getName().asString()) } as List - - for (function in functions) { - val parametersTypes = function.getParametersTypes() - - when (parametersTypes.size) { - 1 -> unaryOperationsMap.add(Triple(function.name.asString(), parametersTypes, function is FunctionDescriptor)) - 2 -> binaryOperationsMap.add(function.name.asString() to parametersTypes) - else -> throw IllegalStateException( - "Couldn't add following method from builtins to operations map: ${function.name} in class ${descriptor.name}" - ) - } - } - } -} - -private fun CallableDescriptor.getParametersTypes(): List = - listOf((containingDeclaration as ClassDescriptor).defaultType) + - valueParameters.map { it.type.makeNotNullable() } diff --git a/generators/tests/org/jetbrains/kotlin/generators/evaluate/GenerateFirOperationsMapTest.kt b/generators/tests/org/jetbrains/kotlin/generators/evaluate/GenerateFirOperationsMapTest.kt deleted file mode 100644 index 48ce098eff1..00000000000 --- a/generators/tests/org/jetbrains/kotlin/generators/evaluate/GenerateFirOperationsMapTest.kt +++ /dev/null @@ -1,18 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.generators.test.evaluate - -import junit.framework.TestCase -import org.jetbrains.kotlin.generators.evaluate.FIR_DEST_FILE -import org.jetbrains.kotlin.generators.evaluate.generateFirMap -import org.jetbrains.kotlin.test.KotlinTestUtils - -class GenerateFirOperationsMapTest : TestCase() { - fun testGeneratedDataIsUpToDate() { - val text = generateFirMap() - KotlinTestUtils.assertEqualsToFile(FIR_DEST_FILE, text) - } -}