Reorganize stdlib-js sources specific to the current JS backend

Move kotlin-stdlib-js project and the sources specific to the current backend to 'stdlib/js-v1' directory,
but leave sources that can be shared with the new IR backend in the common 'stdlib/js' location
with exception for 'stdlib/js/src/generated', which is used exclusively for current backend.
This simplifies sourceset configuration when building stdlib with the new backend.

libraries/stdlib/js-ir/runtime/DefaultConstructorMarker.kt

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+internal object DefaultConstructorMarker

libraries/stdlib/js-ir/runtime/arrays.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+import withType
+
+external fun <T> Array(size: Int): Array<T>
+
+internal fun <T> fillArrayVal(array: Array<T>, initValue: T): Array<T> {
+    for (i in 0..array.size - 1) {
+        array[i] = initValue
+    }
+    return array
+}
+
+internal inline fun <T> arrayWithFun(size: Int, init: (Int) -> T) = fillArrayFun(Array<T>(size), init)
+
+internal inline fun <T> fillArrayFun(array: dynamic, init: (Int) -> T): Array<T> {
+    val result = array.unsafeCast<Array<T>>()
+    var i = 0
+    while (i != result.size) {
+        result[i] = init(i)
+        ++i
+    }
+    return result
+}
+
+internal fun booleanArray(size: Int): BooleanArray = withType("BooleanArray", fillArrayVal(Array<Boolean>(size), false)).unsafeCast<BooleanArray>()
+
+internal fun booleanArrayOf(arr: Array<Boolean>): BooleanArray = withType("BooleanArray", arr.asDynamic().slice()).unsafeCast<BooleanArray>()
+
+internal fun charArray(size: Int): CharArray = withType("CharArray", fillArrayVal(Array<Int>(size), 0)).unsafeCast<CharArray>()
+
+internal fun charArrayOf(arr: Array<Char>): CharArray = withType("CharArray", arr.asDynamic().slice()).unsafeCast<CharArray>()
+
+internal fun longArray(size: Int): LongArray = withType("LongArray", fillArrayVal(Array<Long>(size), 0L)).unsafeCast<LongArray>()
+
+internal fun longArrayOf(arr: Array<Long>): LongArray = withType("LongArray", arr.asDynamic().slice()).unsafeCast<LongArray>()
+
+internal fun <T> arrayIterator(array: Array<T>) = object : Iterator<T> {
+    var index = 0
+    override fun hasNext() = index != array.size
+    override fun next() = if (index != array.size) array[index++] else throw NoSuchElementException("$index")
+}
+
+internal fun booleanArrayIterator(array: BooleanArray) = object : BooleanIterator() {
+    var index = 0
+    override fun hasNext() = index != array.size
+    override fun nextBoolean() = if (index != array.size) array[index++] else throw NoSuchElementException("$index")
+}
+
+internal fun byteArrayIterator(array: ByteArray) = object : ByteIterator() {
+    var index = 0
+    override fun hasNext() = index != array.size
+    override fun nextByte() = if (index != array.size) array[index++] else throw NoSuchElementException("$index")
+}
+
+internal fun shortArrayIterator(array: ShortArray) = object : ShortIterator() {
+    var index = 0
+    override fun hasNext() = index != array.size
+    override fun nextShort() = if (index != array.size) array[index++] else throw NoSuchElementException("$index")
+}
+
+internal fun charArrayIterator(array: CharArray) = object : CharIterator() {
+    var index = 0
+    override fun hasNext() = index != array.size
+    override fun nextChar() = if (index != array.size) array[index++] else throw NoSuchElementException("$index")
+}
+
+internal fun intArrayIterator(array: IntArray) = object : IntIterator() {
+    var index = 0
+    override fun hasNext() = index != array.size
+    override fun nextInt() = if (index != array.size) array[index++] else throw NoSuchElementException("$index")
+}
+
+internal fun floatArrayIterator(array: FloatArray) = object : FloatIterator() {
+    var index = 0
+    override fun hasNext() = index != array.size
+    override fun nextFloat() = if (index != array.size) array[index++] else throw NoSuchElementException("$index")
+}
+
+internal fun doubleArrayIterator(array: DoubleArray) = object : DoubleIterator() {
+    var index = 0
+    override fun hasNext() = index != array.size
+    override fun nextDouble() = if (index != array.size) array[index++] else throw NoSuchElementException("$index")
+}
+
+internal fun longArrayIterator(array: LongArray) = object : LongIterator() {
+    var index = 0
+    override fun hasNext() = index != array.size
+    override fun nextLong() = if (index != array.size) array[index++] else throw NoSuchElementException("$index")
+}

libraries/stdlib/js-ir/runtime/charSequence.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+internal annotation class DoNotIntrinsify
+
+@PublishedApi
+@DoNotIntrinsify
+internal fun charSequenceGet(a: CharSequence, index: Int): Char {
+    return if (isString(a)) {
+        Char(a.asDynamic().charCodeAt(index).unsafeCast<Int>())
+    } else {
+        a[index]
+    }
+}
+
+@PublishedApi
+@DoNotIntrinsify
+internal fun charSequenceLength(a: CharSequence): Int {
+    return if (isString(a)) {
+        js("a.length").unsafeCast<Int>()
+    } else {
+        a.length
+    }
+}
+
+@PublishedApi
+@DoNotIntrinsify
+internal fun charSequenceSubSequence(a: CharSequence, startIndex: Int, endIndex: Int): CharSequence {
+    return if (isString(a)) {
+        a.asDynamic().substring(startIndex, endIndex).unsafeCast<String>()
+    } else {
+        a.subSequence(startIndex, endIndex)
+    }
+}
+
+// Keeping this function as separate non-inline to intrincify `is` operator
+internal fun isString(a: CharSequence) = a is String

libraries/stdlib/js-ir/runtime/collectionsHacks.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.collections
+
+import kotlin.js.*
+
+// Copied from libraries/stdlib/js/src/kotlin/collections/utils.kt
+// Current inliner doesn't rename symbols inside `js` fun
+@Suppress("UNUSED_PARAMETER")
+internal fun deleteProperty(obj: Any, property: Any) {
+    js("delete obj[property]")
+}
+
+internal fun arrayToString(array: Array<*>) = array.joinToString(", ", "[", "]") { toString(it) }
+
+internal fun <T> Array<out T>.contentDeepHashCodeInternal(): Int {
+    var result = 1
+    for (element in this) {
+        val elementHash = when {
+            element == null -> 0
+            isArrayish(element) -> (element.unsafeCast<Array<*>>()).contentDeepHashCodeInternal()
+
+            element is UByteArray   -> element.contentHashCode()
+            element is UShortArray  -> element.contentHashCode()
+            element is UIntArray    -> element.contentHashCode()
+            element is ULongArray   -> element.contentHashCode()
+
+            else                    -> element.hashCode()
+        }
+
+        result = 31 * result + elementHash
+    }
+    return result
+}
+
+internal fun <T> T.contentEqualsInternal(other: T): Boolean {
+    val a = this.asDynamic()
+    val b = other.asDynamic()
+
+    if (a === b) return true
+
+    if (!isArrayish(b) || a.length != b.length) return false
+
+    for (i in 0 until a.length) {
+        if (a[i] != b[i]) {
+            return false
+        }
+    }
+    return true
+}
+
+internal fun <T> T.contentHashCodeInternal(): Int {
+    val a = this.asDynamic()
+    var result = 1
+
+    for (i in 0 until a.length) {
+        result = result * 31 + hashCode(a[i])
+    }
+
+    return result
+}

libraries/stdlib/js-ir/runtime/compareTo.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+
+// Adopted from misc.js
+
+fun compareTo(a: dynamic, b: dynamic): Int = when (typeOf(a)) {
+    "number" -> when {
+        typeOf(b) == "number" ->
+            doubleCompareTo(a, b)
+        b is Long ->
+            doubleCompareTo(a, b.toDouble())
+        else ->
+            primitiveCompareTo(a, b)
+    }
+
+    "string", "boolean" -> primitiveCompareTo(a, b)
+
+    else -> compareToDoNotIntrinsicify(a, b)
+}
+
+@DoNotIntrinsify
+private fun <T : Comparable<T>> compareToDoNotIntrinsicify(a: Comparable<T>, b: T) =
+    a.compareTo(b)
+
+fun primitiveCompareTo(a: dynamic, b: dynamic): Int =
+    js("a < b ? -1 : a > b ? 1 : 0").unsafeCast<Int>()
+
+fun doubleCompareTo(a: dynamic, b: dynamic): Int =
+    js("""
+    if (a < b) return -1;
+    if (a > b) return 1;
+
+    if (a === b) {
+        if (a !== 0) return 0;
+
+        var ia = 1 / a;
+        return ia === 1 / b ? 0 : (ia < 0 ? -1 : 1);
+    }
+
+    return a !== a ? (b !== b ? 0 : 1) : -1
+    """).unsafeCast<Int>()

libraries/stdlib/js-ir/runtime/core.kt

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+fun equals(obj1: dynamic, obj2: dynamic): Boolean {
+    if (obj1 == null) {
+        return obj2 == null
+    }
+    if (obj2 == null) {
+        return false
+    }
+
+    return js("""
+    if (typeof obj1 === "object" && typeof obj1.equals === "function") {
+        return obj1.equals(obj2);
+    }
+
+    if (obj1 !== obj1) {
+        return obj2 !== obj2;
+    }
+
+    if (typeof obj1 === "number" && typeof obj2 === "number") {
+        return obj1 === obj2 && (obj1 !== 0 || 1 / obj1 === 1 / obj2)
+    }
+    return obj1 === obj2;
+    """).unsafeCast<Boolean>()
+}
+
+fun toString(o: dynamic): String = when {
+    js("o == null").unsafeCast<Boolean>() -> "null"
+    isArrayish(o) -> "[...]"
+    else -> js("o.toString()").unsafeCast<String>()
+}
+
+fun anyToString(o: dynamic): String = js("Object.prototype.toString.call(o)")
+
+fun hashCode(obj: dynamic): Int {
+    if (obj == null)
+        return 0
+
+    return when (typeOf(obj)) {
+        "object" ->  if ("function" === js("typeof obj.hashCode")) js("obj.hashCode()") else getObjectHashCode(obj)
+        "function" -> getObjectHashCode(obj)
+        "number" -> getNumberHashCode(obj)
+        "boolean" -> if(obj.unsafeCast<Boolean>()) 1 else 0
+        else -> getStringHashCode(js("String(obj)"))
+    }
+}
+
+fun getObjectHashCode(obj: dynamic) = js("""
+    var POW_2_32 = 4294967296;
+    var OBJECT_HASH_CODE_PROPERTY_NAME = "kotlinHashCodeValue${"$"}";
+
+    if (!(OBJECT_HASH_CODE_PROPERTY_NAME in obj)) {
+        var hash = (Math.random() * POW_2_32) | 0; // Make 32-bit singed integer.
+        Object.defineProperty(obj, OBJECT_HASH_CODE_PROPERTY_NAME, { value: hash, enumerable: false });
+    }
+    return obj[OBJECT_HASH_CODE_PROPERTY_NAME];
+""").unsafeCast<Int>();
+
+fun getStringHashCode(str: String): Int {
+    var hash = 0
+    val length: Int = js("str.length")  // TODO: Implement WString.length
+    for (i in 0..length-1) {
+        val code: Int = js("str.charCodeAt(i)")
+        hash = hash * 31 + code
+    }
+    return hash
+}
+
+fun getNumberHashCode(obj: dynamic) = js("""
+    if ((obj | 0) === obj) {
+        return obj | 0;
+    }
+    else {
+        var byteBuffer = new ArrayBuffer (8);
+        var bufFloat64 = new Float64Array (byteBuffer);
+        var bufInt32 = new Int32Array (byteBuffer);
+
+        bufFloat64[0] = obj;
+        return (bufInt32[1] * 31 | 0)+bufInt32[0] | 0;
+    }
+""").unsafeCast<Int>()
+
+fun identityHashCode(obj: dynamic): Int = getObjectHashCode(obj)
+
+
+@JsName("captureStack")
+internal fun captureStack(instance: Throwable) {
+    if (js("Error").captureStackTrace) {
+        js("Error").captureStackTrace(instance, instance::class.js);
+    } else {
+        instance.asDynamic().stack = js("new Error()").stack;
+    }
+}
+
+@JsName("newThrowable")
+internal fun newThrowable(message: String?, cause: Throwable?): Throwable {
+    val throwable = js("new Error()")
+    throwable.message = if (message == null) {
+        if (cause != null) js("cause.toString()") else null
+    } else {
+        message
+    }
+    throwable.cause = cause
+    throwable.name = "Throwable"
+    return throwable
+}
+
+internal fun <T, R> boxIntrinsic(x: T): R = error("Should be lowered")
+internal fun <T, R> unboxIntrinsic(x: T): R = error("Should be lowered")

libraries/stdlib/js-ir/runtime/coroutineInternalJS.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+
+package kotlin.js
+
+import kotlin.js.coroutineAliases.*
+
+
+@PublishedApi
+internal fun <T> getContinuation(): ContinuationAlias<T> { throw Exception("Implemented as intrinsic") }
+// Do we really need this intrinsic in JS?
+
+@PublishedApi
+internal suspend fun <T> returnIfSuspended(@Suppress("UNUSED_PARAMETER") argument: Any?): T {
+    throw Exception("Implemented as intrinsic")
+}
+
+@PublishedApi
+internal fun <T> interceptContinuationIfNeeded(
+    context: CoroutineContextAlias,
+    continuation: ContinuationAlias<T>
+) = context[ContinuationInterceptorAlias]?.interceptContinuation(continuation) ?: continuation
+
+
+@SinceKotlin("1.2")
+@PublishedApi
+internal suspend fun getCoroutineContext(): CoroutineContextAlias = getContinuation<Any?>().context
+
+// TODO: remove `JS` suffix oncec `NameGenerator` is implemented
+@PublishedApi
+internal suspend fun <T> suspendCoroutineUninterceptedOrReturnJS(block: (ContinuationAlias<T>) -> Any?): T =
+    returnIfSuspended<T>(block(getContinuation<T>()))
+
+

libraries/stdlib/js-ir/runtime/hacks.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin
+
+@PublishedApi
+internal fun throwUninitializedPropertyAccessException(name: String): Nothing =
+    throw UninitializedPropertyAccessException("lateinit property $name has not been initialized")
+
+internal fun noWhenBranchMatchedException(): Nothing = throw NoWhenBranchMatchedException()
+
+
+fun THROW_ISE() {
+    throw IllegalStateException()
+}
+fun THROW_CCE() {
+    throw ClassCastException()
+}
+fun THROW_NPE() {
+    throw NullPointerException()
+}

libraries/stdlib/js-ir/runtime/irTestsJvmAnnotations.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.jvm
+
+import kotlin.annotation.AnnotationTarget.*
+
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CONSTRUCTOR)
+@Retention(AnnotationRetention.SOURCE)
+internal annotation class JvmOverloads
+
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.FILE)
+@Retention(AnnotationRetention.SOURCE)
+@MustBeDocumented
+internal annotation class JvmName(public val name: String)
+
+@Target(AnnotationTarget.FILE)
+@Retention(AnnotationRetention.SOURCE)
+@MustBeDocumented
+internal annotation class JvmMultifileClass
+
+@Target(AnnotationTarget.FILE)
+@Retention(AnnotationRetention.SOURCE)
+@MustBeDocumented
+internal annotation class JvmPackageName(val name: String)
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.SOURCE)
+@MustBeDocumented
+internal annotation class JvmField
+
+
+@Target(FIELD)
+@MustBeDocumented
+@OptionalExpectation
+public expect annotation class Volatile()
+
+@Target(FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER)
+@MustBeDocumented
+@OptionalExpectation
+public expect annotation class Synchronized()

libraries/stdlib/js-ir/runtime/irTestsOptionalExpectation.kt

@@ -0,0 +1,7 @@
+package kotlin
+
+
+annotation class OptionalExpectationDummy()
+
+// in order to make the compiler ignore semantics of the real OptionalExpectation
+typealias OptionalExpectation = OptionalExpectationDummy

libraries/stdlib/js-ir/runtime/kotlinHacks.kt

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+
+// File is a copy of stdlib/js/src/kotlin/kotlin.kt
+// TODO: Compile arrayPlusCollection
+// TODO: implement a copy of jsIsType for both JS backends
+
+@file:Suppress("UNUSED_PARAMETER", "NOTHING_TO_INLINE")
+
+package kotlin
+
+/**
+ * Returns an empty array of the specified type [T].
+ */
+public inline fun <T> emptyArray(): Array<T> = js("[]")
+
+/**
+ * Creates a new instance of the [Lazy] that uses the specified initialization function [initializer].
+ */
+public actual fun <T> lazy(initializer: () -> T): Lazy<T> = UnsafeLazyImpl(initializer)
+
+/**
+ * Creates a new instance of the [Lazy] that uses the specified initialization function [initializer].
+ *
+ * The [mode] parameter is ignored. */
+public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> = UnsafeLazyImpl(initializer)
+
+/**
+ * Creates a new instance of the [Lazy] that uses the specified initialization function [initializer].
+ *
+ * The [lock] parameter is ignored.
+ */
+public actual fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T> = UnsafeLazyImpl(initializer)
+
+
+internal fun fillFrom(src: dynamic, dst: dynamic): dynamic {
+    val srcLen: Int = src.length
+    val dstLen: Int = dst.length
+    var index: Int = 0
+    val arr = dst.unsafeCast<Array<Any?>>()
+    while (index < srcLen && index < dstLen) arr[index] = src[index++]
+    return dst
+}
+
+
+internal fun arrayCopyResize(source: dynamic, newSize: Int, defaultValue: Any?): dynamic {
+    val result = source.slice(0, newSize).unsafeCast<Array<Any?>>()
+    copyArrayType(source, result)
+    var index: Int = source.length
+    if (newSize > index) {
+        result.asDynamic().length = newSize
+        while (index < newSize) result[index++] = defaultValue
+    }
+    return result
+}
+
+internal fun <T> arrayPlusCollection(array: dynamic, collection: Collection<T>): dynamic {
+    val result = array.slice().unsafeCast<Array<T>>()
+    result.asDynamic().length = result.size + collection.size
+    copyArrayType(array, result)
+    var index: Int = array.length
+    for (element in collection) result[index++] = element
+    return result
+}
+
+internal inline fun copyArrayType(from: dynamic, to: dynamic) {
+    if (from.`$type$` !== undefined) {
+        to.`$type$` = from.`$type$`
+    }
+}

libraries/stdlib/js-ir/runtime/kotlinJsHacks.kt

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+@PublishedApi
+internal fun <T : Enum<T>> enumValuesIntrinsic(): Array<T> =
+    throw IllegalStateException("Should be replaced by compiler")
+
+@PublishedApi
+internal fun <T : Enum<T>> enumValueOfIntrinsic(name: String): T =
+    throw IllegalStateException("Should be replaced by compiler")

libraries/stdlib/js-ir/runtime/kotlinNativeHacks.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.native.concurrent
+
+// Current serialization removes expect declarations, so some dummy annotations are needed
+// Expect declarations: libraries/stdlib/common/src/kotlin/NativeAnnotationsH.kt
+
+@Target(AnnotationTarget.PROPERTY, AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.BINARY)
+@OptionalExpectation
+public annotation class ThreadLocal()
+
+@Target(AnnotationTarget.PROPERTY)
+@Retention(AnnotationRetention.BINARY)
+@OptionalExpectation
+public annotation class SharedImmutable()

libraries/stdlib/js-ir/runtime/long.kt

@@ -0,0 +1,263 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin
+
+/**
+ * Represents a 64-bit signed integer.
+ */
+public class Long internal constructor(
+    internal val low: Int,
+    internal val high: Int
+) : Number(), Comparable<Long> {
+
+    companion object {
+        /**
+         * A constant holding the minimum value an instance of Long can have.
+         */
+        public const val MIN_VALUE: Long = -9223372036854775807L - 1L
+
+        /**
+         * A constant holding the maximum value an instance of Long can have.
+         */
+        public const val MAX_VALUE: Long = 9223372036854775807L
+
+        /**
+         * The number of bytes used to represent an instance of Long in a binary form.
+         */
+        @SinceKotlin("1.3")
+        public const val SIZE_BYTES: Int = 8
+
+        /**
+         * The number of bits used to represent an instance of Long in a binary form.
+         */
+        @SinceKotlin("1.3")
+        public const val SIZE_BITS: Int = 64
+    }
+
+    /**
+     * Compares this value with the specified value for order.
+     * Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
+     * or a positive number if it's greater than other.
+     */
+    public inline operator fun compareTo(other: Byte): Int = compareTo(other.toLong())
+
+    /**
+     * Compares this value with the specified value for order.
+     * Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
+     * or a positive number if it's greater than other.
+     */
+    public inline operator fun compareTo(other: Short): Int = compareTo(other.toLong())
+
+    /**
+     * Compares this value with the specified value for order.
+     * Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
+     * or a positive number if it's greater than other.
+     */
+    public inline operator fun compareTo(other: Int): Int = compareTo(other.toLong())
+
+    /**
+     * Compares this value with the specified value for order.
+     * Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
+     * or a positive number if it's greater than other.
+     */
+    public override operator fun compareTo(other: Long): Int = compare(other)
+
+    /**
+     * Compares this value with the specified value for order.
+     * Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
+     * or a positive number if it's greater than other.
+     */
+    public inline operator fun compareTo(other: Float): Int = toFloat().compareTo(other)
+
+    /**
+     * Compares this value with the specified value for order.
+     * Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
+     * or a positive number if it's greater than other.
+     */
+    public inline operator fun compareTo(other: Double): Int = toDouble().compareTo(other)
+
+    /** Adds the other value to this value. */
+    public inline operator fun plus(other: Byte): Long = plus(other.toLong())
+
+    /** Adds the other value to this value. */
+    public inline operator fun plus(other: Short): Long = plus(other.toLong())
+
+    /** Adds the other value to this value. */
+    public inline operator fun plus(other: Int): Long = plus(other.toLong())
+
+    /** Adds the other value to this value. */
+    public operator fun plus(other: Long): Long = add(other)
+
+    /** Adds the other value to this value. */
+    public inline operator fun plus(other: Float): Float = toFloat() + other
+
+    /** Adds the other value to this value. */
+    public inline operator fun plus(other: Double): Double = toDouble() + other
+
+    /** Subtracts the other value from this value. */
+    public inline operator fun minus(other: Byte): Long = minus(other.toLong())
+
+    /** Subtracts the other value from this value. */
+    public inline operator fun minus(other: Short): Long = minus(other.toLong())
+
+    /** Subtracts the other value from this value. */
+    public inline operator fun minus(other: Int): Long = minus(other.toLong())
+
+    /** Subtracts the other value from this value. */
+    public operator fun minus(other: Long): Long = subtract(other)
+
+    /** Subtracts the other value from this value. */
+    public inline operator fun minus(other: Float): Float = toFloat() - other
+
+    /** Subtracts the other value from this value. */
+    public inline operator fun minus(other: Double): Double = toDouble() - other
+
+    /** Multiplies this value by the other value. */
+    public inline operator fun times(other: Byte): Long = times(other.toLong())
+
+    /** Multiplies this value by the other value. */
+    public inline operator fun times(other: Short): Long = times(other.toLong())
+
+    /** Multiplies this value by the other value. */
+    public inline operator fun times(other: Int): Long = times(other.toLong())
+
+    /** Multiplies this value by the other value. */
+    public operator fun times(other: Long): Long = multiply(other)
+
+    /** Multiplies this value by the other value. */
+    public inline operator fun times(other: Float): Float = toFloat() * other
+
+    /** Multiplies this value by the other value. */
+    public inline operator fun times(other: Double): Double = toDouble() * other
+
+    /** Divides this value by the other value. */
+    public inline operator fun div(other: Byte): Long = div(other.toLong())
+
+    /** Divides this value by the other value. */
+    public inline operator fun div(other: Short): Long = div(other.toLong())
+
+    /** Divides this value by the other value. */
+    public inline operator fun div(other: Int): Long = div(other.toLong())
+
+    /** Divides this value by the other value. */
+    public operator fun div(other: Long): Long = divide(other)
+
+    /** Divides this value by the other value. */
+    public inline operator fun div(other: Float): Float = toFloat() / other
+
+    /** Divides this value by the other value. */
+    public inline operator fun div(other: Double): Double = toDouble() / other
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
+    public inline operator fun mod(other: Byte): Long = rem(other)
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
+    public inline operator fun mod(other: Short): Long = rem(other)
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
+    public inline operator fun mod(other: Int): Long = rem(other)
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
+    public inline operator fun mod(other: Long): Long = rem(other)
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
+    public inline operator fun mod(other: Float): Float = rem(other)
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
+    public inline operator fun mod(other: Double): Double = rem(other)
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @SinceKotlin("1.1")
+    public inline operator fun rem(other: Byte): Long = rem(other.toLong())
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @SinceKotlin("1.1")
+    public inline operator fun rem(other: Short): Long = rem(other.toLong())
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @SinceKotlin("1.1")
+    public inline operator fun rem(other: Int): Long = rem(other.toLong())
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @SinceKotlin("1.1")
+    public operator fun rem(other: Long): Long = modulo(other)
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @SinceKotlin("1.1")
+    public inline operator fun rem(other: Float): Float = toFloat() % other
+
+    /** Calculates the remainder of dividing this value by the other value. */
+    @SinceKotlin("1.1")
+    public inline operator fun rem(other: Double): Double = toDouble() % other
+
+    /** Increments this value. */
+    public operator fun inc(): Long = this + 1L
+
+    /** Decrements this value. */
+    public operator fun dec(): Long = this - 1L
+
+    /** Returns this value. */
+    public inline operator fun unaryPlus(): Long = this
+
+    /** Returns the negative of this value. */
+    public operator fun unaryMinus(): Long = inv() + 1L
+
+    /** Creates a range from this value to the specified [other] value. */
+    public operator fun rangeTo(other: Byte): LongRange = rangeTo(other.toLong())
+
+    /** Creates a range from this value to the specified [other] value. */
+    public operator fun rangeTo(other: Short): LongRange = rangeTo(other.toLong())
+
+    /** Creates a range from this value to the specified [other] value. */
+    public operator fun rangeTo(other: Int): LongRange = rangeTo(other.toLong())
+
+    /** Creates a range from this value to the specified [other] value. */
+    public operator fun rangeTo(other: Long): LongRange = LongRange(this, other)
+
+    /** Shifts this value left by the [bitCount] number of bits. */
+    public infix fun shl(bitCount: Int): Long = shiftLeft(bitCount)
+
+    /** Shifts this value right by the [bitCount] number of bits, filling the leftmost bits with copies of the sign bit. */
+    public infix fun shr(bitCount: Int): Long = shiftRight(bitCount)
+
+    /** Shifts this value right by the [bitCount] number of bits, filling the leftmost bits with zeros. */
+    public infix fun ushr(bitCount: Int): Long = shiftRightUnsigned(bitCount)
+
+    /** Performs a bitwise AND operation between the two values. */
+    public infix fun and(other: Long): Long = Long(low and other.low, high and other.high)
+
+    /** Performs a bitwise OR operation between the two values. */
+    public infix fun or(other: Long): Long = Long(low or other.low, high or other.high)
+
+    /** Performs a bitwise XOR operation between the two values. */
+    public infix fun xor(other: Long): Long = Long(low xor other.low, high xor other.high)
+
+    /** Inverts the bits in this value. */
+    public fun inv(): Long = Long(low.inv(), high.inv())
+
+    public override fun toByte(): Byte = low.toByte()
+    public override fun toChar(): Char = low.toChar()
+    public override fun toShort(): Short = low.toShort()
+    public override fun toInt(): Int = low
+    public override fun toLong(): Long = this
+    public override fun toFloat(): Float = toDouble().toFloat()
+    public override fun toDouble(): Double = toNumber()
+
+    // This method is used by `toString()`
+    internal fun valueOf() = toDouble()
+
+    override fun equals(other: Any?): Boolean = other is Long && equalsLong(other)
+
+    override fun hashCode(): Int = hashCode(this)
+
+    override fun toString(): String = toString(10)
+}

libraries/stdlib/js-ir/runtime/longjs.kt

@@ -0,0 +1,386 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+
+// Copyright 2009 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+package kotlin
+
+internal fun Long.toNumber() = high * TWO_PWR_32_DBL_ + getLowBitsUnsigned()
+
+internal fun Long.getLowBitsUnsigned() = if (low >= 0) low.toDouble() else TWO_PWR_32_DBL_ + low
+
+internal fun hashCode(l: Long) = l.low xor l.high
+
+internal fun Long.toString(radix: Int): String {
+    if (radix < 2 || 36 < radix) {
+        throw Exception("radix out of range: $radix")
+    }
+
+    if (isZero()) {
+        return "0"
+    }
+
+    if (isNegative()) {
+        if (equalsLong(MIN_VALUE)) {
+            // We need to change the Long value before it can be negated, so we remove
+            // the bottom-most digit in this base and then recurse to do the rest.
+            val radixLong = fromInt(radix)
+            val div = div(radixLong)
+            val rem = div.multiply(radixLong).subtract(this).toInt();
+            return js("div.toString(radix) + rem.toString(radix)")
+        } else {
+            return "-${negate().toString()}"
+        }
+    }
+
+    // Do several (6) digits each time through the loop, so as to
+    // minimize the calls to the very expensive emulated div.
+    val radixToPower = fromNumber(js("Math.pow(radix, 6)").unsafeCast<Double>())
+
+    var rem = this
+    var result = ""
+    while (true) {
+        val remDiv = rem.div(radixToPower)
+        val intval = rem.subtract(remDiv.multiply(radixToPower)).toInt()
+        var digits = js("intval.toString(radix)").unsafeCast<String>()
+
+        rem = remDiv
+        if (rem.isZero()) {
+            return digits + result
+        } else {
+            while (js("digits.length").unsafeCast<Int>() < 6) {
+                digits = "0" + digits
+            }
+            result = digits + result
+        }
+    }
+}
+
+internal fun Long.negate() = unaryMinus()
+
+internal fun Long.isZero() = high == 0 && low == 0
+
+internal fun Long.isNegative() = high < 0
+
+internal fun Long.isOdd() = low and 1 == 1
+
+internal fun Long.equalsLong(other: Long) = high == other.high && low == other.low
+
+internal fun Long.lessThan(other: Long) = compare(other) < 0
+
+internal fun Long.lessThanOrEqual(other: Long) = compare(other) <= 0
+
+internal fun Long.greaterThan(other: Long) = compare(other) > 0
+
+internal fun Long.greaterThanOrEqual(other: Long) = compare(other) >= 0
+
+internal fun Long.compare(other: Long): Int {
+    if (equalsLong(other)) {
+        return 0;
+    }
+
+    val thisNeg = isNegative();
+    val otherNeg = other.isNegative();
+
+    return when {
+        thisNeg && !otherNeg -> -1
+        !thisNeg && otherNeg -> 1
+    // at this point, the signs are the same, so subtraction will not overflow
+        subtract(other).isNegative() -> -1
+        else -> 1
+    }
+}
+
+internal fun Long.add(other: Long): Long {
+    // Divide each number into 4 chunks of 16 bits, and then sum the chunks.
+
+    val a48 = high ushr 16
+    val a32 = high and 0xFFFF
+    val a16 = low ushr 16
+    val a00 = low and 0xFFFF
+
+    val b48 = other.high ushr 16
+    val b32 = other.high and 0xFFFF
+    val b16 = other.low ushr 16
+    val b00 = other.low and 0xFFFF
+
+    var c48 = 0
+    var c32 = 0
+    var c16 = 0
+    var c00 = 0
+    c00 += a00 + b00
+    c16 += c00 ushr 16
+    c00 = c00 and 0xFFFF
+    c16 += a16 + b16
+    c32 += c16 ushr 16
+    c16 = c16 and 0xFFFF
+    c32 += a32 + b32
+    c48 += c32 ushr 16
+    c32 = c32 and 0xFFFF
+    c48 += a48 + b48
+    c48 = c48 and 0xFFFF
+    return Long((c16 shl 16) or c00, (c48 shl 16) or c32)
+}
+
+internal fun Long.subtract(other: Long) = add(other.unaryMinus())
+
+internal fun Long.multiply(other: Long): Long {
+    if (isZero()) {
+        return ZERO
+    } else if (other.isZero()) {
+        return ZERO
+    }
+
+    if (equalsLong(MIN_VALUE)) {
+        return if (other.isOdd()) MIN_VALUE else ZERO
+    } else if (other.equalsLong(MIN_VALUE)) {
+        return if (isOdd()) MIN_VALUE else ZERO
+    }
+
+    if (isNegative()) {
+        return if (other.isNegative()) {
+            negate().multiply(other.negate())
+        } else {
+            negate().multiply(other).negate()
+        }
+    } else if (other.isNegative()) {
+        return multiply(other.negate()).negate()
+    }
+
+    // If both longs are small, use float multiplication
+    if (lessThan(TWO_PWR_24_) && other.lessThan(TWO_PWR_24_)) {
+        return fromNumber(toNumber() * other.toNumber())
+    }
+
+    // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
+    // We can skip products that would overflow.
+
+    val a48 = high ushr 16
+    val a32 = high and 0xFFFF
+    val a16 = low ushr 16
+    val a00 = low and 0xFFFF
+
+    val b48 = other.high ushr 16
+    val b32 = other.high and 0xFFFF
+    val b16 = other.low ushr 16
+    val b00 = other.low and 0xFFFF
+
+    var c48 = 0
+    var c32 = 0
+    var c16 = 0
+    var c00 = 0
+    c00 += a00 * b00
+    c16 += c00 ushr 16
+    c00 = c00 and 0xFFFF
+    c16 += a16 * b00
+    c32 += c16 ushr 16
+    c16 = c16 and 0xFFFF
+    c16 += a00 * b16
+    c32 += c16 ushr 16
+    c16 = c16 and 0xFFFF
+    c32 += a32 * b00
+    c48 += c32 ushr 16
+    c32 = c32 and 0xFFFF
+    c32 += a16 * b16
+    c48 += c32 ushr 16
+    c32 = c32 and 0xFFFF
+    c32 += a00 * b32
+    c48 += c32 ushr 16
+    c32 = c32 and 0xFFFF
+    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48
+    c48 = c48 and 0xFFFF
+    return Long(c16 shl 16 or c00, c48 shl 16 or c32)
+}
+
+internal fun Long.divide(other: Long): Long {
+    if (other.isZero()) {
+        throw Exception("division by zero")
+    } else if (isZero()) {
+        return ZERO
+    }
+
+    if (equalsLong(MIN_VALUE)) {
+        if (other.equalsLong(ONE) || other.equalsLong(NEG_ONE)) {
+            return MIN_VALUE  // recall that -MIN_VALUE == MIN_VALUE
+        } else if (other.equalsLong(MIN_VALUE)) {
+            return ONE
+        } else {
+            // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
+            val halfThis = shiftRight(1)
+            val approx = halfThis.div(other).shiftLeft(1)
+            if (approx.equalsLong(ZERO)) {
+                return if (other.isNegative()) ONE else NEG_ONE
+            } else {
+                val rem = subtract(other.multiply(approx))
+                return approx.add(rem.div(other))
+            }
+        }
+    } else if (other.equalsLong(MIN_VALUE)) {
+        return ZERO
+    }
+
+    if (isNegative()) {
+        return if (other.isNegative()) {
+            negate().div(other.negate())
+        } else {
+            negate().div(other).negate()
+        }
+    } else if (other.isNegative()) {
+        return div(other.negate()).negate()
+    }
+
+    // Repeat the following until the remainder is less than other:  find a
+    // floating-point that approximates remainder / other *from below*, add this
+    // into the result, and subtract it from the remainder.  It is critical that
+    // the approximate value is less than or equal to the real value so that the
+    // remainder never becomes negative.
+    var res = ZERO
+    var rem = this
+    while (rem.greaterThanOrEqual(other)) {
+        // Approximate the result of division. This may be a little greater or
+        // smaller than the actual value.
+        val approxDouble = rem.toNumber() / other.toNumber()
+        var approx2 = js("Math.max(1, Math.floor(approxDouble))").unsafeCast<Double>()
+
+        // We will tweak the approximate result by changing it in the 48-th digit or
+        // the smallest non-fractional digit, whichever is larger.
+        val log2 = js("Math.ceil(Math.log(approx2) / Math.LN2)").unsafeCast<Int>()
+
+        // TODO: log2 is renamed but usage in js() functions is not
+        val log2_minus48 = log2 - 48
+        val delta = if (log2 <= 48) 1.0 else js("Math.pow(2, log2_minus48)").unsafeCast<Double>()
+
+        // Decrease the approximation until it is smaller than the remainder.  Note
+        // that if it is too large, the product overflows and is negative.
+        var approxRes = fromNumber(approx2)
+        var approxRem = approxRes.multiply(other)
+        while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
+            approx2 -= delta
+            approxRes = fromNumber(approx2)
+            approxRem = approxRes.multiply(other)
+        }
+
+        // We know the answer can't be zero... and actually, zero would cause
+        // infinite recursion since we would make no progress.
+        if (approxRes.isZero()) {
+            approxRes = ONE
+        }
+
+        res = res.add(approxRes)
+        rem = rem.subtract(approxRem)
+    }
+    return res
+}
+
+internal fun Long.modulo(other: Long) = subtract(div(other).multiply(other))
+
+internal fun Long.shiftLeft(numBits: Int): Long {
+    val numBits = numBits and 63
+    if (numBits == 0) {
+        return this
+    } else {
+        if (numBits < 32) {
+            return Long(low shl numBits, (high shl numBits) or (low ushr (32 - numBits)))
+        } else {
+            return Long(0, low shl (numBits - 32))
+        }
+    }
+}
+
+internal fun Long.shiftRight(numBits: Int): Long {
+    val numBits = numBits and 63
+    if (numBits == 0) {
+        return this
+    } else {
+        if (numBits < 32) {
+            return Long((low ushr numBits) or (high shl (32 - numBits)), high shr numBits)
+        } else {
+            return Long(high shr (numBits - 32), if (high >= 0) 0 else -1)
+        }
+    }
+}
+
+internal fun Long.shiftRightUnsigned(numBits: Int): Long {
+    val numBits = numBits and 63
+    if (numBits == 0) {
+        return this
+    } else {
+        if (numBits < 32) {
+            return Long((low ushr numBits) or (high shl (32 - numBits)), high ushr numBits)
+        } else return if (numBits == 32) {
+            Long(high, 0)
+        } else {
+            Long(high ushr (numBits - 32), 0)
+        }
+    }
+}
+
+/**
+ * Returns a Long representing the given (32-bit) integer value.
+ * @param {number} value The 32-bit integer in question.
+ * @return {!Kotlin.Long} The corresponding Long value.
+ */
+// TODO: cache
+internal fun fromInt(value: Int) = Long(value, if (value < 0) -1 else 0)
+
+/**
+ * Returns a Long representing the given value, provided that it is a finite
+ * number.  Otherwise, zero is returned.
+ * @param {number} value The number in question.
+ * @return {!Kotlin.Long} The corresponding Long value.
+ */
+internal fun fromNumber(value: Double): Long {
+    if (js("isNaN(value)").unsafeCast<Boolean>() || !js("isFinite(value)").unsafeCast<Boolean>()) {
+        return ZERO;
+    } else if (value <= -TWO_PWR_63_DBL_) {
+        return MIN_VALUE;
+    } else if (value + 1 >= TWO_PWR_63_DBL_) {
+        return MAX_VALUE;
+    } else if (value < 0) {
+        return fromNumber(-value).negate();
+    } else {
+        val twoPwr32 = TWO_PWR_32_DBL_
+        return Long(
+            js("(value % twoPwr32) | 0").unsafeCast<Int>(),
+            js("(value / twoPwr32) | 0").unsafeCast<Int>()
+        )
+    }
+}
+
+private val TWO_PWR_16_DBL_ = (1 shl 16).toDouble()
+
+private val TWO_PWR_24_DBL_ = (1 shl 24).toDouble()
+
+//private val TWO_PWR_32_DBL_ = TWO_PWR_16_DBL_ * TWO_PWR_16_DBL_
+private val TWO_PWR_32_DBL_ = (1 shl 16).toDouble() * (1 shl 16).toDouble()
+
+//private val TWO_PWR_64_DBL_ = TWO_PWR_32_DBL_ * TWO_PWR_32_DBL_
+private val TWO_PWR_64_DBL_ = ((1 shl 16).toDouble() * (1 shl 16).toDouble()) * ((1 shl 16).toDouble() * (1 shl 16).toDouble())
+
+//private val TWO_PWR_63_DBL_ = TWO_PWR_64_DBL_ / 2
+private val TWO_PWR_63_DBL_ = (((1 shl 16).toDouble() * (1 shl 16).toDouble()) * ((1 shl 16).toDouble() * (1 shl 16).toDouble())) / 2
+
+private val ZERO = fromInt(0)
+
+private val ONE = fromInt(1)
+
+private val NEG_ONE = fromInt(-1)
+
+private val MAX_VALUE = Long(-1, -1 ushr 1)
+
+private val MIN_VALUE = Long(0, 1 shl 31)
+
+private val TWO_PWR_24_ = fromInt(1 shl 24)

libraries/stdlib/js-ir/runtime/misc.kt

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+// TODO: Polyfill
+internal fun imul(a_local: Int, b_local: Int) =
+    js("((a_local & 0xffff0000) * (b_local & 0xffff) + (a_local & 0xffff) * (b_local | 0)) | 0").unsafeCast<Int>()

libraries/stdlib/js-ir/runtime/noPackageHacks.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+/** Concat regular Array's and TypedArray's into an Array.
+ */
+@PublishedApi
+internal fun <T> arrayConcat(vararg args: T): T {
+    val len = args.size
+    val typed = js("Array(len)").unsafeCast<Array<T>>()
+    for (i in 0 .. (len - 1)) {
+        val arr = args[i]
+        if (arr !is Array<*>) {
+            typed[i] = js("[]").slice.call(arr)
+        } else {
+            typed[i] = arr
+        }
+    }
+    return js("[]").concat.apply(js("[]"), typed);
+}
+
+/** Concat primitive arrays. Main use: prepare vararg arguments.
+ */
+@PublishedApi
+internal fun <T> primitiveArrayConcat(vararg args: T): T {
+    var size_local = 0
+    for (i in 0 .. (args.size - 1)) {
+        size_local += args[i].unsafeCast<Array<Any?>>().size
+    }
+    val a = args[0]
+    val result = js("new a.constructor(size_local)").unsafeCast<Array<Any?>>()
+    if (a.asDynamic().`$type$` != null) {
+        withType(a.asDynamic().`$type$`, result)
+    }
+
+    size_local = 0
+    for (i in 0 .. (args.size - 1)) {
+        val arr = args[i].unsafeCast<Array<Any?>>()
+        for (j in 0 .. (arr.size - 1)) {
+            result[size_local++] = arr[j]
+        }
+    }
+    return result.unsafeCast<T>()
+}
+
+@PublishedApi
+internal inline fun withType(type: String, array: dynamic): dynamic {
+    array.`$type$` = type
+    return array
+}

libraries/stdlib/js-ir/runtime/numberConversion.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+fun numberToByte(a: dynamic): Byte = toByte(numberToInt(a))
+
+fun numberToDouble(a: dynamic): Double = js("+a").unsafeCast<Double>()
+
+fun numberToInt(a: dynamic): Int = if (a is Long) a.toInt() else doubleToInt(a)
+
+fun numberToShort(a: dynamic): Short = toShort(numberToInt(a))
+
+// << and >> shifts are used to preserve sign of the number
+fun toByte(a: dynamic): Byte = js("a << 24 >> 24").unsafeCast<Byte>()
+fun toShort(a: dynamic): Short = js("a << 16 >> 16").unsafeCast<Short>()
+
+fun numberToLong(a: dynamic): Long = if (a is Long) a else fromNumber(a)
+
+fun toLong(a: dynamic): Long = fromInt(a)
+
+fun doubleToInt(a: dynamic) = js("""
+    if (a > 2147483647) return 2147483647;
+    if (a < -2147483648) return -2147483648;
+    return a | 0;
+""").unsafeCast<Int>()
+
+fun numberToChar(a: dynamic) = Char(numberToInt(a) and 0xFFFF)

libraries/stdlib/js-ir/runtime/rangeTo.kt

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+// Creates IntRange for {Byte, Short, Int}.rangeTo(x: {Byte, Short, Int})
+fun numberRangeToNumber(start: dynamic, endInclusive: dynamic) =
+    IntRange(start, endInclusive)
+
+// Create LongRange for {Byte, Short, Int}.rangeTo(x: Long)
+// Long.rangeTo(x: *) should be implemented in Long class
+fun numberRangeToLong(start: dynamic, endInclusive: dynamic) =
+    LongRange(numberToLong(start), endInclusive)

libraries/stdlib/js-ir/runtime/tests.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.test
+
+// This file plugs some declaration from "kotlin.test" library used in tests.
+
+fun <T> assertEquals(a: T, b: T) {
+    if (a != b) throw Exception("")
+}
+
+fun assertTrue(x: Boolean) {
+    if (!x) throw Exception("")
+}
+
+fun assertFalse(x: Boolean) {
+    if (x) throw Exception("")
+}
+
+fun <T : Any> assertNotNull(actual: T?, message: String? = null): T {
+    if (actual == null) throw Exception("")
+    return actual
+}
+
+

libraries/stdlib/js-ir/runtime/typeCheckUtils.kt

@@ -0,0 +1,175 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.js
+
+private external interface Metadata {
+    val interfaces: Array<Ctor>
+}
+
+private external interface Ctor {
+    val `$metadata$`: Metadata?
+    val prototype: Ctor?
+}
+
+private fun isInterfaceImpl(ctor: Ctor, iface: dynamic): Boolean {
+    if (ctor === iface) return true
+
+    val metadata = ctor.`$metadata$`
+    if (metadata != null) {
+        val interfaces = metadata.interfaces
+        for (i in interfaces) {
+            if (isInterfaceImpl(i, iface)) {
+                return true
+            }
+        }
+    }
+
+    val superPrototype = if (ctor.prototype != null) js("Object").getPrototypeOf(ctor.prototype) else null
+    val superConstructor: Ctor? = if (superPrototype != null) superPrototype.constructor else null
+    return superConstructor != null && isInterfaceImpl(superConstructor, iface)
+}
+
+public fun isInterface(obj: dynamic, iface: dynamic): Boolean {
+    //TODO: val ctor = obj.constructor
+    val ctor = js("obj.constructor")
+
+    if (ctor == null) return false
+
+    return isInterfaceImpl(ctor, iface)
+}
+
+/*
+
+internal interface ClassMetadata {
+    val simpleName: String
+    val interfaces: Array<dynamic>
+}
+
+// TODO: replace `isInterface` with the following
+public fun isInterface(ctor: dynamic, IType: dynamic): Boolean {
+    if (ctor === IType) return true
+
+    val metadata = ctor.`$metadata$`.unsafeCast<ClassMetadata?>()
+
+    if (metadata !== null) {
+        val interfaces = metadata.interfaces
+        for (i in interfaces) {
+            if (isInterface(i, IType)) {
+                return true
+            }
+        }
+    }
+
+    var superPrototype = ctor.prototype
+    if (superPrototype !== null) {
+        superPrototype = js("Object.getPrototypeOf(superPrototype)")
+    }
+
+    val superConstructor = if (superPrototype !== null) {
+        superPrototype.constructor
+    } else null
+
+    return superConstructor != null && isInterface(superConstructor, IType)
+}
+*/
+
+fun typeOf(obj: dynamic): String = js("typeof obj").unsafeCast<String>()
+
+fun jsTypeOf(obj: Any?): String = js("typeof obj").unsafeCast<String>()
+
+fun instanceOf(obj: dynamic, jsClass_local: dynamic) = js("obj instanceof jsClass_local").unsafeCast<Boolean>()
+
+fun isObject(obj: dynamic): Boolean {
+    val objTypeOf = typeOf(obj)
+
+    return when (objTypeOf) {
+        "string" -> true
+        "number" -> true
+        "boolean" -> true
+        "function" -> true
+        else -> js("obj instanceof Object").unsafeCast<Boolean>()
+    }
+}
+
+private fun isJsArray(obj: Any): Boolean {
+    return js("Array.isArray(obj)").unsafeCast<Boolean>()
+}
+
+public fun isArray(obj: Any): Boolean {
+    return isJsArray(obj) && js("!obj.\$type\$").unsafeCast<Boolean>()
+}
+
+public fun isArrayish(o: dynamic) =
+    isJsArray(o) || js("ArrayBuffer.isView(o)").unsafeCast<Boolean>()
+
+
+public fun isChar(c: Any): Boolean {
+    return js("throw Error(\"isChar is not implemented\")").unsafeCast<Boolean>()
+}
+
+// TODO: Distinguish Boolean/Byte and Short/Char
+public fun isBooleanArray(a: dynamic): Boolean = isJsArray(a) && a.`$type$` === "BooleanArray"
+public fun isByteArray(a: dynamic): Boolean = js("a instanceof Int8Array").unsafeCast<Boolean>()
+public fun isShortArray(a: dynamic): Boolean = js("a instanceof Int16Array").unsafeCast<Boolean>()
+public fun isCharArray(a: dynamic): Boolean = isJsArray(a) && a.`$type$` === "CharArray"
+public fun isIntArray(a: dynamic): Boolean = js("a instanceof Int32Array").unsafeCast<Boolean>()
+public fun isFloatArray(a: dynamic): Boolean = js("a instanceof Float32Array").unsafeCast<Boolean>()
+public fun isDoubleArray(a: dynamic): Boolean = js("a instanceof Float64Array").unsafeCast<Boolean>()
+public fun isLongArray(a: dynamic): Boolean = isJsArray(a) && a.`$type$` === "LongArray"
+
+
+internal fun jsIn(x: String, y: dynamic): Boolean = js("x in y")
+internal fun jsGetPrototypeOf(jsClass: dynamic) = js("Object").getPrototypeOf(jsClass)
+
+public fun jsIsType(obj: dynamic, jsClass: dynamic): Boolean {
+    if (jsClass === js("Object")) {
+        return isObject(obj)
+    }
+
+    if (obj == null || jsClass == null || (typeOf(obj) != "object" && typeOf(obj) != "function")) {
+        return false
+    }
+
+    if (typeOf(jsClass) == "function" && instanceOf(obj, jsClass)) {
+        return true
+    }
+
+    var proto = jsGetPrototypeOf(jsClass)
+    var constructor = proto?.constructor
+    if (constructor != null && jsIn("${'$'}metadata${'$'}", constructor)) {
+        var metadata = constructor.`$metadata$`
+        if (metadata.kind === "object") {
+            return obj === jsClass
+        }
+    }
+
+    var klassMetadata = jsClass.`$metadata$`
+
+    // In WebKit (JavaScriptCore) for some interfaces from DOM typeof returns "object", nevertheless they can be used in RHS of instanceof
+    if (klassMetadata == null) {
+        return instanceOf(obj, jsClass)
+    }
+
+    if (klassMetadata.kind === "interface" && obj.constructor != null) {
+        return isInterfaceImpl(obj.constructor, jsClass)
+    }
+
+    return false
+}
+
+fun isNumber(a: dynamic) = jsTypeOf(a) == "number" || a is Long
+
+fun isComparable(value: dynamic): Boolean {
+    var type = jsTypeOf(value)
+
+    return type == "string" ||
+           type == "boolean" ||
+           isNumber(value) ||
+           isInterface(value, Comparable::class.js)
+}
+
+fun isCharSequence(value: dynamic): Boolean =
+    jsTypeOf(value) == "string" || isInterface(value, CharSequence::class.js)