[TEST] Add IrText klib tests

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

@@ -361,7 +361,7 @@ fun GeneratorContext.generateModuleFragmentWithPlugins(
 }
 
 private fun createBuiltIns(storageManager: StorageManager) = object : KotlinBuiltIns(storageManager) {}
-internal val JsFactories = KlibMetadataFactories(::createBuiltIns, DynamicTypeDeserializer)
+public val JsFactories = KlibMetadataFactories(::createBuiltIns, DynamicTypeDeserializer)
 
 fun getModuleDescriptorByLibrary(current: KotlinLibrary, mapping: Map<String, ModuleDescriptorImpl>): ModuleDescriptorImpl {
     val md = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns(

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractKlibTextTestCase.kt

@@ -0,0 +1,278 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
+import junit.framework.TestCase
+import org.jetbrains.kotlin.backend.common.serialization.DeserializationStrategy
+import org.jetbrains.kotlin.backend.common.serialization.KlibIrVersion
+import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataIncrementalSerializer
+import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataVersion
+import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor
+import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.codegen.CodegenTestCase
+import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.ir.backend.js.JsFactories
+import org.jetbrains.kotlin.ir.backend.js.KotlinFileSerializedData
+import org.jetbrains.kotlin.ir.backend.js.jsResolveLibraries
+import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker
+import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrModuleSerializer
+import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerDesc
+import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
+import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrFunctionFactory
+import org.jetbrains.kotlin.ir.symbols.IrSymbol
+import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
+import org.jetbrains.kotlin.library.*
+import org.jetbrains.kotlin.library.impl.BuiltInsPlatform
+import org.jetbrains.kotlin.library.impl.buildKotlinLibrary
+import org.jetbrains.kotlin.library.resolver.TopologicalLibraryOrder
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration
+import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
+import org.jetbrains.kotlin.psi2ir.generators.TypeTranslatorImpl
+import org.jetbrains.kotlin.resolve.AnalyzingUtils
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingContextUtils
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.test.ConfigurationKind
+import org.jetbrains.kotlin.test.TestJdkKind
+import org.jetbrains.kotlin.test.util.KtTestUtil
+import org.jetbrains.kotlin.util.DummyLogger
+import org.jetbrains.kotlin.utils.rethrow
+import java.io.File
+import java.util.*
+
+abstract class AbstractKlibTextTestCase : CodegenTestCase() {
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
+        setupEnvironment(files)
+
+        loadMultiFiles(files)
+        doTest(wholeFile)
+    }
+
+    private fun setupEnvironment(files: List<TestFile>) {
+        val configuration = createConfiguration(
+            ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, backend,
+            listOf<File>(KtTestUtil.getAnnotationsJar()),
+            listOfNotNull(writeJavaFiles(files)),
+            files
+        )
+        configuration.put(CommonConfigurationKeys.MODULE_NAME, "testModule")
+        myEnvironment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
+    }
+
+    private val CompilerConfiguration.expectActualLinker: Boolean
+        get() = get(CommonConfigurationKeys.EXPECT_ACTUAL_LINKER) ?: false
+
+    fun doTest(wholeFile: File) {
+        val expectActualSymbols = mutableMapOf<DeclarationDescriptor, IrSymbol>()
+        val ignoreErrors = AbstractIrGeneratorTestCase.shouldIgnoreErrors(wholeFile)
+        val stdlib = loadKlibFromPath(listOf(runtimeKlibPath)).single()
+        val (irModule, bindingContext) = buildFragmentAndLinkIt(stdlib, ignoreErrors, expectActualSymbols)
+        val expected = irModule.dump()
+        val mppProject =
+            myEnvironment.configuration.languageVersionSettings.getFeatureSupport(LanguageFeature.MultiPlatformProjects) == LanguageFeature.State.ENABLED
+        val klibPath = serializeModule(irModule, bindingContext, stdlib, ignoreErrors, expectActualSymbols, !mppProject)
+        val libs = loadKlibFromPath(listOf(runtimeKlibPath, klibPath))
+        val stdlib2 = libs[0]
+        val klib = libs[1]
+        val deserializedIrModule = deserializeModule(stdlib2, klib)
+        val actual = deserializedIrModule.dump()
+
+        try {
+            TestCase.assertEquals(wholeFile.name, expected, actual)
+        } catch (e: Throwable) {
+            throw rethrow(e)
+        }
+    }
+
+    private fun KlibMetadataIncrementalSerializer(configuration: CompilerConfiguration, project: Project, allowErrors: Boolean) =
+        KlibMetadataIncrementalSerializer(
+            languageVersionSettings = configuration.languageVersionSettings,
+            metadataVersion = KlibMetadataVersion.INSTANCE,
+            project = project,
+            exportKDoc = false,
+            skipExpects = true,
+            allowErrorTypes = allowErrors
+        )
+
+    private fun getDescriptorForElement(
+        context: BindingContext,
+        element: PsiElement
+    ): DeclarationDescriptor = BindingContextUtils.getNotNull(context, BindingContext.DECLARATION_TO_DESCRIPTOR, element)
+
+    private fun KlibMetadataIncrementalSerializer.serializeScope(
+        ktFile: KtFile,
+        bindingContext: BindingContext,
+        moduleDescriptor: ModuleDescriptor
+    ): ProtoBuf.PackageFragment {
+        val memberScope = ktFile.declarations.map { getDescriptorForElement(bindingContext, it) }
+        return serializePackageFragment(moduleDescriptor, memberScope, ktFile.packageFqName)
+    }
+
+    protected fun serializeModule(irModuleFragment: IrModuleFragment, bindingContext: BindingContext, stdlib: KotlinLibrary, containsErrorCode: Boolean, expectActualSymbols: MutableMap<DeclarationDescriptor, IrSymbol>, skipExpect: Boolean): String {
+        val ktFiles = myFiles.psiFiles
+        val serializedIr =
+            JsIrModuleSerializer(IrMessageLogger.None, irModuleFragment.irBuiltins, expectActualSymbols, skipExpect).serializedIrModule(
+                irModuleFragment
+            )
+
+        val moduleDescriptor = irModuleFragment.descriptor
+        val metadataSerializer = KlibMetadataIncrementalSerializer(myEnvironment.configuration, myEnvironment.project, containsErrorCode)
+
+
+        val compiledKotlinFiles = mutableListOf<KotlinFileSerializedData>()
+        for ((ktFile, binaryFile) in ktFiles.zip(serializedIr.files)) {
+            assert(ktFile.virtualFilePath == binaryFile.path) {
+                """The Kt and Ir files are put in different order
+                Kt: ${ktFile.virtualFilePath}
+                Ir: ${binaryFile.path}
+            """.trimMargin()
+            }
+            val packageFragment = metadataSerializer.serializeScope(ktFile, bindingContext, moduleDescriptor)
+            val compiledKotlinFile = KotlinFileSerializedData(packageFragment.toByteArray(), binaryFile)
+
+            compiledKotlinFiles += compiledKotlinFile
+        }
+
+        val header = metadataSerializer.serializeHeader(
+            moduleDescriptor,
+            compiledKotlinFiles.map { it.irData.fqName }.distinct().sorted(),
+            emptyList()
+        ).toByteArray()
+
+
+        val serializedMetadata = metadataSerializer.serializedMetadata(
+            compiledKotlinFiles.groupBy { it.irData.fqName }
+                .map { (fqn, data) -> fqn to data.sortedBy { it.irData.path }.map { it.metadata } }.toMap(),
+            header
+        )
+
+        val fullSerializedIr = SerializedIrModule(compiledKotlinFiles.map { it.irData })
+
+        val properties = Properties().also { p ->
+            if (containsErrorCode) {
+                p.setProperty(KLIB_PROPERTY_CONTAINS_ERROR_CODE, "true")
+            }
+        }
+
+        val versions = KotlinLibraryVersioning(
+            abiVersion = KotlinAbiVersion.CURRENT,
+            libraryVersion = null,
+            compilerVersion = KotlinCompilerVersion.VERSION,
+            metadataVersion = KlibMetadataVersion.INSTANCE.toString(),
+            irVersion = KlibIrVersion.INSTANCE.toString()
+        )
+
+        val moduleName = irModuleFragment.name.asString()
+        val klibDir = org.jetbrains.kotlin.konan.file.createTempDir(moduleName)
+
+        buildKotlinLibrary(
+            linkDependencies = listOf(stdlib),
+            ir = fullSerializedIr,
+            metadata = serializedMetadata,
+            dataFlowGraph = null,
+            manifestProperties = properties,
+            moduleName = moduleName,
+            nopack = true,
+            perFile = false,
+            output = klibDir.canonicalPath,
+            versions = versions,
+            builtInsPlatform = BuiltInsPlatform.JS
+        )
+
+        return klibDir.canonicalPath
+    }
+
+    protected fun deserializeModule(stdlib: KotlinLibrary, klib: KotlinLibrary): IrModuleFragment {
+        val signaturer = IdSignatureDescriptor(JsManglerDesc)
+
+        val stdlibDescriptor = getModuleDescriptor(stdlib)
+        val testDescriptor = getModuleDescriptor(klib, stdlibDescriptor)
+
+        val symbolTable = SymbolTable(signaturer, IrFactoryImpl)
+        val typeTranslator =
+            TypeTranslatorImpl(symbolTable, myEnvironment.configuration.languageVersionSettings, testDescriptor)
+        val irBuiltIns = IrBuiltIns(testDescriptor.builtIns, typeTranslator, symbolTable)
+        val functionFactory = IrFunctionFactory(irBuiltIns, symbolTable)
+        irBuiltIns.functionFactory = functionFactory
+        val irLinker = JsIrLinker(null, IrMessageLogger.None, irBuiltIns, symbolTable, functionFactory, null, null)
+        irLinker.deserializeIrModuleHeader(stdlibDescriptor, stdlib)
+        val testModule = irLinker.deserializeIrModuleHeader(testDescriptor, klib, DeserializationStrategy.ALL)
+        irLinker.init(null, emptyList())
+        ExternalDependenciesGenerator(symbolTable, listOf(irLinker)).generateUnboundSymbolsAsDependencies()
+        irLinker.postProcess()
+        return testModule
+    }
+
+    private fun loadKlibFromPath(paths: List<String>): List<KotlinLibrary> {
+        val result = jsResolveLibraries(paths, emptyList(), DummyLogger)
+        return result.getFullList(TopologicalLibraryOrder)
+    }
+
+    private val runtimeKlibPath = "libraries/stdlib/js-ir/build/classes/kotlin/js/main"
+
+    private fun buildFragmentAndLinkIt(stdlib: KotlinLibrary, ignoreErrors: Boolean, expectActualSymbols: MutableMap<DeclarationDescriptor, IrSymbol>): Pair<IrModuleFragment, BindingContext> {
+        return generateIrModule(stdlib, ignoreErrors, expectActualSymbols)
+    }
+
+    fun getModuleDescriptor(current: KotlinLibrary, builtins: ModuleDescriptorImpl? = null): ModuleDescriptorImpl {
+        val lookupTracker = LookupTracker.DO_NOTHING
+        val md = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns(
+            current,
+            myEnvironment.configuration.languageVersionSettings,
+            LockBasedStorageManager("ModulesStructure"),
+            builtins?.builtIns,
+            packageAccessHandler = null, // TODO: This is a speed optimization used by Native. Don't bother for now.
+            lookupTracker = lookupTracker
+        )
+        md.setDependencies(listOfNotNull(builtins, md))
+        return md
+    }
+
+    private fun generateIrModule(stdlib: KotlinLibrary, ignoreErrors: Boolean, expectActualSymbols: MutableMap<DeclarationDescriptor, IrSymbol>): Pair<IrModuleFragment, BindingContext> {
+        val stdlibDescriptor = getModuleDescriptor(stdlib)
+
+        val ktFiles = myFiles.psiFiles
+
+        val psi2Ir = Psi2IrTranslator(myEnvironment.configuration.languageVersionSettings, Psi2IrConfiguration(ignoreErrors))
+        val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(
+            ktFiles, myEnvironment.project, myEnvironment.configuration,
+            moduleDescriptors = listOf(stdlibDescriptor),
+            friendModuleDescriptors = emptyList(),
+            CompilerEnvironment,
+            customBuiltInsModule = stdlibDescriptor
+        )
+
+        val (bindingContext, moduleDescriptor) = analysisResult
+        if (!psi2Ir.configuration.ignoreErrors) {
+            analysisResult.throwIfError()
+            AnalyzingUtils.throwExceptionOnErrors(bindingContext)
+        }
+
+        val symbolTable = SymbolTable(IdSignatureDescriptor(JsManglerDesc), IrFactoryImpl, NameProvider.DEFAULT)
+        val context = psi2Ir.createGeneratorContext(moduleDescriptor, bindingContext, symbolTable)
+        val irBuiltIns = context.irBuiltIns
+        val functionFactory = IrFunctionFactory(irBuiltIns, symbolTable)
+        val irLinker = JsIrLinker(moduleDescriptor, IrMessageLogger.None, irBuiltIns, symbolTable, functionFactory, null, null)
+        irLinker.deserializeIrModuleHeader(stdlibDescriptor, stdlib)
+
+        return psi2Ir.generateModuleFragment(context, ktFiles, listOf(irLinker), emptyList(), expectActualSymbols) to bindingContext
+    }
+}
+
+abstract class AbstractKlibJsTextTestCase : AbstractKlibTextTestCase()

compiler/tests-for-compiler-generator/tests/org/jetbrains/kotlin/test/generators/GenerateJUnit3CompilerTests.kt

@@ -32,9 +32,7 @@ import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite
 import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME
 import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME
 import org.jetbrains.kotlin.integration.AbstractAntTaskTest
-import org.jetbrains.kotlin.ir.AbstractIrCfgTestCase
+import org.jetbrains.kotlin.ir.*
-import org.jetbrains.kotlin.ir.AbstractIrJsTextTestCase
-import org.jetbrains.kotlin.ir.AbstractIrSourceRangesTestCase
 import org.jetbrains.kotlin.jvm.compiler.*
 import org.jetbrains.kotlin.jvm.compiler.ir.AbstractIrCompileJavaAgainstKotlinTest
 import org.jetbrains.kotlin.jvm.compiler.ir.AbstractIrCompileKotlinAgainstJavaTest
@@ -138,6 +136,14 @@ fun generateJUnit3CompilerTests(args: Array<String>) {
                 model("ir/irJsText", pattern = "^(.+)\\.kt(s)?\$")
             }
 
+            testClass<AbstractKlibJsTextTestCase> {
+                model("ir/irJsText", pattern = "^(.+)\\.kt\$", targetBackend = TargetBackend.JS_IR)
+            }
+
+            testClass<AbstractKlibTextTestCase> {
+                model("ir/irText", pattern = "^(.+)\\.kt\$", targetBackend = TargetBackend.JS_IR)
+            }
+
             testClass<AbstractIrCfgTestCase> {
                 model("ir/irCfg")
             }

compiler/tests-gen/org/jetbrains/kotlin/ir/KlibJsTextTestCaseGenerated.java

@@ -0,0 +1,204 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
+import org.jetbrains.kotlin.test.KotlinTestUtils;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.jetbrains.kotlin.test.TargetBackend;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("compiler/testData/ir/irJsText")
+@TestDataPath("$PROJECT_ROOT")
+@RunWith(JUnit3RunnerWithInners.class)
+public class KlibJsTextTestCaseGenerated extends AbstractKlibJsTextTestCase {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+    }
+
+    public void testAllFilesPresentInIrJsText() throws Exception {
+        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+    }
+
+    @TestMetadata("compiler/testData/ir/irJsText/dynamic")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Dynamic extends AbstractKlibJsTextTestCase {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInDynamic() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/dynamic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+        }
+
+        @TestMetadata("dynamicAndMembersOfAny.kt")
+        public void testDynamicAndMembersOfAny() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicAndMembersOfAny.kt");
+        }
+
+        @TestMetadata("dynamicArrayAccess.kt")
+        public void testDynamicArrayAccess() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicArrayAccess.kt");
+        }
+
+        @TestMetadata("dynamicArrayAssignment.kt")
+        public void testDynamicArrayAssignment() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicArrayAssignment.kt");
+        }
+
+        @TestMetadata("dynamicArrayAugmentedAssignment.kt")
+        public void testDynamicArrayAugmentedAssignment() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicArrayAugmentedAssignment.kt");
+        }
+
+        @TestMetadata("dynamicArrayIncrementDecrement.kt")
+        public void testDynamicArrayIncrementDecrement() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicArrayIncrementDecrement.kt");
+        }
+
+        @TestMetadata("dynamicBinaryEqualityOperator.kt")
+        public void testDynamicBinaryEqualityOperator() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicBinaryEqualityOperator.kt");
+        }
+
+        @TestMetadata("dynamicBinaryLogicalOperator.kt")
+        public void testDynamicBinaryLogicalOperator() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicBinaryLogicalOperator.kt");
+        }
+
+        @TestMetadata("dynamicBinaryOperator.kt")
+        public void testDynamicBinaryOperator() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicBinaryOperator.kt");
+        }
+
+        @TestMetadata("dynamicBinaryRelationalOperator.kt")
+        public void testDynamicBinaryRelationalOperator() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicBinaryRelationalOperator.kt");
+        }
+
+        @TestMetadata("dynamicCall.kt")
+        public void testDynamicCall() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicCall.kt");
+        }
+
+        @TestMetadata("dynamicElvisOperator.kt")
+        public void testDynamicElvisOperator() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicElvisOperator.kt");
+        }
+
+        @TestMetadata("dynamicExclExclOperator.kt")
+        public void testDynamicExclExclOperator() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicExclExclOperator.kt");
+        }
+
+        @TestMetadata("dynamicInfixCall.kt")
+        public void testDynamicInfixCall() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicInfixCall.kt");
+        }
+
+        @TestMetadata("dynamicMemberAccess.kt")
+        public void testDynamicMemberAccess() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicMemberAccess.kt");
+        }
+
+        @TestMetadata("dynamicMemberAssignment.kt")
+        public void testDynamicMemberAssignment() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicMemberAssignment.kt");
+        }
+
+        @TestMetadata("dynamicMemberAugmentedAssignment.kt")
+        public void testDynamicMemberAugmentedAssignment() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicMemberAugmentedAssignment.kt");
+        }
+
+        @TestMetadata("dynamicMemberIncrementDecrement.kt")
+        public void testDynamicMemberIncrementDecrement() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicMemberIncrementDecrement.kt");
+        }
+
+        @TestMetadata("dynamicUnaryOperator.kt")
+        public void testDynamicUnaryOperator() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicUnaryOperator.kt");
+        }
+
+        @TestMetadata("dynamicWithSmartCast.kt")
+        public void testDynamicWithSmartCast() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/dynamicWithSmartCast.kt");
+        }
+
+        @TestMetadata("implicitCastFromDynamic.kt")
+        public void testImplicitCastFromDynamic() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/implicitCastFromDynamic.kt");
+        }
+
+        @TestMetadata("implicitCastToDynamic.kt")
+        public void testImplicitCastToDynamic() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/implicitCastToDynamic.kt");
+        }
+
+        @TestMetadata("invokeOperator.kt")
+        public void testInvokeOperator() throws Exception {
+            runTest("compiler/testData/ir/irJsText/dynamic/invokeOperator.kt");
+        }
+    }
+
+    @TestMetadata("compiler/testData/ir/irJsText/external")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class External extends AbstractKlibJsTextTestCase {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInExternal() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+        }
+
+        @TestMetadata("kt38765.kt")
+        public void testKt38765() throws Exception {
+            runTest("compiler/testData/ir/irJsText/external/kt38765.kt");
+        }
+    }
+
+    @TestMetadata("compiler/testData/ir/irJsText/native")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Native extends AbstractKlibJsTextTestCase {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInNative() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+        }
+
+        @TestMetadata("nativeNativeKotlin.kt")
+        public void testNativeNativeKotlin() throws Exception {
+            runTest("compiler/testData/ir/irJsText/native/nativeNativeKotlin.kt");
+        }
+    }
+
+    @TestMetadata("compiler/testData/ir/irJsText/scripting")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Scripting extends AbstractKlibJsTextTestCase {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInScripting() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/scripting"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+        }
+    }
+}