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

Deprecate meaningless or vague-defined operations with Char operands.

Browse Source 
Change expected test output.
This commit is contained in:
Ilya Gorbunov
2015-05-26 19:04:07 +03:00
parent c6abf75856
commit 84ca26719d
9 changed files with 256 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/operatorsOverloading/assignmentOperationsCheckReturnType.kt
+4 -4
View File
@@ -1,12 +1,12 @@
fun intBinEq() {
var x = 0
x += 'a'
x <!DEPRECATED_SYMBOL_WITH_MESSAGE!>+=<!> 'a'
x += 1.toByte()
x += 1.toShort()
<!TYPE_MISMATCH!>x += 1L<!>
<!TYPE_MISMATCH!>x += 1f<!>
<!TYPE_MISMATCH!>x += 1.0<!>
x *= 'a'
x <!DEPRECATED_SYMBOL_WITH_MESSAGE!>*=<!> 'a'
x *= 1.toByte()
x *= 1.toShort()
<!TYPE_MISMATCH!>x *= 1L<!>
@@ -16,14 +16,14 @@ fun intBinEq() {
fun shortBinEq() {
var x = 0.toShort()
<!TYPE_MISMATCH!>x += 'a'<!>
<!TYPE_MISMATCH!>x <!DEPRECATED_SYMBOL_WITH_MESSAGE!>+=<!> 'a'<!>
<!TYPE_MISMATCH!>x += 1.toByte()<!>
<!TYPE_MISMATCH!>x += 1.toShort()<!>
<!TYPE_MISMATCH!>x += 1L<!>
<!TYPE_MISMATCH!>x += 1f<!>
<!TYPE_MISMATCH!>x += 1.0<!>
<!TYPE_MISMATCH!>x *= 'a'<!>
<!TYPE_MISMATCH!>x <!DEPRECATED_SYMBOL_WITH_MESSAGE!>*=<!> 'a'<!>
<!TYPE_MISMATCH!>x *= 1.toByte()<!>
<!TYPE_MISMATCH!>x *= 1.toShort()<!>
<!TYPE_MISMATCH!>x *= 1L<!>
compiler/testData/diagnostics/tests/thisAndSuper/thisInFunctionLiterals.kt
+6 -6
View File
@@ -2,17 +2,17 @@
class A(val a:Int) {
inner class B() {
fun Char.xx() : Double.() -> Any {
checkSubtype<Char>(this)
fun Byte.xx() : Double.() -> Any {
checkSubtype<Byte>(this)
val <!UNUSED_VARIABLE!>a<!>: Double.() -> Unit = {
checkSubtype<Double>(this)
checkSubtype<Char>(this@xx)
checkSubtype<Byte>(this@xx)
checkSubtype<B>(this@B)
checkSubtype<A>(this@A)
}
val <!UNUSED_VARIABLE!>b<!>: Double.() -> Unit = a@{ checkSubtype<Double>(this@a) + checkSubtype<Char>(this@xx) }
val <!UNUSED_VARIABLE!>c<!> = a@{ -> <!NO_THIS!>this@a<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> checkSubtype<Char>(this@xx) }
return (a@{checkSubtype<Double>(this@a) + checkSubtype<Char>(this@xx)})
val <!UNUSED_VARIABLE!>b<!>: Double.() -> Unit = a@{ checkSubtype<Double>(this@a) + checkSubtype<Byte>(this@xx) }
val <!UNUSED_VARIABLE!>c<!> = a@{ -> <!NO_THIS!>this@a<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> checkSubtype<Byte>(this@xx) }
return (a@{checkSubtype<Double>(this@a) + checkSubtype<Byte>(this@xx)})
}
}
}
compiler/testData/diagnostics/tests/thisAndSuper/thisInFunctionLiterals.txt
+1 -1
View File
@@ -12,6 +12,6 @@ internal final class A {
public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
internal final fun kotlin.Char.xx(): kotlin.Double.() -> kotlin.Any
internal final fun kotlin.Byte.xx(): kotlin.Double.() -> kotlin.Any
}
}
compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt
+73 -73
View File
@@ -49,10 +49,10 @@ 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.minus() }, 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.plus() }, 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 +115,110 @@ 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.minus(b) }, emptyBinaryFun),
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.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.plus(b) }, emptyBinaryFun),
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.div(b) }, emptyBinaryFun),
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.mod(b) }, emptyBinaryFun),
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.times(b) }, emptyBinaryFun),
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.minus(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.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, "compareTo", { a, b -> a.compareTo(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.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, "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, "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, "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, "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, 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, "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.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.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.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.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 +231,7 @@ 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.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 +239,42 @@ 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.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.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.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.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.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.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 +282,14 @@ 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.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.plus(b) }, emptyBinaryFun),
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 +298,7 @@ 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.div(b) }, emptyBinaryFun),
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 +306,14 @@ 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.mod(b) }, emptyBinaryFun),
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.times(b) }, emptyBinaryFun),
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 +321,7 @@ 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.minus(b) }, emptyBinaryFun),
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 +331,14 @@ 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.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.plus(b) }, emptyBinaryFun),
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 +347,7 @@ 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.div(b) }, emptyBinaryFun),
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 +355,14 @@ 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.mod(b) }, emptyBinaryFun),
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.times(b) }, emptyBinaryFun),
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 +370,7 @@ 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.minus(b) }, emptyBinaryFun),
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 +380,42 @@ 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.minus(b) }, emptyBinaryFun),
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.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.plus(b) }, emptyBinaryFun),
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.div(b) }, emptyBinaryFun),
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.mod(b) }, emptyBinaryFun),
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.times(b) }, emptyBinaryFun),
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) }),