KLIB compat tests, JS: Reorganize utilities for running a custom compiler

1. Introduce an interface class to represent compiler settings
   for custom JS and Wasm compilers: `CustomWebCompilerSettings`.
2. Merge `JsKlibTestSettings` and `CustomJsCompilerArtifacts` into
   a new implementation of `CustomWebCompilerSettings` for JS.
3. Reorganize and rename `CustomJsCompiler` to `CustomWebCompiler`
   to make it suitable for both JS and Wasm custom compilers.

^KT-78188

Author: ddolovov

js/js.tests/testFixtures/org/jetbrains/kotlin/js/test/ir/AbstractJsCompilerInvocationTest.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.cliArgument
 import org.jetbrains.kotlin.cli.js.K2JSCompiler
 import org.jetbrains.kotlin.js.test.ir.AbstractJsCompilerInvocationTest.CompilerType
-import org.jetbrains.kotlin.js.test.klib.JsKlibTestSettings
+import org.jetbrains.kotlin.js.test.klib.customJsCompilerSettings
 import org.jetbrains.kotlin.js.testOld.V8JsTestChecker
 import org.jetbrains.kotlin.klib.KlibCompilerEdition
 import org.jetbrains.kotlin.klib.KlibCompilerInvocationTestUtils
@@ -58,8 +58,8 @@ private class ModuleDetails(val name: ModuleName, val outputDir: File) {
     constructor(dependency: Dependency) : this(dependency.moduleName, dependency.libraryFile.parentFile)
 }
 
-private fun customCompilerCall(): (PrintStream, Array<String>) -> ExitCode = { printStream: PrintStream, allCompilerArgs: Array<String> ->
-    JsKlibTestSettings.customJsCompiler.callCompiler(args = allCompilerArgs, output = printStream)
+private fun customCompilerCall(): (PrintStream, Array<String>) -> ExitCode = { printStream: PrintStream, args: Array<String> ->
+    customJsCompilerSettings.customCompiler.callCompiler(printStream, args)
 }
 
 private fun currentCompilerCall() = { printStream: PrintStream, args: Array<String> ->
@@ -195,7 +195,7 @@ internal class JsCompilerInvocationTestArtifactBuilder(
         )
 
     private fun Set<Dependency>.replaceStdLib(): Set<Dependency> = mapToSetOrEmpty {
-        if (it.moduleName == "stdlib") Dependency("stdlib", JsKlibTestSettings.customJsCompilerArtifacts.jsStdLib) else it
+        if (it.moduleName == "stdlib") Dependency("stdlib", customJsCompilerSettings.stdlib) else it
     }.toSet()
 
     private fun Dependencies.toCompilerArgs(): List<String> = buildList {

js/js.tests/testFixtures/org/jetbrains/kotlin/js/test/klib/CustomWebCompilerUtils.kt

@@ -6,45 +6,81 @@
 package org.jetbrains.kotlin.js.test.klib
 
 import org.jetbrains.kotlin.cli.common.ExitCode
+import org.jetbrains.kotlin.config.LanguageVersion
 import java.io.File
 import java.io.PrintStream
 import java.lang.ref.SoftReference
 import java.net.URLClassLoader
+import kotlin.test.fail
 
-internal object JsKlibTestSettings {
-    val customJsCompilerArtifacts: CustomJsCompilerArtifacts by lazy {
-        val artifactsDir: String? = System.getProperty("kotlin.internal.js.test.compat.customCompilerArtifactsDir")
-        requireNotNull(artifactsDir) { "Custom compiler location is not specified" }
-
-        val version: String? = System.getProperty("kotlin.internal.js.test.compat.customCompilerVersion")
-        requireNotNull(version) { "Custom compiler version is not specified" }
-
-        CustomJsCompilerArtifacts(artifactsDir = File(artifactsDir), version)
-    }
+/**
+ * An accessor to "custom" (alternative) Kotlin/JS compiler and the relevant artifacts (stdlib, kotlin-test)
+ * which are used in KLIB backward/forward compatibility tests.
+ */
+val customJsCompilerSettings: CustomWebCompilerSettings by lazy {
+    createCustomWebCompilerSettings(
+        artifactsDirPropertyName = "kotlin.internal.js.test.compat.customCompilerArtifactsDir",
+        versionPropertyName = "kotlin.internal.js.test.compat.customCompilerVersion",
+        stdlibArtifactName = "kotlin-stdlib-js",
+    )
+}
 
-    val customJsCompiler by lazy {
-        CustomJsCompiler(customJsCompilerArtifacts)
-    }
+/**
+ * A "custom" (alternative) Kotlin/JS or Kotlin/Wasm compiler and the relevant artifacts (stdlib, kotlin-test)
+ * which are used in KLIB backward/forward compatibility tests.
+ */
+interface CustomWebCompilerSettings {
+    val version: String
+    val stdlib: File
+    val customCompiler: CustomWebCompiler
 }
 
-internal class CustomJsCompilerArtifacts(artifactsDir: File, val version: String) {
-    val compilerEmbeddable: File = artifactsDir.resolve("kotlin-compiler-embeddable-$version.jar")
+val CustomWebCompilerSettings.defaultLanguageVersion: LanguageVersion
+    get() = LanguageVersion.fromFullVersionString(version)
+        ?: fail("Cannot deduce the default LV from the compiler version: $version")
+
+private fun createCustomWebCompilerSettings(
+    artifactsDirPropertyName: String,
+    versionPropertyName: String,
+    stdlibArtifactName: String,
+): CustomWebCompilerSettings = object : CustomWebCompilerSettings {
+    private val artifacts: CustomWebCompilerArtifacts by lazy {
+        CustomWebCompilerArtifacts.create(artifactsDirPropertyName, versionPropertyName)
+    }
 
-    val baseStdLib: File = artifactsDir.resolve("kotlin-stdlib-$version.jar")
+    override val version: String get() = artifacts.version
+    override val stdlib: File by lazy { artifacts.resolve(stdlibArtifactName, "klib") }
 
-    val jsStdLib: File = artifactsDir.resolve("kotlin-stdlib-js-$version.klib")
+    override val customCompiler: CustomWebCompiler by lazy {
+        CustomWebCompiler(
+            listOfNotNull(
+                artifacts.resolve("kotlin-compiler-embeddable", "jar"),
+                artifacts.resolveOptionalTrove4j(),
+                artifacts.resolve("kotlin-stdlib", "jar"),
+            )
+        )
+    }
 }
 
-internal class CustomJsCompiler(private val customWebCompilerArtifacts: CustomJsCompilerArtifacts) {
+/**
+ * An entry point to call a custom Kotlin/JS or Kotlin/Wasm compiler inside an isolated class loader.
+ *
+ * Note: The class loader is cached to be easily reused in all later calls without reloading the class path.
+ * Yet it is cached as a [SoftReference] to allow GC in the case of a need.
+ */
+class CustomWebCompiler(private val compilerClassPath: List<File>) {
     private var isolatedClassLoaderSoftRef: SoftReference<URLClassLoader>? = null
 
-    private fun getIsolatedClassLoader(): URLClassLoader = isolatedClassLoaderSoftRef?.get()
-        ?: synchronized(this) {
-            isolatedClassLoaderSoftRef?.get()
-                ?: createIsolatedClassLoader(customWebCompilerArtifacts).also { isolatedClassLoaderSoftRef = SoftReference(it) }
+    private fun getIsolatedClassLoader(): URLClassLoader = isolatedClassLoaderSoftRef?.get() ?: synchronized(this) {
+        isolatedClassLoaderSoftRef?.get() ?: run {
+            val isolatedClassLoader = URLClassLoader(compilerClassPath.map { it.toURI().toURL() }.toTypedArray(), null)
+            isolatedClassLoader.setDefaultAssertionStatus(true)
+            isolatedClassLoaderSoftRef = SoftReference(isolatedClassLoader)
+            isolatedClassLoader
         }
+    }
 
-    fun callCompiler(args: Array<String>, output: PrintStream): ExitCode {
+    fun callCompiler(output: PrintStream, args: Array<String>): ExitCode {
         val isolatedClassLoader = getIsolatedClassLoader()
 
         val compilerClass = Class.forName("org.jetbrains.kotlin.cli.js.K2JSCompiler", true, isolatedClassLoader)
@@ -61,13 +97,56 @@ internal class CustomJsCompiler(private val customWebCompilerArtifacts: CustomJs
     }
 }
 
-private fun createIsolatedClassLoader(customWebCompilerArtifacts: CustomJsCompilerArtifacts): URLClassLoader {
-    val compilerClassPath = setOf(
-        customWebCompilerArtifacts.compilerEmbeddable,
-        customWebCompilerArtifacts.baseStdLib,
-    )
-        .map { it.toURI().toURL() }
-        .toTypedArray()
+private sealed interface CustomWebCompilerArtifacts {
+    val version: String
+
+    /**
+     * Resolves the mandatory artifact '$baseName-$version.$extension', where $extension is one of the passed [extensions].
+     */
+    fun resolve(baseName: String, vararg extensions: String): File
 
-    return URLClassLoader(compilerClassPath, null).apply { setDefaultAssertionStatus(true) }
+    /**
+     * This artifact was removed in Kotlin 2.2.0-Beta1.
+     * But it is still available in older compiler versions, where we need to load it.
+     */
+    fun resolveOptionalTrove4j(): File?
+
+    private class Resolvable(override val version: String, private val artifactsDir: File) : CustomWebCompilerArtifacts {
+        override fun resolve(baseName: String, vararg extensions: String): File {
+            val candidates: List<File> = extensions.map { extension -> artifactsDir.resolve("$baseName-$version.$extension") }
+            return candidates.firstOrNull { it.exists() } ?: fail("Artifact $baseName is not found. Candidates tested: $candidates")
+        }
+
+        override fun resolveOptionalTrove4j(): File? {
+            return artifactsDir.listFiles()?.firstOrNull { file ->
+                file.isFile && file.name.run { startsWith("trove4j") && endsWith("jar") }
+            }
+        }
+    }
+
+    private class Unresolvable(val reason: String) : CustomWebCompilerArtifacts {
+        override val version get() = fail(reason)
+        override fun resolve(baseName: String, vararg extensions: String) = fail(reason)
+        override fun resolveOptionalTrove4j() = fail(reason)
+    }
+
+    companion object {
+        fun create(artifactsDirPropertyName: String, versionPropertyName: String): CustomWebCompilerArtifacts {
+            val version: String = readProperty(versionPropertyName)
+                ?: return propertyNotFound(versionPropertyName)
+
+            val artifactsDir: File = readProperty(artifactsDirPropertyName)?.let(::File)
+                ?: return propertyNotFound(artifactsDirPropertyName)
+
+            return Resolvable(version, artifactsDir)
+        }
+
+        private fun readProperty(propertyName: String): String? =
+            System.getProperty(propertyName)?.trim(Char::isWhitespace)?.takeIf(String::isNotEmpty)
+
+        private fun propertyNotFound(propertyName: String): Unresolvable = Unresolvable(
+            "The Gradle property \"$propertyName\" is not specified. " +
+                    "Please check the README.md in the root of the `klib-compatibility` project."
+        )
+    }
 }