[JS IR] Enable DTS generation in IC

^KT-54398 Fixed

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

@@ -95,10 +95,14 @@ internal fun File.fileHashForIC(): ICHash {
 }
 
 internal fun CompilerConfiguration.configHashForIC() = HashCalculatorForIC().apply {
-    val importantBooleanSettingKeys = listOf(JSConfigurationKeys.PROPERTY_LAZY_INITIALIZATION)
+    val importantSettings = listOf(
-    updateForEach(importantBooleanSettingKeys) { key ->
+        JSConfigurationKeys.GENERATE_DTS,
+        JSConfigurationKeys.MODULE_KIND,
+        JSConfigurationKeys.PROPERTY_LAZY_INITIALIZATION
+    )
+    updateForEach(importantSettings) { key ->
         update(key.toString())
-        update(getBoolean(key).toString())
+        update(get(key).toString())
     }
 
     update(languageVersionSettings.toString())

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.ir.backend.js.ic
 
 import org.jetbrains.kotlin.ir.backend.js.CompilationOutputs
+import org.jetbrains.kotlin.ir.backend.js.export.TypeScriptFragment
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.CrossModuleReferences
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.JsIrModuleHeader
 import java.io.File
@@ -15,6 +16,7 @@ class JsMultiModuleCache(private val moduleArtifacts: List<ModuleArtifact>) {
         private const val JS_MODULE_HEADER = "js.module.header.bin"
         private const val CACHED_MODULE_JS = "module.js"
         private const val CACHED_MODULE_JS_MAP = "module.js.map"
+        private const val CACHED_MODULE_D_TS = "module.d.ts"
     }
 
     private enum class NameType(val typeMask: Int) {
@@ -71,22 +73,26 @@ class JsMultiModuleCache(private val moduleArtifacts: List<ModuleArtifact>) {
         }
     }
 
+    private fun File.writeIfNotNull(data: String?) {
+        if (data != null) {
+            recreate()
+            writeText(data)
+        } else {
+            ifExists { delete() }
+        }
+    }
+
     fun fetchCompiledJsCode(artifact: ModuleArtifact) = artifact.artifactsDir?.let { cacheDir ->
         val jsCode = File(cacheDir, CACHED_MODULE_JS).ifExists { readText() }
         val sourceMap = File(cacheDir, CACHED_MODULE_JS_MAP).ifExists { readText() }
-        jsCode?.let { CompilationOutputs(it, null, null, sourceMap) }
+        val tsDefinitions = File(cacheDir, CACHED_MODULE_D_TS).ifExists { TypeScriptFragment(readText()) }
+        jsCode?.let { CompilationOutputs(it, tsDefinitions, null, sourceMap) }
     }
 
     fun commitCompiledJsCode(artifact: ModuleArtifact, compilationOutputs: CompilationOutputs) = artifact.artifactsDir?.let { cacheDir ->
-        val jsCodeCache = File(cacheDir, CACHED_MODULE_JS).apply { recreate() }
+        File(cacheDir, CACHED_MODULE_JS).writeIfNotNull(compilationOutputs.jsCode)
-        jsCodeCache.writeText(compilationOutputs.jsCode)
+        File(cacheDir, CACHED_MODULE_JS_MAP).writeIfNotNull(compilationOutputs.sourceMap)
-        val jsMapCache = File(cacheDir, CACHED_MODULE_JS_MAP)
+        File(cacheDir, CACHED_MODULE_D_TS).writeIfNotNull(compilationOutputs.tsDefinitions?.raw)
-        if (compilationOutputs.sourceMap != null) {
-            jsMapCache.recreate()
-            jsMapCache.writeText(compilationOutputs.sourceMap)
-        } else {
-            jsMapCache.ifExists { delete() }
-        }
     }
 
     fun loadProgramHeadersFromCache(): List<CachedModuleInfo> {

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/TestModel.kt

@@ -47,7 +47,8 @@ class ModuleInfo(val moduleName: String) {
         val id: Int,
         val dependencies: Collection<Dependency>,
         val modifications: List<Modification>,
-        val expectedFileStats: Map<String, Set<String>>
+        val expectedFileStats: Map<String, Set<String>>,
+        val expectedDTS: Set<String>
     )
 
     val steps = mutableListOf<ModuleStep>()
@@ -65,6 +66,7 @@ private const val FRIENDS = "friends"
 private const val MODIFICATIONS = "modifications"
 private const val MODIFICATION_UPDATE = "U"
 private const val MODIFICATION_DELETE = "D"
+private const val EXPECTED_DTS_LIST = "expected dts"
 
 private val STEP_PATTERN = Pattern.compile("^\\s*STEP\\s+(\\d+)\\.*(\\d+)?\\s*:?$")
 
@@ -210,6 +212,7 @@ class ModuleInfoParser(infoFile: File) : InfoParser<ModuleInfo>(infoFile) {
         val regularDependencies = mutableSetOf<String>()
         val friendDependencies = mutableSetOf<String>()
         val modifications = mutableListOf<ModuleInfo.Modification>()
+        val expectedDTS = mutableSetOf<String>()
 
         loop { line ->
             if (line.matches(STEP_PATTERN.toRegex()))
@@ -230,6 +233,7 @@ class ModuleInfoParser(infoFile: File) : InfoParser<ModuleInfo>(infoFile) {
                     DEPENDENCIES -> getOpArgs().forEach { regularDependencies += it }
                     FRIENDS -> getOpArgs().forEach { friendDependencies += it }
                     MODIFICATIONS -> modifications += parseModifications()
+                    EXPECTED_DTS_LIST -> getOpArgs().forEach { expectedDTS += it }
                     else -> error(diagnosticMessage("Unknown op $op", line))
                 }
             }
@@ -250,7 +254,8 @@ class ModuleInfoParser(infoFile: File) : InfoParser<ModuleInfo>(infoFile) {
                 id = it,
                 dependencies = dependencies,
                 modifications = modifications,
-                expectedFileStats = expectedFileStats
+                expectedFileStats = expectedFileStats,
+                expectedDTS = expectedDTS
             )
         }
     }

js/js.tests/test/org/jetbrains/kotlin/incremental/AbstractInvalidationTest.kt

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.serialization.js.ModuleKind
 import org.jetbrains.kotlin.test.builders.LanguageVersionSettingsBuilder
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
 import org.jetbrains.kotlin.test.util.JUnit4Assertions
+import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
 import org.junit.ComparisonFailure
 import java.io.File
 import java.util.EnumSet
@@ -49,6 +50,8 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
         private const val STDLIB_MODULE_NAME = "kotlin-kotlin-stdlib-js-ir"
 
         private val KT_FILE_IGNORE_PATTERN = Regex("^.*\\..+\\.kt$")
+
+        private val JS_MODULE_KIND = ModuleKind.PLAIN
     }
 
     override fun createEnvironment(): KotlinCoreEnvironment {
@@ -94,7 +97,8 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
     private fun createConfiguration(moduleName: String, language: List<String>): CompilerConfiguration {
         val copy = environment.configuration.copy()
         copy.put(CommonConfigurationKeys.MODULE_NAME, moduleName)
-        copy.put(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
+        copy.put(JSConfigurationKeys.GENERATE_DTS, true)
+        copy.put(JSConfigurationKeys.MODULE_KIND, JS_MODULE_KIND)
         copy.put(JSConfigurationKeys.PROPERTY_LAZY_INITIALIZATION, true)
 
         copy.languageVersionSettings = with(LanguageVersionSettingsBuilder()) {
@@ -123,7 +127,8 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
             val moduleName: String,
             val modulePath: String,
             val friends: List<String>,
-            val expectedFileStats: Map<String, Set<String>>
+            val expectedFileStats: Map<String, Set<String>>,
+            val expectedDTS: String?
         )
 
         private fun setupTestStep(projStep: ProjectInfo.ProjectBuildStep, module: String, buildKlib: Boolean): TestStepInfo {
@@ -158,11 +163,16 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
                 val configuration = createConfiguration(module, projStep.language)
                 buildArtifact(configuration, module, moduleSourceDir, dependencies, friends, outputKlibFile)
             }
+
+            val dtsFile = moduleStep.expectedDTS.ifNotEmpty {
+                moduleTestDir.resolve(singleOrNull() ?: error("$module module may generate only one d.ts at step $projStepId"))
+            }
             return TestStepInfo(
                 module.safeModuleName,
                 outputKlibFile.canonicalPath,
                 friends.map { it.canonicalPath },
-                expectedFileStats
+                expectedFileStats,
+                dtsFile?.readText()
             )
         }
 
@@ -232,6 +242,17 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
             }
         }
 
+        private fun verifyDTS(stepId: Int, testInfo: List<TestStepInfo>, jsOutput: CompilationOutputs) {
+            for (info in testInfo) {
+                val expectedDTS = info.expectedDTS ?: continue
+                val output = jsOutput.dependencies.find { it.first == info.moduleName }?.second ?: jsOutput
+                val gotDTS = output.getFullTsDefinition(info.moduleName, JS_MODULE_KIND)
+                JUnit4Assertions.assertEquals(expectedDTS, gotDTS) {
+                    "Mismatched d.ts for module ${info.moduleName} at step $stepId"
+                }
+            }
+        }
+
         fun execute() {
             for (projStep in projectInfo.steps) {
                 val testInfo = projStep.order.map { setupTestStep(projStep, it, true) }
@@ -272,6 +293,7 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
                 val (jsOutput, rebuiltModules) = jsExecutableProducer.buildExecutable(multiModule = true, outJsProgram = true)
                 verifyJsExecutableProducerBuildModules(projStep.id, rebuiltModules, projStep.dirtyJS)
                 verifyJsCode(projStep.id, mainModuleName, jsOutput)
+                verifyDTS(projStep.id, testInfo, jsOutput)
             }
         }
     }

js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/InvalidationTestGenerated.java

@@ -330,6 +330,11 @@ public class InvalidationTestGenerated extends AbstractInvalidationTest {
         runTest("js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/");
     }
 
+    @TestMetadata("typeScriptExports")
+    public void testTypeScriptExports() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/typeScriptExports/");
+    }
+
     @TestMetadata("unicodeSerializationAndDeserialization")
     public void testUnicodeSerializationAndDeserialization() throws Exception {
         runTest("js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/");

js/js.translator/testData/incremental/invalidation/typeScriptExports/lib1/l1.0.4.kt

@@ -0,0 +1 @@
+fun foo() = 0

js/js.translator/testData/incremental/invalidation/typeScriptExports/lib1/l1.1.kt

@@ -0,0 +1,2 @@
+@JsExport
+fun foo() = 0

js/js.translator/testData/incremental/invalidation/typeScriptExports/lib1/l1.2.kt

@@ -0,0 +1,3 @@
+@JsExport
+@JsName("bar")
+fun foo() = 0

js/js.translator/testData/incremental/invalidation/typeScriptExports/lib1/module.info

@@ -0,0 +1,18 @@
+STEP 0:
+    modifications:
+        U : l1.0.4.kt -> l1.kt
+    added file: l1.kt
+STEP 1:
+    modifications:
+        U : l1.1.kt -> l1.kt
+    modified ir: l1.kt
+STEP 2:
+    modifications:
+        U : l1.2.kt -> l1.kt
+    modified ir: l1.kt
+STEP 3:
+STEP 4:
+    modifications:
+        U : l1.0.4.kt -> l1.kt
+    modified ir: l1.kt
+STEP 5..6:

js/js.translator/testData/incremental/invalidation/typeScriptExports/lib2/l2.0.kt

@@ -0,0 +1,4 @@
+class MyClass(val stepId: Int) {
+    fun qux() = foo() + stepId
+}
+

js/js.translator/testData/incremental/invalidation/typeScriptExports/lib2/l2.3.kt

@@ -0,0 +1,5 @@
+@JsExport
+class MyClass(val stepId: Int) {
+    fun qux() = foo() + stepId
+}
+

js/js.translator/testData/incremental/invalidation/typeScriptExports/lib2/l2.5.kt

@@ -0,0 +1,6 @@
+@JsExport
+class MyClass(val stepId: Int) {
+    @JsName("baz")
+    fun qux() = foo() + stepId
+}
+

js/js.translator/testData/incremental/invalidation/typeScriptExports/lib2/l2.6.kt

@@ -0,0 +1,6 @@
+@JsExport
+class MyClass(val stepId: Int) {
+    @JsName("bar")
+    fun qux() = foo() + stepId
+}
+

js/js.translator/testData/incremental/invalidation/typeScriptExports/lib2/module.info

@@ -0,0 +1,26 @@
+STEP 0:
+    dependencies: lib1
+    modifications:
+        U : l2.0.kt -> l2.kt
+    added file: l2.kt
+STEP 1..2:
+    dependencies: lib1
+    updated imports: l2.kt
+STEP 3:
+    dependencies: lib1
+    modifications:
+        U : l2.3.kt -> l2.kt
+    modified ir: l2.kt
+STEP 4:
+    dependencies: lib1
+    updated imports: l2.kt
+STEP 5:
+    dependencies: lib1
+    modifications:
+        U : l2.5.kt -> l2.kt
+    modified ir: l2.kt
+STEP 6:
+    dependencies: lib1
+    modifications:
+        U : l2.6.kt -> l2.kt
+    modified ir: l2.kt

js/js.translator/testData/incremental/invalidation/typeScriptExports/main/m.0.d.ts

@@ -0,0 +1,4 @@
+declare namespace kotlin_main {
+    type Nullable<T> = T | null | undefined
+    function box(stepId: number): string;
+}

js/js.translator/testData/incremental/invalidation/typeScriptExports/main/m.1.d.ts

@@ -0,0 +1,5 @@
+declare namespace kotlin_main {
+    type Nullable<T> = T | null | undefined
+    function foo(): number;
+    function box(stepId: number): string;
+}

js/js.translator/testData/incremental/invalidation/typeScriptExports/main/m.2.d.ts

@@ -0,0 +1,5 @@
+declare namespace kotlin_main {
+    type Nullable<T> = T | null | undefined
+    function bar(): number;
+    function box(stepId: number): string;
+}

js/js.translator/testData/incremental/invalidation/typeScriptExports/main/m.3.d.ts

@@ -0,0 +1,10 @@
+declare namespace kotlin_main {
+    type Nullable<T> = T | null | undefined
+    function bar(): number;
+    class MyClass {
+        constructor(stepId: number);
+        get stepId(): number;
+        qux(): number;
+    }
+    function box(stepId: number): string;
+}

js/js.translator/testData/incremental/invalidation/typeScriptExports/main/m.4.d.ts

@@ -0,0 +1,9 @@
+declare namespace kotlin_main {
+    type Nullable<T> = T | null | undefined
+    class MyClass {
+        constructor(stepId: number);
+        get stepId(): number;
+        qux(): number;
+    }
+    function box(stepId: number): string;
+}

js/js.translator/testData/incremental/invalidation/typeScriptExports/main/m.5.d.ts

@@ -0,0 +1,9 @@
+declare namespace kotlin_main {
+    type Nullable<T> = T | null | undefined
+    class MyClass {
+        constructor(stepId: number);
+        get stepId(): number;
+        baz(): number;
+    }
+    function box(stepId: number): string;
+}

js/js.translator/testData/incremental/invalidation/typeScriptExports/main/m.6.d.ts

@@ -0,0 +1,9 @@
+declare namespace kotlin_main {
+    type Nullable<T> = T | null | undefined
+    class MyClass {
+        constructor(stepId: number);
+        get stepId(): number;
+        bar(): number;
+    }
+    function box(stepId: number): string;
+}

js/js.translator/testData/incremental/invalidation/typeScriptExports/main/m.kt

@@ -0,0 +1,7 @@
+fun box(stepId: Int): String {
+    val x = MyClass(stepId).qux()
+    if (x != stepId) {
+        return "Fail: $x != $stepId"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/typeScriptExports/main/module.info

@@ -0,0 +1,25 @@
+STEP 0:
+    dependencies: lib1, lib2
+    added file: m.kt
+    expected dts: m.0.d.ts
+STEP 1:
+    dependencies: lib1, lib2
+    expected dts: m.1.d.ts
+STEP 2:
+    dependencies: lib1, lib2
+    expected dts: m.2.d.ts
+STEP 3:
+    dependencies: lib1, lib2
+    updated imports: m.kt
+    expected dts: m.3.d.ts
+STEP 4:
+    dependencies: lib1, lib2
+    expected dts: m.4.d.ts
+STEP 5:
+    dependencies: lib1, lib2
+    updated imports: m.kt
+    expected dts: m.5.d.ts
+STEP 6:
+    dependencies: lib1, lib2
+    updated imports: m.kt
+    expected dts: m.6.d.ts

js/js.translator/testData/incremental/invalidation/typeScriptExports/project.info

@@ -0,0 +1,17 @@
+MODULES: lib1, lib2, main
+
+STEP 0..1:
+    libs: lib1, lib2, main
+    dirty js: lib1, lib2, main
+STEP 2:
+    libs: lib1, lib2, main
+    dirty js: lib1, lib2
+STEP 3:
+    libs: lib1, lib2, main
+    dirty js: lib2, main
+STEP 4:
+    libs: lib1, lib2, main
+    dirty js: lib1, lib2, main
+STEP 5..6:
+    libs: lib1, lib2, main
+    dirty js: lib2, main