[WASM] Initial infrastructure

- New module ":compiler:backend.wasm"
    - Initial compiler infra (driver, phaser, context)
    - Subset of Wasm AST
    - Skeleton of IR -> Wasm AST
    - Wasm AST -> WAT transformer

- Testing infra

- SpiderMonkey jsshell tool

js/js.translator/testData/wasmBox/number/assignmentIntOverflow.kt

@@ -0,0 +1,26 @@
+// EXPECTED_REACHABLE_NODES: 1282
+package foo
+
+fun bigValue() = 0x7FFFFFFC
+
+fun mediumValue() = 0x12345
+
+fun box(): String {
+    var v = bigValue()
+    v += 1
+    if (v != 0x7FFFFFFD) return "fail1"
+
+    v = bigValue()
+    v += 8
+    if (v != -0x7FFFFFFC) return "fail2"
+
+    v = mediumValue()
+    v *= 0x23456
+    if (v != -2112496338) return "fail3"
+
+    v = bigValue()
+    v *= bigValue()
+    if (v != 16) return "fail4"
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/byteAndShortConversions.kt

@@ -0,0 +1,46 @@
+// EXPECTED_REACHABLE_NODES: 1284
+package foo
+
+fun testShortConversions(c: Short): Boolean {
+    if (c.toDouble() != 3.0) {
+        return false
+    }
+    if (c.toFloat() != 3.toFloat()) {
+        return false
+    }
+    if (c.toByte() != 3.toByte()) {
+        return false
+    }
+    if (c.toInt() != 3) {
+        return false
+    }
+    if (c.toShort() != 3.toShort()) {
+        return false
+    }
+    return true
+}
+
+fun testByteConversions(c: Byte): Boolean {
+    if (c.toDouble() != 3.0) {
+        return false
+    }
+    if (c.toFloat() != 3.toFloat()) {
+        return false
+    }
+    if (c.toByte() != 3.toByte()) {
+        return false
+    }
+    if (c.toInt() != 3) {
+        return false
+    }
+    if (c.toShort() != 3.toShort()) {
+        return false
+    }
+    return true
+}
+
+fun box(): String {
+    if (!testShortConversions(3)) return "fail: testShortConversions"
+    if (!testByteConversions(3)) return "fail: testByteConversions"
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/conversionsWithTruncation.kt

@@ -0,0 +1,51 @@
+// EXPECTED_REACHABLE_NODES: 1227
+package foo
+
+// TODO: Floats to ints
+
+fun box(): String {
+
+//    assertEquals(65, 321.0.toByte())
+//    assertEquals(-56, 200.0.toByte())
+//
+//    assertEquals(65, 321.0f.toByte())
+//    assertEquals(-56, 200.0f.toByte())
+
+    assertEquals(65, 321L.toByte())
+    assertEquals(-56, 200L.toByte())
+
+    assertEquals(65, 321.toByte())
+    assertEquals(-56, 200.toByte())
+
+    assertEquals(65, (321.toShort()).toByte())
+    assertEquals(-56, (200.toShort()).toByte())
+
+//    assertEquals(-1, 65535.0.toShort())
+//    assertEquals(-1, 65535.0f.toShort())
+    assertEquals(-1, 65535L.toShort())
+    assertEquals(-1, 65535.toShort())
+
+//    assertEquals(65535, 65535.2.toInt())
+//    assertEquals(23, 23.6f.toInt())
+//    assertEquals(-12, -12.4.toShort())
+//    assertEquals(-12, -12.4.toByte())
+
+    assertEquals('\u0419', (-654311).toChar())
+//    assertEquals('\u0419', (-654311.0).toChar())
+//    assertEquals('\u0419', (-654311.0f).toChar())
+
+    // TODO: Long.toString
+    val longX: Long = 9223372034707292481L
+    //  assertEquals("9223372034707292481", longX.toString())
+
+    assertEquals(-2147483327, longX.toInt())
+    assertEquals(321, longX.toShort())
+    assertEquals(65, longX.toByte())
+    assertEquals('\u0141', longX.toChar())
+
+    val intX: Int = longX.toInt()
+    assertEquals(321, intX.toShort())
+    assertEquals(65, intX.toByte())
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/conversionsWithoutTruncation.kt

@@ -0,0 +1,81 @@
+// EXPECTED_REACHABLE_NODES: 1293
+package foo
+
+//fun testForNumber(numberX: Number) {
+//    assertEquals(true, 65.0 == numberX.toDouble())
+//    assertEquals(true, 65.0f == numberX.toFloat())
+//    assertEquals(true, 65L == numberX.toLong())
+//    assertEquals(true, 65 == numberX.toInt())
+//    assertEquals(true, 65.toShort() == numberX.toShort())
+//    assertEquals(true, 65.toByte() == numberX.toByte())
+//    assertEquals(true, 'A' == numberX.toChar())
+//}
+
+fun box(): String {
+
+// TODO: Number is not supported yet
+//    testForNumber(65.0)
+//    testForNumber(65.0f)
+//    testForNumber(65L)
+//    testForNumber(65)
+//    testForNumber(65.toShort())
+//    testForNumber(65.toByte())
+
+    var doubleX: Double = 65.0
+    assertEquals(true, 65.0 == doubleX.toDouble())
+    assertEquals(true, 65.0f == doubleX.toFloat())
+    // TODO: Float to integer convertions are not supported yet
+    // assertEquals(true, 65L == doubleX.toLong())
+    // assertEquals(true, 65 == doubleX.toInt())
+    // assertEquals(true, 65.toShort() == doubleX.toShort())
+    // assertEquals(true, 65.toByte() == doubleX.toByte())
+    // assertEquals(true, 'A' == doubleX.toChar())
+
+    var floatX: Float = 65.0f
+    assertEquals(true, 65.0 == floatX.toDouble())
+    assertEquals(true, 65.0f == floatX.toFloat())
+    // TODO: Float to integer convertions are not supported yet
+//    assertEquals(true, 65L == floatX.toLong())
+//    assertEquals(true, 65 == floatX.toInt())
+//    assertEquals(true, 65.toShort() == floatX.toShort())
+//    assertEquals(true, 65.toByte() == floatX.toByte())
+//    assertEquals(true, 'A' == floatX.toChar())
+
+    val longX: Long = 65L
+    assertEquals(true, 65.0 == longX.toDouble())
+    assertEquals(true, 65.0f == longX.toFloat())
+    assertEquals(true, 65L == longX.toLong())
+    assertEquals(true, 65 == longX.toInt())
+    assertEquals(true, 65.toShort() == longX.toShort())
+    assertEquals(true, 65.toByte() == longX.toByte())
+    assertEquals(true, 'A' == longX.toChar())
+
+    val intX: Int = 65
+    assertEquals(true, 65.0 == intX.toDouble())
+    assertEquals(true, 65.0f == intX.toFloat())
+    assertEquals(true, 65L == intX.toLong())
+    assertEquals(true, 65 == intX.toInt())
+    assertEquals(true, 65.toShort() == intX.toShort())
+    assertEquals(true, 65.toByte() == intX.toByte())
+    assertEquals(true, 'A' == intX.toChar())
+
+    val shortX: Short = 65.toShort()
+    assertEquals(true, 65.0 == shortX.toDouble())
+    assertEquals(true, 65.0f == shortX.toFloat())
+    assertEquals(true, 65L == shortX.toLong())
+    assertEquals(true, 65 == shortX.toInt())
+    assertEquals(true, 65.toShort() == shortX.toShort())
+    assertEquals(true, 65.toByte() == shortX.toByte())
+    assertEquals(true, 'A' == shortX.toChar())
+
+    val byteX: Byte = 65.toByte()
+    assertEquals(true, 65.0 == byteX.toDouble())
+    assertEquals(true, 65.0f == byteX.toFloat())
+    assertEquals(true, 65L == byteX.toLong())
+    assertEquals(true, 65 == byteX.toInt())
+    assertEquals(true, 65.toShort() == byteX.toShort())
+    assertEquals(true, 65.toByte() == byteX.toByte())
+    assertEquals(true, 'A' == byteX.toChar())
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/division.kt

@@ -0,0 +1,45 @@
+// EXPECTED_REACHABLE_NODES: 1280
+package foo
+
+fun box(): String {
+    if (3 / 4 != 0) {
+        return "fail11"
+    }
+    if (-5 / 4 != -1) {
+        return "fail2"
+    }
+    if ((3.0 / 4.0 - 0.75) > 0.01) {
+        return "fail3"
+    }
+    if ((-10.0 / 4.0 + 2.5) > 0.01) {
+        return "fail44"
+    }
+    val i1: Int = 5
+    val i2: Int = 2
+    if (i1 / i2 != 2) {
+        return "fail55"
+    }
+    val i3: Short = 5
+    val i4: Short = 2
+    if (i3 / i4 != 2) {
+        return "fail6"
+    }
+    val i5: Byte = 5
+    val i6: Byte = 2
+    if (i5 / i6 != 2) {
+        return "fail7"
+    }
+
+    val f1: Double = 5.0
+    val f2: Double = 2.0
+    if ((f1 / f2 - 2.5) > 0.01) {
+        return "fail8"
+    }
+
+    val f3: Float = 5.0.toFloat()
+    val f4: Float = 2.0.toFloat()
+    if ((f3 / f4 - 2.5.toFloat()) > 0.01) {
+        return "fail9"
+    }
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/doubleConversions.kt

@@ -0,0 +1,77 @@
+// EXPECTED_REACHABLE_NODES: 1222
+
+// IGNORE_BACKEND: WASM
+// TODO: Support floating-point to integer conversions
+package foo
+
+fun box(): String {
+    val c: Double = 3.6
+    if (c.toDouble() != 3.6) {
+        return "fail1"
+    }
+    if (c.toFloat() != 3.6.toFloat()) {
+        return "fail2"
+    }
+    if (c.toByte() != 3.toByte()) {
+        return "fail3"
+    }
+    if (c.toInt() != 3) {
+        return "fail4"
+    }
+    if (c.toShort() != 3.toShort()) {
+        return "fail5"
+    }
+
+    val cn: Double = -3.6
+    if (cn.toDouble() != -3.6) {
+        return "fail6"
+    }
+    if (cn.toFloat() != -3.6.toFloat()) {
+        return "fail7"
+    }
+    if (cn.toByte() != (-3).toByte()) {
+        return "fail8"
+    }
+    if (cn.toInt() != -3) {
+        return "fail9"
+    }
+    if (cn.toShort() != (-3).toShort()) {
+        return "fail10"
+    }
+
+    val f: Float = 3.6.toFloat()
+    if (f.toDouble() != 3.6) {
+        return "fail11"
+    }
+    if (f.toFloat() != 3.6.toFloat()) {
+        return "fail12"
+    }
+    if (f.toByte() != 3.toByte()) {
+        return "fail13"
+    }
+    if (f.toInt() != 3) {
+        return "fail14"
+    }
+    if (f.toShort() != 3.toShort()) {
+        return "fail15"
+    }
+
+    val fn: Float = -3.6.toFloat()
+    if (fn.toDouble() != -3.6) {
+        return "fail16"
+    }
+    if (fn.toFloat() != -3.6.toFloat()) {
+        return "fail17"
+    }
+    if (fn.toByte() != (-3).toByte()) {
+        return "fail18"
+    }
+    if (fn.toInt() != -3) {
+        return "fail19"
+    }
+    if (fn.toShort() != (-3).toShort()) {
+        return "fail20"
+    }
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/hashCode.kt

@@ -0,0 +1,23 @@
+// TARGET_BACKEND: WASM
+// EXPECTED_REACHABLE_NODES: 1280
+
+// NOTE: Hash codes are the same as in Native and JVM
+
+fun box(): String {
+    var value = (3).hashCode()
+    if (value != 3) return "fail1"
+
+    value = (3.14).hashCode()
+    if (value != 300063655) return "fail2"
+
+    value = (3.14159).hashCode()
+    if (value != -1340954729) return "fail3"
+
+    value = (1e80).hashCode()
+    if (value != 24774576) return "fail4"
+
+    value = (1e81).hashCode()
+    if (value != -1007271154) return "fail5"
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/hexadecimalConstant.kt

@@ -0,0 +1,7 @@
+// EXPECTED_REACHABLE_NODES: 1219
+package foo
+
+fun box(): String {
+    val i = 0x80000000 + 0x8000000
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/incDecOptimization.kt

@@ -0,0 +1,21 @@
+// EXPECTED_REACHABLE_NODES: 1283
+// CHECK_VARS_COUNT: function=test count=1
+
+// TODO: Support classes
+
+fun test(): String {
+
+    var i = 23
+
+    var x = ++i
+    if (x != 24) return "fail1:"
+
+    i++
+    if (i != 25) return "fail2:"
+
+    // a.i++, used as expression, requires temporary variable
+
+    return "OK"
+}
+
+fun box(): String = test()

js/js.translator/testData/wasmBox/number/intConversions.kt

@@ -0,0 +1,29 @@
+// EXPECTED_REACHABLE_NODES: 1282
+package foo
+
+fun box(): String {
+    val c: Int = 3
+    if (c.toDouble() != 3.0) {
+        return "fail1"
+    }
+    if (c.toFloat() != 3.toFloat()) {
+        return "fail2"
+    }
+    if (c.toByte() != 3.toByte()) {
+        return "fail3"
+    }
+    if (c.toInt() != 3) {
+        return "fail4"
+    }
+    if (c.toShort() != 3.toShort()) {
+        return "fail5"
+    }
+    val c2: Int = -5
+    if (c2.toShort() != (-5).toShort()) {
+        return "fail6"
+    }
+    if (c2.toFloat() != -5.toFloat()) {
+        return "fail7"
+    }
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/intDivFloat.kt

@@ -0,0 +1,20 @@
+// EXPECTED_REACHABLE_NODES: 1284
+// http://youtrack.jetbrains.com/issue/KT-5345
+// KT-5345 (Javascript) Type mismatch on Int / Float division
+// If any of Number operands is floating-point, the result should be float too.
+
+package foo
+
+fun box(): String {
+    assertEquals(0.5f, 1 / 2.0f, "Int / Float")
+
+    assertEquals(0.5, 1 / 2.0, "Int / Double")
+
+    assertEquals(0.5f, 1.toShort() / 2.0f, "Short / Float")
+    assertEquals(0.5, 1.toShort() / 2.0, "Short / Double")
+
+    assertEquals(0.5f, 1.toByte() / 2.0f, "Byte / Float")
+    assertEquals(0.5, 1.toByte() / 2.0, "Byte / Double")
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/intIncDecOverflow.kt

@@ -0,0 +1,25 @@
+// EXPECTED_REACHABLE_NODES: 1282
+package foo
+
+
+fun box(): String {
+    var b: Byte = 0x7F
+    b++
+    if (b.toInt() != -0x80) return "fail1a"
+    b--
+    if (b.toInt() != 0x7F) return "fail1b"
+
+    var s: Short = 0x7FFF
+    s++
+    if (s.toInt() != -0x8000) return "fail2a"
+    s--
+    if (s.toInt() != 0x7FFF) return "fail2b"
+
+    var i: Int = 0x7FFFFFFF
+    i++
+    if (i != -0x80000000) return "fail3a"
+    i--
+    if (i != 0x7FFFFFFF) return "fail3b"
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/intOverflow.kt

@@ -0,0 +1,35 @@
+// EXPECTED_REACHABLE_NODES: 1284
+package foo
+
+fun bigValue() = 0x7FFFFFFC
+
+fun mediumValue() = 0x12345
+
+fun four() = 4
+
+fun box(): String {
+    var v = bigValue() + 1
+    if (v != 0x7FFFFFFD) return "fail1"
+
+    v = bigValue() + 8
+    if (v != -0x7FFFFFFC) return "fail2"
+
+    v = bigValue() + four() + 4
+    if (v != -0x7FFFFFFC) return "fail3"
+
+    v = (bigValue() + four() - 4) shr 1
+    if (v != 0x3FFFFFFE) return "fail3"
+
+    v = mediumValue() * 0x23456
+    if (v != -2112496338) return "fail5"
+
+    v = bigValue() * bigValue()
+    if (v != 16) return "fail6"
+
+    v = -minInt()
+    if (v != -2147483648) return "fail7"
+
+    return "OK"
+}
+
+fun minInt() = -2147483648

js/js.translator/testData/wasmBox/number/kt2342.kt

@@ -0,0 +1,20 @@
+// EXPECTED_REACHABLE_NODES: 1281
+package foo
+
+fun test(a: Int, b: Int, expected: Int): Int {
+    val result = a / b
+    if (expected == result) return 100
+    return 25
+}
+
+fun box(): String {
+    var r = test(10, 3, 3)
+    if (r != 100) return "Fail1"
+
+    r = test(49, 6, 8)
+    if (r != 100) return "Fail 2"
+
+    if (2133 / 3 / 7 / (91 / 5) != 5) return "2133 / 3 / 7 / (91 / 5) != 5"
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/longBinaryOperations.kt

@@ -0,0 +1,57 @@
+// EXPECTED_REACHABLE_NODES: 1230
+package foo
+
+fun fact(n: Int): Long = if (n == 1) 1L else n * fact(n - 1)
+
+// TODO: Support loops
+//fun fib(n: Int): Long {
+//    var a = 0L
+//    var b = 1L
+//    for (i in 2..n) {
+//        var tmp = a
+//        a = b
+//        b = b + tmp
+//    }
+//    return b
+//}
+
+fun box(): String {
+
+    assertEquals(30.0, 10L + 20.0)
+    assertEquals(30.0f, 10L + 20.0f)
+    assertEquals(30L, 10L + 20L)
+    assertEquals(30L, 10L + 20)
+    assertEquals(30L, 10L + 20.toShort())
+    assertEquals(30L, 10L + 20.toByte())
+
+    assertEquals(30.0, 20.0 + 10L)
+    assertEquals(30.0f, 20.0f + 10L)
+    assertEquals(20L, 10 + 10L)
+    assertEquals(20L, 10.toShort() + 10L)
+    assertEquals(20L, 10.toByte() + 10L)
+
+    assertEquals(20L, 30 - 10L)
+
+    assertEquals(100L, 10 * 10L)
+    assertEquals(100.0, 10.0 * 10L)
+
+    assertEquals(100L, 10L * 10)
+    assertEquals(100.0, 10L * 10.0)
+
+    assertEquals(100L, 1000L / 10)
+    assertEquals(100L, 1000 / 10L)
+
+    assertEquals(100.0, 1000L / 10.0)
+    assertEquals(100.0, 1000.0 / 10L)
+
+    assertEquals(2L, 100L % 7)
+    assertEquals(2L, 100 % 7L)
+
+    assertEquals(2432902008176640000L, fact(20))
+
+// TODO: Support loops
+//    assertEquals(12586269025L, fib(50))
+//    assertEquals(7540113804746346429L, fib(92))
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/longBitOperations.kt

@@ -0,0 +1,24 @@
+// EXPECTED_REACHABLE_NODES: 1228
+package foo
+
+fun box(): String {
+
+    assertEquals(65536L, 1L shl 16)
+    assertEquals(1L, 65536L shr 16)
+
+    assertEquals(-1L, -1L shr 48)
+    assertEquals(65535L, -1L ushr 48)
+
+    assertEquals(-1L, 0L.inv())
+
+    assertEquals(0b1000L, 0b1100L and 0b1010L)
+    assertEquals(0b1110L, 0b1100L or 0b1010L)
+    assertEquals(0b0110L, 0b1100L xor 0b1010L)
+
+    assertEquals(0xab88ac0021L, 0xabcdef0123L and 0xefaabcdef1L)
+    assertEquals(0xefefffdff3L, 0xabcdef0123L or 0xefaabcdef1L)
+    assertEquals(0x446753dfd2L, 0xabcdef0123L xor 0xefaabcdef1L)
+    assertEquals(-737894400292, 0xabcdef0123L.inv())
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/longCompareToIntrinsic.kt

@@ -0,0 +1,41 @@
+// EXPECTED_REACHABLE_NODES: 1226
+package foo
+
+fun box(): String {
+
+    assertEquals(true, 10.0 < 20L, "Double.compareTo(Long)")
+    assertEquals(true, 10.0 < 7540113804746346429L, "Double.compareTo(Long)")
+
+    assertEquals(true, 10.0f < 20L, "Float.compareTo(Long)")
+    assertEquals(true, 10.0f < 7540113804746346429L, "Float.compareTo(Long)")
+
+    assertEquals(true, 10L < 20L, "Long.compareTo(Long)")
+    assertEquals(true, 10 < 20L, "Int.compareTo(Long)")
+    assertEquals(true, 10 < 7540113804746346429L, "Int.compareTo(Long)")
+
+    assertEquals(true, 10.toShort() < 20L, "Short.compareTo(Long)")
+    assertEquals(true, 10.toShort() < 7540113804746346429L, "Short.compareTo(Long)")
+    assertEquals(true, 10.toByte() < 20L, "Byte.compareTo(Long)")
+    assertEquals(true, 10.toByte() < 7540113804746346429L, "Byte.compareTo(Long)")
+
+    assertEquals(true, 10L < 20.0, "Long.compareTo(Double)")
+    assertEquals(false, 7540113804746346429L < 20.0, "Long.compareTo(Double)")
+
+    assertEquals(true, 10L < 20.0f, "Long.compareTo(Float)")
+    assertEquals(true, 7540113804746346429L > 20.0f, "Long.compareTo(Float)")
+    assertEquals(false, 7540113804746346429L < 20.0f, "Long.compareTo(Float)")
+
+    assertEquals(true, 10L < 20, "Long.compareTo(Int)")
+    assertEquals(true, 7540113804746346429L > 20, "Long.compareTo(Int)")
+    assertEquals(false, 7540113804746346429L < 20, "Long.compareTo(Int)")
+
+    assertEquals(true, 10L < 20.toShort(), "Long.compareTo(Short)")
+    assertEquals(true, 7540113804746346429L > 20.toShort(), "Long.compareTo(Short)")
+    assertEquals(false, 7540113804746346429L < 20.toShort(), "Long.compareTo(Short)")
+
+    assertEquals(true, 10L < 20.toByte(), "Long.compareTo(Byte)")
+    assertEquals(true, 7540113804746346429L > 20.toByte(), "Long.compareTo(Byte)")
+    assertEquals(false, 7540113804746346429L < 20.toByte(), "Long.compareTo(Byte)")
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/longEqualsIntrinsic.kt

@@ -0,0 +1,45 @@
+// EXPECTED_REACHABLE_NODES: 1284
+package foo
+
+// WASM: TODO: Nullable types, Number, Any
+
+fun box(): String {
+    assertEquals(true, 10L == 10L, "Long == Long")
+    assertEquals(true, 10L != 11L, "Long != Long")
+
+//    val x1: Long? = 10L
+//    val x2: Long? = 10L
+//    assertEquals(false, x1 == null, "Long? == null")
+//    assertEquals(false, null == x1, "null == Long?")
+//    assertEquals(true, x1 == 10L, "Long? == Long")
+//    assertEquals(true, 10L == x1, "Long == Long?")
+//    assertEquals(true, x1 == x2, "Long? == Long?")
+
+//    val x3: Long? = null
+//    val x4: Long? = null
+//    assertEquals(true, x3 == null, "Long?(null) == null")
+//    assertEquals(true, null == x3, "null == Long?(null)")
+//    assertEquals(false, x3 == 10L, "Long?(null) == Long")
+//    assertEquals(false, 10L == x3, "Long == Long?(null)")
+//    assertEquals(false, x3 == x1, "Long?(null) == Long?")
+//    assertEquals(true, x3 == x4, "Long?(null) == Long?(null)")
+
+//    val number1: Number = 10L
+//    val number2: Number = 10L
+//    assertEquals(true, number1 == number2, "Number == Number")
+//    assertEquals(true, number1 == 10L, "Number == Long")
+//    assertEquals(true, number1 != 11L, "Number != Long")
+//    assertEquals(true, 10L == number1, "Long == Number")
+//    assertEquals(true, 11L != number1, "Long != Number")
+//
+//    val y1: Any = 10L
+//    var y2: Any = 10
+//    var y3: Any? = null
+//    assertEquals(true, y1 == 10L, "Any == Long")
+//    assertEquals(true, 10L == y1, "Long == Any 1")
+//    assertEquals(false, 10L == y2, "Long == Any 2")
+//    assertEquals(false, 10L == y3, "Long == Any?(null)")
+//    assertEquals(true, x3 == y3, "Long?(null) == Any?(null)")
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/longHashCode.kt

@@ -0,0 +1,18 @@
+// EXPECTED_REACHABLE_NODES: 1284
+package foo
+
+fun box(): String {
+    var l1: Long = 0x12344478935690
+    var l2: Long = 0x12344478935698
+    var diff: Long = l2 - l1
+    l1 += (diff / 2)
+    l2 -= (diff / 2)
+
+    assertEquals(l1, l2, "When L1 == L2")
+    assertEquals(l1.hashCode(), l2.hashCode(), "L1.hashCode() == L2.hashCode()")
+
+//    var l3: Any = l2
+//    assertEquals(l1.hashCode(), l3.hashCode(), "Any(Long).hashCode()")
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/longUnaryOperations.kt

@@ -0,0 +1,32 @@
+// EXPECTED_REACHABLE_NODES: 1225
+package foo
+
+fun box(): String {
+
+    var x: Long = 2L
+    x++
+    assertEquals(3L, x)
+    ++x
+    assertEquals(4L, x)
+
+    var y = x++
+    assertEquals(4L, y)
+    assertEquals(5L, x)
+
+    y = ++x
+    assertEquals(6L, y)
+    assertEquals(6L, x)
+
+    x--
+    assertEquals(5L, x)
+    --x
+    assertEquals(4L, x)
+
+    y = +x
+    assertEquals(4L, y)
+
+    y = -x
+    assertEquals(-4L, y)
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/mixedTypesOverflow.kt

@@ -0,0 +1,34 @@
+// EXPECTED_REACHABLE_NODES: 1284
+// IGNORE_BACKEND: JS
+package foo
+
+// TODO(WASM) Companions are not supported yet
+
+fun box(): String {
+    val byteOne = 1.toByte()
+    val shortOne = 1.toShort()
+    var v: Int
+
+    v = maxInt() + byteOne
+    if (v != minInt()) return "fail1"
+
+    v = minInt() - byteOne
+    if (v != maxInt()) return "fail2"
+
+    v = maxInt() + shortOne
+    if (v != minInt()) return "fail3"
+
+    v = minInt() - shortOne
+    if (v != maxInt()) return "fail4"
+
+    v = maxInt() * 127 // Byte.MAX_VALUE
+    if (v != 2147483521) return "fail5"
+
+    v = maxInt() * 32767 // Short.MAX_VALUE
+    if (v != 2147450881) return "fail6"
+
+    return "OK"
+}
+
+fun minInt() = -2147483648 // Int.MIN_VALUE
+fun maxInt() = 2147483647 // Int.MAX_VALUE

js/js.translator/testData/wasmBox/number/numberCompareTo.kt

@@ -0,0 +1,127 @@
+// EXPECTED_REACHABLE_NODES: 1289
+package foo
+
+// TODO: Wasm global initialization is not supported
+//var global: String = ""
+//
+//fun id(s: String, value: Int): Int {
+//    global += s
+//    return value
+//}
+
+fun box(): String {
+
+    assertEquals(-1, 1.compareTo(2))
+    // assertEquals(-1, (1 as Comparable<Int>).compareTo(2))
+
+    assertEquals(-1, 1.compareTo(2L))
+    assertEquals(-1, 1.compareTo(2L))
+    assertEquals(-1, 1.compareTo(7540113804746346429L))
+    assertEquals(-1, 1.compareTo(2.toShort()))
+    assertEquals(-1, 1.compareTo(2.toByte()))
+    assertEquals(-1, 1.compareTo(2.0))
+    assertEquals(-1, 1.compareTo(2.0f))
+
+    assertEquals(1, 10.compareTo(2L))
+    assertEquals(1, 10.compareTo(2))
+    assertEquals(1, 10.compareTo(2.toShort()))
+    assertEquals(1, 10.compareTo(2.toByte()))
+    assertEquals(1, 10.compareTo(2.0))
+    assertEquals(1, 10.compareTo(2.0f))
+
+    assertEquals(0, 2.compareTo(2L))
+    assertEquals(0, 2.compareTo(2))
+    assertEquals(0, 2.compareTo(2.toShort()))
+    assertEquals(0, 2.compareTo(2.toByte()))
+    assertEquals(0, 2.compareTo(2.0))
+    assertEquals(0, 2.compareTo(2.0f))
+
+    assertEquals(-1, 1.toShort().compareTo(2L))
+    assertEquals(-1, 1.toShort().compareTo(7540113804746346429L))
+    assertEquals(-1, 1.toShort().compareTo(2))
+    assertEquals(-1, 1.toShort().compareTo(2.toShort()))
+    // assertEquals(-1, (1.toShort() as Comparable<Short>).compareTo(2.toShort()))
+    assertEquals(-1, 1.toShort().compareTo(2.toByte()))
+    assertEquals(-1, 1.toShort().compareTo(2.0))
+    assertEquals(-1, 1.toShort().compareTo(2.0f))
+
+    assertEquals(1, 10.toByte().compareTo(2L))
+    assertEquals(-1, 10.toByte().compareTo(7540113804746346429L))
+    assertEquals(1, 10.toByte().compareTo(2))
+    assertEquals(1, 10.toByte().compareTo(2.toShort()))
+    assertEquals(1, 10.toByte().compareTo(2.toByte()))
+    // assertEquals(1, (10.toByte() as Comparable<Byte>).compareTo(2.toByte()))
+    assertEquals(1, 10.toByte().compareTo(2.0))
+    assertEquals(1, 10.toByte().compareTo(2.0f))
+
+    assertEquals(0, 2.0.compareTo(2L))
+    assertEquals(-1, 2.0.compareTo(7540113804746346429L))
+    assertEquals(0, 2.0.compareTo(2))
+    assertEquals(0, 2.0.compareTo(2.toShort()))
+    assertEquals(0, 2.0.compareTo(2.toByte()))
+    assertEquals(0, 2.0.compareTo(2.0))
+    // assertEquals(0, (2.0 as Comparable<Double>).compareTo(2.0))
+    assertEquals(0, 2.0.compareTo(2.0f))
+
+    assertEquals(1, 3.0f.compareTo(2L))
+    assertEquals(-1, 3.0f.compareTo(7540113804746346429L))
+    assertEquals(1, 3.0f.compareTo(2))
+    assertEquals(1, 3.0f.compareTo(2.toShort()))
+    assertEquals(1, 3.0f.compareTo(2.toByte()))
+    assertEquals(1, 3.0f.compareTo(2.0))
+    assertEquals(1, 3.0f.compareTo(2.0f))
+    // assertEquals(1, (3.0f as Comparable<Float>).compareTo(2.0f))
+
+    assertEquals(1, 10L.compareTo(2L))
+    assertEquals(-1, 10L.compareTo(7540113804746346429L))
+    // assertEquals(1, (10L as Comparable<Long>).compareTo(2L))
+    assertEquals(1, 10L.compareTo(2))
+    assertEquals(1, 10L.compareTo(2.toShort()))
+    assertEquals(1, 10L.compareTo(2.toByte()))
+    assertEquals(1, 10L.compareTo(2.0))
+    assertEquals(1, 10L.compareTo(2.0f))
+
+    assertEquals(0, 'A'.compareTo('A'))
+
+    assertEquals(-1, 1L.compareTo(2L))
+    assertEquals(-1, 1L.compareTo(2))
+    assertEquals(-1, 1L.compareTo(2.toShort()))
+    assertEquals(-1, 1L.compareTo(2.toByte()))
+    assertEquals(-1, 1L.compareTo(2.0))
+    assertEquals(-1, 1L.compareTo(2.0f))
+
+    assertEquals(0, 7540113804746346429L.compareTo(7540113804746346429L))
+    assertEquals(1, 7540113804746346429L.compareTo(2L))
+    assertEquals(0, 2L.compareTo(2L))
+    assertEquals(0, 2L.compareTo(2))
+    assertEquals(0, 2L.compareTo(2.toShort()))
+    assertEquals(0, 2L.compareTo(2.toByte()))
+    assertEquals(0, 2L.compareTo(2.0))
+    assertEquals(0, 2L.compareTo(2.0f))
+
+    assertEquals(1, 10L.compareTo(2L))
+    assertEquals(1, 10L.compareTo(2))
+    assertEquals(1, 10L.compareTo(2.toShort()))
+    assertEquals(1, 10L.compareTo(2.toByte()))
+    assertEquals(1, 10L.compareTo(2.0))
+    assertEquals(1, 10L.compareTo(2.0f))
+
+    assertEquals(-1, 1L.compareTo(2L))
+    assertEquals(-1, 1L.compareTo(2))
+    assertEquals(-1, 1L.compareTo(2.toShort()))
+    assertEquals(-1, 1L.compareTo(2.toByte()))
+    assertEquals(-1, 1L.compareTo(2.0))
+    assertEquals(-1, 1L.compareTo(2.0f))
+
+    assertEquals(0, 2L.compareTo(2L))
+    assertEquals(0, 2L.compareTo(2))
+    assertEquals(0, 2L.compareTo(2.toShort()))
+    assertEquals(0, 2L.compareTo(2.toByte()))
+    assertEquals(0, 2L.compareTo(2.0))
+    assertEquals(0, 2L.compareTo(2.0f))
+
+//    assertEquals(1, id("A", 10).compareTo(id("B", 5)))
+//    assertEquals("AB", global)
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/numberConversions.kt

@@ -0,0 +1,91 @@
+// EXPECTED_REACHABLE_NODES: 1289
+package foo
+
+fun testIntegerConversions(c: Byte): Boolean {
+    if (c.toDouble() != 3.0) {
+        return false
+    }
+    if (c.toFloat() != 3.toFloat()) {
+        return false
+    }
+    if (c.toByte() != 3.toByte()) {
+        return false
+    }
+    if (c.toInt() != 3) {
+        return false
+    }
+    if (c.toShort() != 3.toShort()) {
+        return false
+    }
+    return true
+}
+
+fun testIntegerConversions(c: Short): Boolean {
+    if (c.toDouble() != 3.0) {
+        return false
+    }
+    if (c.toFloat() != 3.toFloat()) {
+        return false
+    }
+    if (c.toByte() != 3.toByte()) {
+        return false
+    }
+    if (c.toInt() != 3) {
+        return false
+    }
+    if (c.toShort() != 3.toShort()) {
+        return false
+    }
+    return true
+}
+
+fun testIntegerConversions(c: Int): Boolean {
+    if (c.toDouble() != 3.0) {
+        return false
+    }
+    if (c.toFloat() != 3.toFloat()) {
+        return false
+    }
+    if (c.toByte() != 3.toByte()) {
+        return false
+    }
+    if (c.toInt() != 3) {
+        return false
+    }
+    if (c.toShort() != 3.toShort()) {
+        return false
+    }
+    return true
+}
+
+
+fun testFloatingPointConversions(c: Float): Boolean {
+// This is FALSE on JVM
+//    if (c.toDouble() != 3.6) {
+//        return false
+//    }
+    if (c.toFloat() != 3.6.toFloat()) {
+        return false
+    }
+    return true
+}
+
+fun testFloatingPointConversions(c: Double): Boolean {
+    if (c.toDouble() != 3.6) {
+        return false
+    }
+    if (c.toFloat() != 3.6.toFloat()) {
+        return false
+    }
+    return true
+}
+
+
+fun box(): String {
+    if (!testIntegerConversions(3)) return "fail: testIntegerConversions1"
+    if (!testFloatingPointConversions(3.6)) return "fail: testFloatingPointConversions1"
+    if (!testFloatingPointConversions(3.6.toFloat())) return "fail: testFloaintPointConversions2"
+    if (!testIntegerConversions(3.toByte())) return "fail: testIntegerConversions2"
+    if (!testIntegerConversions(3.toShort())) return "fail: testIntegerConversions3"
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/numberEquals.kt

@@ -0,0 +1,55 @@
+// !LANGUAGE: +ProperIeee754Comparisons
+package foo
+
+
+//fun testNullable(): String {
+//    val undefined: Double? = js("undefined")
+//    val doubleNull: Double? = null
+//
+//    val plusZero: Double? = +0.0
+//    val minusZero: Double? = -0.0
+//
+//    if ((+0.0).equals(minusZero)) return "Total order fail"
+//    if (plusZero != minusZero) return "IEEE 754 equals fail"
+//
+//    if (plusZero == doubleNull) return "+0.0 != null fail"
+//    if (plusZero == undefined) return "+0.0 != undefined fail"
+//
+//    if (undefined != doubleNull) return "undefined == null fail"
+//    if (undefined != undefined) return "undefined = undefined fail"
+//    if (doubleNull != doubleNull) return "doubleNull = doubleNull fail"
+//
+//    // Double == Float
+//    val plusZeroAny: Any? = +0.0
+//    val minusZeroAny: Any? = -0.0f
+//
+//    if (plusZeroAny is Double && minusZeroAny is Float) {
+//        if  (plusZeroAny != minusZeroAny) return "IEEE 754 quals fail 2"
+//    }
+//
+//    return "OK"
+//}
+
+fun box(): String {
+    val plusZero: Double = +0.0
+    val minusZero: Double = -0.0
+
+    if (plusZero.equals(minusZero)) return "Total order fail"
+    if (plusZero != minusZero) return "IEEE 754 equals fail"
+
+    val plusZeroFloat: Float = +0.0f
+    val minusZeroFloat: Float = -0.0f
+
+    if (plusZeroFloat.equals(minusZeroFloat)) return "Total order fail 2"
+    if (plusZeroFloat != minusZeroFloat) return "IEEE 754 equals fail 2"
+
+//    if ((plusZero as Any) == (minusZero as Any)) return "Total order fail 4"
+//    if ((plusZeroFloat as Any) == (minusZeroFloat as Any)) return "Total order fail 5"
+//    if (plusZero == (minusZero as Any)) return "Total order fail 6"
+
+//    val nullableRes = testNullable()
+//    if (nullableRes != "OK")
+//        return "Nullable" + nullableRes
+
+    return "OK"
+}

js/js.translator/testData/wasmBox/number/numberIncDec.kt

@@ -0,0 +1,17 @@
+// EXPECTED_REACHABLE_NODES: 1282
+package foo
+
+fun box(): String {
+
+    assertEquals(100.inc(), 101)
+    assertEquals(100.dec(), 99)
+
+    var x = 100
+    assertEquals(x.inc(), 101)
+    assertEquals(x, 100)
+
+    assertEquals(x.dec(), 99)
+    assertEquals(x, 100)
+
+    return "OK"
+}