[PL][tests] Learn PL test infra to work with JS files

^KT-57378
2023-04-24 13:36:43 +02:00
parent b5ad5edc08
commit e85406b561
3 changed files with 62 additions and 28 deletions
@@ -24,7 +24,7 @@ object PartialLinkageTestUtils {
        fun customizeModuleSources(moduleName: String, moduleSourceDir: File) = Unit

        // Build a KLIB from a module.
-        fun buildKlib(moduleName: String, moduleSourceDir: File, dependencies: Dependencies, klibFile: File)
+        fun buildKlib(moduleName: String, buildDirs: ModuleBuildDirs, dependencies: Dependencies, klibFile: File)

        // Build a binary (executable) file given the main KLIB and dependencies.
        fun buildBinaryAndRun(mainModuleKlibFile: File, dependencies: Dependencies)
@@ -105,14 +105,12 @@ object PartialLinkageTestUtils {

                customizeModuleSources(moduleName, moduleBuildDirs.sourceDir)

-                val moduleOutputDir = moduleBuildDirs.outputDir.apply { mkdirs() }
-                val klibFile = moduleOutputDir.resolve("$moduleName.klib")
+                moduleBuildDirs.outputDir.apply { mkdirs() }

                this[moduleName] = ModuleUnderTest(
                    info = moduleInfo,
                    testDir = moduleTestDir,
-                    buildDirs = moduleBuildDirs,
-                    klibFile = klibFile
+                    buildDirs = moduleBuildDirs
                )
            }
        }
@@ -122,9 +120,8 @@ object PartialLinkageTestUtils {

        projectInfo.steps.forEach { projectStep ->
            projectStep.order.forEach { moduleName ->
-                val (moduleInfo, moduleTestDir, moduleBuildDirs, klibFile) = modulesMap[moduleName]
-                    ?: fail { "No module $moduleName found on step ${projectStep.id}" }
-
+                val moduleUnderTest = modulesMap[moduleName] ?: fail { "No module $moduleName found on step ${projectStep.id}" }
+                val (moduleInfo, moduleTestDir, moduleBuildDirs) = moduleUnderTest
                val moduleStep = moduleInfo.steps.getValue(projectStep.id)

                moduleStep.modifications.forEach { modification ->
@@ -141,9 +138,9 @@ object PartialLinkageTestUtils {
                    if (dependency.moduleName == "stdlib")
                        regularDependencies += Dependency("stdlib", stdlibFile)
                    else {
-                        val moduleFile = modulesMap[dependency.moduleName]?.klibFile
+                        val klibFile = modulesMap[dependency.moduleName]?.klibFile
                            ?: fail { "No module ${dependency.moduleName} found on step ${projectStep.id}" }
-                        val moduleDependency = Dependency(dependency.moduleName, moduleFile)
+                        val moduleDependency = Dependency(dependency.moduleName, klibFile)
                        regularDependencies += moduleDependency
                        if (dependency.isFriend) friendDependencies += moduleDependency
                    }
@@ -152,7 +149,7 @@ object PartialLinkageTestUtils {
                val dependencies = Dependencies(regularDependencies, friendDependencies)
                binaryDependencies = binaryDependencies.mergeWith(dependencies)

-                buildKlib(moduleInfo.moduleName, moduleBuildDirs.sourceDir, dependencies, klibFile)
+                buildKlib(moduleInfo.moduleName, moduleBuildDirs, dependencies, moduleUnderTest.klibFile)
            }
        }

@@ -166,7 +163,7 @@ object PartialLinkageTestUtils {
    private fun copySources(from: File, to: File, patchSourceFile: ((String) -> String)? = null) {
        var anyFilePatched = false

-        from.walk().filter { it.isFile && it.extension == "kt" }.forEach { sourceFile ->
+        from.walk().filter { it.isFile && (it.extension == "kt" || it.extension == "js") }.forEach { sourceFile ->
            val destFile = to.resolve(sourceFile.relativeTo(from))
            destFile.parentFile.mkdirs()
            sourceFile.copyTo(destFile)
@@ -200,12 +197,9 @@ object PartialLinkageTestUtils {
        }
    }

-    private data class ModuleUnderTest(
-        val info: ModuleInfo,
-        val testDir: File,
-        val buildDirs: ModuleBuildDirs,
-        val klibFile: File
-    )
+    private data class ModuleUnderTest(val info: ModuleInfo, val testDir: File, val buildDirs: ModuleBuildDirs) {
+        val klibFile get() = buildDirs.outputDir.resolve("${info.moduleName}.klib")
+    }

    const val MAIN_MODULE_NAME = "main"
    private const val PL_UTILS_DIR = "__utils__"
@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.ir.backend.js.ic.JsExecutableProducer
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.CompilationOutputs
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformer
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
+import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
 import org.jetbrains.kotlin.ir.linkage.partial.PartialLinkageConfig
@@ -43,6 +44,7 @@ import org.jetbrains.kotlin.js.testOld.V8IrJsTestChecker
 import org.jetbrains.kotlin.klib.PartialLinkageTestUtils
 import org.jetbrains.kotlin.klib.PartialLinkageTestUtils.Dependencies
 import org.jetbrains.kotlin.klib.PartialLinkageTestUtils.MAIN_MODULE_NAME
+import org.jetbrains.kotlin.klib.PartialLinkageTestUtils.ModuleBuildDirs
 import org.jetbrains.kotlin.konan.file.ZipFileSystemCacheableAccessor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
@@ -107,10 +109,10 @@ abstract class AbstractJsPartialLinkageTestCase(val compilerType: CompilerType)

        override fun buildKlib(
            moduleName: String,
-            moduleSourceDir: File,
+            buildDirs: ModuleBuildDirs,
            dependencies: Dependencies,
            klibFile: File
-        ) = this@AbstractJsPartialLinkageTestCase.buildKlib(moduleName, moduleSourceDir, dependencies, klibFile)
+        ) = this@AbstractJsPartialLinkageTestCase.buildKlib(moduleName, buildDirs, dependencies, klibFile)

        override fun buildBinaryAndRun(mainModuleKlibFile: File, dependencies: Dependencies) =
            this@AbstractJsPartialLinkageTestCase.buildBinaryAndRun(mainModuleKlibFile, dependencies)
@@ -128,10 +130,14 @@ abstract class AbstractJsPartialLinkageTestCase(val compilerType: CompilerType)
    // The entry point to generated test classes.
    fun doTest(testPath: String) = PartialLinkageTestUtils.runTest(JsTestConfiguration(testPath))

-    private fun buildKlib(moduleName: String, moduleSourceDir: File, dependencies: Dependencies, klibFile: File) {
+    private fun buildKlib(moduleName: String, buildDirs: ModuleBuildDirs, dependencies: Dependencies, klibFile: File) {
+        buildDirs.sourceDir.walkTopDown()
+            .filter { file -> file.isFile && file.extension == "js" }
+            .forEach { file -> file.copyTo(buildDirs.outputDir.resolve(file.relativeTo(buildDirs.sourceDir)), overwrite = true) }
+
        when (compilerType) {
-            CompilerType.K1_NO_IC, CompilerType.K1_WITH_IC -> buildKlibWithK1(moduleName, moduleSourceDir, dependencies, klibFile)
-            CompilerType.K2_NO_IC -> buildKlibWithK2(moduleName, moduleSourceDir, dependencies, klibFile)
+            CompilerType.K1_NO_IC, CompilerType.K1_WITH_IC -> buildKlibWithK1(moduleName, buildDirs.sourceDir, dependencies, klibFile)
+            CompilerType.K2_NO_IC -> buildKlibWithK2(moduleName, buildDirs.sourceDir, dependencies, klibFile)
        }
    }

@@ -246,11 +252,37 @@ abstract class AbstractJsPartialLinkageTestCase(val compilerType: CompilerType)
        }

        val binariesDir = File(buildDir, BIN_DIR_NAME).also { it.mkdirs() }
-        val binaries = compilationOutputs.writeAll(binariesDir, MAIN_MODULE_NAME, false, MAIN_MODULE_NAME, ModuleKind.PLAIN).filter {
-            it.extension == "js"
+
+        // key = module name, value = list of produced JS files
+        val producedBinaries: Map<String, List<File>> = compilationOutputs
+            .writeAll(binariesDir, MAIN_MODULE_NAME, false, MAIN_MODULE_NAME, ModuleKind.PLAIN)
+            .filter { file -> file.extension == "js" }
+            .groupByTo(linkedMapOf()) { file -> file.nameWithoutExtension.toInnerName() }
+
+        // key = module name, value = list of JS files out of test data
+        val providedBinaries: Map<String, List<File>> =
+            (allDependencies.regularDependencies.asSequence().map { it.libraryFile } + mainModuleKlibFile)
+                .mapNotNull { klibFile ->
+                    val moduleName = if (klibFile.extension == "klib") klibFile.nameWithoutExtension else return@mapNotNull null
+                    val outputDir = klibFile.parentFile
+
+                    val providedJsFiles = outputDir.listFiles()?.filter { it.isFile && it.extension == "js" }.orEmpty()
+                    if (providedJsFiles.isEmpty()) return@mapNotNull null
+
+                    moduleName to providedJsFiles
+                }.toMap()
+
+        val unexpectedModuleNames = providedBinaries.keys - producedBinaries.keys
+        check(unexpectedModuleNames.isEmpty()) { "Unexpected module names: $unexpectedModuleNames" }
+
+        val allBinaries: List<File> = buildList {
+            producedBinaries.forEach { (moduleName, producedJsFiles) ->
+                this += providedBinaries[moduleName].orEmpty()
+                this += producedJsFiles
+            }
        }

-        executeAndCheckBinaries(MAIN_MODULE_NAME, binaries)
+        executeAndCheckBinaries(MAIN_MODULE_NAME, allBinaries)
    }

    private fun buildBinaryNoIC(
@@ -321,6 +353,9 @@ abstract class AbstractJsPartialLinkageTestCase(val compilerType: CompilerType)
        return jsExecutableProducer.buildExecutable(multiModule = true, outJsProgram = true).compilationOut
    }

+    private val IrModuleFragment.exportName get() = "kotlin_${name.asStringStripSpecialMarkers()}"
+    private fun String.toInnerName() = if (startsWith("kotlin_")) substringAfter("kotlin_") else this
+
    private fun KotlinCoreEnvironment.createPsiFiles(sourceDir: File): List<KtFile> {
        val psiManager = PsiManager.getInstance(project)
        val fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) as CoreLocalFileSystem
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.codegen.ProjectInfo
 import org.jetbrains.kotlin.klib.PartialLinkageTestUtils
 import org.jetbrains.kotlin.klib.PartialLinkageTestUtils.Dependencies
 import org.jetbrains.kotlin.klib.PartialLinkageTestUtils.MAIN_MODULE_NAME
+import org.jetbrains.kotlin.klib.PartialLinkageTestUtils.ModuleBuildDirs
 import org.jetbrains.kotlin.konan.blackboxtest.support.*
 import org.jetbrains.kotlin.konan.blackboxtest.support.TestCase.WithTestRunnerExtras
 import org.jetbrains.kotlin.konan.blackboxtest.support.compilation.*
@@ -48,8 +49,12 @@ abstract class AbstractNativePartialLinkageTest : AbstractNativeSimpleTest() {
                customizeMainModuleSources(moduleSourceDir)
        }

-        override fun buildKlib(moduleName: String, moduleSourceDir: File, dependencies: Dependencies, klibFile: File) =
-            this@AbstractNativePartialLinkageTest.buildKlib(moduleName, moduleSourceDir, dependencies, klibFile)
+        override fun buildKlib(
+            moduleName: String,
+            buildDirs: ModuleBuildDirs,
+            dependencies: Dependencies,
+            klibFile: File
+        ) = this@AbstractNativePartialLinkageTest.buildKlib(moduleName, buildDirs.sourceDir, dependencies, klibFile)

        override fun buildBinaryAndRun(mainModuleKlibFile: File, dependencies: Dependencies) =
            this@AbstractNativePartialLinkageTest.buildBinaryAndRun(dependencies)