FirConstKind has been renamed to ConstantValueKind (d243319)
This commit is contained in:
Jinseong Jeon
+39
-38
@@ -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.FirImplicitBuiltinTypeRef
|
||||||
import org.jetbrains.kotlin.fir.types.impl.FirImplicitIntTypeRef
|
import org.jetbrains.kotlin.fir.types.impl.FirImplicitIntTypeRef
|
||||||
import org.jetbrains.kotlin.resolve.constants.ConstantValue
|
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
|
* 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
|
private val FirFunctionCall.isNumericOperatorCall: Boolean
|
||||||
get() {
|
get() {
|
||||||
val function = getOriginalFunction() ?: return false
|
val function = getOriginalFunction() ?: return false
|
||||||
return typeRef.toFirConstKind() != null &&
|
return typeRef.toConstantValueKind() != null &&
|
||||||
// LHS is const expression with numeric constant value.
|
// LHS is const expression with numeric constant value.
|
||||||
explicitReceiver != null && explicitReceiver!!.isNumericConst &&
|
explicitReceiver != null && explicitReceiver!!.isNumericConst &&
|
||||||
function is FirSimpleFunction &&
|
function is FirSimpleFunction &&
|
||||||
@@ -74,7 +75,7 @@ class CompileTimeConstantEvaluator {
|
|||||||
this is FirConstExpression<*> && typedValue is Number
|
this is FirConstExpression<*> && typedValue is Number
|
||||||
|
|
||||||
private fun FirConstExpression<*>.adjustType(expectedType: FirTypeRef): FirConstExpression<*> {
|
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,
|
// Note that the resolved type for the const expression is not always matched with the const kind. For example,
|
||||||
// fun foo(x: Int) {
|
// fun foo(x: Int) {
|
||||||
// when (x) {
|
// when (x) {
|
||||||
@@ -101,7 +102,7 @@ class CompileTimeConstantEvaluator {
|
|||||||
// TODO: need some systematic check, e.g., integer overflow
|
// TODO: need some systematic check, e.g., integer overflow
|
||||||
return try {
|
return try {
|
||||||
val r = f(typedValue)
|
val r = f(typedValue)
|
||||||
r.toFirConstKind()!!.toConstExpression(source, r)
|
r.toConstantValueKind()!!.toConstExpression(source, r)
|
||||||
} catch (e: Exception) {
|
} catch (e: Exception) {
|
||||||
null
|
null
|
||||||
}
|
}
|
||||||
@@ -116,7 +117,7 @@ class CompileTimeConstantEvaluator {
|
|||||||
// TODO: need some systematic check, e.g., div by zero (1 / 0 v.s. 1 / 0.f)
|
// TODO: need some systematic check, e.g., div by zero (1 / 0 v.s. 1 / 0.f)
|
||||||
return try {
|
return try {
|
||||||
val r = f(typedValue, other.typedValue)
|
val r = f(typedValue, other.typedValue)
|
||||||
r.toFirConstKind()!!.toConstExpression(source, r)
|
r.toConstantValueKind()!!.toConstExpression(source, r)
|
||||||
} catch (e: Exception) {
|
} catch (e: Exception) {
|
||||||
null
|
null
|
||||||
}
|
}
|
||||||
@@ -124,63 +125,63 @@ class CompileTimeConstantEvaluator {
|
|||||||
|
|
||||||
////// KINDS
|
////// KINDS
|
||||||
|
|
||||||
private fun FirTypeRef.toFirConstKind(): FirConstKind<out Number>? =
|
private fun FirTypeRef.toConstantValueKind(): ConstantValueKind<out Number>? =
|
||||||
when (this) {
|
when (this) {
|
||||||
!is FirResolvedTypeRef -> null
|
!is FirResolvedTypeRef -> null
|
||||||
!is FirImplicitBuiltinTypeRef -> type.toFirConstKind()
|
!is FirImplicitBuiltinTypeRef -> type.toConstantValueKind()
|
||||||
is FirImplicitIntTypeRef -> FirConstKind.Int
|
is FirImplicitIntTypeRef -> ConstantValueKind.Int
|
||||||
else -> null
|
else -> null
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun ConeKotlinType.toFirConstKind(): FirConstKind<out Number>? =
|
private fun ConeKotlinType.toConstantValueKind(): ConstantValueKind<out Number>? =
|
||||||
when (this) {
|
when (this) {
|
||||||
is ConeKotlinErrorType -> null
|
is ConeKotlinErrorType -> null
|
||||||
is ConeLookupTagBasedType -> {
|
is ConeLookupTagBasedType -> {
|
||||||
when (lookupTag.name.asString()) {
|
when (lookupTag.name.asString()) {
|
||||||
"Byte" -> FirConstKind.Byte
|
"Byte" -> ConstantValueKind.Byte
|
||||||
"Double" -> FirConstKind.Double
|
"Double" -> ConstantValueKind.Double
|
||||||
"Float" -> FirConstKind.Float
|
"Float" -> ConstantValueKind.Float
|
||||||
"Int" -> FirConstKind.Int
|
"Int" -> ConstantValueKind.Int
|
||||||
"Long" -> FirConstKind.Long
|
"Long" -> ConstantValueKind.Long
|
||||||
"Short" -> FirConstKind.Short
|
"Short" -> ConstantValueKind.Short
|
||||||
else -> null
|
else -> null
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
is ConeFlexibleType -> upperBound.toFirConstKind()
|
is ConeFlexibleType -> upperBound.toConstantValueKind()
|
||||||
is ConeCapturedType -> lowerType?.toFirConstKind() ?: constructor.supertypes!!.first().toFirConstKind()
|
is ConeCapturedType -> lowerType?.toConstantValueKind() ?: constructor.supertypes!!.first().toConstantValueKind()
|
||||||
is ConeDefinitelyNotNullType -> original.toFirConstKind()
|
is ConeDefinitelyNotNullType -> original.toConstantValueKind()
|
||||||
is ConeIntersectionType -> intersectedTypes.first().toFirConstKind()
|
is ConeIntersectionType -> intersectedTypes.first().toConstantValueKind()
|
||||||
is ConeStubType -> null
|
is ConeStubType -> null
|
||||||
is ConeIntegerLiteralType -> null
|
is ConeIntegerLiteralType -> null
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun <T : Number> T.toFirConstKind(): FirConstKind<out Number>? =
|
private fun <T : Number> T.toConstantValueKind(): ConstantValueKind<out Number>? =
|
||||||
when (this) {
|
when (this) {
|
||||||
is Byte -> FirConstKind.Byte
|
is Byte -> ConstantValueKind.Byte
|
||||||
is Double -> FirConstKind.Double
|
is Double -> ConstantValueKind.Double
|
||||||
is Float -> FirConstKind.Float
|
is Float -> ConstantValueKind.Float
|
||||||
is Int -> FirConstKind.Int
|
is Int -> ConstantValueKind.Int
|
||||||
is Long -> FirConstKind.Long
|
is Long -> ConstantValueKind.Long
|
||||||
is Short -> FirConstKind.Short
|
is Short -> ConstantValueKind.Short
|
||||||
else -> null
|
else -> null
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun FirConstKind<*>.convert(value: Number?): Number? {
|
private fun ConstantValueKind<*>.convert(value: Number?): Number? {
|
||||||
if (value == null) {
|
if (value == null) {
|
||||||
return null
|
return null
|
||||||
}
|
}
|
||||||
return when {
|
return when {
|
||||||
this == FirConstKind.Byte -> value.toByte()
|
this == ConstantValueKind.Byte -> value.toByte()
|
||||||
this == FirConstKind.Double -> value.toDouble()
|
this == ConstantValueKind.Double -> value.toDouble()
|
||||||
this == FirConstKind.Float -> value.toFloat()
|
this == ConstantValueKind.Float -> value.toFloat()
|
||||||
this == FirConstKind.Int -> value.toInt()
|
this == ConstantValueKind.Int -> value.toInt()
|
||||||
this == FirConstKind.Long -> value.toLong()
|
this == ConstantValueKind.Long -> value.toLong()
|
||||||
this == FirConstKind.Short -> value.toShort()
|
this == ConstantValueKind.Short -> value.toShort()
|
||||||
else -> null
|
else -> null
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun <T : Number> FirConstKind<T>.toConstExpression(source: FirSourceElement?, value: Number): FirConstExpression<T> =
|
private fun <T : Number> ConstantValueKind<T>.toConstExpression(source: FirSourceElement?, value: Number): FirConstExpression<T> =
|
||||||
@Suppress("UNCHECKED_CAST")
|
@Suppress("UNCHECKED_CAST")
|
||||||
buildConstExpression(source, this, value as T)
|
buildConstExpression(source, this, value as T)
|
||||||
}
|
}
|
||||||
@@ -190,11 +191,11 @@ val <T> FirConstExpression<T>.typedValue: T
|
|||||||
get() =
|
get() =
|
||||||
(value as? Long)?.let {
|
(value as? Long)?.let {
|
||||||
when (kind) {
|
when (kind) {
|
||||||
FirConstKind.Byte -> it.toByte()
|
ConstantValueKind.Byte -> it.toByte()
|
||||||
FirConstKind.Short -> it.toShort()
|
ConstantValueKind.Short -> it.toShort()
|
||||||
FirConstKind.Int -> it.toInt()
|
ConstantValueKind.Int -> it.toInt()
|
||||||
FirConstKind.Float -> it.toFloat()
|
ConstantValueKind.Float -> it.toFloat()
|
||||||
FirConstKind.Double -> it.toDouble()
|
ConstantValueKind.Double -> it.toDouble()
|
||||||
else -> it
|
else -> it
|
||||||
}
|
}
|
||||||
} as T ?: value
|
} as T ?: value
|
||||||
|
|||||||
+254
-254
@@ -16,280 +16,280 @@
|
|||||||
|
|
||||||
package org.jetbrains.kotlin.fir.evaluate
|
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 */
|
/** This file is generated by org.jetbrains.kotlin.generators.evaluate:generateFirMap(). DO NOT MODIFY MANUALLY */
|
||||||
|
|
||||||
internal data class UnaryOperationKey<out T>(val opr: FirConstKind<out T>, val opName: String)
|
internal data class UnaryOperationKey<out T>(val opr: ConstantValueKind<out T>, val opName: String)
|
||||||
internal data class BinaryOperationKey<out T, out U>(val opr1: FirConstKind<out T>, val opr2: FirConstKind<out U>, val opName: String)
|
internal data class BinaryOperationKey<out T, out U>(val opr1: ConstantValueKind<out T>, val opr2: ConstantValueKind<out U>, val opName: String)
|
||||||
|
|
||||||
@Suppress("UNCHECKED_CAST")
|
@Suppress("UNCHECKED_CAST")
|
||||||
private fun <T> unaryOperation(
|
private fun <T> unaryOperation(
|
||||||
t: FirConstKind<T>,
|
t: ConstantValueKind<T>,
|
||||||
opName: String,
|
opName: String,
|
||||||
operation: Function1<T, Number>
|
operation: Function1<T, Number>
|
||||||
) = UnaryOperationKey(t, opName) to operation as Function1<Number, Number>
|
) = UnaryOperationKey(t, opName) to operation as Function1<Number, Number>
|
||||||
|
|
||||||
@Suppress("UNCHECKED_CAST")
|
@Suppress("UNCHECKED_CAST")
|
||||||
private fun <T, U> binaryOperation(
|
private fun <T, U> binaryOperation(
|
||||||
t: FirConstKind<T>,
|
t: ConstantValueKind<T>,
|
||||||
u: FirConstKind<U>,
|
u: ConstantValueKind<U>,
|
||||||
opName: String,
|
opName: String,
|
||||||
operation: Function2<T, U, Number>
|
operation: Function2<T, U, Number>
|
||||||
) = BinaryOperationKey(t, u, opName) to operation as Function2<Number, Number, Number>
|
) = BinaryOperationKey(t, u, opName) to operation as Function2<Number, Number, Number>
|
||||||
|
|
||||||
internal val unaryOperations: HashMap<UnaryOperationKey<*>, Function1<Number, Number>> = hashMapOf(
|
internal val unaryOperations: HashMap<UnaryOperationKey<*>, Function1<Number, Number>> = hashMapOf(
|
||||||
unaryOperation(FirConstKind.Byte, "dec", { a -> a.dec() }),
|
unaryOperation(ConstantValueKind.Byte, "dec", { a -> a.dec() }),
|
||||||
unaryOperation(FirConstKind.Byte, "hashCode", { a -> a.hashCode() }),
|
unaryOperation(ConstantValueKind.Byte, "hashCode", { a -> a.hashCode() }),
|
||||||
unaryOperation(FirConstKind.Byte, "inc", { a -> a.inc() }),
|
unaryOperation(ConstantValueKind.Byte, "inc", { a -> a.inc() }),
|
||||||
unaryOperation(FirConstKind.Byte, "toByte", { a -> a.toByte() }),
|
unaryOperation(ConstantValueKind.Byte, "toByte", { a -> a.toByte() }),
|
||||||
unaryOperation(FirConstKind.Byte, "toDouble", { a -> a.toDouble() }),
|
unaryOperation(ConstantValueKind.Byte, "toDouble", { a -> a.toDouble() }),
|
||||||
unaryOperation(FirConstKind.Byte, "toFloat", { a -> a.toFloat() }),
|
unaryOperation(ConstantValueKind.Byte, "toFloat", { a -> a.toFloat() }),
|
||||||
unaryOperation(FirConstKind.Byte, "toInt", { a -> a.toInt() }),
|
unaryOperation(ConstantValueKind.Byte, "toInt", { a -> a.toInt() }),
|
||||||
unaryOperation(FirConstKind.Byte, "toLong", { a -> a.toLong() }),
|
unaryOperation(ConstantValueKind.Byte, "toLong", { a -> a.toLong() }),
|
||||||
unaryOperation(FirConstKind.Byte, "toShort", { a -> a.toShort() }),
|
unaryOperation(ConstantValueKind.Byte, "toShort", { a -> a.toShort() }),
|
||||||
unaryOperation(FirConstKind.Byte, "unaryMinus", { a -> a.unaryMinus() }),
|
unaryOperation(ConstantValueKind.Byte, "unaryMinus", { a -> a.unaryMinus() }),
|
||||||
unaryOperation(FirConstKind.Byte, "unaryPlus", { a -> a.unaryPlus() }),
|
unaryOperation(ConstantValueKind.Byte, "unaryPlus", { a -> a.unaryPlus() }),
|
||||||
unaryOperation(FirConstKind.Double, "dec", { a -> a.dec() }),
|
unaryOperation(ConstantValueKind.Double, "dec", { a -> a.dec() }),
|
||||||
unaryOperation(FirConstKind.Double, "hashCode", { a -> a.hashCode() }),
|
unaryOperation(ConstantValueKind.Double, "hashCode", { a -> a.hashCode() }),
|
||||||
unaryOperation(FirConstKind.Double, "inc", { a -> a.inc() }),
|
unaryOperation(ConstantValueKind.Double, "inc", { a -> a.inc() }),
|
||||||
unaryOperation(FirConstKind.Double, "toByte", { a -> a.toByte() }),
|
unaryOperation(ConstantValueKind.Double, "toByte", { a -> a.toByte() }),
|
||||||
unaryOperation(FirConstKind.Double, "toDouble", { a -> a.toDouble() }),
|
unaryOperation(ConstantValueKind.Double, "toDouble", { a -> a.toDouble() }),
|
||||||
unaryOperation(FirConstKind.Double, "toFloat", { a -> a.toFloat() }),
|
unaryOperation(ConstantValueKind.Double, "toFloat", { a -> a.toFloat() }),
|
||||||
unaryOperation(FirConstKind.Double, "toInt", { a -> a.toInt() }),
|
unaryOperation(ConstantValueKind.Double, "toInt", { a -> a.toInt() }),
|
||||||
unaryOperation(FirConstKind.Double, "toLong", { a -> a.toLong() }),
|
unaryOperation(ConstantValueKind.Double, "toLong", { a -> a.toLong() }),
|
||||||
unaryOperation(FirConstKind.Double, "toShort", { a -> a.toShort() }),
|
unaryOperation(ConstantValueKind.Double, "toShort", { a -> a.toShort() }),
|
||||||
unaryOperation(FirConstKind.Double, "unaryMinus", { a -> a.unaryMinus() }),
|
unaryOperation(ConstantValueKind.Double, "unaryMinus", { a -> a.unaryMinus() }),
|
||||||
unaryOperation(FirConstKind.Double, "unaryPlus", { a -> a.unaryPlus() }),
|
unaryOperation(ConstantValueKind.Double, "unaryPlus", { a -> a.unaryPlus() }),
|
||||||
unaryOperation(FirConstKind.Float, "dec", { a -> a.dec() }),
|
unaryOperation(ConstantValueKind.Float, "dec", { a -> a.dec() }),
|
||||||
unaryOperation(FirConstKind.Float, "hashCode", { a -> a.hashCode() }),
|
unaryOperation(ConstantValueKind.Float, "hashCode", { a -> a.hashCode() }),
|
||||||
unaryOperation(FirConstKind.Float, "inc", { a -> a.inc() }),
|
unaryOperation(ConstantValueKind.Float, "inc", { a -> a.inc() }),
|
||||||
unaryOperation(FirConstKind.Float, "toByte", { a -> a.toByte() }),
|
unaryOperation(ConstantValueKind.Float, "toByte", { a -> a.toByte() }),
|
||||||
unaryOperation(FirConstKind.Float, "toDouble", { a -> a.toDouble() }),
|
unaryOperation(ConstantValueKind.Float, "toDouble", { a -> a.toDouble() }),
|
||||||
unaryOperation(FirConstKind.Float, "toFloat", { a -> a.toFloat() }),
|
unaryOperation(ConstantValueKind.Float, "toFloat", { a -> a.toFloat() }),
|
||||||
unaryOperation(FirConstKind.Float, "toInt", { a -> a.toInt() }),
|
unaryOperation(ConstantValueKind.Float, "toInt", { a -> a.toInt() }),
|
||||||
unaryOperation(FirConstKind.Float, "toLong", { a -> a.toLong() }),
|
unaryOperation(ConstantValueKind.Float, "toLong", { a -> a.toLong() }),
|
||||||
unaryOperation(FirConstKind.Float, "toShort", { a -> a.toShort() }),
|
unaryOperation(ConstantValueKind.Float, "toShort", { a -> a.toShort() }),
|
||||||
unaryOperation(FirConstKind.Float, "unaryMinus", { a -> a.unaryMinus() }),
|
unaryOperation(ConstantValueKind.Float, "unaryMinus", { a -> a.unaryMinus() }),
|
||||||
unaryOperation(FirConstKind.Float, "unaryPlus", { a -> a.unaryPlus() }),
|
unaryOperation(ConstantValueKind.Float, "unaryPlus", { a -> a.unaryPlus() }),
|
||||||
unaryOperation(FirConstKind.Int, "dec", { a -> a.dec() }),
|
unaryOperation(ConstantValueKind.Int, "dec", { a -> a.dec() }),
|
||||||
unaryOperation(FirConstKind.Int, "hashCode", { a -> a.hashCode() }),
|
unaryOperation(ConstantValueKind.Int, "hashCode", { a -> a.hashCode() }),
|
||||||
unaryOperation(FirConstKind.Int, "inc", { a -> a.inc() }),
|
unaryOperation(ConstantValueKind.Int, "inc", { a -> a.inc() }),
|
||||||
unaryOperation(FirConstKind.Int, "inv", { a -> a.inv() }),
|
unaryOperation(ConstantValueKind.Int, "inv", { a -> a.inv() }),
|
||||||
unaryOperation(FirConstKind.Int, "toByte", { a -> a.toByte() }),
|
unaryOperation(ConstantValueKind.Int, "toByte", { a -> a.toByte() }),
|
||||||
unaryOperation(FirConstKind.Int, "toDouble", { a -> a.toDouble() }),
|
unaryOperation(ConstantValueKind.Int, "toDouble", { a -> a.toDouble() }),
|
||||||
unaryOperation(FirConstKind.Int, "toFloat", { a -> a.toFloat() }),
|
unaryOperation(ConstantValueKind.Int, "toFloat", { a -> a.toFloat() }),
|
||||||
unaryOperation(FirConstKind.Int, "toInt", { a -> a.toInt() }),
|
unaryOperation(ConstantValueKind.Int, "toInt", { a -> a.toInt() }),
|
||||||
unaryOperation(FirConstKind.Int, "toLong", { a -> a.toLong() }),
|
unaryOperation(ConstantValueKind.Int, "toLong", { a -> a.toLong() }),
|
||||||
unaryOperation(FirConstKind.Int, "toShort", { a -> a.toShort() }),
|
unaryOperation(ConstantValueKind.Int, "toShort", { a -> a.toShort() }),
|
||||||
unaryOperation(FirConstKind.Int, "unaryMinus", { a -> a.unaryMinus() }),
|
unaryOperation(ConstantValueKind.Int, "unaryMinus", { a -> a.unaryMinus() }),
|
||||||
unaryOperation(FirConstKind.Int, "unaryPlus", { a -> a.unaryPlus() }),
|
unaryOperation(ConstantValueKind.Int, "unaryPlus", { a -> a.unaryPlus() }),
|
||||||
unaryOperation(FirConstKind.Long, "dec", { a -> a.dec() }),
|
unaryOperation(ConstantValueKind.Long, "dec", { a -> a.dec() }),
|
||||||
unaryOperation(FirConstKind.Long, "hashCode", { a -> a.hashCode() }),
|
unaryOperation(ConstantValueKind.Long, "hashCode", { a -> a.hashCode() }),
|
||||||
unaryOperation(FirConstKind.Long, "inc", { a -> a.inc() }),
|
unaryOperation(ConstantValueKind.Long, "inc", { a -> a.inc() }),
|
||||||
unaryOperation(FirConstKind.Long, "inv", { a -> a.inv() }),
|
unaryOperation(ConstantValueKind.Long, "inv", { a -> a.inv() }),
|
||||||
unaryOperation(FirConstKind.Long, "toByte", { a -> a.toByte() }),
|
unaryOperation(ConstantValueKind.Long, "toByte", { a -> a.toByte() }),
|
||||||
unaryOperation(FirConstKind.Long, "toDouble", { a -> a.toDouble() }),
|
unaryOperation(ConstantValueKind.Long, "toDouble", { a -> a.toDouble() }),
|
||||||
unaryOperation(FirConstKind.Long, "toFloat", { a -> a.toFloat() }),
|
unaryOperation(ConstantValueKind.Long, "toFloat", { a -> a.toFloat() }),
|
||||||
unaryOperation(FirConstKind.Long, "toInt", { a -> a.toInt() }),
|
unaryOperation(ConstantValueKind.Long, "toInt", { a -> a.toInt() }),
|
||||||
unaryOperation(FirConstKind.Long, "toLong", { a -> a.toLong() }),
|
unaryOperation(ConstantValueKind.Long, "toLong", { a -> a.toLong() }),
|
||||||
unaryOperation(FirConstKind.Long, "toShort", { a -> a.toShort() }),
|
unaryOperation(ConstantValueKind.Long, "toShort", { a -> a.toShort() }),
|
||||||
unaryOperation(FirConstKind.Long, "unaryMinus", { a -> a.unaryMinus() }),
|
unaryOperation(ConstantValueKind.Long, "unaryMinus", { a -> a.unaryMinus() }),
|
||||||
unaryOperation(FirConstKind.Long, "unaryPlus", { a -> a.unaryPlus() }),
|
unaryOperation(ConstantValueKind.Long, "unaryPlus", { a -> a.unaryPlus() }),
|
||||||
unaryOperation(FirConstKind.Short, "dec", { a -> a.dec() }),
|
unaryOperation(ConstantValueKind.Short, "dec", { a -> a.dec() }),
|
||||||
unaryOperation(FirConstKind.Short, "hashCode", { a -> a.hashCode() }),
|
unaryOperation(ConstantValueKind.Short, "hashCode", { a -> a.hashCode() }),
|
||||||
unaryOperation(FirConstKind.Short, "inc", { a -> a.inc() }),
|
unaryOperation(ConstantValueKind.Short, "inc", { a -> a.inc() }),
|
||||||
unaryOperation(FirConstKind.Short, "toByte", { a -> a.toByte() }),
|
unaryOperation(ConstantValueKind.Short, "toByte", { a -> a.toByte() }),
|
||||||
unaryOperation(FirConstKind.Short, "toDouble", { a -> a.toDouble() }),
|
unaryOperation(ConstantValueKind.Short, "toDouble", { a -> a.toDouble() }),
|
||||||
unaryOperation(FirConstKind.Short, "toFloat", { a -> a.toFloat() }),
|
unaryOperation(ConstantValueKind.Short, "toFloat", { a -> a.toFloat() }),
|
||||||
unaryOperation(FirConstKind.Short, "toInt", { a -> a.toInt() }),
|
unaryOperation(ConstantValueKind.Short, "toInt", { a -> a.toInt() }),
|
||||||
unaryOperation(FirConstKind.Short, "toLong", { a -> a.toLong() }),
|
unaryOperation(ConstantValueKind.Short, "toLong", { a -> a.toLong() }),
|
||||||
unaryOperation(FirConstKind.Short, "toShort", { a -> a.toShort() }),
|
unaryOperation(ConstantValueKind.Short, "toShort", { a -> a.toShort() }),
|
||||||
unaryOperation(FirConstKind.Short, "unaryMinus", { a -> a.unaryMinus() }),
|
unaryOperation(ConstantValueKind.Short, "unaryMinus", { a -> a.unaryMinus() }),
|
||||||
unaryOperation(FirConstKind.Short, "unaryPlus", { a -> a.unaryPlus() }),
|
unaryOperation(ConstantValueKind.Short, "unaryPlus", { a -> a.unaryPlus() }),
|
||||||
)
|
)
|
||||||
|
|
||||||
internal val binaryOperations: HashMap<BinaryOperationKey<*, *>, Function2<Number, Number, Number>> = hashMapOf(
|
internal val binaryOperations: HashMap<BinaryOperationKey<*, *>, Function2<Number, Number, Number>> = hashMapOf(
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Byte, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Double, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Float, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Int, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Long, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Short, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Double, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Float, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Int, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Long, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Short, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Double, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Float, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Int, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Long, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Short, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Double, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Float, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Int, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Long, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Short, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Byte, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Double, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Double, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Float, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Float, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Int, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Int, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Long, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Long, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Byte, FirConstKind.Short, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Byte, ConstantValueKind.Short, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Byte, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Double, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Float, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Int, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Long, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Short, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Double, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Float, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Int, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Long, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Short, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Double, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Float, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Int, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Long, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Short, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Double, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Float, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Int, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Long, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Short, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Byte, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Double, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Double, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Float, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Float, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Int, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Int, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Long, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Long, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Double, FirConstKind.Short, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Double, ConstantValueKind.Short, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Byte, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Double, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Float, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Int, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Long, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Short, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Double, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Float, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Int, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Long, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Short, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Double, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Float, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Int, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Long, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Short, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Double, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Float, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Int, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Long, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Short, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Byte, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Double, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Double, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Float, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Float, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Int, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Int, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Long, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Long, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Float, FirConstKind.Short, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Float, ConstantValueKind.Short, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Byte, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Double, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Float, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Int, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Long, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Short, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Double, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Float, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Int, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Long, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Short, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Double, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Float, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Int, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Long, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Short, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Double, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Float, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Int, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Long, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Short, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Byte, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Double, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Double, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Float, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Float, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Int, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Int, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Long, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Long, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Int, FirConstKind.Short, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Int, ConstantValueKind.Short, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Byte, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Double, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Float, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Int, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Long, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Short, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Double, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Float, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Int, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Long, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Short, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Double, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Float, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Int, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Long, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Short, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Double, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Float, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Int, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Long, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Short, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Byte, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Double, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Double, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Float, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Float, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Int, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Int, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Long, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Long, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Long, FirConstKind.Short, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Long, ConstantValueKind.Short, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Byte, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Double, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Float, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Int, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Long, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Short, "div", { a, b -> a.div(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Short, "div", { a, b -> a.div(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Byte, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Double, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Float, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Int, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Long, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Short, "minus", { a, b -> a.minus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Short, "minus", { a, b -> a.minus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Byte, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Double, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Float, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Int, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Long, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Short, "plus", { a, b -> a.plus(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Short, "plus", { a, b -> a.plus(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Byte, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Double, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Float, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Int, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Long, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Short, "rem", { a, b -> a.rem(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Short, "rem", { a, b -> a.rem(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Byte, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Byte, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Double, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Double, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Float, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Float, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Int, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Int, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Long, "times", { a, b -> a.times(b) }),
|
binaryOperation(ConstantValueKind.Short, ConstantValueKind.Long, "times", { a, b -> a.times(b) }),
|
||||||
binaryOperation(FirConstKind.Short, FirConstKind.Short, "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 unaryOperatorNames = unaryOperations.map { it.key.opName }.toHashSet()
|
||||||
|
|||||||
@@ -32,24 +32,24 @@ fun generateFirMap(): String {
|
|||||||
"""
|
"""
|
||||||
|package org.jetbrains.kotlin.fir.evaluate
|
|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 */
|
|/** This file is generated by org.jetbrains.kotlin.generators.evaluate:generateFirMap(). DO NOT MODIFY MANUALLY */
|
||||||
|
|
|
|
||||||
|internal data class UnaryOperationKey<out T>(val opr: FirConstKind<out T>, val opName: String)
|
|internal data class UnaryOperationKey<out T>(val opr: ConstantValueKind<out T>, val opName: String)
|
||||||
|internal data class BinaryOperationKey<out T, out U>(val opr1: FirConstKind<out T>, val opr2: FirConstKind<out U>, val opName: String)
|
|internal data class BinaryOperationKey<out T, out U>(val opr1: ConstantValueKind<out T>, val opr2: ConstantValueKind<out U>, val opName: String)
|
||||||
|
|
|
|
||||||
|@Suppress("UNCHECKED_CAST")
|
|@Suppress("UNCHECKED_CAST")
|
||||||
|private fun <T> unaryOperation(
|
|private fun <T> unaryOperation(
|
||||||
| t: FirConstKind<T>,
|
| t: ConstantValueKind<T>,
|
||||||
| opName: String,
|
| opName: String,
|
||||||
| operation: Function1<T, Number>
|
| operation: Function1<T, Number>
|
||||||
|) = UnaryOperationKey(t, opName) to operation as Function1<Number, Number>
|
|) = UnaryOperationKey(t, opName) to operation as Function1<Number, Number>
|
||||||
|
|
|
|
||||||
|@Suppress("UNCHECKED_CAST")
|
|@Suppress("UNCHECKED_CAST")
|
||||||
|private fun <T, U> binaryOperation(
|
|private fun <T, U> binaryOperation(
|
||||||
| t: FirConstKind<T>,
|
| t: ConstantValueKind<T>,
|
||||||
| u: FirConstKind<U>,
|
| u: ConstantValueKind<U>,
|
||||||
| opName: String,
|
| opName: String,
|
||||||
| operation: Function2<T, U, Number>
|
| operation: Function2<T, U, Number>
|
||||||
|) = BinaryOperationKey(t, u, opName) to operation as Function2<Number, Number, Number>
|
|) = BinaryOperationKey(t, u, opName) to operation as Function2<Number, Number, Number>
|
||||||
@@ -122,4 +122,4 @@ private fun Printer.renderBinaryOperations(binaryOperationsMap: List<Pair<String
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun KotlinType.asString(): String = "FirConstKind." + constructor.declarationDescriptor!!.name.asString()
|
private fun KotlinType.asString(): String = "ConstantValueKind." + constructor.declarationDescriptor!!.name.asString()
|
||||||
|
|||||||
Reference in New Issue
Block a user