[JS IR BE] Make Int inline class

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt

@@ -177,6 +177,18 @@ class JsIntrinsics(private val irBuiltIns: IrBuiltIns, val context: JsIrBackendC
         )
     )
 
+    val intTo = listOf(
+        PrimitiveType.BYTE,
+        PrimitiveType.SHORT,
+        PrimitiveType.LONG
+    ).associateWith {
+        context.symbolTable.referenceSimpleFunction(
+            context.getClass(FqName("kotlin.Int")).unsubstitutedMemberScope.findSingleFunction(
+                Name.identifier("to${it.typeName}")
+            )
+        )
+    }
+
     val charClassSymbol = getInternalClassWithoutPackage("kotlin.Char")
     val charConstructor = charClassSymbol.constructors.single().owner
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/AutoboxingTransformer.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.ir.backend.js.lower
 
+import com.intellij.lang.jvm.actions.expectedTypes
 import org.jetbrains.kotlin.backend.common.FileLoweringPass
 import org.jetbrains.kotlin.backend.common.lower.AbstractValueUsageTransformer
 import org.jetbrains.kotlin.backend.common.utils.isPrimitiveArray
@@ -13,6 +14,7 @@ import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
 import org.jetbrains.kotlin.ir.backend.js.utils.realOverrideTarget
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
+import org.jetbrains.kotlin.ir.types.IrDynamicType
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.isNothing
 import org.jetbrains.kotlin.ir.types.makeNotNull
@@ -80,6 +82,16 @@ class AutoboxingTransformer(val context: JsIrBackendContext) : AbstractValueUsag
             else -> return this
         }
 
+        if (actualType is IrDynamicType || expectedType is IrDynamicType) {
+            if (this is IrGetValue && this.symbol.owner.name.asString().contains("_unsafeCast_")) {
+                return this
+            } else if (this is IrConst<*>) {
+                return this
+            } else {
+            //    TODO("Fix dynamic boxing/unboxing")
+            }
+        }
+
         return buildSafeCall(this, actualType, expectedType) { arg ->
             JsIrBuilder.buildCall(
                 function,

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/MoveBodilessDeclarationsToSeparatePlace.kt

@@ -36,7 +36,7 @@ class MoveBodilessDeclarationsToSeparatePlace : FileLoweringPass {
         "Boolean",
         "Byte",
         "Short",
-        "Int",
+        //"Int",
         "Float",
         "Double"
     ).map { Name.identifier(it) }.toSet()

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/TypeOperatorLowering.kt

@@ -8,11 +8,14 @@ package org.jetbrains.kotlin.ir.backend.js.lower
 import org.jetbrains.kotlin.backend.common.FileLoweringPass
 import org.jetbrains.kotlin.backend.common.utils.getPrimitiveArrayElementType
 import org.jetbrains.kotlin.backend.common.utils.isPrimitiveArray
+import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
 import org.jetbrains.kotlin.ir.backend.js.ir.JsIrArithBuilder
 import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
-import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.IrDeclaration
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrExpressionWithCopy
 import org.jetbrains.kotlin.ir.expressions.IrTypeOperator
@@ -28,12 +31,6 @@ class TypeOperatorLowering(val context: JsIrBackendContext) : FileLoweringPass {
     private val unit = context.irBuiltIns.unitType
     private val unitValue get() = JsIrBuilder.buildGetObjectValue(unit, unit.classifierOrFail as IrClassSymbol)
 
-    private val lit24 get() = JsIrBuilder.buildInt(context.irBuiltIns.intType, 24)
-    private val lit16 get() = JsIrBuilder.buildInt(context.irBuiltIns.intType, 16)
-
-    private val byteMask get() = JsIrBuilder.buildInt(context.irBuiltIns.intType, 0xFF)
-    private val shortMask get() = JsIrBuilder.buildInt(context.irBuiltIns.intType, 0xFFFF)
-
     private val calculator = JsIrArithBuilder(context)
 
     //NOTE: Should we define JS-own functions similar to current implementation?
@@ -132,7 +129,7 @@ class TypeOperatorLowering(val context: JsIrBackendContext) : FileLoweringPass {
             private fun isTypeOfCheckingType(type: IrType) =
                 type.isByte() ||
                         type.isShort() ||
-                        type.isInt() ||
+                        //type.isInt() ||
                         type.isFloat() ||
                         type.isDouble() ||
                         type.isBoolean() ||
@@ -308,21 +305,18 @@ class TypeOperatorLowering(val context: JsIrBackendContext) : FileLoweringPass {
                 val isNullable = expression.argument.type.isNullable()
                 val toType = expression.typeOperand
 
-                fun maskOp(arg: IrExpression, mask: IrExpression, shift: IrExpressionWithCopy) = calculator.run {
-                    shr(shl(and(arg, mask), shift), shift.copy())
-                }
-
                 val newStatements = mutableListOf<IrStatement>()
                 val argument = cacheValue(expression.argument, newStatements, declaration)
 
-                val casted = when {
-                    toType.isByte() -> maskOp(argument(), byteMask, lit24)
-                    toType.isShort() -> maskOp(argument(), shortMask, lit16)
-                    toType.isLong() -> JsIrBuilder.buildCall(context.intrinsics.jsToLong).apply {
-                        putValueArgument(0, argument())
-                    }
+                val toPrimitiveType = when {
+                    toType.isByte() -> PrimitiveType.BYTE
+                    toType.isShort() -> PrimitiveType.SHORT
+                    toType.isLong() -> PrimitiveType.LONG
                     else -> error("Unreachable execution (coercion to non-Integer type")
                 }
+                val casted = JsIrBuilder.buildCall(context.intrinsics.intTo[toPrimitiveType]!!).apply {
+                    dispatchReceiver = argument()
+                }
 
                 newStatements += if (isNullable) JsIrBuilder.buildIfElse(toType, nullCheck(argument()), litNull, casted) else casted
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLowering.kt

@@ -12,10 +12,20 @@ import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.isChar
+import org.jetbrains.kotlin.ir.types.isInt
 import org.jetbrains.kotlin.ir.util.hasAnnotation
+import org.jetbrains.kotlin.ir.util.parentAsClass
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
 
+fun IrType.isPrimitiveNativelyImplemented(): Boolean = when {
+    isInt() -> true
+    isChar() -> true
+    else -> false
+}
+
 class CallsLowering(val context: JsIrBackendContext) : FileLoweringPass {
     private val transformers = listOf(
         NumberOperatorCallsTransformer(context),
@@ -29,6 +39,14 @@ class CallsLowering(val context: JsIrBackendContext) : FileLoweringPass {
         ExceptionHelperCallsTransformer(context)
     )
 
+    fun shouldSkipCall(call: IrCall): Boolean {
+        val function = call.symbol.owner
+        val dispathReceiver = function.dispatchReceiverParameter ?: return false
+        if (dispathReceiver.type.isPrimitiveNativelyImplemented())
+            return true
+        return false
+    }
+
     override fun lower(irFile: IrFile) {
         irFile.transformChildrenVoid(object : IrElementTransformerVoid() {
             override fun visitFunction(declaration: IrFunction): IrStatement {
@@ -39,7 +57,7 @@ class CallsLowering(val context: JsIrBackendContext) : FileLoweringPass {
 
             override fun visitCall(expression: IrCall): IrExpression {
                 val call = super.visitCall(expression)
-                if (call is IrCall) {
+                if (call is IrCall && !shouldSkipCall(call)) {
                     for (transformer in transformers) {
                         val newCall = transformer.transformCall(call)
                         if (newCall !== call) {

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/CallsLoweringUtils.kt

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.ir.backend.js.lower.calls
 
-import org.jetbrains.kotlin.ir.util.irCall
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.types.impl.originalKotlinType
+import org.jetbrains.kotlin.ir.util.irCall
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.SimpleType
 
@@ -80,7 +80,7 @@ internal class SimpleMemberKey(val klass: IrType, val name: Name) {
     }
 }
 
-enum class PrimitiveType {
+internal enum class PrimitiveTypeType {
     FLOATING_POINT_NUMBER,
     INTEGER_NUMBER,
     STRING,
@@ -88,12 +88,12 @@ enum class PrimitiveType {
     OTHER
 }
 
-fun IrType.getPrimitiveType() = makeNotNull().run {
+internal fun IrType.getPrimitiveType() = makeNotNull().run {
     when {
-        isBoolean() -> PrimitiveType.BOOLEAN
-        isByte() || isShort() || isInt() -> PrimitiveType.INTEGER_NUMBER
-        isFloat() || isDouble() -> PrimitiveType.FLOATING_POINT_NUMBER
-        isString() -> PrimitiveType.STRING
-        else -> PrimitiveType.OTHER
+        isBoolean() -> PrimitiveTypeType.BOOLEAN
+        isByte() || isShort() || isInt() -> PrimitiveTypeType.INTEGER_NUMBER
+        isFloat() || isDouble() -> PrimitiveTypeType.FLOATING_POINT_NUMBER
+        isString() -> PrimitiveTypeType.STRING
+        else -> PrimitiveTypeType.OTHER
     }
 }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EqualityAndComparisonCallsTransformer.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.ir.backend.js.lower.calls
 
 import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
-import org.jetbrains.kotlin.ir.util.irCall
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrExpression
@@ -56,12 +55,11 @@ class EqualityAndComparisonCallsTransformer(context: JsIrBackendContext) : Calls
         val lhs = call.getValueArgument(0)!!
         val rhs = call.getValueArgument(1)!!
 
-
         val lhsJsType = lhs.type.getPrimitiveType()
         val rhsJsType = rhs.type.getPrimitiveType()
 
         val equalsMethod = lhs.type.findEqualsMethod()
-        val isLhsPrimitive = lhsJsType != PrimitiveType.OTHER
+        val isLhsPrimitive = lhsJsType != PrimitiveTypeType.OTHER && !lhs.type.isPrimitiveNativelyImplemented()
 
         return when {
             lhs.type is IrDynamicType ->
@@ -72,7 +70,7 @@ class EqualityAndComparisonCallsTransformer(context: JsIrBackendContext) : Calls
                 irCall(call, intrinsics.jsEqeq.symbol)
 
             // For non-float primitives of the same type use JS `==`
-            isLhsPrimitive && lhsJsType == rhsJsType && lhsJsType != PrimitiveType.FLOATING_POINT_NUMBER ->
+            isLhsPrimitive && lhsJsType == rhsJsType && lhsJsType != PrimitiveTypeType.FLOATING_POINT_NUMBER ->
                 chooseEqualityOperatorForPrimitiveTypes(call)
 
             !isLhsPrimitive && !lhs.type.toKotlinType().isNullable() && equalsMethod != null ->
@@ -149,7 +147,7 @@ class EqualityAndComparisonCallsTransformer(context: JsIrBackendContext) : Calls
 
     private fun IrFunction.isMethodOfPrimitiveJSType() =
         dispatchReceiverParameter?.let {
-            it.type.getPrimitiveType() != PrimitiveType.OTHER
+            it.type.getPrimitiveType() != PrimitiveTypeType.OTHER
         } ?: false
 
     private fun IrFunction.isMethodOfPotentiallyPrimitiveJSType() =

compiler/testData/codegen/box/inlineClasses/hiddenConstructor/kt28855.kt

@@ -1,5 +1,5 @@
 // !LANGUAGE: +InlineClasses
-// IGNORE_BACKEND: JS_IR, JVM_IR
+// IGNORE_BACKEND: JVM_IR
 // WITH_RUNTIME
 
 class C<T>(val x: T, vararg ys: UInt) {

compiler/testData/codegen/box/primitiveTypes/kt6590_identityEquals.kt

@@ -1,3 +1,5 @@
+// IGNORE_BACKEND: JS_IR
+
 fun box(): String {
     val i: Int = 10000
     if (!(i === i)) return "Fail int ==="

compiler/testData/codegen/box/reified/filterIsInstance.kt

@@ -1,5 +1,4 @@
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 // TODO: muted automatically, investigate should it be ran for JS or not
 // IGNORE_BACKEND: JS
 

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsExternalChecker.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.resolve.isInlineClassType
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.typeUtil.isPrimitiveNumberOrNullableType
 
 object JsExternalChecker : DeclarationChecker {
     val DEFINED_EXTERNALLY_PROPERTY_NAMES = setOf(FqNameUnsafe("kotlin.js.noImpl"), FqNameUnsafe("kotlin.js.definedExternally"))
@@ -116,7 +117,9 @@ object JsExternalChecker : DeclarationChecker {
             }
         }
 
-        reportOnParametersAndReturnTypesIf(ErrorsJs.INLINE_CLASS_IN_EXTERNAL_DECLARATION, KotlinType::isInlineClassType)
+        reportOnParametersAndReturnTypesIf(ErrorsJs.INLINE_CLASS_IN_EXTERNAL_DECLARATION) {
+            it.isInlineClassType() && !it.isPrimitiveNumberOrNullableType()
+        }
         reportOnParametersAndReturnTypesIf(ErrorsJs.EXTENSION_FUNCTION_IN_EXTERNAL_DECLARATION, KotlinType::isExtensionFunctionType)
 
         if (descriptor is CallableMemberDescriptor && descriptor.isNonAbstractMemberOfInterface() &&

js/js.translator/testData/box/inlineMultiFile/buildersAndLambdaCapturing.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1681
 /*
  * Copy of JVM-backend test

js/js.translator/testData/box/native/typeof.kt

@@ -4,7 +4,7 @@ package foo
 class A
 
 fun box(): String {
-    assertEquals("number", jsTypeOf(1))
+    assertEquals("object", jsTypeOf(1))
     assertEquals("number", jsTypeOf(1.2))
     assertEquals("boolean", jsTypeOf(true))
     assertEquals("string", jsTypeOf("sss"))

js/js.translator/testData/box/number/mulInt32.kt

@@ -35,6 +35,6 @@ fun testSingle(a: Int, b: Int): String? {
 
 fun box(): String {
     val error = test(generateSeries(listOf(3, 0x1234, 0xFFFF, 0xABCD, 0xABCDEF, 0x43211234, 0x7FFFFFFC, 0x7FFFFFFF)))
-    if (error != null) return "fail: error"
+    if (error != null) return "fail: $error"
     return "OK"
 }

js/js.translator/testData/box/number/numberIsCheck.kt

@@ -5,7 +5,7 @@ package foo
 
 fun testNum(numX: Number) {
     assertEquals(true, numX is Number, "numX is Number")
-    assertEquals(true, numX is Int, "numX is Int")
+    assertEquals(false, numX is Int, "numX is Int")
 
     assertEquals(true, numX is Short, "numX is Short")
     assertEquals(true, numX is Byte, "numX is Byte")
@@ -17,7 +17,7 @@ fun testNum(numX: Number) {
 
 fun testAny(anyX: Any) {
     assertEquals(true, anyX is Number, "anyX is Number")
-    assertEquals(true, anyX is Int, "anyX is Int")
+    assertEquals(false, anyX is Int, "anyX is Int")
 
     assertEquals(true, anyX is Short, "anyX is Short")
     assertEquals(true, anyX is Byte, "anyX is Byte")
@@ -36,12 +36,16 @@ fun box(): String {
     var anyX: Any = "A"
     assertEquals(false, anyX is Number, "anyX is Number")
 
-    testNum(100)
     testNum(100.toShort())
     testNum(100.toByte())
     testNum(100.0)
     testNum(100.0f)
 
+    anyX = 100
+    assertEquals(true, anyX is Number, "anyX is Number")
+    assertEquals(true, anyX is Int, "anyX is Int")
+    assertEquals(false, anyX is Float, "anyX is Float")
+
     anyX = 100L
     assertEquals(true, anyX is Number, "anyX is Number")
     assertEquals(true, anyX is Long, "anyX is Long")

js/js.translator/testData/box/rtti/isJsPrimitiveNullableType.kt

@@ -1,4 +1,6 @@
 // EXPECTED_REACHABLE_NODES: 1291
+// IGNORE_BACKEND: JS_IR
+
 package foo
 
 val NUMBER = 1

js/js.translator/testData/box/rtti/isJsPrimitiveType.kt

@@ -1,4 +1,5 @@
 // EXPECTED_REACHABLE_NODES: 1291
+// IGNORE_BACKEND: JS_IR
 package foo
 
 val NUMBER = 1

js/js.translator/testData/box/standardClasses/hashMapTypeOfElement.kt

@@ -1,5 +1,7 @@
 // KJS_WITH_FULL_RUNTIME
 // EXPECTED_REACHABLE_NODES: 1284
+// IGNORE_BACKEND: JS_IR
+
 package foo
 
 

js/js.translator/testData/box/standardClasses/hashSetTypeOfElement.kt

@@ -1,5 +1,7 @@
 // KJS_WITH_FULL_RUNTIME
 // EXPECTED_REACHABLE_NODES: 1300
+// IGNORE_BACKEND: JS_IR
+
 package foo
 
 

libraries/stdlib/js/irRuntime/builtins/Primitives.kt

@@ -4,7 +4,7 @@
  */
 
 // Auto-generated file. DO NOT EDIT!
-@file:Suppress("NON_ABSTRACT_FUNCTION_WITH_NO_BODY")
+@file:Suppress("NON_ABSTRACT_FUNCTION_WITH_NO_BODY", "RESERVED_MEMBER_INSIDE_INLINE_CLASS")
 
 package kotlin
 
@@ -388,7 +388,8 @@ public class Short private constructor() : Number(), Comparable<Short> {
  * Represents a 32-bit signed integer.
  * On the JVM, non-nullable values of this type are represented as values of the primitive type `int`.
  */
-public class Int private constructor() : Number(), Comparable<Int> {
+@Suppress("NON_PUBLIC_PRIMARY_CONSTRUCTOR_OF_INLINE_CLASS")
+public inline class Int internal constructor(val value: Double) : Number(), Comparable<Int> {
     companion object {
         /**
          * A constant holding the minimum value an instance of Int can have.
@@ -418,175 +419,189 @@ public class Int private constructor() : Number(), Comparable<Int> {
      * 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 operator fun compareTo(other: Byte): Int
+    public operator fun compareTo(other: Byte): Int = value.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 operator fun compareTo(other: Short): Int
+    public operator fun compareTo(other: Short): Int = value.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 override operator fun compareTo(other: Int): Int
+    public override operator fun compareTo(other: Int): Int = value.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 operator fun compareTo(other: Long): Int
+    public operator fun compareTo(other: Long): Int = value.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 operator fun compareTo(other: Float): Int
+    public operator fun compareTo(other: Float): Int = value.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 operator fun compareTo(other: Double): Int
+    public operator fun compareTo(other: Double): Int = value.compareTo(other)
 
     /** Adds the other value to this value. */
-    public operator fun plus(other: Byte): Int
+    public operator fun plus(other: Byte): Int = trunkateToInt(value + other.toInt().value)
     /** Adds the other value to this value. */
-    public operator fun plus(other: Short): Int
+    public operator fun plus(other: Short): Int = trunkateToInt(value + other.toInt().value)
     /** Adds the other value to this value. */
-    public operator fun plus(other: Int): Int
+    public operator fun plus(other: Int): Int = trunkateToInt(value + other.value)
     /** Adds the other value to this value. */
-    public operator fun plus(other: Long): Long
+    public operator fun plus(other: Long): Long = value.toLong() + other
     /** Adds the other value to this value. */
-    public operator fun plus(other: Float): Float
+    public operator fun plus(other: Float): Float = value.toFloat() + other
     /** Adds the other value to this value. */
-    public operator fun plus(other: Double): Double
+    public operator fun plus(other: Double): Double = value + other
 
     /** Subtracts the other value from this value. */
-    public operator fun minus(other: Byte): Int
+    public operator fun minus(other: Byte): Int = trunkateToInt(value - other.toInt().value)
     /** Subtracts the other value from this value. */
-    public operator fun minus(other: Short): Int
+    public operator fun minus(other: Short): Int = trunkateToInt(value - other.toInt().value)
     /** Subtracts the other value from this value. */
-    public operator fun minus(other: Int): Int
+    public operator fun minus(other: Int): Int = trunkateToInt(value - other.toInt().value)
     /** Subtracts the other value from this value. */
-    public operator fun minus(other: Long): Long
+    public operator fun minus(other: Long): Long = value.toLong() - other
     /** Subtracts the other value from this value. */
-    public operator fun minus(other: Float): Float
+    public operator fun minus(other: Float): Float = value.toFloat() - other
     /** Subtracts the other value from this value. */
-    public operator fun minus(other: Double): Double
+    public operator fun minus(other: Double): Double = value - other
 
     /** Multiplies this value by the other value. */
-    public operator fun times(other: Byte): Int
+    public operator fun times(other: Byte): Int = imul(this, other.toInt())
     /** Multiplies this value by the other value. */
-    public operator fun times(other: Short): Int
+    public operator fun times(other: Short): Int = imul(this, other.toInt())
     /** Multiplies this value by the other value. */
-    public operator fun times(other: Int): Int
+    public operator fun times(other: Int): Int = imul(this, other)
     /** Multiplies this value by the other value. */
-    public operator fun times(other: Long): Long
+    public operator fun times(other: Long): Long = value.toLong() * other
     /** Multiplies this value by the other value. */
-    public operator fun times(other: Float): Float
+    public operator fun times(other: Float): Float = value.toFloat() * other
     /** Multiplies this value by the other value. */
-    public operator fun times(other: Double): Double
+    public operator fun times(other: Double): Double = value.toDouble() * other
 
     /** Divides this value by the other value. */
-    public operator fun div(other: Byte): Int
+    public operator fun div(other: Byte): Int = trunkateToInt(value / other.toInt().value)
     /** Divides this value by the other value. */
-    public operator fun div(other: Short): Int
+    public operator fun div(other: Short): Int = trunkateToInt(value / other.toInt().value)
     /** Divides this value by the other value. */
-    public operator fun div(other: Int): Int
+    public operator fun div(other: Int): Int = trunkateToInt(value / other.toInt().value).toInt()
     /** Divides this value by the other value. */
-    public operator fun div(other: Long): Long
+    public operator fun div(other: Long): Long = value.toLong() / other
     /** Divides this value by the other value. */
-    public operator fun div(other: Float): Float
+    public operator fun div(other: Float): Float = value.toFloat() / other
     /** Divides this value by the other value. */
-    public operator fun div(other: Double): Double
+    public operator fun div(other: Double): Double = value / other
 
     /** Calculates the remainder of dividing this value by the other value. */
     @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.ERROR)
-    public operator fun mod(other: Byte): Int
+    public operator fun mod(other: Byte): Int = trunkateToInt(value % other.toInt().value)
     /** Calculates the remainder of dividing this value by the other value. */
     @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.ERROR)
-    public operator fun mod(other: Short): Int
+    public operator fun mod(other: Short): Int = trunkateToInt(value % other.toInt().value)
     /** Calculates the remainder of dividing this value by the other value. */
     @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.ERROR)
-    public operator fun mod(other: Int): Int
+    public operator fun mod(other: Int): Int = trunkateToInt(value % other.toInt().value)
     /** Calculates the remainder of dividing this value by the other value. */
     @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.ERROR)
-    public operator fun mod(other: Long): Long
+    public operator fun mod(other: Long): Long = value.toLong() % other
     /** Calculates the remainder of dividing this value by the other value. */
     @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.ERROR)
-    public operator fun mod(other: Float): Float
+    public operator fun mod(other: Float): Float = value.toFloat() % other
     /** Calculates the remainder of dividing this value by the other value. */
     @Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.ERROR)
-    public operator fun mod(other: Double): Double
+    public operator fun mod(other: Double): Double = value % other
 
     /** Calculates the remainder of dividing this value by the other value. */
     @SinceKotlin("1.1")
-    public operator fun rem(other: Byte): Int
+    public operator fun rem(other: Byte): Int = trunkateToInt(value % other.toInt().value)
     /** Calculates the remainder of dividing this value by the other value. */
     @SinceKotlin("1.1")
-    public operator fun rem(other: Short): Int
+    public operator fun rem(other: Short): Int = trunkateToInt(value % other.toInt().value)
     /** Calculates the remainder of dividing this value by the other value. */
     @SinceKotlin("1.1")
-    public operator fun rem(other: Int): Int
+    public operator fun rem(other: Int): Int = trunkateToInt(value % other.toInt().value)
     /** Calculates the remainder of dividing this value by the other value. */
     @SinceKotlin("1.1")
-    public operator fun rem(other: Long): Long
+    public operator fun rem(other: Long): Long = value.toLong() % other
     /** Calculates the remainder of dividing this value by the other value. */
     @SinceKotlin("1.1")
-    public operator fun rem(other: Float): Float
+    public operator fun rem(other: Float): Float = value.toFloat() % other
     /** Calculates the remainder of dividing this value by the other value. */
     @SinceKotlin("1.1")
-    public operator fun rem(other: Double): Double
+    public operator fun rem(other: Double): Double = value % other
 
     /** Increments this value. */
-    public operator fun inc(): Int
+    public operator fun inc(): Int = this + 1
     /** Decrements this value. */
-    public operator fun dec(): Int
+    public operator fun dec(): Int = this - 1
     /** Returns this value. */
-    public operator fun unaryPlus(): Int
+    public operator fun unaryPlus(): Int = this
     /** Returns the negative of this value. */
-    public operator fun unaryMinus(): Int
+    public operator fun unaryMinus(): Int = trunkateToInt(-value)
 
      /** Creates a range from this value to the specified [other] value. */
-    public operator fun rangeTo(other: Byte): IntRange
+    public operator fun rangeTo(other: Byte): IntRange = IntRange(this, other.toInt())
      /** Creates a range from this value to the specified [other] value. */
-    public operator fun rangeTo(other: Short): IntRange
+    public operator fun rangeTo(other: Short): IntRange = IntRange(this, other.toInt())
      /** Creates a range from this value to the specified [other] value. */
-    public operator fun rangeTo(other: Int): IntRange
+    public operator fun rangeTo(other: Int): IntRange = IntRange(this, other.toInt())
      /** Creates a range from this value to the specified [other] value. */
-    public operator fun rangeTo(other: Long): LongRange
+    public operator fun rangeTo(other: Long): LongRange = LongRange(this.toLong(), other)
 
     /** Shifts this value left by the [bitCount] number of bits. */
-    public infix fun shl(bitCount: Int): Int
+    public infix fun shl(bitCount: Int): Int = jsShl(value, bitCount.value)
     /** 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): Int
+    public infix fun shr(bitCount: Int): Int = jsShr(value, bitCount.value)
     /** Shifts this value right by the [bitCount] number of bits, filling the leftmost bits with zeros. */
-    public infix fun ushr(bitCount: Int): Int
+    public infix fun ushr(bitCount: Int): Int = jsShru(value, bitCount.value)
     /** Performs a bitwise AND operation between the two values. */
-    public infix fun and(other: Int): Int
+    public infix fun and(other: Int): Int = jsAnd(value, other.value)
     /** Performs a bitwise OR operation between the two values. */
-    public infix fun or(other: Int): Int
+    public infix fun or(other: Int): Int = jsOr(value, other.value)
     /** Performs a bitwise XOR operation between the two values. */
-    public infix fun xor(other: Int): Int
+    public infix fun xor(other: Int): Int = jsXor(value, other.value)
     /** Inverts the bits in this value. */
-    public fun inv(): Int
+    public fun inv(): Int = jsInv(value)
 
-    public override fun toByte(): Byte
-    public override fun toChar(): Char
-    public override fun toShort(): Short
-    public override fun toInt(): Int
-    public override fun toLong(): Long
-    public override fun toFloat(): Float
-    public override fun toDouble(): Double
+    public override fun toByte(): Byte = value.toByte()
+    public override fun toChar(): Char = value.toChar()
+    public override fun toShort(): Short = value.toShort()
+    public override fun toInt(): Int = this
+    public override fun toLong(): Long = value.toLong()
+    public override fun toFloat(): Float = value.toFloat()
+    public override fun toDouble(): Double = value
+
+    override fun toString() = value.toString()
+
+    override fun hashCode(): Int = this
 }
 
+fun d2i(x: dynamic): Int = Int(x.unsafeCast<Double>())
+fun trunkateToInt(x: Double): Int = Int(js("x | 0").unsafeCast<Double>())
+fun jsShl(a: Double, b: Double): Int = d2i(js("a << b"))
+fun jsShr(a: Double, b: Double): Int = d2i(js("a >> b"))
+fun jsShru(a: Double, b: Double): Int = d2i(js("a >>> b"))
+fun jsAnd(a: Double, b: Double): Int = d2i(js("a & b"))
+fun jsOr(a: Double, b: Double): Int = d2i(js("a | b"))
+fun jsXor(a: Double, b: Double): Int = d2i(js("a ^ b"))
+fun jsInv(a: Double): Int = d2i(js("~a"))
+
 /**
  * Represents a single-precision 32-bit IEEE 754 floating point number.
  * On the JVM, non-nullable values of this type are represented as values of the primitive type `float`.

libraries/stdlib/js/irRuntime/core.kt

@@ -42,12 +42,16 @@ fun hashCode(obj: dynamic): Int {
         return 0
 
     return when (typeOf(obj)) {
-        "object" ->  if ("function" === js("typeof obj.hashCode")) js("obj.hashCode()") else getObjectHashCode(obj)
+        "object" ->  when {
+            "function" === js("typeof obj.hashCode") -> js("obj.hashCode()")
+            "function" === js("typeof obj.hashCode_ret\$kotlin_Int") -> js("obj.hashCode_ret\$kotlin_Int()")
+            else -> getObjectHashCode(obj)
+        }
         "function" -> getObjectHashCode(obj)
         "number" -> getNumberHashCode(obj)
         "boolean" -> if(obj.unsafeCast<Boolean>()) 1 else 0
         else -> getStringHashCode(js("String(obj)"))
-    }
+    }.unsafeCast<Int>()
 }
 
 fun getObjectHashCode(obj: dynamic) = js("""

libraries/stdlib/js/irRuntime/numberConversion.kt

@@ -19,12 +19,12 @@ 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 toLong(a: Int): Long = fromInt(a)
 
-fun doubleToInt(a: dynamic) = js("""
-    if (a > 2147483647) return 2147483647;
-    if (a < -2147483648) return -2147483648;
-    return a | 0;
-""").unsafeCast<Int>()
+fun doubleToInt(a: Double) = when {
+    a > 2147483647.0 -> 2147483647
+    a < -2147483648.0 -> -2147483648
+    else -> Int(js("a | 0").unsafeCast<Double>())
+}
 
 fun numberToChar(a: dynamic) = Char(numberToInt(a) and 0xFFFF)

libraries/stdlib/js/irRuntime/rangeTo.kt

@@ -6,7 +6,7 @@
 package kotlin.js
 
 // Creates IntRange for {Byte, Short, Int}.rangeTo(x: {Byte, Short, Int})
-fun numberRangeToNumber(start: dynamic, endInclusive: dynamic) =
+fun numberRangeToNumber(start: Int, endInclusive: Int) =
     IntRange(start, endInclusive)
 
 // Create LongRange for {Byte, Short, Int}.rangeTo(x: Long)

libraries/stdlib/js/irRuntime/typeCheckUtils.kt

@@ -152,7 +152,7 @@ public fun jsIsType(obj: dynamic, jsClass: dynamic): Boolean {
     return false
 }
 
-fun isNumber(a: dynamic) = jsTypeOf(a) == "number" || a is Long
+fun isNumber(a: dynamic) = jsTypeOf(a) == "number" || a is Long || a is Int
 
 fun isComparable(value: dynamic): Boolean {
     var type = jsTypeOf(value)

libraries/stdlib/js/src/kotlin/char.kt

@@ -9,10 +9,10 @@ package kotlin.text
 public actual fun Char.isWhitespace(): Boolean = toString().matches("[\\s\\xA0]")
 
 @kotlin.internal.InlineOnly
-public actual inline fun Char.toLowerCase(): Char = js("String.fromCharCode")(toInt()).toLowerCase().charCodeAt(0).unsafeCast<Int>().toChar()
+public actual inline fun Char.toLowerCase(): Char = js("String.fromCharCode")(toDouble()).toLowerCase().charCodeAt(0).unsafeCast<Int>().toChar()
 
 @kotlin.internal.InlineOnly
-public actual inline fun Char.toUpperCase(): Char = js("String.fromCharCode")(toInt()).toUpperCase().charCodeAt(0).unsafeCast<Int>().toChar()
+public actual inline fun Char.toUpperCase(): Char = js("String.fromCharCode")(toDouble()).toUpperCase().charCodeAt(0).unsafeCast<Int>().toChar()
 
 /**
  * Returns `true` if this character is a Unicode high-surrogate code unit (also known as leading-surrogate code unit).

libraries/stdlib/js/src/kotlin/collections.kt

@@ -133,8 +133,8 @@ internal fun <T> arrayCopy(source: Array<out T>, destination: Array<in T>, desti
     AbstractList.checkRangeIndexes(destinationOffset, destinationOffset + rangeSize, destination.size)
 
     if (js("ArrayBuffer").isView(destination) && js("ArrayBuffer").isView(source)) {
-        val subrange = source.asDynamic().subarray(startIndex, endIndex)
-        destination.asDynamic().set(subrange, destinationOffset)
+        val subrange = source.asDynamic().subarray(startIndex.toDouble(), endIndex.toDouble())
+        destination.asDynamic().set(subrange, destinationOffset.toDouble())
     } else {
         if (source !== destination || destinationOffset <= startIndex) {
             for (index in 0 until rangeSize) {

libraries/stdlib/js/src/kotlin/string.kt

@@ -53,10 +53,10 @@ public actual inline fun String.toUpperCase(): String = asDynamic().toUpperCase(
 public actual inline fun String.toLowerCase(): String = asDynamic().toLowerCase()
 
 @kotlin.internal.InlineOnly
-internal actual inline fun String.nativeIndexOf(str: String, fromIndex: Int): Int = asDynamic().indexOf(str, fromIndex)
+internal actual inline fun String.nativeIndexOf(str: String, fromIndex: Int): Int = asDynamic().indexOf(str, fromIndex.toDouble()).unsafeCast<Int>()
 
 @kotlin.internal.InlineOnly
-internal actual inline fun String.nativeLastIndexOf(str: String, fromIndex: Int): Int = asDynamic().lastIndexOf(str, fromIndex)
+internal actual inline fun String.nativeLastIndexOf(str: String, fromIndex: Int): Int = asDynamic().lastIndexOf(str, fromIndex.toDouble()).unsafeCast<Int>()
 
 @kotlin.internal.InlineOnly
 internal inline fun String.nativeStartsWith(s: String, position: Int): Boolean = asDynamic().startsWith(s, position)
@@ -65,10 +65,10 @@ internal inline fun String.nativeStartsWith(s: String, position: Int): Boolean =
 internal inline fun String.nativeEndsWith(s: String): Boolean = asDynamic().endsWith(s)
 
 @kotlin.internal.InlineOnly
-public actual inline fun String.substring(startIndex: Int): String = asDynamic().substring(startIndex)
+public actual inline fun String.substring(startIndex: Int): String = asDynamic().substring(startIndex.toDouble())
 
 @kotlin.internal.InlineOnly
-public actual inline fun String.substring(startIndex: Int, endIndex: Int): String = asDynamic().substring(startIndex, endIndex)
+public actual inline fun String.substring(startIndex: Int, endIndex: Int): String = asDynamic().substring(startIndex.toDouble(), endIndex.toDouble())
 
 @kotlin.internal.InlineOnly
 public inline fun String.concat(str: String): String = asDynamic().concat(str)