From fc5d1d8cb5217fcdf33af900f7b07eb244e1c166 Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Fri, 11 Jun 2021 00:33:52 -0700 Subject: [PATCH] FirConstKind has been renamed to ConstantValueKind (d243319) --- .../evaluate/CompileTimeConstantEvaluator.kt | 77 +-- .../fir/evaluate/FirOperationsMapGenerated.kt | 508 +++++++++--------- .../evaluate/GenerateFirOperationsMap.kt | 14 +- 3 files changed, 300 insertions(+), 299 deletions(-) diff --git a/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/CompileTimeConstantEvaluator.kt b/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/CompileTimeConstantEvaluator.kt index a65dae565c0..764c47eb811 100644 --- a/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/CompileTimeConstantEvaluator.kt +++ b/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/CompileTimeConstantEvaluator.kt @@ -16,6 +16,7 @@ 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.resolve.constants.ConstantValue +import org.jetbrains.kotlin.types.ConstantValueKind /** * An evaluator that transform numeric operation, such as div, into compile-time constant iff involved operands, such as explicit receiver @@ -60,7 +61,7 @@ class CompileTimeConstantEvaluator { private val FirFunctionCall.isNumericOperatorCall: Boolean get() { val function = getOriginalFunction() ?: return false - return typeRef.toFirConstKind() != null && + return typeRef.toConstantValueKind() != null && // LHS is const expression with numeric constant value. explicitReceiver != null && explicitReceiver!!.isNumericConst && function is FirSimpleFunction && @@ -74,7 +75,7 @@ class CompileTimeConstantEvaluator { this is FirConstExpression<*> && typedValue is Number private fun FirConstExpression<*>.adjustType(expectedType: FirTypeRef): FirConstExpression<*> { - val expectedKind = expectedType.toFirConstKind() + val expectedKind = expectedType.toConstantValueKind() // Note that the resolved type for the const expression is not always matched with the const kind. For example, // fun foo(x: Int) { // when (x) { @@ -101,7 +102,7 @@ class CompileTimeConstantEvaluator { // TODO: need some systematic check, e.g., integer overflow return try { val r = f(typedValue) - r.toFirConstKind()!!.toConstExpression(source, r) + r.toConstantValueKind()!!.toConstExpression(source, r) } catch (e: Exception) { null } @@ -116,7 +117,7 @@ class CompileTimeConstantEvaluator { // 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.toFirConstKind()!!.toConstExpression(source, r) + r.toConstantValueKind()!!.toConstExpression(source, r) } catch (e: Exception) { null } @@ -124,63 +125,63 @@ class CompileTimeConstantEvaluator { ////// KINDS - private fun FirTypeRef.toFirConstKind(): FirConstKind? = + private fun FirTypeRef.toConstantValueKind(): ConstantValueKind? = when (this) { !is FirResolvedTypeRef -> null - !is FirImplicitBuiltinTypeRef -> type.toFirConstKind() - is FirImplicitIntTypeRef -> FirConstKind.Int + !is FirImplicitBuiltinTypeRef -> type.toConstantValueKind() + is FirImplicitIntTypeRef -> ConstantValueKind.Int else -> null } - private fun ConeKotlinType.toFirConstKind(): FirConstKind? = + private fun ConeKotlinType.toConstantValueKind(): ConstantValueKind? = when (this) { is ConeKotlinErrorType -> null is ConeLookupTagBasedType -> { when (lookupTag.name.asString()) { - "Byte" -> FirConstKind.Byte - "Double" -> FirConstKind.Double - "Float" -> FirConstKind.Float - "Int" -> FirConstKind.Int - "Long" -> FirConstKind.Long - "Short" -> FirConstKind.Short + "Byte" -> ConstantValueKind.Byte + "Double" -> ConstantValueKind.Double + "Float" -> ConstantValueKind.Float + "Int" -> ConstantValueKind.Int + "Long" -> ConstantValueKind.Long + "Short" -> ConstantValueKind.Short else -> null } } - is ConeFlexibleType -> upperBound.toFirConstKind() - is ConeCapturedType -> lowerType?.toFirConstKind() ?: constructor.supertypes!!.first().toFirConstKind() - is ConeDefinitelyNotNullType -> original.toFirConstKind() - is ConeIntersectionType -> intersectedTypes.first().toFirConstKind() + is ConeFlexibleType -> upperBound.toConstantValueKind() + is ConeCapturedType -> lowerType?.toConstantValueKind() ?: constructor.supertypes!!.first().toConstantValueKind() + is ConeDefinitelyNotNullType -> original.toConstantValueKind() + is ConeIntersectionType -> intersectedTypes.first().toConstantValueKind() is ConeStubType -> null is ConeIntegerLiteralType -> null } - private fun T.toFirConstKind(): FirConstKind? = + private fun T.toConstantValueKind(): ConstantValueKind? = when (this) { - is Byte -> FirConstKind.Byte - is Double -> FirConstKind.Double - is Float -> FirConstKind.Float - is Int -> FirConstKind.Int - is Long -> FirConstKind.Long - is Short -> FirConstKind.Short + is Byte -> ConstantValueKind.Byte + is Double -> ConstantValueKind.Double + is Float -> ConstantValueKind.Float + is Int -> ConstantValueKind.Int + is Long -> ConstantValueKind.Long + is Short -> ConstantValueKind.Short else -> null } - private fun FirConstKind<*>.convert(value: Number?): Number? { + private fun ConstantValueKind<*>.convert(value: Number?): Number? { if (value == null) { return null } return when { - this == FirConstKind.Byte -> value.toByte() - this == FirConstKind.Double -> value.toDouble() - this == FirConstKind.Float -> value.toFloat() - this == FirConstKind.Int -> value.toInt() - this == FirConstKind.Long -> value.toLong() - this == FirConstKind.Short -> value.toShort() + this == ConstantValueKind.Byte -> value.toByte() + this == ConstantValueKind.Double -> value.toDouble() + this == ConstantValueKind.Float -> value.toFloat() + this == ConstantValueKind.Int -> value.toInt() + this == ConstantValueKind.Long -> value.toLong() + this == ConstantValueKind.Short -> value.toShort() else -> null } } - private fun FirConstKind.toConstExpression(source: FirSourceElement?, value: Number): FirConstExpression = + private fun ConstantValueKind.toConstExpression(source: FirSourceElement?, value: Number): FirConstExpression = @Suppress("UNCHECKED_CAST") buildConstExpression(source, this, value as T) } @@ -190,11 +191,11 @@ val FirConstExpression.typedValue: T get() = (value as? Long)?.let { when (kind) { - FirConstKind.Byte -> it.toByte() - FirConstKind.Short -> it.toShort() - FirConstKind.Int -> it.toInt() - FirConstKind.Float -> it.toFloat() - FirConstKind.Double -> it.toDouble() + 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 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 index 1a8b489de48..af308e6dc4a 100644 --- a/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirOperationsMapGenerated.kt +++ b/compiler/fir/evaluate/src/org/jetbrains/kotlin/fir/evaluate/FirOperationsMapGenerated.kt @@ -16,280 +16,280 @@ package org.jetbrains.kotlin.fir.evaluate -import org.jetbrains.kotlin.fir.expressions.FirConstKind +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: FirConstKind, val opName: String) -internal data class BinaryOperationKey(val opr1: FirConstKind, val opr2: FirConstKind, val opName: String) +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: FirConstKind, + t: ConstantValueKind, opName: String, operation: Function1 ) = UnaryOperationKey(t, opName) to operation as Function1 @Suppress("UNCHECKED_CAST") private fun binaryOperation( - t: FirConstKind, - u: FirConstKind, + t: ConstantValueKind, + u: ConstantValueKind, opName: String, operation: Function2 ) = BinaryOperationKey(t, u, opName) to operation as Function2 internal val unaryOperations: HashMap, Function1> = hashMapOf( - unaryOperation(FirConstKind.Byte, "dec", { a -> a.dec() }), - unaryOperation(FirConstKind.Byte, "hashCode", { a -> a.hashCode() }), - unaryOperation(FirConstKind.Byte, "inc", { a -> a.inc() }), - unaryOperation(FirConstKind.Byte, "toByte", { a -> a.toByte() }), - unaryOperation(FirConstKind.Byte, "toDouble", { a -> a.toDouble() }), - unaryOperation(FirConstKind.Byte, "toFloat", { a -> a.toFloat() }), - unaryOperation(FirConstKind.Byte, "toInt", { a -> a.toInt() }), - unaryOperation(FirConstKind.Byte, "toLong", { a -> a.toLong() }), - unaryOperation(FirConstKind.Byte, "toShort", { a -> a.toShort() }), - unaryOperation(FirConstKind.Byte, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(FirConstKind.Byte, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(FirConstKind.Double, "dec", { a -> a.dec() }), - unaryOperation(FirConstKind.Double, "hashCode", { a -> a.hashCode() }), - unaryOperation(FirConstKind.Double, "inc", { a -> a.inc() }), - unaryOperation(FirConstKind.Double, "toByte", { a -> a.toByte() }), - unaryOperation(FirConstKind.Double, "toDouble", { a -> a.toDouble() }), - unaryOperation(FirConstKind.Double, "toFloat", { a -> a.toFloat() }), - unaryOperation(FirConstKind.Double, "toInt", { a -> a.toInt() }), - unaryOperation(FirConstKind.Double, "toLong", { a -> a.toLong() }), - unaryOperation(FirConstKind.Double, "toShort", { a -> a.toShort() }), - unaryOperation(FirConstKind.Double, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(FirConstKind.Double, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(FirConstKind.Float, "dec", { a -> a.dec() }), - unaryOperation(FirConstKind.Float, "hashCode", { a -> a.hashCode() }), - unaryOperation(FirConstKind.Float, "inc", { a -> a.inc() }), - unaryOperation(FirConstKind.Float, "toByte", { a -> a.toByte() }), - unaryOperation(FirConstKind.Float, "toDouble", { a -> a.toDouble() }), - unaryOperation(FirConstKind.Float, "toFloat", { a -> a.toFloat() }), - unaryOperation(FirConstKind.Float, "toInt", { a -> a.toInt() }), - unaryOperation(FirConstKind.Float, "toLong", { a -> a.toLong() }), - unaryOperation(FirConstKind.Float, "toShort", { a -> a.toShort() }), - unaryOperation(FirConstKind.Float, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(FirConstKind.Float, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(FirConstKind.Int, "dec", { a -> a.dec() }), - unaryOperation(FirConstKind.Int, "hashCode", { a -> a.hashCode() }), - unaryOperation(FirConstKind.Int, "inc", { a -> a.inc() }), - unaryOperation(FirConstKind.Int, "inv", { a -> a.inv() }), - unaryOperation(FirConstKind.Int, "toByte", { a -> a.toByte() }), - unaryOperation(FirConstKind.Int, "toDouble", { a -> a.toDouble() }), - unaryOperation(FirConstKind.Int, "toFloat", { a -> a.toFloat() }), - unaryOperation(FirConstKind.Int, "toInt", { a -> a.toInt() }), - unaryOperation(FirConstKind.Int, "toLong", { a -> a.toLong() }), - unaryOperation(FirConstKind.Int, "toShort", { a -> a.toShort() }), - unaryOperation(FirConstKind.Int, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(FirConstKind.Int, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(FirConstKind.Long, "dec", { a -> a.dec() }), - unaryOperation(FirConstKind.Long, "hashCode", { a -> a.hashCode() }), - unaryOperation(FirConstKind.Long, "inc", { a -> a.inc() }), - unaryOperation(FirConstKind.Long, "inv", { a -> a.inv() }), - unaryOperation(FirConstKind.Long, "toByte", { a -> a.toByte() }), - unaryOperation(FirConstKind.Long, "toDouble", { a -> a.toDouble() }), - unaryOperation(FirConstKind.Long, "toFloat", { a -> a.toFloat() }), - unaryOperation(FirConstKind.Long, "toInt", { a -> a.toInt() }), - unaryOperation(FirConstKind.Long, "toLong", { a -> a.toLong() }), - unaryOperation(FirConstKind.Long, "toShort", { a -> a.toShort() }), - unaryOperation(FirConstKind.Long, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(FirConstKind.Long, "unaryPlus", { a -> a.unaryPlus() }), - unaryOperation(FirConstKind.Short, "dec", { a -> a.dec() }), - unaryOperation(FirConstKind.Short, "hashCode", { a -> a.hashCode() }), - unaryOperation(FirConstKind.Short, "inc", { a -> a.inc() }), - unaryOperation(FirConstKind.Short, "toByte", { a -> a.toByte() }), - unaryOperation(FirConstKind.Short, "toDouble", { a -> a.toDouble() }), - unaryOperation(FirConstKind.Short, "toFloat", { a -> a.toFloat() }), - unaryOperation(FirConstKind.Short, "toInt", { a -> a.toInt() }), - unaryOperation(FirConstKind.Short, "toLong", { a -> a.toLong() }), - unaryOperation(FirConstKind.Short, "toShort", { a -> a.toShort() }), - unaryOperation(FirConstKind.Short, "unaryMinus", { a -> a.unaryMinus() }), - unaryOperation(FirConstKind.Short, "unaryPlus", { a -> a.unaryPlus() }), + 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(FirConstKind.Byte, FirConstKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Byte, FirConstKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Double, FirConstKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Float, FirConstKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Int, FirConstKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Long, FirConstKind.Short, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Byte, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Double, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Float, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Int, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Long, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Short, "div", { a, b -> a.div(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Double, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Float, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Int, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Long, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Short, "minus", { a, b -> a.minus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Double, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Float, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Int, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Long, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Short, "plus", { a, b -> a.plus(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Double, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Float, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Int, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Long, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Short, "rem", { a, b -> a.rem(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Byte, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Double, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Float, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Int, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Long, "times", { a, b -> a.times(b) }), - binaryOperation(FirConstKind.Short, FirConstKind.Short, "times", { a, b -> a.times(b) }), + 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() diff --git a/generators/evaluate/GenerateFirOperationsMap.kt b/generators/evaluate/GenerateFirOperationsMap.kt index 812ce0ee125..36171c4140f 100644 --- a/generators/evaluate/GenerateFirOperationsMap.kt +++ b/generators/evaluate/GenerateFirOperationsMap.kt @@ -32,24 +32,24 @@ fun generateFirMap(): String { """ |package org.jetbrains.kotlin.fir.evaluate | - |import org.jetbrains.kotlin.fir.expressions.FirConstKind + |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: FirConstKind, val opName: String) - |internal data class BinaryOperationKey(val opr1: FirConstKind, val opr2: FirConstKind, val opName: String) + |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: FirConstKind, + | t: ConstantValueKind, | opName: String, | operation: Function1 |) = UnaryOperationKey(t, opName) to operation as Function1 | |@Suppress("UNCHECKED_CAST") |private fun binaryOperation( - | t: FirConstKind, - | u: FirConstKind, + | t: ConstantValueKind, + | u: ConstantValueKind, | opName: String, | operation: Function2 |) = BinaryOperationKey(t, u, opName) to operation as Function2 @@ -122,4 +122,4 @@ private fun Printer.renderBinaryOperations(binaryOperationsMap: List