[JS IR BE] Reflection support

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/utils/kotlinTypeBasedUtils.kt

@@ -26,6 +26,8 @@ fun IrType.isInterface() = toKotlinType().isInterface()
 
 fun IrType.isPrimitiveArray() = KotlinBuiltIns.isPrimitiveArray(toKotlinType())
 
+fun IrType.getPrimitiveArrayElementType() = KotlinBuiltIns.getPrimitiveArrayElementType(toKotlinType())
+
 fun IrType.isTypeParameter() = toKotlinType().isTypeParameter()
 
 fun IrType.isFunctionOrKFunction() = toKotlinType().isFunctionOrKFunctionType

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.ir.backend.js
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
@@ -118,11 +119,21 @@ class JsIntrinsics(
     //    val isCharSymbol = getInternalFunction("isChar")
     val isObjectSymbol = getInternalFunction("isObject")
 
+    val isPrimitiveArray = mapOf(
+        PrimitiveType.BOOLEAN to getInternalFunction("isBooleanArray"),
+        PrimitiveType.BYTE to getInternalFunction("isByteArray"),
+        PrimitiveType.SHORT to getInternalFunction("isShortArray"),
+        PrimitiveType.CHAR to getInternalFunction("isCharArray"),
+        PrimitiveType.INT to getInternalFunction("isIntArray"),
+        PrimitiveType.FLOAT to getInternalFunction("isFloatArray"),
+        PrimitiveType.LONG to getInternalFunction("isLongArray"),
+        PrimitiveType.DOUBLE to getInternalFunction("isLongArray")
+    )
+
     // Other:
 
     val jsObjectCreate = defineObjectCreateIntrinsic() // Object.create
     val jsSetJSField = defineSetJSPropertyIntrinsic() // till we don't have dynamic type we use intrinsic which sets a field with any name
-    val jsToJsType = defineToJsType() // creates name reference to KotlinType
     val jsCode = getInternalFunction("js") // js("<code>")
     val jsHashCode = getInternalFunction("hashCode")
     val jsGetObjectHashCode = getInternalFunction("getObjectHashCode")
@@ -139,6 +150,10 @@ class JsIntrinsics(
         val f = getInternalFunctions("getContinuation")
         symbolTable.referenceSimpleFunction(f.single())
     }
+    val jsGetKClass = getInternalWithoutPackage("getKClass")
+    val jsGetKClassFromExpression = getInternalWithoutPackage("getKClassFromExpression")
+    val jsClass = getInternalFunction("jsClass")
+
     val jsNumberRangeToNumber = getInternalFunction("numberRangeToNumber")
     val jsNumberRangeToLong = getInternalFunction("numberRangeToLong")
 
@@ -162,28 +177,9 @@ class JsIntrinsics(
     private fun getInternalFunction(name: String) =
         context.symbolTable.referenceSimpleFunction(context.getInternalFunctions(name).single())
 
-    private fun defineToJsType(): IrSimpleFunction {
+    private fun getInternalWithoutPackage(name: String) =
-        val desc = SimpleFunctionDescriptorImpl.create(
+        context.symbolTable.referenceSimpleFunction(context.getFunctions(FqName(name)).single())
-            module,
-            Annotations.EMPTY,
-            Name.identifier("\$toJSType\$"),
-            CallableMemberDescriptor.Kind.SYNTHESIZED,
-            SourceElement.NO_SOURCE
-        ).apply {
 
-            val typeParameter = TypeParameterDescriptorImpl.createWithDefaultBound(
-                this,
-                Annotations.EMPTY,
-                false,
-                Variance.INVARIANT,
-                Name.identifier("T"),
-                0
-            )
-            initialize(null, null, listOf(typeParameter), emptyList(), builtIns.anyType, Modality.FINAL, Visibilities.PUBLIC)
-        }
-
-        return stubBuilder.generateFunctionStub(desc)
-    }
 
     // TODO: unify how we create intrinsic symbols
     private fun defineObjectCreateIntrinsic(): IrSimpleFunction {

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

@@ -114,6 +114,7 @@ private fun JsIrBackendContext.lower(moduleFragment: IrModuleFragment) {
     moduleFragment.files.forEach(clble.getReferenceCollector())
     moduleFragment.files.forEach(clble.getClosureBuilder())
     moduleFragment.files.forEach(clble.getReferenceReplacer())
+    moduleFragment.files.forEach(ClassReferenceLowering(this)::lower)
     moduleFragment.files.forEach(IntrinsicifyCallsLowering(this)::lower)
 }
 

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

@@ -0,0 +1,53 @@
+/*
+ * 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 org.jetbrains.kotlin.ir.backend.js.lower
+
+import org.jetbrains.kotlin.backend.common.FileLoweringPass
+import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
+import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
+import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.expressions.IrClassReference
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrGetClass
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
+import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
+
+class ClassReferenceLowering(val context: JsIrBackendContext) : FileLoweringPass {
+    private val intrinsics = context.intrinsics
+
+    private fun callGetKClassFromExpression(returnType: IrType, typeArgument: IrType, argument: IrExpression) =
+        JsIrBuilder.buildCall(intrinsics.jsGetKClassFromExpression, returnType, listOf(typeArgument)).apply {
+            putValueArgument(0, argument)
+        }
+
+    private fun callGetKClass(returnType: IrType, typeArgument: IrType, argument: IrExpression) =
+        JsIrBuilder.buildCall(intrinsics.jsGetKClass, returnType, listOf(typeArgument)).apply {
+            putValueArgument(0, argument)
+        }
+
+    private fun callJsClass(type: IrType) =
+        JsIrBuilder.buildCall(intrinsics.jsClass, typeArguments = listOf(type))
+
+    override fun lower(irFile: IrFile) {
+        irFile.transformChildrenVoid(object : IrElementTransformerVoid() {
+            override fun visitGetClass(expression: IrGetClass) =
+                callGetKClassFromExpression(
+                    returnType = expression.type,
+                    typeArgument = expression.argument.type,
+                    argument = expression.argument.transform(this, null)
+                )
+
+            override fun visitClassReference(expression: IrClassReference) =
+                callGetKClass(
+                    returnType = expression.type,
+                    typeArgument = expression.classType,
+                    argument = callJsClass(expression.classType)
+                )
+        })
+    }
+}
+

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

@@ -325,9 +325,10 @@ class IntrinsicifyCallsLowering(private val context: JsIrBackendContext) : FileL
 
                             // assignment to a property
                             IrStatementOrigin.EQ -> {
-                                val fieldSymbol = IrFieldSymbolImpl((symbol.descriptor as PropertyAccessorDescriptor).correspondingProperty)
+                                if (symbol.descriptor is PropertyAccessorDescriptor) {
-                                return JsIrBuilder.buildSetField(fieldSymbol, call.dispatchReceiver, call.getValueArgument(0)!!, call.type)
+                                    val fieldSymbol = IrFieldSymbolImpl((symbol.descriptor as PropertyAccessorDescriptor).correspondingProperty)
-
+                                    return JsIrBuilder.buildSetField(fieldSymbol, call.dispatchReceiver, call.getValueArgument(0)!!, call.type)
+                                }
                             }
                         }
                     }

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

@@ -50,7 +50,7 @@ class TypeOperatorLowering(val context: JsIrBackendContext) : FileLoweringPass {
 
     private val instanceOfIntrinsicSymbol = context.intrinsics.jsInstanceOf.symbol
     private val typeOfIntrinsicSymbol = context.intrinsics.jsTypeOf.symbol
-    private val toJSTypeIntrinsicSymbol = context.intrinsics.jsToJsType.symbol
+    private val jsClassIntrinsicSymbol = context.intrinsics.jsClass
 
     private val stringMarker = JsIrBuilder.buildString(context.irBuiltIns.stringType, "string")
     private val booleanMarker = JsIrBuilder.buildString(context.irBuiltIns.stringType, "boolean")
@@ -241,13 +241,14 @@ class TypeOperatorLowering(val context: JsIrBackendContext) : FileLoweringPass {
             }
 
             private fun wrapTypeReference(toType: IrType) =
-                JsIrBuilder.buildCall(toJSTypeIntrinsicSymbol).apply { putTypeArgument(0, toType) }
+                JsIrBuilder.buildCall(jsClassIntrinsicSymbol).apply { putTypeArgument(0, toType) }
 
             private fun generateGenericArrayCheck(argument: IrExpression) =
                 JsIrBuilder.buildCall(isArraySymbol).apply { putValueArgument(0, argument) }
 
             private fun generatePrimitiveArrayTypeCheck(argument: IrExpression, toType: IrType): IrExpression {
-                TODO("Implement Typed Array check")
+                val f = context.intrinsics.isPrimitiveArray[toType.getPrimitiveArrayElementType()]!!
+                return JsIrBuilder.buildCall(f).apply { putValueArgument(0, argument) }
             }
 
             private fun generateInterfaceCheck(argument: IrExpression, toType: IrType): IrExpression {

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/JsClassGenerator.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.ir.types.classifierOrFail
 import org.jetbrains.kotlin.ir.types.isAny
 import org.jetbrains.kotlin.ir.util.defaultType
 import org.jetbrains.kotlin.ir.util.isInterface
+import org.jetbrains.kotlin.ir.util.isObject
 import org.jetbrains.kotlin.ir.util.isReal
 import org.jetbrains.kotlin.ir.util.resolveFakeOverride
 import org.jetbrains.kotlin.js.backend.ast.*
@@ -158,6 +159,15 @@ class JsClassGenerator(private val irClass: IrClass, val context: JsGenerationCo
             metadataLiteral.propertyInitializers += simpleNameProp
         }
 
+        val classKind = JsStringLiteral(
+            when {
+                irClass.isInterface -> "interface"
+                irClass.isObject -> "object"
+                else -> "class"
+            }
+        )
+        metadataLiteral.propertyInitializers += JsPropertyInitializer(JsNameRef(Namer.METADATA_CLASS_KIND), classKind)
+
         metadataLiteral.propertyInitializers += generateSuperClasses()
         return jsAssignment(JsNameRef(Namer.METADATA, classNameRef), metadataLiteral).makeStmt()
     }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/JsIntrinsicTransformers.kt

@@ -90,7 +90,7 @@ class JsIntrinsicTransformers(backendContext: JsIrBackendContext) {
                 jsAssignment(JsNameRef(fieldNameLiteral, receiver), fieldValue)
             }
 
-            add(intrinsics.jsToJsType) { call, context ->
+            add(intrinsics.jsClass) { call, context ->
                 val typeName = context.getNameForSymbol(call.getTypeArgument(0)!!.classifierOrFail)
                 typeName.makeRef()
             }

compiler/testData/codegen/box/binaryOp/kt11163.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 operator fun Int.compareTo(c: Char) = 0
 
 fun foo(x: Int, y: Char): String {

compiler/testData/codegen/box/binaryOp/kt11163_properIeee754comparisons.kt

@@ -1,5 +1,4 @@
 // !LANGUAGE: +ProperIeee754Comparisons
-// IGNORE_BACKEND: JS_IR
 operator fun Int.compareTo(c: Char) = 0
 
 fun foo(x: Int, y: Char): String {

compiler/testData/codegen/box/binaryOp/kt23030_properIeee754comparisons.kt

@@ -1,5 +1,4 @@
 // !LANGUAGE: +ProperIeee754Comparisons
-// IGNORE_BACKEND: JS_IR
 class C {
     operator fun Int.compareTo(c: Char) = 0
 

compiler/testData/codegen/box/boxingOptimization/kt5844.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 import kotlin.test.assertEquals

compiler/testData/codegen/box/callableReference/bound/genericValOnLHS.kt

@@ -1,5 +1,4 @@
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 // IGNORE_BACKEND: NATIVE
 
 class Generic<P : Any>(val p: P)

compiler/testData/codegen/box/callableReference/bound/smartCastForExtensionReceiver.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 class B
 
 fun B.magic() {

compiler/testData/codegen/box/callableReference/property/privateSetterOutsideClass.kt

@@ -1,5 +1,4 @@
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 // See KT-12337 Reference to property with invisible setter should not be a KMutableProperty
 
 import kotlin.reflect.KProperty1

compiler/testData/codegen/box/classLiteral/bound/smartCast.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // IGNORE_BACKEND: NATIVE
 // KT-16291 Smart cast doesn't work when getting class of instance
 

compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyAssign.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 fun box(): String {

compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyCAO.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 fun box(): String {

compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyIncrDecr.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 fun box(): String {

compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyIndexedCAO.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 class Host(var value: String) {

compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedVarsOfSize2.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 fun box(): String {

compiler/testData/codegen/box/closures/capturedVarsOptimization/kt17588.kt

@@ -1,5 +1,4 @@
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 //WITH_RUNTIME
 class Test {
 

compiler/testData/codegen/box/closures/capturedVarsOptimization/sharedSlotsWithCapturedVars.kt

@@ -1,5 +1,4 @@
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 fun box(): String {

compiler/testData/codegen/box/defaultArguments/kt6382.kt

@@ -1,5 +1,4 @@
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 fun box(): String {

compiler/testData/codegen/box/enum/kt20651_inlineLambda.kt

@@ -1,5 +1,4 @@
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 enum class Test(val x: String, val closure1: () -> String) {
     FOO("O", run { { FOO.x } }) {
         override val y: String = "K"

compiler/testData/codegen/box/enum/kt7257.kt

@@ -1,5 +1,4 @@
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 enum class X {
     B {
         val value2 = "K"

compiler/testData/codegen/box/extensionFunctions/kt13312.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 fun test1(f: (Int) -> Int) = f(1)
 
 fun test2(f: Int.() -> Int) = 2.f()

compiler/testData/codegen/box/functions/localFunctions/localFunctionVsLocalVariable.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 fun box(): String {
     var s = ""
     var foo = "O"

compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunWithoutClosure.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 fun box(): String {
     fun foo(x: String) = x
     fun foo() = foo("K")

compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 fun box(): String {
     var s = ""
 

compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction1.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 fun box(): String {
     var s = ""
     var foo = "K"

compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction3.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 fun box(): String {
     var s = ""
     var foo = "O"

compiler/testData/codegen/box/inlineClasses/castInsideWhenExpression.kt

@@ -1,6 +1,5 @@
 // !LANGUAGE: +InlineClasses
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 
 inline class Foo<T>(val x: Any) {
     fun bar() {}

compiler/testData/codegen/box/inlineClasses/kt25771.kt

@@ -1,5 +1,5 @@
 // !LANGUAGE: +InlineClasses
-// IGNORE_BACKEND: JVM_IR, JS_IR
+// IGNORE_BACKEND: JVM_IR
 
 inline class SuccessOrFailure<out T>(val value: Any?) {
     val isFailure: Boolean get() = value is Failure

compiler/testData/codegen/box/objects/selfReferenceToCompanionObjectInInlineLambdaInSuperConstructorCall.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 abstract class Base(val fn: () -> String)
 
 class Host {

compiler/testData/codegen/box/objects/selfReferenceToInterfaceCompanionObjectInInlineLambdaInSuperConstructorCall.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 abstract class Base(val fn: () -> String)
 
 interface Host {

compiler/testData/codegen/box/objects/selfReferenceToObjectInInlineLambdaInSuperConstructorCall.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 abstract class Base(val fn: () -> String)
 
 object Test : Base(run { { Test.ok() } }) {

compiler/testData/codegen/box/properties/lateinit/local/localLateinit.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // LANGUAGE_VERSION: 1.2
 
 fun box(): String {

compiler/testData/codegen/box/ranges/forInDownTo/forIntInDownTo.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 import kotlin.test.assertEquals

compiler/testData/codegen/box/ranges/forInUntil/forInUntilChar0.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 import kotlin.test.assertEquals

compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToCharMinValue.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 const val M = 0.toChar()

compiler/testData/codegen/box/reflection/classLiterals/annotationClassLiteral.kt

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

compiler/testData/codegen/box/reflection/classLiterals/genericClass.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // IGNORE_BACKEND: NATIVE
 // WITH_REFLECT
 

compiler/testData/codegen/box/reflection/classLiterals/simpleClassLiteral.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // IGNORE_BACKEND: NATIVE
 // WITH_REFLECT
 

compiler/testData/codegen/box/reflection/classes/localClassSimpleName.kt

@@ -1,5 +1,4 @@
 // IGNORE_BACKEND: JVM_IR
-// IGNORE_BACKEND: JS_IR
 // IGNORE_BACKEND: NATIVE
 // WITH_REFLECT
 

compiler/testData/codegen/box/regressions/intersectionOfEqualTypes.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 // FILE: test.kt

compiler/testData/codegen/box/regressions/kt5786_privateWithDefault.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 
 fun box(): String {

compiler/testData/codegen/box/regressions/lambdaAsLastExpressionInLambda.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 val foo: ((String) -> String) = run {
     { it }
 }

compiler/testData/codegen/box/regressions/lambdaWrongReturnType.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 fun test() = foo({ line: String -> line })
 
 fun <T> foo(x: T): T = TODO()

compiler/testData/codegen/box/secondaryConstructors/withNonLocalReturn.kt

@@ -1,12 +1,12 @@
 // IGNORE_BACKEND: JVM_IR
-inline fun run(block: () -> Unit) = block()
+inline fun run2(block: () -> Unit) = block()
 
 class A {
     val prop: Int
     constructor(arg: Boolean) {
         if (arg) {
             prop = 1
-            run { return }
+            run2 { return }
             throw RuntimeException("fail 0")
         }
         prop = 2

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicIrBoxTest.kt

@@ -5,10 +5,7 @@
 
 package org.jetbrains.kotlin.js.test
 
-import org.jetbrains.kotlin.config.ApiVersion
+import org.jetbrains.kotlin.config.*
-import org.jetbrains.kotlin.config.LanguageVersion
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.ir.backend.js.Result
 import org.jetbrains.kotlin.ir.backend.js.compile
 import org.jetbrains.kotlin.js.config.JsConfig
@@ -24,9 +21,11 @@ private val runtimeSources = listOfKtFilesFrom(
     "libraries/stdlib/js/src/kotlin/jsTypeOf.kt",
     "libraries/stdlib/js/src/kotlin/dynamic.kt",
     "libraries/stdlib/js/src/kotlin/annotations.kt",
+    "libraries/stdlib/js/src/kotlin/reflect",
+    "libraries/stdlib/js/src/kotlin/annotationsJVM.kt",
 
-    "libraries/stdlib/src/kotlin/internal/Annotations.kt",
+    "libraries/stdlib/src/kotlin/internal",
-
+    "libraries/stdlib/src/kotlin/util/Standard.kt",
     "core/builtins/native/kotlin/Annotation.kt",
     "core/builtins/native/kotlin/Number.kt",
     "core/builtins/native/kotlin/Comparable.kt",
@@ -39,9 +38,14 @@ private val runtimeSources = listOfKtFilesFrom(
     "core/builtins/src/kotlin/Range.kt",
     "core/builtins/src/kotlin/Ranges.kt",
     "core/builtins/src/kotlin/Unit.kt",
+    "core/builtins/src/kotlin/reflect",
+    "core/builtins/src/kotlin/Function.kt",
+
     "core/builtins/native/kotlin/Collections.kt",
     "core/builtins/native/kotlin/Iterator.kt",
 
+    "libraries/stdlib/common/src/kotlin/JvmAnnotationsH.kt",
+
     "libraries/stdlib/js/irRuntime",
     BasicBoxTest.COMMON_FILES_DIR_PATH
 )
@@ -85,13 +89,20 @@ abstract class BasicIrBoxTest(
             // TODO: split input files to some parts (global common, local common, test)
             .filterNot { it.virtualFilePath.contains(BasicBoxTest.COMMON_FILES_DIR_PATH) }
 
+        val runtimeConfiguration = config.configuration.copy()
+
+        // TODO: is it right in general? Maybe sometimes we need to compile with newer versions or with additional language features.
+        runtimeConfiguration.languageVersionSettings = LanguageVersionSettingsImpl(
+            LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE,
+            specificFeatures = mapOf(
+                LanguageFeature.AllowContractsForCustomFunctions to LanguageFeature.State.ENABLED,
+                LanguageFeature.MultiPlatformProjects to LanguageFeature.State.ENABLED
+            )
+        )
+
+
         if (runtimeResult == null) {
-            val myConfiguration = config.configuration.copy()
+            runtimeResult = compile(config.project, runtimeSources.map(::createPsiFile), runtimeConfiguration)
-
-            // TODO: is it right in general? Maybe sometimes we need to compile with newer versions or with additional language features.
-            myConfiguration.languageVersionSettings = LanguageVersionSettingsImpl(LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE)
-
-            runtimeResult = compile(config.project, runtimeSources.map(::createPsiFile), myConfiguration)
             runtimeFile.write(runtimeResult!!.generatedCode)
         }
 
@@ -101,7 +112,7 @@ abstract class BasicIrBoxTest(
             compile(
                 config.project,
                 allFiles,
-                config.configuration,
+                runtimeConfiguration,
                 FqName((testPackage?.let { "$it." } ?: "") + testFunction))
         } else {
             compile(

js/js.translator/testData/box/char/charInStringTemplate.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1114
 package foo
 import kotlin.test.assertEquals

js/js.translator/testData/box/expression/cast/checkThrowCCE.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1094
 package foo
 

js/js.translator/testData/box/inline/extension.kt

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

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

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

js/js.translator/testData/box/inlineStdlib/callNameClash.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1127
 package foo
 

js/js.translator/testData/box/inlineStdlib/localNamesClash.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1115
 package foo
 

js/js.translator/testData/box/inlineStdlib/thisInExtension.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1116
 package foo
 

js/js.translator/testData/box/labels/labelOnExpression.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1122
 // CHECK_LABELS_COUNT: function=test0 count=0
 // CHECK_LABELS_COUNT: function=test1 count=0

js/js.translator/testData/box/nameClashes/withBuiltin.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1135
 open class C {
     private fun constructor() = "C.constructor"

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

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1111
 //FILE: nativeClassAsReifiedTypeArgument.kt
 

js/js.translator/testData/box/reflection/external.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1099
 external class A
 

js/js.translator/testData/box/reflection/jsClass.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1169
 package foo
 

js/js.translator/testData/box/reflection/jsClassOnReifiedType.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1165
 package foo
 

js/js.translator/testData/box/reflection/jsClassSimpleName.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1177
 package foo
 

js/js.translator/testData/box/reflection/kClass.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1168
 package foo
 

js/js.translator/testData/box/reflection/kClassIsInstance.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1177
 package foo
 

js/js.translator/testData/box/reflection/kClassOnReifiedType.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1165
 package foo
 

js/js.translator/testData/box/reflection/kClassSimpleName.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JS_IR
 // EXPECTED_REACHABLE_NODES: 1177
 package foo
 

libraries/stdlib/js/irRuntime/exceptions.kt

@@ -4,6 +4,12 @@
  */
 package kotlin
 
+open class Error(override val message: String?, override val cause: Throwable?) : Throwable() {
+    constructor() : this(null, null)
+    constructor(_message: String?) : this(_message, null)
+    constructor(_cause: Throwable?) : this(null, _cause)
+}
+
 open class Exception(override val message: String?, override val cause: Throwable?) : Throwable() {
     constructor() : this(null, null)
     constructor(_message: String?) : this(_message, null)

libraries/stdlib/js/irRuntime/hacks.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
+
+// TODO: Ignore FunctionN interfaces
+
+public interface Function0<out R> : Function<R> {
+    public operator fun invoke(): R
+}
+
+public interface Function1<in P1, out R> : Function<R> {
+    public operator fun invoke(p1: P1): R
+}
+
+public interface Function2<in P1, in P2, out R> : Function<R> {
+    public operator fun invoke(p1: P1, p2: P2): R
+}
+
+public interface Function3<in P1, in P2, in P3, out R> : Function<R> {
+    public operator fun invoke(p1: P1, p2: P2, p3: P3): R
+}
+
+public inline fun <reified T> arrayOfNulls(size: Int): Array<T?> = js("[]")  // FIXME: Implement
+

libraries/stdlib/js/irRuntime/rangeExtensions.kt

@@ -0,0 +1,355 @@
+/*
+ * 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.ranges
+
+// FIXME: Use stdlib _Ranges.kt instead
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Int.downTo(to: Byte): IntProgression {
+    return IntProgression.fromClosedRange(this, to.toInt(), -1)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Long.downTo(to: Byte): LongProgression {
+    return LongProgression.fromClosedRange(this, to.toLong(), -1L)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Byte.downTo(to: Byte): IntProgression {
+    return IntProgression.fromClosedRange(this.toInt(), to.toInt(), -1)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Short.downTo(to: Byte): IntProgression {
+    return IntProgression.fromClosedRange(this.toInt(), to.toInt(), -1)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Char.downTo(to: Char): CharProgression {
+    return CharProgression.fromClosedRange(this, to, -1)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Int.downTo(to: Int): IntProgression {
+    return IntProgression.fromClosedRange(this, to, -1)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Long.downTo(to: Int): LongProgression {
+    return LongProgression.fromClosedRange(this, to.toLong(), -1L)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Byte.downTo(to: Int): IntProgression {
+    return IntProgression.fromClosedRange(this.toInt(), to, -1)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Short.downTo(to: Int): IntProgression {
+    return IntProgression.fromClosedRange(this.toInt(), to, -1)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Int.downTo(to: Long): LongProgression {
+    return LongProgression.fromClosedRange(this.toLong(), to, -1L)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Long.downTo(to: Long): LongProgression {
+    return LongProgression.fromClosedRange(this, to, -1L)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Byte.downTo(to: Long): LongProgression {
+    return LongProgression.fromClosedRange(this.toLong(), to, -1L)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Short.downTo(to: Long): LongProgression {
+    return LongProgression.fromClosedRange(this.toLong(), to, -1L)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Int.downTo(to: Short): IntProgression {
+    return IntProgression.fromClosedRange(this, to.toInt(), -1)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Long.downTo(to: Short): LongProgression {
+    return LongProgression.fromClosedRange(this, to.toLong(), -1L)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Byte.downTo(to: Short): IntProgression {
+    return IntProgression.fromClosedRange(this.toInt(), to.toInt(), -1)
+}
+
+/**
+ * Returns a progression from this value down to the specified [to] value with the step -1.
+ * 
+ * The [to] value should be less than or equal to `this` value.
+ * If the [to] value is greater than `this` value the returned progression is empty.
+ */
+public infix fun Short.downTo(to: Short): IntProgression {
+    return IntProgression.fromClosedRange(this.toInt(), to.toInt(), -1)
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ */
+public infix fun Int.until(to: Byte): IntRange {
+    return this .. (to.toInt() - 1).toInt()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ */
+public infix fun Long.until(to: Byte): LongRange {
+    return this .. (to.toLong() - 1).toLong()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ */
+public infix fun Byte.until(to: Byte): IntRange {
+    return this.toInt() .. (to.toInt() - 1).toInt()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ */
+public infix fun Short.until(to: Byte): IntRange {
+    return this.toInt() .. (to.toInt() - 1).toInt()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ * 
+ * If the [to] value is less than or equal to `'\u0000'` the returned range is empty.
+ */
+public infix fun Char.until(to: Char): CharRange {
+    if (to <= '\u0000') return CharRange.EMPTY
+    return this .. (to - 1).toChar()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ * 
+ * If the [to] value is less than or equal to [Int.MIN_VALUE] the returned range is empty.
+ */
+public infix fun Int.until(to: Int): IntRange {
+    if (to <= Int.MIN_VALUE) return IntRange.EMPTY
+    return this .. (to - 1).toInt()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ */
+public infix fun Long.until(to: Int): LongRange {
+    return this .. (to.toLong() - 1).toLong()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ * 
+ * If the [to] value is less than or equal to [Int.MIN_VALUE] the returned range is empty.
+ */
+public infix fun Byte.until(to: Int): IntRange {
+    if (to <= Int.MIN_VALUE) return IntRange.EMPTY
+    return this.toInt() .. (to - 1).toInt()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ * 
+ * If the [to] value is less than or equal to [Int.MIN_VALUE] the returned range is empty.
+ */
+public infix fun Short.until(to: Int): IntRange {
+    if (to <= Int.MIN_VALUE) return IntRange.EMPTY
+    return this.toInt() .. (to - 1).toInt()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ * 
+ * If the [to] value is less than or equal to [Long.MIN_VALUE] the returned range is empty.
+ */
+public infix fun Int.until(to: Long): LongRange {
+    if (to <= Long.MIN_VALUE) return LongRange.EMPTY
+    return this.toLong() .. (to - 1).toLong()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ * 
+ * If the [to] value is less than or equal to [Long.MIN_VALUE] the returned range is empty.
+ */
+public infix fun Long.until(to: Long): LongRange {
+    if (to <= Long.MIN_VALUE) return LongRange.EMPTY
+    return this .. (to - 1).toLong()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ * 
+ * If the [to] value is less than or equal to [Long.MIN_VALUE] the returned range is empty.
+ */
+public infix fun Byte.until(to: Long): LongRange {
+    if (to <= Long.MIN_VALUE) return LongRange.EMPTY
+    return this.toLong() .. (to - 1).toLong()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ * 
+ * If the [to] value is less than or equal to [Long.MIN_VALUE] the returned range is empty.
+ */
+public infix fun Short.until(to: Long): LongRange {
+    if (to <= Long.MIN_VALUE) return LongRange.EMPTY
+    return this.toLong() .. (to - 1).toLong()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ */
+public infix fun Int.until(to: Short): IntRange {
+    return this .. (to.toInt() - 1).toInt()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ */
+public infix fun Long.until(to: Short): LongRange {
+    return this .. (to.toLong() - 1).toLong()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ */
+public infix fun Byte.until(to: Short): IntRange {
+    return this.toInt() .. (to.toInt() - 1).toInt()
+}
+
+/**
+ * Returns a range from this value up to but excluding the specified [to] value.
+ * 
+ * If the [to] value is less than or equal to `this` value the returned range is empty.
+ */
+public infix fun Short.until(to: Short): IntRange {
+    return this.toInt() .. (to.toInt() - 1).toInt()
+}

libraries/stdlib/js/irRuntime/typeCheckUtils.kt

@@ -74,6 +74,8 @@ public fun isInterface(ctor: dynamic, IType: dynamic): Boolean {
 
 fun typeOf(obj: dynamic) = js("typeof obj").unsafeCast<String>()
 
+fun instanceOf(obj: dynamic, jsClass: dynamic) = js("obj instanceof jsClass").unsafeCast<Boolean>()
+
 fun isObject(obj: dynamic): Boolean {
     val objTypeOf = typeOf(obj)
 
@@ -96,4 +98,54 @@ public fun isArrayish(o: dynamic) =
 
 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) = js("a instanceof Int8Array")
+public fun isByteArray(a: dynamic) = js("a instanceof Int8Array")
+public fun isShortArray(a: dynamic) = js("a instanceof Int16Array")
+public fun isCharArray(a: dynamic) = js("a instanceof Uint16Array")
+public fun isIntArray(a: dynamic) = js("a instanceof Int32Array")
+public fun isFloatArray(a: dynamic) = js("a instanceof Float32Array")
+public fun isDoubleArray(a: dynamic) = js("a instanceof Float64Array")
+public fun isLongArray(a: dynamic) = isArray(a)  // TODO: Implement
+
+
+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
 }

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

@@ -98,3 +98,5 @@ internal inline fun copyArrayType(from: dynamic, to: dynamic) {
         to.`$type$` = from.`$type$`
     }
 }
+
+internal inline fun jsIsType(obj: dynamic, jsClass: dynamic) = js("Kotlin").isType(obj, jsClass)

libraries/stdlib/js/src/kotlin/reflect/KClassImpl.kt

@@ -60,7 +60,7 @@ internal class SimpleKClassImpl<T : Any>(jClass: JsClass<T>) : KClassImpl<T>(jCl
     override val simpleName: String? = jClass.asDynamic().`$metadata$`?.simpleName.unsafeCast<String?>()
 
     override fun isInstance(value: Any?): Boolean {
-        return js("Kotlin").isType(value, jClass)
+        return jsIsType(value, jClass)
     }
 }