azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Drop deprecated char binary operations.

Browse Source
This commit is contained in:
Ilya Gorbunov
2015-07-01 22:56:16 +03:00
parent 005a0a1eb6
commit 2c4db42319
5 changed files with 6 additions and 373 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/OperationsMapGenerated.kt
-72
View File
@@ -38,8 +38,6 @@ private val unaryOperations: HashMap<UnaryOperationKey<*>, Pair<Function1<Any?,
unaryOperation(BYTE, "toLong", { a -> a.toLong() }, emptyUnaryFun),
unaryOperation(BYTE, "toShort", { a -> a.toShort() }, emptyUnaryFun),
unaryOperation(BYTE, "toString", { a -> a.toString() }, emptyUnaryFun),
unaryOperation(CHAR, "minus", { a -> a.minus() }, emptyUnaryFun),
unaryOperation(CHAR, "plus", { a -> a.plus() }, emptyUnaryFun),
unaryOperation(CHAR, "toByte", { a -> a.toByte() }, emptyUnaryFun),
unaryOperation(CHAR, "toChar", { a -> a.toChar() }, emptyUnaryFun),
unaryOperation(CHAR, "toDouble", { a -> a.toDouble() }, emptyUnaryFun),
@@ -112,124 +110,78 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(BOOLEAN, BOOLEAN, "xor", { a, b -> a.xor(b) }, emptyBinaryFun),
binaryOperation(BOOLEAN, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(BYTE, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(BYTE, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(BYTE, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(BYTE, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(BYTE, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(BYTE, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(BYTE, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(BYTE, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(BYTE, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(BYTE, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(BYTE, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(BYTE, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(BYTE, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(BYTE, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(BYTE, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(BYTE, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(BYTE, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(BYTE, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(BYTE, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(BYTE, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(BYTE, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(BYTE, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(BYTE, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(BYTE, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(BYTE, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(BYTE, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(BYTE, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(BYTE, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(BYTE, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(BYTE, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(BYTE, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(BYTE, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(BYTE, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(BYTE, LONG, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(BYTE, SHORT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(BYTE, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(BYTE, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(BYTE, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(BYTE, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(BYTE, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(BYTE, LONG, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(BYTE, SHORT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(BYTE, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(CHAR, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(CHAR, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(CHAR, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, BYTE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, INT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, LONG, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, SHORT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, BYTE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, INT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, LONG, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, SHORT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, BYTE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, INT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, LONG, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, SHORT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, BYTE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, INT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, LONG, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, SHORT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, BYTE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, INT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
@@ -237,42 +189,36 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(DOUBLE, SHORT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(FLOAT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(FLOAT, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(FLOAT, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(FLOAT, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(FLOAT, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(FLOAT, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(FLOAT, BYTE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(FLOAT, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(FLOAT, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(FLOAT, INT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(FLOAT, LONG, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(FLOAT, SHORT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(FLOAT, BYTE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, INT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, LONG, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, SHORT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, BYTE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(FLOAT, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(FLOAT, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(FLOAT, INT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(FLOAT, LONG, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(FLOAT, SHORT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(FLOAT, BYTE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, INT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, LONG, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, SHORT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, BYTE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(FLOAT, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(FLOAT, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(FLOAT, INT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
@@ -281,28 +227,24 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(FLOAT, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(INT, INT, "and", { a, b -> a.and(b) }, { a, b -> a.and(b) }),
binaryOperation(INT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(INT, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(INT, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(INT, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(INT, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(INT, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(INT, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(INT, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(INT, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(INT, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(INT, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(INT, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(INT, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(INT, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(INT, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(INT, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(INT, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(INT, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(INT, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(INT, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(INT, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(INT, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(INT, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(INT, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(INT, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(INT, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
@@ -310,7 +252,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(INT, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(INT, INT, "or", { a, b -> a.or(b) }, { a, b -> a.or(b) }),
binaryOperation(INT, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(INT, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(INT, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(INT, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(INT, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
@@ -319,7 +260,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(INT, INT, "shl", { a, b -> a.shl(b) }, emptyBinaryFun),
binaryOperation(INT, INT, "shr", { a, b -> a.shr(b) }, emptyBinaryFun),
binaryOperation(INT, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(INT, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(INT, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(INT, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(INT, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
@@ -330,28 +270,24 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(INT, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(LONG, LONG, "and", { a, b -> a.and(b) }, { a, b -> a.and(b) }),
binaryOperation(LONG, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(LONG, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(LONG, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(LONG, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(LONG, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(LONG, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(LONG, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(LONG, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(LONG, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(LONG, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(LONG, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(LONG, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(LONG, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(LONG, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(LONG, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(LONG, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(LONG, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(LONG, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(LONG, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(LONG, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(LONG, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(LONG, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(LONG, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(LONG, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(LONG, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(LONG, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
@@ -359,7 +295,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(LONG, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(LONG, LONG, "or", { a, b -> a.or(b) }, { a, b -> a.or(b) }),
binaryOperation(LONG, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(LONG, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(LONG, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(LONG, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(LONG, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
@@ -368,7 +303,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(LONG, INT, "shl", { a, b -> a.shl(b) }, emptyBinaryFun),
binaryOperation(LONG, INT, "shr", { a, b -> a.shr(b) }, emptyBinaryFun),
binaryOperation(LONG, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(LONG, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(LONG, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(LONG, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(LONG, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
@@ -378,42 +312,36 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(LONG, LONG, "xor", { a, b -> a.xor(b) }, { a, b -> a.xor(b) }),
binaryOperation(LONG, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(SHORT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(SHORT, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(SHORT, DOUBLE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(SHORT, FLOAT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(SHORT, INT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(SHORT, LONG, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(SHORT, SHORT, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(SHORT, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(SHORT, CHAR, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(SHORT, DOUBLE, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(SHORT, FLOAT, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(SHORT, INT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(SHORT, LONG, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(SHORT, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(SHORT, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(SHORT, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(SHORT, DOUBLE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(SHORT, FLOAT, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(SHORT, INT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(SHORT, LONG, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(SHORT, SHORT, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(SHORT, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(SHORT, CHAR, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(SHORT, DOUBLE, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(SHORT, FLOAT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(SHORT, INT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(SHORT, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(SHORT, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(SHORT, BYTE, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(SHORT, CHAR, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(SHORT, DOUBLE, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(SHORT, FLOAT, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(SHORT, INT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(SHORT, LONG, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(SHORT, SHORT, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(SHORT, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(SHORT, CHAR, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(SHORT, DOUBLE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(SHORT, FLOAT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(SHORT, INT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
core/builtins/native/kotlin/Char.kt
-135
View File
@@ -23,162 +23,27 @@ package kotlin
public class Char private () : Comparable<Char> {
companion object {}
/**
* Compares the character code of this character with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.")
public fun compareTo(other: Byte): Int
/**
* 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 its less than other,
* or a positive number if its greater than other.
*/
public override fun compareTo(other: Char): Int
/**
* Compares the character code of this character with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.")
public fun compareTo(other: Short): Int
/**
* Compares the character code of this character with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.")
public fun compareTo(other: Int): Int
/**
* Compares the character code of this character with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int or other operand to Char.")
public fun compareTo(other: Long): Int
/**
* Compares the character code of this character with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun compareTo(other: Float): Int
/**
* Compares the character code of this character with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun compareTo(other: Double): Int
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Byte): Int
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Short): Int
/** Adds the other value to this value. */
deprecated("This operation will change return type to Char in M13. Either call toInt or toChar on return value or convert Char operand to Int.")
public fun plus(other: Int): Int
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Long): Long
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Float): Float
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Double): Double
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Byte): Int
/** Subtracts the other value from this value. */
public fun minus(other: Char): Int
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Short): Int
/** Subtracts the other value from this value. */
deprecated("This operation will change return type to Char in M13. Either call toInt or toChar on return value or convert Char operand to Int.")
public fun minus(other: Int): Int
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Long): Long
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Float): Float
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Double): Double
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Byte): Int
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Short): Int
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Int): Int
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Long): Long
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Float): Float
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Double): Double
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Byte): Int
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Short): Int
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Int): Int
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Long): Long
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Float): Float
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Double): Double
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Byte): Int
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Short): Int
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Int): Int
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Long): Long
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Float): Float
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Double): Double
/** Increments this value. */
public fun inc(): Char
/** Decrements this value. */
public fun dec(): Char
/** Returns this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(): Int
/** Returns the negative of this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(): Int
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Char): CharRange
core/builtins/native/kotlin/Primitives.kt
-150
View File
@@ -31,13 +31,6 @@ public class Byte private () : Number, Comparable<Byte> {
* or a positive number if its greater than other.
*/
public override fun compareTo(other: Byte): Int
/**
* Compares this value with the character code of the specified character for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun compareTo(other: Char): Int
/**
* 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 its less than other,
@@ -72,9 +65,6 @@ public class Byte private () : Number, Comparable<Byte> {
/** Adds the other value to this value. */
public fun plus(other: Byte): Int
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Char): Int
/** Adds the other value to this value. */
public fun plus(other: Short): Int
/** Adds the other value to this value. */
public fun plus(other: Int): Int
@@ -88,9 +78,6 @@ public class Byte private () : Number, Comparable<Byte> {
/** Subtracts the other value from this value. */
public fun minus(other: Byte): Int
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Char): Int
/** Subtracts the other value from this value. */
public fun minus(other: Short): Int
/** Subtracts the other value from this value. */
public fun minus(other: Int): Int
@@ -104,9 +91,6 @@ public class Byte private () : Number, Comparable<Byte> {
/** Multiplies this value by the other value. */
public fun times(other: Byte): Int
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Char): Int
/** Multiplies this value by the other value. */
public fun times(other: Short): Int
/** Multiplies this value by the other value. */
public fun times(other: Int): Int
@@ -120,9 +104,6 @@ public class Byte private () : Number, Comparable<Byte> {
/** Divides this value by the other value. */
public fun div(other: Byte): Int
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Char): Int
/** Divides this value by the other value. */
public fun div(other: Short): Int
/** Divides this value by the other value. */
public fun div(other: Int): Int
@@ -136,9 +117,6 @@ public class Byte private () : Number, Comparable<Byte> {
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Byte): Int
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Char): Int
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Short): Int
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Int): Int
@@ -161,9 +139,6 @@ public class Byte private () : Number, Comparable<Byte> {
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Byte): ByteRange
/** Creates a range from this value to the specified [other] value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun rangeTo(other: Char): CharRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Short): ShortRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Int): IntRange
@@ -196,13 +171,6 @@ public class Short private () : Number, Comparable<Short> {
* or a positive number if its greater than other.
*/
public fun compareTo(other: Byte): Int
/**
* Compares this value with the character code of the specified character for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun compareTo(other: Char): Int
/**
* 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 its less than other,
@@ -237,9 +205,6 @@ public class Short private () : Number, Comparable<Short> {
/** Adds the other value to this value. */
public fun plus(other: Byte): Int
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Char): Int
/** Adds the other value to this value. */
public fun plus(other: Short): Int
/** Adds the other value to this value. */
public fun plus(other: Int): Int
@@ -253,9 +218,6 @@ public class Short private () : Number, Comparable<Short> {
/** Subtracts the other value from this value. */
public fun minus(other: Byte): Int
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Char): Int
/** Subtracts the other value from this value. */
public fun minus(other: Short): Int
/** Subtracts the other value from this value. */
public fun minus(other: Int): Int
@@ -269,9 +231,6 @@ public class Short private () : Number, Comparable<Short> {
/** Multiplies this value by the other value. */
public fun times(other: Byte): Int
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Char): Int
/** Multiplies this value by the other value. */
public fun times(other: Short): Int
/** Multiplies this value by the other value. */
public fun times(other: Int): Int
@@ -285,9 +244,6 @@ public class Short private () : Number, Comparable<Short> {
/** Divides this value by the other value. */
public fun div(other: Byte): Int
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Char): Int
/** Divides this value by the other value. */
public fun div(other: Short): Int
/** Divides this value by the other value. */
public fun div(other: Int): Int
@@ -301,9 +257,6 @@ public class Short private () : Number, Comparable<Short> {
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Byte): Int
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Char): Int
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Short): Int
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Int): Int
@@ -326,9 +279,6 @@ public class Short private () : Number, Comparable<Short> {
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Byte): ShortRange
/** Creates a range from this value to the specified [other] value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun rangeTo(other: Char): ShortRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Short): ShortRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Int): IntRange
@@ -361,13 +311,6 @@ public class Int private () : Number, Comparable<Int> {
* or a positive number if its greater than other.
*/
public fun compareTo(other: Byte): Int
/**
* Compares this value with the character code of the specified character for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun compareTo(other: Char): Int
/**
* 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 its less than other,
@@ -402,9 +345,6 @@ public class Int private () : Number, Comparable<Int> {
/** Adds the other value to this value. */
public fun plus(other: Byte): Int
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Char): Int
/** Adds the other value to this value. */
public fun plus(other: Short): Int
/** Adds the other value to this value. */
public fun plus(other: Int): Int
@@ -418,9 +358,6 @@ public class Int private () : Number, Comparable<Int> {
/** Subtracts the other value from this value. */
public fun minus(other: Byte): Int
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Char): Int
/** Subtracts the other value from this value. */
public fun minus(other: Short): Int
/** Subtracts the other value from this value. */
public fun minus(other: Int): Int
@@ -434,9 +371,6 @@ public class Int private () : Number, Comparable<Int> {
/** Multiplies this value by the other value. */
public fun times(other: Byte): Int
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Char): Int
/** Multiplies this value by the other value. */
public fun times(other: Short): Int
/** Multiplies this value by the other value. */
public fun times(other: Int): Int
@@ -450,9 +384,6 @@ public class Int private () : Number, Comparable<Int> {
/** Divides this value by the other value. */
public fun div(other: Byte): Int
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Char): Int
/** Divides this value by the other value. */
public fun div(other: Short): Int
/** Divides this value by the other value. */
public fun div(other: Int): Int
@@ -466,9 +397,6 @@ public class Int private () : Number, Comparable<Int> {
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Byte): Int
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Char): Int
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Short): Int
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Int): Int
@@ -491,9 +419,6 @@ public class Int private () : Number, Comparable<Int> {
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Byte): IntRange
/** Creates a range from this value to the specified [other] value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun rangeTo(other: Char): IntRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Short): IntRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Int): IntRange
@@ -541,13 +466,6 @@ public class Long private () : Number, Comparable<Long> {
* or a positive number if its greater than other.
*/
public fun compareTo(other: Byte): Int
/**
* Compares this value with the character code of the specified character for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun compareTo(other: Char): Int
/**
* 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 its less than other,
@@ -582,9 +500,6 @@ public class Long private () : Number, Comparable<Long> {
/** Adds the other value to this value. */
public fun plus(other: Byte): Long
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Char): Long
/** Adds the other value to this value. */
public fun plus(other: Short): Long
/** Adds the other value to this value. */
public fun plus(other: Int): Long
@@ -598,9 +513,6 @@ public class Long private () : Number, Comparable<Long> {
/** Subtracts the other value from this value. */
public fun minus(other: Byte): Long
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Char): Long
/** Subtracts the other value from this value. */
public fun minus(other: Short): Long
/** Subtracts the other value from this value. */
public fun minus(other: Int): Long
@@ -614,9 +526,6 @@ public class Long private () : Number, Comparable<Long> {
/** Multiplies this value by the other value. */
public fun times(other: Byte): Long
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Char): Long
/** Multiplies this value by the other value. */
public fun times(other: Short): Long
/** Multiplies this value by the other value. */
public fun times(other: Int): Long
@@ -630,9 +539,6 @@ public class Long private () : Number, Comparable<Long> {
/** Divides this value by the other value. */
public fun div(other: Byte): Long
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Char): Long
/** Divides this value by the other value. */
public fun div(other: Short): Long
/** Divides this value by the other value. */
public fun div(other: Int): Long
@@ -646,9 +552,6 @@ public class Long private () : Number, Comparable<Long> {
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Byte): Long
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Char): Long
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Short): Long
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Int): Long
@@ -671,9 +574,6 @@ public class Long private () : Number, Comparable<Long> {
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Byte): LongRange
/** Creates a range from this value to the specified [other] value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun rangeTo(other: Char): LongRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Short): LongRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Int): LongRange
@@ -721,13 +621,6 @@ public class Float private () : Number, Comparable<Float> {
* or a positive number if its greater than other.
*/
public fun compareTo(other: Byte): Int
/**
* Compares this value with the character code of the specified character for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun compareTo(other: Char): Int
/**
* 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 its less than other,
@@ -762,9 +655,6 @@ public class Float private () : Number, Comparable<Float> {
/** Adds the other value to this value. */
public fun plus(other: Byte): Float
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Char): Float
/** Adds the other value to this value. */
public fun plus(other: Short): Float
/** Adds the other value to this value. */
public fun plus(other: Int): Float
@@ -778,9 +668,6 @@ public class Float private () : Number, Comparable<Float> {
/** Subtracts the other value from this value. */
public fun minus(other: Byte): Float
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Char): Float
/** Subtracts the other value from this value. */
public fun minus(other: Short): Float
/** Subtracts the other value from this value. */
public fun minus(other: Int): Float
@@ -794,9 +681,6 @@ public class Float private () : Number, Comparable<Float> {
/** Multiplies this value by the other value. */
public fun times(other: Byte): Float
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Char): Float
/** Multiplies this value by the other value. */
public fun times(other: Short): Float
/** Multiplies this value by the other value. */
public fun times(other: Int): Float
@@ -810,9 +694,6 @@ public class Float private () : Number, Comparable<Float> {
/** Divides this value by the other value. */
public fun div(other: Byte): Float
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Char): Float
/** Divides this value by the other value. */
public fun div(other: Short): Float
/** Divides this value by the other value. */
public fun div(other: Int): Float
@@ -826,9 +707,6 @@ public class Float private () : Number, Comparable<Float> {
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Byte): Float
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Char): Float
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Short): Float
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Int): Float
@@ -851,9 +729,6 @@ public class Float private () : Number, Comparable<Float> {
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Byte): FloatRange
/** Creates a range from this value to the specified [other] value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun rangeTo(other: Char): FloatRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Short): FloatRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Int): FloatRange
@@ -886,13 +761,6 @@ public class Double private () : Number, Comparable<Double> {
* or a positive number if its greater than other.
*/
public fun compareTo(other: Byte): Int
/**
* Compares this value with the character code of the specified character for order.
* Returns zero if this value is equal to the specified other value, a negative number if its less than other,
* or a positive number if its greater than other.
*/
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun compareTo(other: Char): Int
/**
* 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 its less than other,
@@ -927,9 +795,6 @@ public class Double private () : Number, Comparable<Double> {
/** Adds the other value to this value. */
public fun plus(other: Byte): Double
/** Adds the other value to this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun plus(other: Char): Double
/** Adds the other value to this value. */
public fun plus(other: Short): Double
/** Adds the other value to this value. */
public fun plus(other: Int): Double
@@ -943,9 +808,6 @@ public class Double private () : Number, Comparable<Double> {
/** Subtracts the other value from this value. */
public fun minus(other: Byte): Double
/** Subtracts the other value from this value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun minus(other: Char): Double
/** Subtracts the other value from this value. */
public fun minus(other: Short): Double
/** Subtracts the other value from this value. */
public fun minus(other: Int): Double
@@ -959,9 +821,6 @@ public class Double private () : Number, Comparable<Double> {
/** Multiplies this value by the other value. */
public fun times(other: Byte): Double
/** Multiplies this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun times(other: Char): Double
/** Multiplies this value by the other value. */
public fun times(other: Short): Double
/** Multiplies this value by the other value. */
public fun times(other: Int): Double
@@ -975,9 +834,6 @@ public class Double private () : Number, Comparable<Double> {
/** Divides this value by the other value. */
public fun div(other: Byte): Double
/** Divides this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun div(other: Char): Double
/** Divides this value by the other value. */
public fun div(other: Short): Double
/** Divides this value by the other value. */
public fun div(other: Int): Double
@@ -991,9 +847,6 @@ public class Double private () : Number, Comparable<Double> {
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Byte): Double
/** Calculates the remainder of dividing this value by the other value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun mod(other: Char): Double
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Short): Double
/** Calculates the remainder of dividing this value by the other value. */
public fun mod(other: Int): Double
@@ -1016,9 +869,6 @@ public class Double private () : Number, Comparable<Double> {
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Byte): DoubleRange
/** Creates a range from this value to the specified [other] value. */
deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")
public fun rangeTo(other: Char): DoubleRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Short): DoubleRange
/** Creates a range from this value to the specified [other] value. */
public fun rangeTo(other: Int): DoubleRange
generators/src/org/jetbrains/kotlin/generators/builtins/common.kt
+2 -2
View File
@@ -31,8 +31,8 @@ enum class PrimitiveType {
val capitalized: String get() = name().toLowerCase().capitalize()
companion object {
val exceptBoolean: List<PrimitiveType> by Delegates.lazy { PrimitiveType.values().filterNot { it == BOOLEAN } }
val onlyNumeric: List<PrimitiveType> by Delegates.lazy { PrimitiveType.values().filterNot { it == BOOLEAN || it == CHAR }}
val exceptBoolean: List<PrimitiveType> by lazy { PrimitiveType.values().filterNot { it == BOOLEAN } }
val onlyNumeric: List<PrimitiveType> by lazy { PrimitiveType.values().filterNot { it == BOOLEAN || it == CHAR }}
}
}
generators/src/org/jetbrains/kotlin/generators/builtins/primitives.kt
+4 -14
View File
@@ -90,18 +90,12 @@ class GeneratePrimitives(out: PrintWriter) : BuiltInsSourceGenerator(out) {
}
private fun generateCompareTo(thisKind: PrimitiveType) {
for (otherKind in PrimitiveType.exceptBoolean) {
for (otherKind in PrimitiveType.onlyNumeric) {
out.println("/**")
if (otherKind == PrimitiveType.CHAR) {
out.println(" * Compares this value with the character code of the specified character for order.")
} else {
out.println(" * Compares this value with the specified value for order.")
}
out.println(" * Compares this value with the specified value for order.")
out.println(" * Returns zero if this value is equal to the specified other value, a negative number if its less than other, ")
out.println(" * or a positive number if its greater than other.")
out.println(" */")
if (otherKind == PrimitiveType.CHAR)
out.println(""" deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")""")
out.print(" public ")
if (otherKind == thisKind) out.print("override ")
out.println("fun compareTo(other: ${otherKind.capitalized}): Int")
@@ -116,22 +110,18 @@ class GeneratePrimitives(out: PrintWriter) : BuiltInsSourceGenerator(out) {
}
private fun generateOperator(name: String, doc: String, thisKind: PrimitiveType) {
for (otherKind in PrimitiveType.exceptBoolean) {
for (otherKind in PrimitiveType.onlyNumeric) {
val returnType = getOperatorReturnType(thisKind, otherKind)
out.println(" /** $doc */")
if (otherKind == PrimitiveType.CHAR)
out.println(""" deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")""")
out.println(" public fun $name(other: ${otherKind.capitalized}): $returnType")
}
out.println()
}
private fun generateRangeTo(thisKind: PrimitiveType) {
for (otherKind in PrimitiveType.exceptBoolean) {
for (otherKind in PrimitiveType.onlyNumeric) {
val returnType = if (otherKind.ordinal() > thisKind.ordinal()) otherKind else thisKind
out.println(" /** Creates a range from this value to the specified [other] value. */")
if (otherKind == PrimitiveType.CHAR)
out.println(""" deprecated("This operation doesn't make sense and shall be removed in M13. Consider converting Char operand to Int.")""")
out.println(" public fun rangeTo(other: ${otherKind.capitalized}): ${returnType.capitalized}Range")
}
out.println()