Ilya Gorbunov
638 lines
29 KiB
Kotlin
638 lines
29 KiB
Kotlin
/*
|
|
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
|
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
|
*/
|
|
|
|
package org.jetbrains.kotlin.generators.builtins.numbers.primitives
|
|
|
|
import org.jetbrains.kotlin.generators.builtins.PrimitiveType
|
|
import org.jetbrains.kotlin.generators.builtins.generateBuiltIns.BuiltInsGenerator
|
|
import java.io.PrintWriter
|
|
|
|
abstract class BasePrimitivesGenerator(private val writer: PrintWriter) : BuiltInsGenerator {
|
|
companion object {
|
|
internal val binaryOperators: List<String> = listOf(
|
|
"plus",
|
|
"minus",
|
|
"times",
|
|
"div",
|
|
"rem",
|
|
)
|
|
|
|
internal val unaryPlusMinusOperators: Map<String, String> = mapOf(
|
|
"unaryPlus" to "Returns this value.",
|
|
"unaryMinus" to "Returns the negative of this value."
|
|
)
|
|
|
|
internal val shiftOperators: Map<String, String> = mapOf(
|
|
"shl" to "Shifts this value left by the [bitCount] number of bits.",
|
|
"shr" to "Shifts this value right by the [bitCount] number of bits, filling the leftmost bits with copies of the sign bit.",
|
|
"ushr" to "Shifts this value right by the [bitCount] number of bits, filling the leftmost bits with zeros."
|
|
)
|
|
|
|
internal val bitwiseOperators: Map<String, String> = mapOf(
|
|
"and" to "Performs a bitwise AND operation between the two values.",
|
|
"or" to "Performs a bitwise OR operation between the two values.",
|
|
"xor" to "Performs a bitwise XOR operation between the two values."
|
|
)
|
|
|
|
internal fun shiftOperatorsDocDetail(kind: PrimitiveType): String {
|
|
val bitsUsed = when (kind) {
|
|
PrimitiveType.INT -> "five"
|
|
PrimitiveType.LONG -> "six"
|
|
else -> throw IllegalArgumentException("Bit shift operation is not implemented for $kind")
|
|
}
|
|
return """
|
|
Note that only the $bitsUsed lowest-order bits of the [bitCount] are used as the shift distance.
|
|
The shift distance actually used is therefore always in the range `0..${kind.bitSize - 1}`.
|
|
""".trimIndent()
|
|
}
|
|
|
|
internal fun incDecOperatorsDoc(name: String): String {
|
|
val diff = if (name == "inc") "incremented" else "decremented"
|
|
|
|
return """
|
|
Returns this value $diff by one.
|
|
|
|
@sample samples.misc.Builtins.$name
|
|
""".trimIndent()
|
|
}
|
|
|
|
internal fun binaryOperatorDoc(operator: String, operand1: PrimitiveType, operand2: PrimitiveType): String = when (operator) {
|
|
"plus" -> "Adds the other value to this value."
|
|
"minus" -> "Subtracts the other value from this value."
|
|
"times" -> "Multiplies this value by the other value."
|
|
"div" -> {
|
|
if (operand1.isIntegral && operand2.isIntegral)
|
|
"Divides this value by the other value, truncating the result to an integer that is closer to zero."
|
|
else
|
|
"Divides this value by the other value."
|
|
}
|
|
"floorDiv" ->
|
|
"Divides this value by the other value, flooring the result to an integer that is closer to negative infinity."
|
|
"rem" -> {
|
|
"""
|
|
Calculates the remainder of truncating division of this value (dividend) by the other value (divisor).
|
|
|
|
The result is either zero or has the same sign as the _dividend_ and has the absolute value less than the absolute value of the divisor.
|
|
""".trimIndent()
|
|
}
|
|
"mod" -> {
|
|
"""
|
|
Calculates the remainder of flooring division of this value (dividend) by the other value (divisor).
|
|
|
|
The result is either zero or has the same sign as the _divisor_ and has the absolute value less than the absolute value of the divisor.
|
|
""".trimIndent() + if (operand1.isFloatingPoint)
|
|
"\n\n" + "If the result cannot be represented exactly, it is rounded to the nearest representable number. In this case the absolute value of the result can be less than or _equal to_ the absolute value of the divisor."
|
|
else ""
|
|
}
|
|
else -> error("No documentation for operator $operator")
|
|
}
|
|
|
|
private fun compareByDomainCapacity(type1: PrimitiveType, type2: PrimitiveType): Int {
|
|
return if (type1.isIntegral && type2.isIntegral) type1.byteSize - type2.byteSize else type1.ordinal - type2.ordinal
|
|
}
|
|
|
|
private fun docForConversionFromFloatingToIntegral(fromFloating: PrimitiveType, toIntegral: PrimitiveType): String {
|
|
require(fromFloating.isFloatingPoint)
|
|
require(toIntegral.isIntegral)
|
|
|
|
val thisName = fromFloating.capitalized
|
|
val otherName = toIntegral.capitalized
|
|
|
|
return if (compareByDomainCapacity(toIntegral, PrimitiveType.INT) < 0) {
|
|
"""
|
|
The resulting `$otherName` value is equal to `this.toInt().to$otherName()`.
|
|
""".trimIndent()
|
|
} else {
|
|
"""
|
|
The fractional part, if any, is rounded down towards zero.
|
|
Returns zero if this `$thisName` value is `NaN`, [$otherName.MIN_VALUE] if it's less than `$otherName.MIN_VALUE`,
|
|
[$otherName.MAX_VALUE] if it's bigger than `$otherName.MAX_VALUE`.
|
|
""".trimIndent()
|
|
}
|
|
}
|
|
|
|
private fun docForConversionFromFloatingToFloating(fromFloating: PrimitiveType, toFloating: PrimitiveType): String {
|
|
require(fromFloating.isFloatingPoint)
|
|
require(toFloating.isFloatingPoint)
|
|
|
|
val thisName = fromFloating.capitalized
|
|
val otherName = toFloating.capitalized
|
|
|
|
return if (compareByDomainCapacity(toFloating, fromFloating) < 0) {
|
|
"""
|
|
The resulting value is the closest `$otherName` to this `$thisName` value.
|
|
In case when this `$thisName` value is exactly between two `$otherName`s,
|
|
the one with zero at least significant bit of mantissa is selected.
|
|
""".trimIndent()
|
|
} else {
|
|
"""
|
|
The resulting `$otherName` value represents the same numerical value as this `$thisName`.
|
|
""".trimIndent()
|
|
}
|
|
}
|
|
|
|
private fun docForConversionFromIntegralToIntegral(fromIntegral: PrimitiveType, toIntegral: PrimitiveType): String {
|
|
require(fromIntegral.isIntegral)
|
|
require(toIntegral.isIntegral)
|
|
|
|
val thisName = fromIntegral.capitalized
|
|
val otherName = toIntegral.capitalized
|
|
|
|
return if (toIntegral == PrimitiveType.CHAR) {
|
|
when (fromIntegral) {
|
|
PrimitiveType.SHORT -> """
|
|
The resulting `Char` code is equal to this value reinterpreted as an unsigned number,
|
|
i.e. it has the same binary representation as this `Short`.
|
|
""".trimIndent()
|
|
PrimitiveType.BYTE -> """
|
|
If this value is non-negative, the resulting `Char` code is equal to this value.
|
|
|
|
The least significant 8 bits of the resulting `Char` code are the same as the bits of this `Byte` value,
|
|
whereas the most significant 8 bits are filled with the sign bit of this value.
|
|
""".trimIndent()
|
|
else -> """
|
|
If this value is in the range of `Char` codes `Char.MIN_VALUE..Char.MAX_VALUE`,
|
|
the resulting `Char` code is equal to this value.
|
|
|
|
The resulting `Char` code is represented by the least significant 16 bits of this `$thisName` value.
|
|
""".trimIndent()
|
|
}
|
|
} else if (compareByDomainCapacity(toIntegral, fromIntegral) < 0) {
|
|
"""
|
|
If this value is in [$otherName.MIN_VALUE]..[$otherName.MAX_VALUE], the resulting `$otherName` value represents
|
|
the same numerical value as this `$thisName`.
|
|
|
|
The resulting `$otherName` value is represented by the least significant ${toIntegral.bitSize} bits of this `$thisName` value.
|
|
""".trimIndent()
|
|
} else {
|
|
"""
|
|
The resulting `$otherName` value represents the same numerical value as this `$thisName`.
|
|
|
|
The least significant ${fromIntegral.bitSize} bits of the resulting `$otherName` value are the same as the bits of this `$thisName` value,
|
|
whereas the most significant ${toIntegral.bitSize - fromIntegral.bitSize} bits are filled with the sign bit of this value.
|
|
""".trimIndent()
|
|
}
|
|
}
|
|
|
|
private fun docForConversionFromIntegralToFloating(fromIntegral: PrimitiveType, toFloating: PrimitiveType): String {
|
|
require(fromIntegral.isIntegral)
|
|
require(toFloating.isFloatingPoint)
|
|
|
|
val thisName = fromIntegral.capitalized
|
|
val otherName = toFloating.capitalized
|
|
|
|
return if (fromIntegral == PrimitiveType.LONG || fromIntegral == PrimitiveType.INT && toFloating == PrimitiveType.FLOAT) {
|
|
"""
|
|
The resulting value is the closest `$otherName` to this `$thisName` value.
|
|
In case when this `$thisName` value is exactly between two `$otherName`s,
|
|
the one with zero at least significant bit of mantissa is selected.
|
|
""".trimIndent()
|
|
} else {
|
|
"""
|
|
The resulting `$otherName` value represents the same numerical value as this `$thisName`.
|
|
""".trimIndent()
|
|
}
|
|
}
|
|
|
|
private fun maxByDomainCapacity(type1: PrimitiveType, type2: PrimitiveType): PrimitiveType {
|
|
return if (type1.ordinal > type2.ordinal) type1 else type2
|
|
}
|
|
|
|
fun getOperatorReturnType(kind1: PrimitiveType, kind2: PrimitiveType): PrimitiveType {
|
|
require(kind1 != PrimitiveType.BOOLEAN) { "kind1 must not be BOOLEAN" }
|
|
require(kind2 != PrimitiveType.BOOLEAN) { "kind2 must not be BOOLEAN" }
|
|
return maxByDomainCapacity(maxByDomainCapacity(kind1, kind2), PrimitiveType.INT)
|
|
}
|
|
}
|
|
|
|
private val typeDescriptions: Map<PrimitiveType, String> = mapOf(
|
|
PrimitiveType.DOUBLE to "double-precision 64-bit IEEE 754 floating point number",
|
|
PrimitiveType.FLOAT to "single-precision 32-bit IEEE 754 floating point number",
|
|
PrimitiveType.LONG to "64-bit signed integer",
|
|
PrimitiveType.INT to "32-bit signed integer",
|
|
PrimitiveType.SHORT to "16-bit signed integer",
|
|
PrimitiveType.BYTE to "8-bit signed integer",
|
|
PrimitiveType.CHAR to "16-bit Unicode character"
|
|
)
|
|
|
|
open fun primitiveConstants(type: PrimitiveType): List<Any> = when (type) {
|
|
PrimitiveType.INT -> listOf(java.lang.Integer.MIN_VALUE, java.lang.Integer.MAX_VALUE)
|
|
PrimitiveType.BYTE -> listOf(java.lang.Byte.MIN_VALUE, java.lang.Byte.MAX_VALUE)
|
|
PrimitiveType.SHORT -> listOf(java.lang.Short.MIN_VALUE, java.lang.Short.MAX_VALUE)
|
|
PrimitiveType.LONG -> listOf((java.lang.Long.MIN_VALUE + 1).toString() + "L - 1L", java.lang.Long.MAX_VALUE.toString() + "L")
|
|
PrimitiveType.DOUBLE -> listOf(java.lang.Double.MIN_VALUE, java.lang.Double.MAX_VALUE, "1.0/0.0", "-1.0/0.0", "-(0.0/0.0)")
|
|
PrimitiveType.FLOAT -> listOf(java.lang.Float.MIN_VALUE, java.lang.Float.MAX_VALUE, "1.0F/0.0F", "-1.0F/0.0F", "-(0.0F/0.0F)").map { it as? String ?: "${it}F" }
|
|
else -> throw IllegalArgumentException("type: $type")
|
|
}
|
|
|
|
open fun PrimitiveType.shouldGenerate(): Boolean = true
|
|
|
|
override fun generate() {
|
|
writer.print(generateFile().build())
|
|
}
|
|
|
|
private fun generateFile(): FileBuilder {
|
|
return file(this::class) { generateClasses() }.apply { this.modifyGeneratedFile() }
|
|
}
|
|
|
|
private fun FileBuilder.generateClasses() {
|
|
for (thisKind in PrimitiveType.onlyNumeric.filter { it.shouldGenerate() }) {
|
|
val className = thisKind.capitalized
|
|
|
|
klass {
|
|
appendDoc("Represents a ${typeDescriptions[thisKind]}.")
|
|
name = className
|
|
superType("Number()")
|
|
superType("Comparable<$name>")
|
|
generateCompanionObject(thisKind)
|
|
|
|
generateCompareTo(thisKind)
|
|
generateBinaryOperators(thisKind)
|
|
generateUnaryOperators(thisKind)
|
|
generateRangeTo(thisKind)
|
|
generateRangeUntil(thisKind)
|
|
|
|
if (thisKind == PrimitiveType.INT || thisKind == PrimitiveType.LONG) {
|
|
generateBitShiftOperators(thisKind)
|
|
generateBitwiseOperators(thisKind)
|
|
}
|
|
|
|
generateConversions(thisKind)
|
|
generateToString(thisKind)
|
|
generateEquals(thisKind)
|
|
generateAdditionalMethods(thisKind)
|
|
}.modifyGeneratedClass(thisKind)
|
|
}
|
|
}
|
|
|
|
private fun ClassBuilder.generateCompanionObject(thisKind: PrimitiveType) {
|
|
companionObject {
|
|
val className = thisKind.capitalized
|
|
if (thisKind == PrimitiveType.FLOAT || thisKind == PrimitiveType.DOUBLE) {
|
|
val (minValue, maxValue, posInf, negInf, nan) = primitiveConstants(thisKind)
|
|
property {
|
|
appendDoc("A constant holding the smallest *positive* nonzero value of $className.")
|
|
name = "MIN_VALUE"
|
|
type = className
|
|
value = minValue.toString()
|
|
}.modifyGeneratedCompanionObjectProperty(thisKind)
|
|
|
|
property {
|
|
appendDoc("A constant holding the largest positive finite value of $className.")
|
|
name = "MAX_VALUE"
|
|
type = className
|
|
value = maxValue.toString()
|
|
}.modifyGeneratedCompanionObjectProperty(thisKind)
|
|
|
|
property {
|
|
appendDoc("A constant holding the positive infinity value of $className.")
|
|
name = "POSITIVE_INFINITY"
|
|
type = className
|
|
value = posInf.toString()
|
|
}.modifyGeneratedCompanionObjectProperty(thisKind)
|
|
|
|
property {
|
|
appendDoc("A constant holding the negative infinity value of $className.")
|
|
name = "NEGATIVE_INFINITY"
|
|
type = className
|
|
value = negInf.toString()
|
|
}.modifyGeneratedCompanionObjectProperty(thisKind)
|
|
|
|
property {
|
|
appendDoc("A constant holding the \"not a number\" value of $className.")
|
|
name = "NaN"
|
|
type = className
|
|
value = nan.toString()
|
|
}.modifyGeneratedCompanionObjectProperty(thisKind)
|
|
}
|
|
|
|
if (thisKind == PrimitiveType.INT || thisKind == PrimitiveType.LONG || thisKind == PrimitiveType.SHORT || thisKind == PrimitiveType.BYTE) {
|
|
val (minValue, maxValue) = primitiveConstants(thisKind)
|
|
property {
|
|
appendDoc("A constant holding the minimum value an instance of $className can have.")
|
|
name = "MIN_VALUE"
|
|
type = className
|
|
value = minValue.toString()
|
|
}.modifyGeneratedCompanionObjectProperty(thisKind)
|
|
|
|
property {
|
|
appendDoc("A constant holding the maximum value an instance of $className can have.")
|
|
name = "MAX_VALUE"
|
|
type = className
|
|
value = maxValue.toString()
|
|
}.modifyGeneratedCompanionObjectProperty(thisKind)
|
|
}
|
|
|
|
val sizeSince = if (thisKind.isFloatingPoint) "1.4" else "1.3"
|
|
property {
|
|
appendDoc("The number of bytes used to represent an instance of $className in a binary form.")
|
|
annotations += mutableListOf("SinceKotlin(\"$sizeSince\")")
|
|
name = "SIZE_BYTES"
|
|
type = "Int"
|
|
value = thisKind.byteSize.toString()
|
|
}.modifyGeneratedCompanionObjectProperty(thisKind)
|
|
|
|
property {
|
|
appendDoc("The number of bits used to represent an instance of $className in a binary form.")
|
|
annotations += mutableListOf("SinceKotlin(\"$sizeSince\")")
|
|
name = "SIZE_BITS"
|
|
type = "Int"
|
|
value = thisKind.bitSize.toString()
|
|
}.modifyGeneratedCompanionObjectProperty(thisKind)
|
|
}.modifyGeneratedCompanionObject(thisKind)
|
|
}
|
|
|
|
private fun ClassBuilder.generateCompareTo(thisKind: PrimitiveType) {
|
|
for (otherKind in PrimitiveType.onlyNumeric) {
|
|
val doc = """
|
|
Compares this value with the specified value for order.
|
|
Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
|
|
or a positive number if it's greater than other.
|
|
""".trimIndent()
|
|
|
|
method {
|
|
appendDoc(doc)
|
|
annotations += intrinsicConstEvaluationAnnotation
|
|
signature {
|
|
isOverride = otherKind == thisKind
|
|
isOperator = true
|
|
methodName = "compareTo"
|
|
parameter {
|
|
name = "other"
|
|
type = otherKind.capitalized
|
|
}
|
|
returnType = PrimitiveType.INT.capitalized
|
|
}
|
|
}.modifyGeneratedCompareTo(thisKind, otherKind)
|
|
}
|
|
}
|
|
|
|
private fun ClassBuilder.generateBinaryOperators(thisKind: PrimitiveType) {
|
|
for (name in binaryOperators) {
|
|
generateOperator(name, thisKind)
|
|
}
|
|
}
|
|
|
|
private fun ClassBuilder.generateOperator(operatorName: String, thisKind: PrimitiveType) {
|
|
for (otherKind in PrimitiveType.onlyNumeric) {
|
|
val opReturnType = getOperatorReturnType(thisKind, otherKind)
|
|
|
|
val annotationsToAdd = buildList {
|
|
if (operatorName == "rem") add("SinceKotlin(\"1.1\")")
|
|
add(intrinsicConstEvaluationAnnotation)
|
|
}
|
|
|
|
method {
|
|
appendDoc(binaryOperatorDoc(operatorName, thisKind, otherKind))
|
|
annotations += annotationsToAdd
|
|
signature {
|
|
isOperator = true
|
|
methodName = operatorName
|
|
parameter {
|
|
name = "other"
|
|
type = otherKind.capitalized
|
|
}
|
|
returnType = opReturnType.capitalized
|
|
}
|
|
}.modifyGeneratedBinaryOperation(thisKind, otherKind)
|
|
}
|
|
}
|
|
|
|
private fun ClassBuilder.generateUnaryOperators(thisKind: PrimitiveType) {
|
|
for (operatorName in listOf("inc", "dec")) {
|
|
method {
|
|
appendDoc(incDecOperatorsDoc(operatorName))
|
|
signature {
|
|
isOperator = true
|
|
methodName = operatorName
|
|
returnType = thisKind.capitalized
|
|
}
|
|
}.modifyGeneratedUnaryOperation(thisKind)
|
|
}
|
|
|
|
for ((operatorName, doc) in unaryPlusMinusOperators) {
|
|
val opReturnType = when (thisKind) {
|
|
in listOf(PrimitiveType.SHORT, PrimitiveType.BYTE, PrimitiveType.CHAR) -> PrimitiveType.INT.capitalized
|
|
else -> thisKind.capitalized
|
|
}
|
|
|
|
method {
|
|
appendDoc(doc)
|
|
annotations += intrinsicConstEvaluationAnnotation
|
|
signature {
|
|
isOperator = true
|
|
methodName = operatorName
|
|
returnType = opReturnType
|
|
}
|
|
}.modifyGeneratedUnaryOperation(thisKind)
|
|
}
|
|
}
|
|
|
|
private fun ClassBuilder.generateRangeTo(thisKind: PrimitiveType) {
|
|
for (otherKind in PrimitiveType.onlyNumeric) {
|
|
val opReturnType = maxByDomainCapacity(maxByDomainCapacity(thisKind, otherKind), PrimitiveType.INT)
|
|
|
|
if (opReturnType == PrimitiveType.DOUBLE || opReturnType == PrimitiveType.FLOAT) {
|
|
continue
|
|
}
|
|
|
|
method {
|
|
appendDoc("Creates a range from this value to the specified [other] value.")
|
|
signature {
|
|
isOperator = true
|
|
methodName = "rangeTo"
|
|
parameter {
|
|
name = "other"
|
|
type = otherKind.capitalized
|
|
}
|
|
returnType = "${opReturnType.capitalized}Range"
|
|
}
|
|
val thisCasted = "this${thisKind.castToIfNecessary(opReturnType)}"
|
|
val otherCasted = "other${otherKind.castToIfNecessary(opReturnType)}"
|
|
"${returnType}($thisCasted, $otherCasted)".setAsExpressionBody()
|
|
}.modifyGeneratedRangeTo(thisKind, otherKind, opReturnType)
|
|
}
|
|
}
|
|
|
|
private fun ClassBuilder.generateRangeUntil(thisKind: PrimitiveType) {
|
|
for (otherKind in PrimitiveType.onlyNumeric) {
|
|
val opReturnType = maxByDomainCapacity(maxByDomainCapacity(thisKind, otherKind), PrimitiveType.INT)
|
|
|
|
if (opReturnType == PrimitiveType.DOUBLE || opReturnType == PrimitiveType.FLOAT) {
|
|
continue
|
|
}
|
|
|
|
method {
|
|
appendDoc(
|
|
"""
|
|
Creates a range from this value up to but excluding the specified [other] value.
|
|
|
|
If the [other] value is less than or equal to `this` value, then the returned range is empty.
|
|
""".trimIndent()
|
|
)
|
|
annotations += mutableListOf("SinceKotlin(\"1.9\")", "WasExperimental(ExperimentalStdlibApi::class)")
|
|
signature {
|
|
isOperator = true
|
|
methodName = "rangeUntil"
|
|
parameter {
|
|
name = "other"
|
|
type = otherKind.capitalized
|
|
}
|
|
returnType = "${opReturnType.capitalized}Range"
|
|
}
|
|
"this until $parameterName".setAsExpressionBody()
|
|
}.modifyGeneratedRangeUntil(thisKind, otherKind, opReturnType)
|
|
}
|
|
}
|
|
|
|
private fun ClassBuilder.generateBitShiftOperators(thisKind: PrimitiveType) {
|
|
val className = thisKind.capitalized
|
|
val detail = shiftOperatorsDocDetail(thisKind)
|
|
for ((operatorName, doc) in shiftOperators) {
|
|
method {
|
|
appendDoc(doc + END_LINE + END_LINE + detail)
|
|
annotations += intrinsicConstEvaluationAnnotation
|
|
signature {
|
|
isInfix = true
|
|
methodName = operatorName
|
|
parameter {
|
|
name = "bitCount"
|
|
type = PrimitiveType.INT.capitalized
|
|
}
|
|
returnType = className
|
|
}
|
|
}.modifyGeneratedBitShiftOperators(thisKind)
|
|
}
|
|
}
|
|
|
|
private fun ClassBuilder.generateBitwiseOperators(thisKind: PrimitiveType) {
|
|
for ((operatorName, doc) in bitwiseOperators) {
|
|
method {
|
|
appendDoc(doc)
|
|
annotations += intrinsicConstEvaluationAnnotation
|
|
signature {
|
|
isInfix = true
|
|
methodName = operatorName
|
|
parameter {
|
|
name = "other"
|
|
type = thisKind.capitalized
|
|
}
|
|
returnType = thisKind.capitalized
|
|
}
|
|
|
|
}.modifyGeneratedBitwiseOperators(thisKind)
|
|
}
|
|
|
|
method {
|
|
appendDoc("Inverts the bits in this value.")
|
|
annotations += intrinsicConstEvaluationAnnotation
|
|
signature {
|
|
methodName = "inv"
|
|
returnType = thisKind.capitalized
|
|
}
|
|
}.modifyGeneratedBitwiseOperators(thisKind)
|
|
}
|
|
|
|
private fun ClassBuilder.generateConversions(thisKind: PrimitiveType) {
|
|
fun isFpToIntConversionDeprecated(otherKind: PrimitiveType): Boolean {
|
|
return thisKind in PrimitiveType.floatingPoint && otherKind in listOf(PrimitiveType.BYTE, PrimitiveType.SHORT)
|
|
}
|
|
|
|
fun isCharConversionDeprecated(otherKind: PrimitiveType): Boolean {
|
|
return thisKind != PrimitiveType.INT && otherKind == PrimitiveType.CHAR
|
|
}
|
|
|
|
val thisName = thisKind.capitalized
|
|
for (otherKind in PrimitiveType.exceptBoolean) {
|
|
val otherName = otherKind.capitalized
|
|
val doc = if (thisKind == otherKind) {
|
|
"Returns this value."
|
|
} else {
|
|
val detail = if (thisKind in PrimitiveType.integral) {
|
|
if (otherKind.isIntegral) {
|
|
docForConversionFromIntegralToIntegral(thisKind, otherKind)
|
|
} else {
|
|
docForConversionFromIntegralToFloating(thisKind, otherKind)
|
|
}
|
|
} else {
|
|
if (otherKind.isIntegral) {
|
|
docForConversionFromFloatingToIntegral(thisKind, otherKind)
|
|
} else {
|
|
docForConversionFromFloatingToFloating(thisKind, otherKind)
|
|
}
|
|
}
|
|
|
|
"Converts this [$thisName] value to [$otherName].$END_LINE$END_LINE$detail"
|
|
}
|
|
|
|
val annotationsToAdd = mutableListOf<String>()
|
|
if (isFpToIntConversionDeprecated(otherKind)) {
|
|
annotationsToAdd += "Deprecated(\"Unclear conversion. To achieve the same result convert to Int explicitly and then to $otherName.\", ReplaceWith(\"toInt().to$otherName()\"))"
|
|
annotationsToAdd += "DeprecatedSinceKotlin(warningSince = \"1.3\", errorSince = \"1.5\")"
|
|
}
|
|
if (isCharConversionDeprecated(otherKind)) {
|
|
annotationsToAdd += "Deprecated(\"Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\", ReplaceWith(\"this.toInt().toChar()\"))"
|
|
annotationsToAdd += "DeprecatedSinceKotlin(warningSince = \"1.5\", errorSince = \"2.3\")"
|
|
}
|
|
if (thisKind == PrimitiveType.INT && otherKind == PrimitiveType.CHAR) {
|
|
annotationsToAdd += "Suppress(\"OVERRIDE_DEPRECATION\")"
|
|
}
|
|
|
|
annotationsToAdd += intrinsicConstEvaluationAnnotation
|
|
method {
|
|
appendDoc(doc)
|
|
annotations += annotationsToAdd
|
|
signature {
|
|
isOverride = true
|
|
methodName = "to$otherName"
|
|
returnType = otherName
|
|
}
|
|
}.modifyGeneratedConversions(thisKind, otherKind)
|
|
}
|
|
}
|
|
|
|
private fun ClassBuilder.generateEquals(thisKind: PrimitiveType) {
|
|
method {
|
|
annotations += intrinsicConstEvaluationAnnotation
|
|
signature {
|
|
isOverride = true
|
|
methodName = "equals"
|
|
parameter {
|
|
name = "other"
|
|
type = "Any?"
|
|
}
|
|
returnType = "Boolean"
|
|
}
|
|
}.modifyGeneratedEquals(thisKind)
|
|
}
|
|
|
|
private fun ClassBuilder.generateToString(thisKind: PrimitiveType) {
|
|
method {
|
|
annotations += intrinsicConstEvaluationAnnotation
|
|
signature {
|
|
isOverride = true
|
|
methodName = "toString"
|
|
returnType = "String"
|
|
}
|
|
}.modifyGeneratedToString(thisKind)
|
|
}
|
|
|
|
internal open fun FileBuilder.modifyGeneratedFile() {}
|
|
internal open fun ClassBuilder.modifyGeneratedClass(thisKind: PrimitiveType) {}
|
|
internal open fun CompanionObjectBuilder.modifyGeneratedCompanionObject(thisKind: PrimitiveType) {}
|
|
internal open fun PropertyBuilder.modifyGeneratedCompanionObjectProperty(thisKind: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedCompareTo(thisKind: PrimitiveType, otherKind: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedBinaryOperation(thisKind: PrimitiveType, otherKind: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedUnaryOperation(thisKind: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedRangeTo(thisKind: PrimitiveType, otherKind: PrimitiveType, opReturnType: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedRangeUntil(thisKind: PrimitiveType, otherKind: PrimitiveType, opReturnType: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedBitShiftOperators(thisKind: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedBitwiseOperators(thisKind: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedConversions(thisKind: PrimitiveType, otherKind: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedEquals(thisKind: PrimitiveType) {}
|
|
internal open fun MethodBuilder.modifyGeneratedToString(thisKind: PrimitiveType) {}
|
|
internal open fun ClassBuilder.generateAdditionalMethods(thisKind: PrimitiveType) {}
|
|
}
|