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

Drop deprecated char operations: correct test data.

Browse Source
This commit is contained in:
Ilya Gorbunov
2015-07-02 18:04:54 +03:00
parent e8aff3360a
commit 39b27751df
11 changed files with 17 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt
Vendored
+1 -72
View File
@@ -49,10 +49,8 @@ private val unaryOperations: HashMap<UnaryOperationKey<*>, Pair<Function1<Any?,
unaryOperation(BYTE, "toShort", { a -> a.toShort() }, emptyUnaryFun),
unaryOperation(BYTE, "toByte", { a -> a.toByte() }, emptyUnaryFun),
unaryOperation(CHAR, "toInt", { a -> a.toInt() }, emptyUnaryFun),
unaryOperation(CHAR, "minus", { a -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>() }, emptyUnaryFun),
unaryOperation(CHAR, "toChar", { a -> a.toChar() }, emptyUnaryFun),
unaryOperation(CHAR, "toLong", { a -> a.toLong() }, emptyUnaryFun),
unaryOperation(CHAR, "plus", { a -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>() }, emptyUnaryFun),
unaryOperation(CHAR, "toFloat", { a -> a.toFloat() }, emptyUnaryFun),
unaryOperation(CHAR, "toDouble", { a -> a.toDouble() }, emptyUnaryFun),
unaryOperation(CHAR, "toShort", { a -> a.toShort() }, emptyUnaryFun),
@@ -115,110 +113,66 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(BOOLEAN, BOOLEAN, "and", { a, b -> a.and(b) }, emptyBinaryFun),
binaryOperation(BOOLEAN, BOOLEAN, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(BYTE, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(BYTE, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(BYTE, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(BYTE, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(BYTE, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(BYTE, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(BYTE, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, CHAR, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, CHAR, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>compareTo<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>minus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>plus<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>div<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>mod<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, BYTE, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, DOUBLE, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, FLOAT, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, INT, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, LONG, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, SHORT, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>times<!>(b) }, emptyBinaryFun),
binaryOperation(CHAR, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, BYTE, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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),
@@ -231,7 +185,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(DOUBLE, LONG, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, SHORT, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, BYTE, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(DOUBLE, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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),
@@ -239,42 +192,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, "minus", { a, b -> a.minus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "plus", { a, b -> a.plus(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "div", { a, b -> a.div(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "mod", { a, b -> a.mod(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(FLOAT, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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),
@@ -282,14 +229,12 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(FLOAT, SHORT, "times", { a, b -> a.times(b) }, emptyBinaryFun),
binaryOperation(FLOAT, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(INT, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(INT, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(INT, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
@@ -298,7 +243,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(INT, INT, "shl", { a, b -> a.shl(b) }, emptyBinaryFun),
binaryOperation(INT, INT, "ushr", { a, b -> a.ushr(b) }, emptyBinaryFun),
binaryOperation(INT, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(INT, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
@@ -306,14 +250,12 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(INT, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(INT, INT, "shr", { a, b -> a.shr(b) }, emptyBinaryFun),
binaryOperation(INT, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(INT, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
binaryOperation(INT, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(INT, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(INT, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(INT, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
@@ -321,7 +263,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(INT, SHORT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(INT, INT, "or", { a, b -> a.or(b) }, { a, b -> a.or(b) }),
binaryOperation(INT, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(INT, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
@@ -331,14 +272,12 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(INT, INT, "xor", { a, b -> a.xor(b) }, { a, b -> a.xor(b) }),
binaryOperation(INT, ANY, "equals", { a, b -> a.equals(b) }, emptyBinaryFun),
binaryOperation(LONG, BYTE, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(LONG, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(LONG, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
@@ -347,7 +286,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(LONG, INT, "shl", { a, b -> a.shl(b) }, emptyBinaryFun),
binaryOperation(LONG, INT, "ushr", { a, b -> a.ushr(b) }, emptyBinaryFun),
binaryOperation(LONG, BYTE, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(LONG, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
@@ -355,14 +293,12 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(LONG, SHORT, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(LONG, INT, "shr", { a, b -> a.shr(b) }, emptyBinaryFun),
binaryOperation(LONG, BYTE, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(LONG, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
binaryOperation(LONG, LONG, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(LONG, SHORT, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(LONG, BYTE, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(LONG, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
@@ -370,7 +306,6 @@ private val binaryOperations: HashMap<BinaryOperationKey<*, *>, Pair<Function2<A
binaryOperation(LONG, SHORT, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(LONG, LONG, "or", { a, b -> a.or(b) }, { a, b -> a.or(b) }),
binaryOperation(LONG, BYTE, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(LONG, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),
@@ -380,42 +315,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, "minus", { a, b -> a.minus(b) }, { a, b -> a.subtract(b) }),
binaryOperation(SHORT, CHAR, "minus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "compareTo", { a, b -> a.compareTo(b) }, emptyBinaryFun),
binaryOperation(SHORT, CHAR, "compareTo", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "plus", { a, b -> a.plus(b) }, { a, b -> a.add(b) }),
binaryOperation(SHORT, CHAR, "plus", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "div", { a, b -> a.div(b) }, { a, b -> a.divide(b) }),
binaryOperation(SHORT, CHAR, "div", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "mod", { a, b -> a.mod(b) }, { a, b -> a.mod(b) }),
binaryOperation(SHORT, CHAR, "mod", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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, "times", { a, b -> a.times(b) }, { a, b -> a.multiply(b) }),
binaryOperation(SHORT, CHAR, "times", { a, b -> a.<!DEPRECATED_SYMBOL_WITH_MESSAGE!>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) }),