Create test fixture stub for K2JKlibCompiler

Author: nikita-nazarov

compiler/testData/codegen/jklib/aliases.kt

@@ -0,0 +1,22 @@
+// IGNORE_BACKEND: JVM_IR
+// FILE: klib.kt
+package defs
+
+inline class Wrapper(val s: String)
+
+typealias StrList = List<String>
+
+fun combine(w: Wrapper, list: StrList): String =
+	w.s + list.joinToString()
+
+// FILE: test.kt
+import defs.Wrapper
+import defs.StrList
+import defs.combine
+
+fun box(): String {
+	val w = Wrapper("X")
+	val l: StrList = listOf("Y", "Z")
+	return combine(w, l)
+}
+

compiler/testData/codegen/jklib/enum.kt

@@ -0,0 +1,22 @@
+// IGNORE_BACKEND: JVM_IR
+// FILE: enums.kt
+package e
+
+enum class Mode { A, B }
+
+fun select(m: Mode = Mode.B): String =
+    when (m) {
+        Mode.A -> "A"
+        Mode.B -> "B"
+    }
+
+// FILE: test.kt
+import e.Mode
+import e.select
+
+fun box(): String {
+	if (select(Mode.A) != "A") return "FAIL1"
+	if (select() != "B") return "FAIL2"
+	return "OK"
+}
+

compiler/testData/codegen/jklib/import.kt

@@ -0,0 +1,27 @@
+// IGNORE_BACKEND: JVM_IR
+// FILE: foo.kt
+package foo
+
+class C {
+    val inClass = "O"
+}
+
+val toplevel get() = "K"
+
+fun referByDescriptor(s: String) = s.length
+
+inline fun foo() {
+    println()
+}
+
+// FILE: test.kt
+import foo.C
+import foo.referByDescriptor
+import foo.toplevel
+import foo.foo
+
+fun box(): String {
+    referByDescriptor("")
+    foo()
+    return C().inClass + toplevel
+}

compiler/testData/codegen/jklib/inheritance.kt

@@ -0,0 +1,28 @@
+// IGNORE_BACKEND: JVM_IR
+// FILE: base.kt
+package base
+
+open class Parent {
+	open fun run() = "P"
+}
+
+inline fun doInline(block: () -> String) = block()
+
+// FILE: impl.kt
+package impl
+
+import base.Parent
+
+class Child : Parent() {
+	override fun run() = "C"
+}
+
+// FILE: test.kt
+import impl.Child
+import base.doInline
+
+fun box(): String {
+	val c = Child()
+	return doInline { c.run() }
+}
+

compiler/testData/codegen/jklib/nested.kt

@@ -0,0 +1,24 @@
+// IGNORE_BACKEND: JVM_IR
+// FILE: nested.kt
+package n
+
+class Outer(val base: Int) {
+	class Inner(val x: Int)
+
+	companion object {
+		val CONST = "X"
+	}
+}
+
+fun make(inner: Outer.Inner) = inner.x * 3
+
+// FILE: test.kt
+import n.Outer
+import n.make
+
+fun box(): String {
+	val i = Outer.Inner(4)
+	if (make(i) != 12) return "FAIL"
+	return Outer.CONST
+}
+

compiler/testData/codegen/jklib/sealed.kt

@@ -0,0 +1,24 @@
+// IGNORE_BACKEND: JVM_IR
+// FILE: sealed.kt
+package s
+
+sealed class Node
+class Leaf(val value: Int) : Node()
+class Branch(val left: Node, val right: Node) : Node()
+
+fun <T : Node> eval(n: T): Int =
+	when (n) {
+		is Leaf -> n.value
+		is Branch -> eval(n.left) + eval(n.right)
+	}
+
+// FILE: test.kt
+import s.Leaf
+import s.Branch
+import s.eval
+
+fun box(): String {
+	val tree = Branch(Leaf(1), Branch(Leaf(2), Leaf(3)))
+	return eval(tree).toString()
+}
+

compiler/tests-against-klib/build.gradle.kts

@@ -32,6 +32,8 @@ compilerTests {
     // - compiler/testData/codegen/boxKlib/properties.kt
     // - compiler/testData/codegen/boxKlib/simple.kt
     testData(project(":compiler").isolated, "testData/codegen/boxKlib")
+
+    testData(project(":compiler").isolated, "testData/codegen/jklib")
 }
 
 projectTest(parallel = true) {

compiler/tests-against-klib/tests-gen/org/jetbrains/kotlin/codegen/ir/JKlibTestGenerated.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010-2025 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.codegen.ir
+
+import com.intellij.openapi.util.Disposer
+import org.jetbrains.kotlin.ObsoleteTestInfrastructure
+import org.jetbrains.kotlin.cli.common.CLICompiler
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.arguments.K2JKlibCompilerArguments
+import org.jetbrains.kotlin.cli.common.computeKotlinPaths
+import org.jetbrains.kotlin.cli.common.messages.MessageCollectorImpl
+import org.jetbrains.kotlin.cli.jklib.K2JKlibCompiler
+import org.jetbrains.kotlin.codegen.AbstractBlackBoxCodegenTest
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.test.util.KtTestUtil
+import org.jetbrains.kotlin.utils.PathUtil
+import java.io.File
+import java.nio.file.Paths
+
+@OptIn(ObsoleteTestInfrastructure::class)
+abstract class AbstractJKlibTest : AbstractBlackBoxCodegenTest() {
+    lateinit var klibName: String
+    lateinit var outputDir: File
+
+    override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
+        outputDir = KtTestUtil.tmpDir("java-files")
+        klibName = wholeFile.nameWithoutExtension
+
+        compileToKlibAndDeserializeIr(
+            wholeFile.nameWithoutExtension,
+            KtTestUtil.tmpDir("java-files").toString(),
+            files
+        )
+    }
+
+    override fun updateConfiguration(configuration: CompilerConfiguration) {
+        super.updateConfiguration(configuration)
+        configuration.put(JVMConfigurationKeys.KLIB_PATHS, listOf(klibName))
+    }
+
+    // We need real (as opposed to virtual) files in order to produce a Klib.
+    private fun loadMultiFilesReal(outputDir: String, files: List<TestFile>): List<String> {
+        return files.map { testFile ->
+            assert(testFile.name.endsWith(".kt"))
+            val ktFile = File(Paths.get(outputDir, testFile.name).toString())
+            ktFile.writeText(testFile.content)
+            ktFile.toString()
+        }
+    }
+
+    private fun compileToKlibAndDeserializeIr(klibName: String, outputDir: String, files: List<TestFile>) {
+        val sourceFiles = loadMultiFilesReal(outputDir, files)
+        // TODO find a way to implement it properly
+        val jsStdlibPath =
+            File(".").absoluteFile.parentFile.parentFile.parentFile.absolutePath + "/" + PathUtil.kotlinPathsForCompiler.jsStdLibKlibPath.toString()
+        val compiler = K2JKlibCompiler()
+
+        val messageCollector = MessageCollectorImpl()
+        val configuration = CompilerConfiguration().apply {
+            put(CommonConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
+            put(CLIConfigurationKeys.PERF_MANAGER, compiler.defaultPerformanceManager)
+        }
+
+        val arguments = K2JKlibCompilerArguments().apply {
+            destination = klibName
+            klibLibraries = jsStdlibPath
+            freeArgs = sourceFiles
+        }
+
+        val rootDisposable = Disposer.newDisposable("Disposable for ${CLICompiler::class.simpleName}.execImpl")
+        val paths = computeKotlinPaths(messageCollector, arguments)
+
+        K2JKlibCompiler().compileKlibAndDeserializeIr(
+            arguments, configuration, rootDisposable, paths
+        )
+    }
+}

compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractJKlibTest.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.generators.tests
 
 import org.jetbrains.kotlin.codegen.ir.AbstractCompileKotlinAgainstKlibTest
+import org.jetbrains.kotlin.codegen.ir.AbstractJKlibTest
 import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite
 import org.jetbrains.kotlin.test.TargetBackend
 
@@ -17,6 +18,9 @@ fun main(args: Array<String>) {
             testClass<AbstractCompileKotlinAgainstKlibTest> {
                 model("codegen/boxKlib", targetBackend = TargetBackend.JVM_IR)
             }
+            testClass<AbstractJKlibTest> {
+                model("codegen/jklib", targetBackend = TargetBackend.JVM_IR)
+            }
         }
     }
 }