[JS FIR] Use FIR in JS IR invalidation tests

Related to KT-56740

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -7,18 +7,13 @@ package org.jetbrains.kotlin.cli.js
 
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.util.text.StringUtil
-import org.jetbrains.kotlin.KtSourceFile
 import org.jetbrains.kotlin.backend.common.CompilationException
-import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver
-import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.wasm.compileToLoweredIr
 import org.jetbrains.kotlin.backend.wasm.compileWasm
 import org.jetbrains.kotlin.backend.wasm.dce.eliminateDeadDeclarations
 import org.jetbrains.kotlin.backend.wasm.wasmPhases
 import org.jetbrains.kotlin.backend.wasm.writeCompilationResult
-import org.jetbrains.kotlin.builtins.DefaultBuiltIns
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.cli.common.*
 import org.jetbrains.kotlin.cli.common.ExitCode.*
 import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
@@ -26,7 +21,6 @@ import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants
 import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.RUNTIME_DIAGNOSTIC_EXCEPTION
 import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.RUNTIME_DIAGNOSTIC_LOG
 import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*
@@ -34,29 +28,16 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.MessageUtil
 import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForJSIR
 import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForWasm
+import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFir
 import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization
+import org.jetbrains.kotlin.cli.js.klib.serializeFirKlib
+import org.jetbrains.kotlin.cli.js.klib.transformFirToIr
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
-import org.jetbrains.kotlin.fir.BinaryModuleData
-import org.jetbrains.kotlin.fir.DependencyListForCliModule
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
-import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
-import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
-import org.jetbrains.kotlin.fir.pipeline.FirResult
-import org.jetbrains.kotlin.fir.pipeline.buildResolveAndCheckFir
-import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.serialization.FirElementAwareSerializableStringTable
-import org.jetbrains.kotlin.fir.serialization.FirKLibSerializerExtension
-import org.jetbrains.kotlin.fir.serialization.serializeSingleFirFile
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
@@ -65,7 +46,6 @@ import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
 import org.jetbrains.kotlin.ir.backend.js.*
 import org.jetbrains.kotlin.ir.backend.js.codegen.JsGenerationGranularity
 import org.jetbrains.kotlin.ir.backend.js.ic.*
-import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.CompilationOutputsBuilt
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformer
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.JsCodeGenerator
@@ -73,27 +53,19 @@ import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
-import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult
 import org.jetbrains.kotlin.js.config.*
-import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
-import org.jetbrains.kotlin.library.KotlinAbiVersion
 import org.jetbrains.kotlin.library.metadata.KlibMetadataVersion
-import org.jetbrains.kotlin.library.unresolvedDependencies
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.js.JsPlatforms
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.serialization.js.ModuleKind
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.utils.KotlinPaths
 import org.jetbrains.kotlin.utils.PathUtil
 import org.jetbrains.kotlin.utils.join
-import org.jetbrains.kotlin.utils.metadataVersion
 import java.io.File
 import java.io.IOException
-import java.nio.file.Paths
+import java.nio.charset.Charset
 
 private val K2JSCompilerArguments.granularity: JsGenerationGranularity
     get() = when {
@@ -490,134 +462,36 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         val configuration = environmentForJS.configuration
         val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
         val diagnosticsReporter = DiagnosticReporterFactory.createPendingReporter()
-        val renderDiagnosticNames = configuration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME)
-
-        // FIR
-        val extensionRegistrars = FirExtensionRegistrar.getInstances(environmentForJS.project)
-
-        val mainModuleName = configuration.get(CommonConfigurationKeys.MODULE_NAME)!!
-        val escapedMainModuleName = Name.special("<$mainModuleName>")
-
-        val ktFiles = environmentForJS.getSourceFiles()
-        val syntaxErrors = ktFiles.fold(false) { errorsFound, ktFile ->
-            AnalyzerWithCompilerReport.reportSyntaxErrors(ktFile, messageCollector).isHasErrors or errorsFound
-        }
 
         val mainModule = MainModule.SourceFiles(environmentForJS.getSourceFiles())
+        val moduleStructure = ModulesStructure(environmentForJS.project, mainModule, configuration, libraries, friendLibraries)
 
-        val binaryModuleData = BinaryModuleData.initialize(escapedMainModuleName, JsPlatforms.defaultJsPlatform, JsPlatformAnalyzerServices)
+        val outputs = compileModuleToAnalyzedFir(
-        val dependencyList = DependencyListForCliModule.build(binaryModuleData) {
+            moduleStructure = moduleStructure,
-            dependencies(libraries.map { Paths.get(it).toAbsolutePath() })
+            ktFiles = environmentForJS.getSourceFiles(),
-            friendDependencies(friendLibraries.map { Paths.get(it).toAbsolutePath() })
+            libraries = libraries,
-            // TODO: !!! dependencies module data?
+            friendLibraries = friendLibraries,
-        }
+            messageCollector = messageCollector,
-
+            diagnosticsReporter = diagnosticsReporter
-        val logger = configuration.resolverLogger
+        ) ?: return null
-        val resolvedLibraries = CommonJsKLibResolver.resolve(libraries + friendLibraries, logger).getFullResolvedList()
-
-        val sessionsWithSources = prepareJsSessions(
-            ktFiles, configuration, escapedMainModuleName.asString(), resolvedLibraries, dependencyList,
-            extensionRegistrars, isCommonSourceForPsi, fileBelongsToModuleForPsi
-        )
-
-        val outputs = sessionsWithSources.map {
-            buildResolveAndCheckFir(it.session, it.files, diagnosticsReporter)
-        }
-
-        if (syntaxErrors || diagnosticsReporter.hasErrors) {
-            FirDiagnosticsCompilerResultsReporter.reportToMessageCollector(diagnosticsReporter, messageCollector, renderDiagnosticNames)
-            return null
-        }
 
         // FIR2IR
-
+        val irResult = transformFirToIr(moduleStructure, outputs)
-        val fir2IrExtensions = Fir2IrExtensions.Default
-
-        var builtInsModule: KotlinBuiltIns? = null
-        val dependencies = mutableListOf<ModuleDescriptorImpl>()
-
-        val librariesDescriptors = resolvedLibraries.map { resolvedLibrary ->
-            val storageManager = LockBasedStorageManager("ModulesStructure")
-
-            val moduleDescriptor = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns(
-                resolvedLibrary.library,
-                configuration.languageVersionSettings,
-                storageManager,
-                builtInsModule,
-                packageAccessHandler = null,
-                lookupTracker = LookupTracker.DO_NOTHING
-            )
-            dependencies += moduleDescriptor
-            moduleDescriptor.setDependencies(ArrayList(dependencies))
-
-            val isBuiltIns = resolvedLibrary.library.unresolvedDependencies.isEmpty()
-            if (isBuiltIns) builtInsModule = moduleDescriptor.builtIns
-
-            moduleDescriptor
-        }
-
-        val firResult = FirResult(outputs)
-        val irResult = firResult.convertToIrAndActualize(
-            fir2IrExtensions,
-            IrGenerationExtension.getInstances(environmentForJS.project),
-            linkViaSignatures = false,
-            signatureComposerCreator = null,
-            irMangler = JsManglerIr,
-            visibilityConverter = Fir2IrVisibilityConverter.Default,
-            kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance,
-            fir2IrResultPostCompute = {
-                (this.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors }
-            }
-        )
 
         // Serialize klib
-
         if (arguments.irProduceKlibDir || arguments.irProduceKlibFile) {
-            val sourceFiles = mutableListOf<KtSourceFile>()
+            serializeFirKlib(
-            val firFilesAndSessionsBySourceFile = mutableMapOf<KtSourceFile, Triple<FirFile, FirSession, ScopeSession>>()
+                moduleStructure = moduleStructure,
-
+                firOutputs = outputs,
-            for (output in outputs) {
+                irResult = irResult,
-                output.fir.forEach {
+                outputKlibPath = outputKlibPath,
-                    sourceFiles.add(it.sourceFile!!)
+                messageCollector = messageCollector,
-                    firFilesAndSessionsBySourceFile[it.sourceFile!!] = Triple(it, output.session, output.scopeSession)
+                diagnosticsReporter = diagnosticsReporter,
-                }
+                jsOutputName = arguments.irPerModuleOutputName
-            }
+            )
-
-            val icData = environmentForJS.configuration.incrementalDataProvider?.getSerializedData(sourceFiles) ?: emptyList()
-
-            val metadataVersion = configuration.metadataVersion()
-
-            serializeModuleIntoKlib(
-                configuration[CommonConfigurationKeys.MODULE_NAME]!!,
-                configuration,
-                configuration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None,
-                sourceFiles,
-                klibPath = outputKlibPath,
-                resolvedLibraries.map { it.library },
-                irResult.irModuleFragment,
-                expectDescriptorToSymbol = mutableMapOf(),
-                cleanFiles = icData,
-                nopack = true,
-                perFile = false,
-                containsErrorCode = messageCollector.hasErrors() || diagnosticsReporter.hasErrors,
-                abiVersion = KotlinAbiVersion.CURRENT, // TODO get from test file data
-                jsOutputName = null
-            ) { file ->
-                val (firFile, session, scopeSession) = firFilesAndSessionsBySourceFile[file]
-                    ?: error("cannot find FIR file by source file ${file.name} (${file.path})")
-                serializeSingleFirFile(
-                    firFile,
-                    session,
-                    scopeSession,
-                    FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()),
-                    configuration.languageVersionSettings,
-                )
-            }
         }
 
-        return ModulesStructure(
+        return moduleStructure
-            environmentForJS.project, mainModule, configuration, libraries, friendLibraries
-        )
     }
 
     class IcCachesArtifacts(val artifacts: List<ModuleArtifact>, val cacheGuard: IncrementalCacheGuard)

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt

@@ -0,0 +1,193 @@
+/*
+ * Copyright 2010-2023 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.cli.js.klib
+
+import org.jetbrains.kotlin.KtSourceFile
+import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
+import org.jetbrains.kotlin.builtins.DefaultBuiltIns
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.fileBelongsToModuleForPsi
+import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter
+import org.jetbrains.kotlin.cli.common.isCommonSourceForPsi
+import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.common.prepareJsSessions
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector
+import org.jetbrains.kotlin.fir.BinaryModuleData
+import org.jetbrains.kotlin.fir.DependencyListForCliModule
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
+import org.jetbrains.kotlin.fir.backend.Fir2IrResult
+import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.pipeline.FirResult
+import org.jetbrains.kotlin.fir.pipeline.ModuleCompilerAnalyzedOutput
+import org.jetbrains.kotlin.fir.pipeline.buildResolveAndCheckFir
+import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.serialization.FirElementAwareSerializableStringTable
+import org.jetbrains.kotlin.fir.serialization.FirKLibSerializerExtension
+import org.jetbrains.kotlin.fir.serialization.serializeSingleFirFile
+import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.ir.backend.js.*
+import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr
+import org.jetbrains.kotlin.ir.util.IrMessageLogger
+import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
+import org.jetbrains.kotlin.library.KotlinAbiVersion
+import org.jetbrains.kotlin.library.unresolvedDependencies
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.js.JsPlatforms
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.utils.metadataVersion
+import java.nio.file.Paths
+
+fun compileModuleToAnalyzedFir(
+    moduleStructure: ModulesStructure,
+    ktFiles: List<KtFile>,
+    libraries: List<String>,
+    friendLibraries: List<String>,
+    messageCollector: MessageCollector,
+    diagnosticsReporter: BaseDiagnosticsCollector
+): List<ModuleCompilerAnalyzedOutput>? {
+    val renderDiagnosticNames = moduleStructure.compilerConfiguration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME)
+
+    // FIR
+    val extensionRegistrars = FirExtensionRegistrar.getInstances(moduleStructure.project)
+
+    val mainModuleName = moduleStructure.compilerConfiguration.get(CommonConfigurationKeys.MODULE_NAME)!!
+    val escapedMainModuleName = Name.special("<$mainModuleName>")
+
+    val syntaxErrors = ktFiles.fold(false) { errorsFound, ktFile ->
+        AnalyzerWithCompilerReport.reportSyntaxErrors(ktFile, messageCollector).isHasErrors or errorsFound
+    }
+
+    val binaryModuleData = BinaryModuleData.initialize(escapedMainModuleName, JsPlatforms.defaultJsPlatform, JsPlatformAnalyzerServices)
+    val dependencyList = DependencyListForCliModule.build(binaryModuleData) {
+        dependencies(libraries.map { Paths.get(it).toAbsolutePath() })
+        friendDependencies(friendLibraries.map { Paths.get(it).toAbsolutePath() })
+        // TODO: !!! dependencies module data?
+    }
+
+    val resolvedLibraries = moduleStructure.fullResolvedLibraries
+
+    val sessionsWithSources = prepareJsSessions(
+        ktFiles, moduleStructure.compilerConfiguration, escapedMainModuleName.asString(),
+        resolvedLibraries, dependencyList, extensionRegistrars, isCommonSourceForPsi, fileBelongsToModuleForPsi
+    )
+
+    val outputs = sessionsWithSources.map {
+        buildResolveAndCheckFir(it.session, it.files, diagnosticsReporter)
+    }
+
+    if (syntaxErrors || diagnosticsReporter.hasErrors) {
+        FirDiagnosticsCompilerResultsReporter.reportToMessageCollector(diagnosticsReporter, messageCollector, renderDiagnosticNames)
+        return null
+    }
+
+    return outputs
+}
+
+fun transformFirToIr(
+    moduleStructure: ModulesStructure,
+    firOutputs: List<ModuleCompilerAnalyzedOutput>
+): Fir2IrResult {
+    val fir2IrExtensions = Fir2IrExtensions.Default
+
+    var builtInsModule: KotlinBuiltIns? = null
+    val dependencies = mutableListOf<ModuleDescriptorImpl>()
+
+    val librariesDescriptors = moduleStructure.fullResolvedLibraries.map { resolvedLibrary ->
+        val storageManager = LockBasedStorageManager("ModulesStructure")
+
+        val moduleDescriptor = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns(
+            resolvedLibrary.library,
+            moduleStructure.compilerConfiguration.languageVersionSettings,
+            storageManager,
+            builtInsModule,
+            packageAccessHandler = null,
+            lookupTracker = LookupTracker.DO_NOTHING
+        )
+        dependencies += moduleDescriptor
+        moduleDescriptor.setDependencies(ArrayList(dependencies))
+
+        val isBuiltIns = resolvedLibrary.library.unresolvedDependencies.isEmpty()
+        if (isBuiltIns) builtInsModule = moduleDescriptor.builtIns
+
+        moduleDescriptor
+    }
+
+    val firResult = FirResult(firOutputs)
+    return firResult.convertToIrAndActualize(
+        fir2IrExtensions,
+        IrGenerationExtension.getInstances(moduleStructure.project),
+        linkViaSignatures = false,
+        signatureComposerCreator = null,
+        irMangler = JsManglerIr,
+        visibilityConverter = Fir2IrVisibilityConverter.Default,
+        kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance,
+        fir2IrResultPostCompute = {
+            (this.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors }
+        }
+    )
+}
+
+fun serializeFirKlib(
+    moduleStructure: ModulesStructure,
+    firOutputs: List<ModuleCompilerAnalyzedOutput>,
+    irResult: Fir2IrResult,
+    outputKlibPath: String,
+    messageCollector: MessageCollector,
+    diagnosticsReporter: BaseDiagnosticsCollector,
+    jsOutputName: String?
+) {
+    val sourceFiles = mutableListOf<KtSourceFile>()
+    val firFilesAndSessionsBySourceFile = mutableMapOf<KtSourceFile, Triple<FirFile, FirSession, ScopeSession>>()
+
+    for (output in firOutputs) {
+        output.fir.forEach {
+            sourceFiles.add(it.sourceFile!!)
+            firFilesAndSessionsBySourceFile[it.sourceFile!!] = Triple(it, output.session, output.scopeSession)
+        }
+    }
+
+    val icData = moduleStructure.compilerConfiguration.incrementalDataProvider?.getSerializedData(sourceFiles) ?: emptyList()
+
+    val metadataVersion = moduleStructure.compilerConfiguration.metadataVersion()
+
+    serializeModuleIntoKlib(
+        moduleStructure.compilerConfiguration[CommonConfigurationKeys.MODULE_NAME]!!,
+        moduleStructure.compilerConfiguration,
+        moduleStructure.compilerConfiguration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None,
+        sourceFiles,
+        klibPath = outputKlibPath,
+        moduleStructure.fullResolvedLibraries.map { it.library },
+        irResult.irModuleFragment,
+        expectDescriptorToSymbol = mutableMapOf(),
+        cleanFiles = icData,
+        nopack = true,
+        perFile = false,
+        containsErrorCode = messageCollector.hasErrors() || diagnosticsReporter.hasErrors,
+        abiVersion = KotlinAbiVersion.CURRENT, // TODO get from test file data
+        jsOutputName = jsOutputName
+    ) { file ->
+        val (firFile, session, scopeSession) = firFilesAndSessionsBySourceFile[file]
+            ?: error("cannot find FIR file by source file ${file.name} (${file.path})")
+        serializeSingleFirFile(
+            firFile,
+            session,
+            scopeSession,
+            FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()),
+            moduleStructure.compilerConfiguration.languageVersionSettings,
+        )
+    }
+}

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

@@ -475,6 +475,10 @@ class ModulesStructure(
         compilerConfiguration.resolverLogger
     )
 
+    val fullResolvedLibraries by lazy {
+        allDependenciesResolution.resolveWithDependencies().getFullResolvedList()
+    }
+
     val allDependencies: List<KotlinLibrary>
         get() = allDependenciesResolution.libraries
 

js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.generators.generateTestGroupSuiteWithJUnit5
 import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite
 import org.jetbrains.kotlin.incremental.AbstractJsIrES6InvalidationTest
 import org.jetbrains.kotlin.incremental.AbstractJsIrInvalidationTest
+import org.jetbrains.kotlin.incremental.AbstractJsFirInvalidationTest
 import org.jetbrains.kotlin.js.test.*
 import org.jetbrains.kotlin.js.test.fir.*
 import org.jetbrains.kotlin.js.test.ir.*
@@ -55,6 +56,10 @@ fun main(args: Array<String>) {
             testClass<AbstractJsIrES6InvalidationTest> {
                 model("incremental/invalidation/", pattern = "^([^_](.+))$", targetBackend = TargetBackend.JS_IR_ES6, recursive = false)
             }
+
+            testClass<AbstractJsFirInvalidationTest> {
+                model("incremental/invalidation/", pattern = "^([^_](.+))$", targetBackend = TargetBackend.JS_IR, recursive = false)
+            }
         }
 
         testGroup("js/js.tests/tests-gen", "compiler/testData/binaryCompatibility", testRunnerMethodName = "runTest0") {

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

@@ -12,8 +12,6 @@ import com.intellij.psi.PsiManager
 import com.intellij.psi.SingleRootFileViewProvider
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.common.phaser.toPhaseMap
-import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
-import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.*
@@ -21,16 +19,13 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.languageVersionSettings
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.backend.js.*
 import org.jetbrains.kotlin.ir.backend.js.ic.*
 import org.jetbrains.kotlin.ir.backend.js.SourceMapsInfo
 import org.jetbrains.kotlin.ir.backend.js.codegen.JsGenerationGranularity
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.CompilationOutputs
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.safeModuleName
-import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.test.converters.ClassicJsBackendFacade
 import org.jetbrains.kotlin.js.test.utils.MODULE_EMULATION_FILE
@@ -48,9 +43,6 @@ import org.junit.ComparisonFailure
 import java.io.File
 import java.util.EnumSet
 
-abstract class AbstractJsIrInvalidationTest : AbstractInvalidationTest(TargetBackend.JS_IR, "incrementalOut/invalidation")
-abstract class AbstractJsIrES6InvalidationTest : AbstractInvalidationTest(TargetBackend.JS_IR_ES6, "incrementalOut/invalidationES6")
-
 abstract class AbstractInvalidationTest(
     private val targetBackend: TargetBackend,
     private val workingDirPath: String
@@ -90,7 +82,9 @@ abstract class AbstractInvalidationTest(
         val projectInfoFile = File(testDirectory, PROJECT_INFO_FILE)
         val projectInfo = parseProjectInfo(testName, projectInfoFile)
 
-        if (projectInfo.muted) return
+        if (isIgnoredTest(projectInfo)){
+            return
+        }
 
         val modulesInfos = mutableMapOf<String, ModuleInfo>()
         for (module in projectInfo.modules) {
@@ -182,7 +176,8 @@ abstract class AbstractInvalidationTest(
                     }
                 }
                 val configuration = createConfiguration(module, projStep.language)
-                buildArtifact(configuration, module, moduleSourceDir, dependencies, friends, outputKlibFile)
+                outputKlibFile.delete()
+                buildKlib(configuration, module, moduleSourceDir, dependencies, friends, outputKlibFile)
             }
 
             val dtsFile = moduleStep.expectedDTS.ifNotEmpty {
@@ -369,77 +364,11 @@ abstract class AbstractInvalidationTest(
 
     private fun String.isAllowedJsFile() = endsWith(".js") && !TEST_FILE_IGNORE_PATTERN.matches(this)
 
-    private fun File.filteredKtFiles(): Collection<File> {
+    protected fun File.filteredKtFiles(): Collection<File> {
         assert(isDirectory && exists())
         return listFiles { _, name -> name.isAllowedKtFile() }!!.toList()
     }
 
-    private fun KotlinCoreEnvironment.createPsiFile(file: File): KtFile {
-        val psiManager = PsiManager.getInstance(project)
-        val fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) as CoreLocalFileSystem
-
-        val vFile = fileSystem.findFileByIoFile(file) ?: error("File not found: $file")
-
-        return SingleRootFileViewProvider(psiManager, vFile).allFiles.find {
-            it is KtFile && it.virtualFile.canonicalPath == vFile.canonicalPath
-        } as KtFile
-    }
-
-    private fun buildArtifact(
-        configuration: CompilerConfiguration,
-        moduleName: String,
-        sourceDir: File,
-        dependencies: Collection<File>,
-        friends: Collection<File>,
-        outputKlibFile: File
-    ) {
-        if (outputKlibFile.exists()) outputKlibFile.delete()
-
-        val projectJs = environment.project
-
-        val sourceFiles = sourceDir.filteredKtFiles().map { environment.createPsiFile(it) }
-
-        val sourceModule = prepareAnalyzedSourceModule(
-            project = projectJs,
-            files = sourceFiles,
-            configuration = configuration,
-            dependencies = dependencies.map { it.canonicalPath },
-            friendDependencies = friends.map { it.canonicalPath },
-            analyzer = AnalyzerWithCompilerReport(configuration)
-        )
-
-        val moduleSourceFiles = (sourceModule.mainModule as MainModule.SourceFiles).files
-        val icData = sourceModule.compilerConfiguration.incrementalDataProvider?.getSerializedData(moduleSourceFiles) ?: emptyList()
-        val expectDescriptorToSymbol = mutableMapOf<DeclarationDescriptor, IrSymbol>()
-        val (moduleFragment, _) = generateIrForKlibSerialization(
-            environment.project,
-            moduleSourceFiles,
-            configuration,
-            sourceModule.jsFrontEndResult.jsAnalysisResult,
-            sortDependencies(sourceModule.moduleDependencies),
-            icData,
-            expectDescriptorToSymbol,
-            IrFactoryImpl,
-            verifySignatures = true
-        ) {
-            sourceModule.getModuleDescriptor(it)
-        }
-        val metadataSerializer =
-            KlibMetadataIncrementalSerializer(configuration, sourceModule.project, sourceModule.jsFrontEndResult.hasErrors)
-
-        generateKLib(
-            sourceModule,
-            outputKlibFile.canonicalPath,
-            nopack = false,
-            jsOutputName = moduleName,
-            icData = icData,
-            expectDescriptorToSymbol = expectDescriptorToSymbol,
-            moduleFragment = moduleFragment
-        ) { file ->
-            metadataSerializer.serializeScope(file, sourceModule.jsFrontEndResult.bindingContext, moduleFragment.descriptor)
-        }
-    }
-
     private fun initializeWorkingDir(projectInfo: ProjectInfo, testDir: File, sourceDir: File, buildDir: File) {
         for (module in projectInfo.modules) {
             val moduleSourceDir = File(sourceDir, module).also { it.invalidateDir() }
@@ -466,4 +395,26 @@ abstract class AbstractInvalidationTest(
 
         return dir
     }
+
+    protected fun KotlinCoreEnvironment.createPsiFile(file: File): KtFile {
+        val psiManager = PsiManager.getInstance(project)
+        val fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) as CoreLocalFileSystem
+
+        val vFile = fileSystem.findFileByIoFile(file) ?: error("File not found: $file")
+
+        return SingleRootFileViewProvider(psiManager, vFile).allFiles.find {
+            it is KtFile && it.virtualFile.canonicalPath == vFile.canonicalPath
+        } as KtFile
+    }
+
+    protected open fun isIgnoredTest(projectInfo: ProjectInfo) = projectInfo.muted
+
+    protected abstract fun buildKlib(
+        configuration: CompilerConfiguration,
+        moduleName: String,
+        sourceDir: File,
+        dependencies: Collection<File>,
+        friends: Collection<File>,
+        outputKlibFile: File
+    )
 }

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

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2010-2023 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.incremental
+
+import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
+import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
+import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFir
+import org.jetbrains.kotlin.cli.js.klib.serializeFirKlib
+import org.jetbrains.kotlin.cli.js.klib.transformFirToIr
+import org.jetbrains.kotlin.codegen.ProjectInfo
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
+import org.jetbrains.kotlin.ir.backend.js.*
+import org.jetbrains.kotlin.test.TargetBackend
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.PrintStream
+import java.nio.charset.Charset
+
+abstract class AbstractJsFirInvalidationTest : FirAbstractInvalidationTest(TargetBackend.JS_IR, "incrementalOut/invalidationFir")
+
+abstract class FirAbstractInvalidationTest(
+    targetBackend: TargetBackend,
+    workingDirPath: String
+) : AbstractInvalidationTest(targetBackend, workingDirPath) {
+    private val mutedTests = setOf("constVals", "enum")
+
+    override fun isIgnoredTest(projectInfo: ProjectInfo): Boolean {
+        return super.isIgnoredTest(projectInfo) || projectInfo.name in mutedTests
+    }
+
+    override fun buildKlib(
+        configuration: CompilerConfiguration,
+        moduleName: String,
+        sourceDir: File,
+        dependencies: Collection<File>,
+        friends: Collection<File>,
+        outputKlibFile: File
+    ) {
+        val outputStream = ByteArrayOutputStream()
+        val messageCollector = PrintingMessageCollector(PrintStream(outputStream), MessageRenderer.PLAIN_FULL_PATHS, true)
+        val diagnosticsReporter = DiagnosticReporterFactory.createPendingReporter()
+
+        val libraries = dependencies.map { it.absolutePath }
+        val friendLibraries = friends.map { it.absolutePath }
+        val sourceFiles = sourceDir.filteredKtFiles().map { environment.createPsiFile(it) }
+        val moduleStructure = ModulesStructure(
+            project = environment.project,
+            mainModule = MainModule.SourceFiles(sourceFiles),
+            compilerConfiguration = configuration,
+            dependencies = libraries,
+            friendDependenciesPaths = friendLibraries
+        )
+
+        val outputs = compileModuleToAnalyzedFir(
+            moduleStructure = moduleStructure,
+            ktFiles = sourceFiles,
+            libraries = libraries,
+            friendLibraries = friendLibraries,
+            messageCollector = messageCollector,
+            diagnosticsReporter = diagnosticsReporter
+        )
+
+        if (outputs != null) {
+            val irResult = transformFirToIr(moduleStructure, outputs)
+
+            serializeFirKlib(
+                moduleStructure = moduleStructure,
+                firOutputs = outputs,
+                irResult = irResult,
+                outputKlibPath = outputKlibFile.absolutePath,
+                messageCollector = messageCollector,
+                diagnosticsReporter = diagnosticsReporter,
+                jsOutputName = moduleName
+            )
+        }
+
+        if (messageCollector.hasErrors()) {
+            val messages = outputStream.toByteArray().toString(Charset.forName("UTF-8"))
+            throw AssertionError("The following errors occurred compiling test:\n$messages")
+        }
+    }
+}

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

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2010-2023 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.incremental
+
+import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
+import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.ir.backend.js.*
+import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
+import org.jetbrains.kotlin.ir.symbols.IrSymbol
+import org.jetbrains.kotlin.test.TargetBackend
+import java.io.File
+
+abstract class AbstractJsIrInvalidationTest : IrAbstractInvalidationTest(TargetBackend.JS_IR, "incrementalOut/invalidation")
+abstract class AbstractJsIrES6InvalidationTest : IrAbstractInvalidationTest(TargetBackend.JS_IR_ES6, "incrementalOut/invalidationES6")
+
+abstract class IrAbstractInvalidationTest(
+    targetBackend: TargetBackend,
+    workingDirPath: String
+) : AbstractInvalidationTest(targetBackend, workingDirPath) {
+    override fun buildKlib(
+        configuration: CompilerConfiguration,
+        moduleName: String,
+        sourceDir: File,
+        dependencies: Collection<File>,
+        friends: Collection<File>,
+        outputKlibFile: File
+    ) {
+        val projectJs = environment.project
+
+        val sourceFiles = sourceDir.filteredKtFiles().map { environment.createPsiFile(it) }
+
+        val sourceModule = prepareAnalyzedSourceModule(
+            project = projectJs,
+            files = sourceFiles,
+            configuration = configuration,
+            dependencies = dependencies.map { it.canonicalPath },
+            friendDependencies = friends.map { it.canonicalPath },
+            analyzer = AnalyzerWithCompilerReport(configuration)
+        )
+
+        val moduleSourceFiles = (sourceModule.mainModule as MainModule.SourceFiles).files
+        val icData = sourceModule.compilerConfiguration.incrementalDataProvider?.getSerializedData(moduleSourceFiles) ?: emptyList()
+        val expectDescriptorToSymbol = mutableMapOf<DeclarationDescriptor, IrSymbol>()
+        val (moduleFragment, _) = generateIrForKlibSerialization(
+            environment.project,
+            moduleSourceFiles,
+            configuration,
+            sourceModule.jsFrontEndResult.jsAnalysisResult,
+            sortDependencies(sourceModule.moduleDependencies),
+            icData,
+            expectDescriptorToSymbol,
+            IrFactoryImpl,
+            verifySignatures = true
+        ) {
+            sourceModule.getModuleDescriptor(it)
+        }
+        val metadataSerializer =
+            KlibMetadataIncrementalSerializer(configuration, sourceModule.project, sourceModule.jsFrontEndResult.hasErrors)
+
+        generateKLib(
+            sourceModule,
+            outputKlibFile.canonicalPath,
+            nopack = false,
+            jsOutputName = moduleName,
+            icData = icData,
+            expectDescriptorToSymbol = expectDescriptorToSymbol,
+            moduleFragment = moduleFragment
+        ) { file ->
+            metadataSerializer.serializeScope(file, sourceModule.jsFrontEndResult.bindingContext, moduleFragment.descriptor)
+        }
+    }
+}

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

@@ -0,0 +1,397 @@
+/*
+ * Copyright 2010-2023 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.incremental;
+
+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.GenerateJsTestsKt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("js/js.translator/testData/incremental/invalidation")
+@TestDataPath("$PROJECT_ROOT")
+@RunWith(JUnit3RunnerWithInners.class)
+public class JsFirInvalidationTestGenerated extends AbstractJsFirInvalidationTest {
+    private void runTest(String testDataFilePath) throws Exception {
+        KotlinTestUtils.runTest(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+    }
+
+    @TestMetadata("addUpdateRemoveDependentFile")
+    public void testAddUpdateRemoveDependentFile() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/");
+    }
+
+    @TestMetadata("addUpdateRemoveDependentModule")
+    public void testAddUpdateRemoveDependentModule() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/");
+    }
+
+    public void testAllFilesPresentInInvalidation() throws Exception {
+        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/incremental/invalidation"), Pattern.compile("^([^_](.+))$"), null, TargetBackend.JS_IR, false);
+    }
+
+    @TestMetadata("breakKlibBinaryCompatibilityWithVariance")
+    public void testBreakKlibBinaryCompatibilityWithVariance() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/breakKlibBinaryCompatibilityWithVariance/");
+    }
+
+    @TestMetadata("circleExportsUpdate")
+    public void testCircleExportsUpdate() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/circleExportsUpdate/");
+    }
+
+    @TestMetadata("circleInlineImportsUpdate")
+    public void testCircleInlineImportsUpdate() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/");
+    }
+
+    @TestMetadata("class")
+    public void testClass() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/class/");
+    }
+
+    @TestMetadata("classFunctionsAndFields")
+    public void testClassFunctionsAndFields() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/");
+    }
+
+    @TestMetadata("companionFunction")
+    public void testCompanionFunction() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/companionFunction/");
+    }
+
+    @TestMetadata("companionInlineFunction")
+    public void testCompanionInlineFunction() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/companionInlineFunction/");
+    }
+
+    @TestMetadata("companionProperties")
+    public void testCompanionProperties() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/companionProperties/");
+    }
+
+    @TestMetadata("companionWithStdLibCall")
+    public void testCompanionWithStdLibCall() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/companionWithStdLibCall/");
+    }
+
+    @TestMetadata("constVals")
+    public void testConstVals() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/constVals/");
+    }
+
+    @TestMetadata("crossModuleReferences")
+    public void testCrossModuleReferences() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/crossModuleReferences/");
+    }
+
+    @TestMetadata("eagerInitialization")
+    public void testEagerInitialization() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/eagerInitialization/");
+    }
+
+    @TestMetadata("enum")
+    public void testEnum() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/enum/");
+    }
+
+    @TestMetadata("enumsInInlineFunctions")
+    public void testEnumsInInlineFunctions() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/enumsInInlineFunctions/");
+    }
+
+    @TestMetadata("exceptionsFromInlineFunction")
+    public void testExceptionsFromInlineFunction() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/exceptionsFromInlineFunction/");
+    }
+
+    @TestMetadata("exportsThroughInlineFunction")
+    public void testExportsThroughInlineFunction() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/");
+    }
+
+    @TestMetadata("fakeOverrideClassFunctionQualifiers")
+    public void testFakeOverrideClassFunctionQualifiers() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideClassFunctionQualifiers/");
+    }
+
+    @TestMetadata("fakeOverrideInheritance")
+    public void testFakeOverrideInheritance() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInheritance/");
+    }
+
+    @TestMetadata("fakeOverrideInlineExtension")
+    public void testFakeOverrideInlineExtension() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInlineExtension/");
+    }
+
+    @TestMetadata("fakeOverrideInlineFunction")
+    public void testFakeOverrideInlineFunction() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInlineFunction/");
+    }
+
+    @TestMetadata("fakeOverrideInlineProperty")
+    public void testFakeOverrideInlineProperty() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInlineProperty/");
+    }
+
+    @TestMetadata("fakeOverrideInterfaceFunctionQualifiers")
+    public void testFakeOverrideInterfaceFunctionQualifiers() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInterfaceFunctionQualifiers/");
+    }
+
+    @TestMetadata("fastPath1")
+    public void testFastPath1() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/fastPath1/");
+    }
+
+    @TestMetadata("fastPath2")
+    public void testFastPath2() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/fastPath2/");
+    }
+
+    @TestMetadata("friendDependency")
+    public void testFriendDependency() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/friendDependency/");
+    }
+
+    @TestMetadata("functionDefaultParams")
+    public void testFunctionDefaultParams() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/functionDefaultParams/");
+    }
+
+    @TestMetadata("functionSignature")
+    public void testFunctionSignature() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/functionSignature/");
+    }
+
+    @TestMetadata("functionTypeInterface")
+    public void testFunctionTypeInterface() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/functionTypeInterface/");
+    }
+
+    @TestMetadata("functionTypeInterfaceReflect")
+    public void testFunctionTypeInterfaceReflect() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/functionTypeInterfaceReflect/");
+    }
+
+    @TestMetadata("genericFunctions")
+    public void testGenericFunctions() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/genericFunctions/");
+    }
+
+    @TestMetadata("genericInlineFunctions")
+    public void testGenericInlineFunctions() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/genericInlineFunctions/");
+    }
+
+    @TestMetadata("gettersAndSettersInlining")
+    public void testGettersAndSettersInlining() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/");
+    }
+
+    @TestMetadata("inlineBecomeNonInline")
+    public void testInlineBecomeNonInline() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/");
+    }
+
+    @TestMetadata("inlineFunctionAnnotations")
+    public void testInlineFunctionAnnotations() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionAnnotations/");
+    }
+
+    @TestMetadata("inlineFunctionAsFunctionReference")
+    public void testInlineFunctionAsFunctionReference() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionAsFunctionReference/");
+    }
+
+    @TestMetadata("inlineFunctionAsParam")
+    public void testInlineFunctionAsParam() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/");
+    }
+
+    @TestMetadata("inlineFunctionCircleUsage")
+    public void testInlineFunctionCircleUsage() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionCircleUsage/");
+    }
+
+    @TestMetadata("inlineFunctionDefaultParams")
+    public void testInlineFunctionDefaultParams() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/");
+    }
+
+    @TestMetadata("inlineFunctionWithObject")
+    public void testInlineFunctionWithObject() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionWithObject/");
+    }
+
+    @TestMetadata("interfaceSuperUsage")
+    public void testInterfaceSuperUsage() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/interfaceSuperUsage/");
+    }
+
+    @TestMetadata("interfaceWithDefaultParams")
+    public void testInterfaceWithDefaultParams() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/interfaceWithDefaultParams/");
+    }
+
+    @TestMetadata("jsCode")
+    public void testJsCode() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/jsCode/");
+    }
+
+    @TestMetadata("jsExport")
+    public void testJsExport() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/jsExport/");
+    }
+
+    @TestMetadata("jsModuleAnnotation")
+    public void testJsModuleAnnotation() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/jsModuleAnnotation/");
+    }
+
+    @TestMetadata("languageVersionSettings")
+    public void testLanguageVersionSettings() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/languageVersionSettings/");
+    }
+
+    @TestMetadata("localInlineFunction")
+    public void testLocalInlineFunction() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/localInlineFunction/");
+    }
+
+    @TestMetadata("mainModuleInvalidation")
+    public void testMainModuleInvalidation() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/");
+    }
+
+    @TestMetadata("moveAndModifyInlineFunction")
+    public void testMoveAndModifyInlineFunction() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/moveAndModifyInlineFunction/");
+    }
+
+    @TestMetadata("moveExternalDeclarationsBetweenJsModules")
+    public void testMoveExternalDeclarationsBetweenJsModules() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/moveExternalDeclarationsBetweenJsModules/");
+    }
+
+    @TestMetadata("moveFilesBetweenModules")
+    public void testMoveFilesBetweenModules() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/");
+    }
+
+    @TestMetadata("moveInlineFunctionBetweenModules")
+    public void testMoveInlineFunctionBetweenModules() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/");
+    }
+
+    @TestMetadata("nestedClass")
+    public void testNestedClass() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/nestedClass/");
+    }
+
+    @TestMetadata("nonInlineBecomeInline")
+    public void testNonInlineBecomeInline() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/");
+    }
+
+    @TestMetadata("privateDeclarationLeakThroughDefaultParam")
+    public void testPrivateDeclarationLeakThroughDefaultParam() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/privateDeclarationLeakThroughDefaultParam/");
+    }
+
+    @TestMetadata("privateInlineFunction1")
+    public void testPrivateInlineFunction1() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/privateInlineFunction1/");
+    }
+
+    @TestMetadata("removeFile")
+    public void testRemoveFile() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/removeFile/");
+    }
+
+    @TestMetadata("removeModule")
+    public void testRemoveModule() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/removeModule/");
+    }
+
+    @TestMetadata("removeUnusedFile")
+    public void testRemoveUnusedFile() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/removeUnusedFile/");
+    }
+
+    @TestMetadata("renameFile")
+    public void testRenameFile() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/renameFile/");
+    }
+
+    @TestMetadata("renameModule")
+    public void testRenameModule() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/renameModule/");
+    }
+
+    @TestMetadata("simple")
+    public void testSimple() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/simple/");
+    }
+
+    @TestMetadata("splitJoinModule")
+    public void testSplitJoinModule() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/splitJoinModule/");
+    }
+
+    @TestMetadata("suspendFunctions")
+    public void testSuspendFunctions() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/suspendFunctions/");
+    }
+
+    @TestMetadata("suspendInterfaceWithDefaultParams")
+    public void testSuspendInterfaceWithDefaultParams() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/suspendInterfaceWithDefaultParams/");
+    }
+
+    @TestMetadata("toplevelProperties")
+    public void testToplevelProperties() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/toplevelProperties/");
+    }
+
+    @TestMetadata("transitiveInlineFunction")
+    public void testTransitiveInlineFunction() throws Exception {
+        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/");
+    }
+
+    @TestMetadata("updateExports")
+    public void testUpdateExports() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/updateExports/");
+    }
+
+    @TestMetadata("updateExportsAndInlineImports")
+    public void testUpdateExportsAndInlineImports() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/");
+    }
+
+    @TestMetadata("variance")
+    public void testVariance() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/variance/");
+    }
+}