[JS IR] initial support for KLIB incremental compilation with K2

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

@@ -61,6 +61,7 @@ import org.jetbrains.kotlin.library.impl.BuiltInsPlatform
 import org.jetbrains.kotlin.library.metadata.KlibMetadataVersion
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.progress.IncrementalNextRoundException
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.serialization.js.ModuleKind
 import org.jetbrains.kotlin.utils.KotlinPaths
@@ -481,18 +482,28 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         val mainModule = MainModule.SourceFiles(environmentForJS.getSourceFiles())
         val moduleStructure = ModulesStructure(environmentForJS.project, mainModule, configuration, libraries, friendLibraries)
 
+        val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: LookupTracker.DO_NOTHING
+
         val outputs = compileModuleToAnalyzedFir(
             moduleStructure = moduleStructure,
             ktFiles = environmentForJS.getSourceFiles(),
             libraries = libraries,
             friendLibraries = friendLibraries,
             messageCollector = messageCollector,
-            diagnosticsReporter = diagnosticsReporter
+            diagnosticsReporter = diagnosticsReporter,
+            incrementalDataProvider = configuration[JSConfigurationKeys.INCREMENTAL_DATA_PROVIDER],
+            lookupTracker = lookupTracker,
         ) ?: return null
 
         // FIR2IR
         val fir2IrActualizedResult = transformFirToIr(moduleStructure, outputs, diagnosticsReporter)
 
+        if (configuration.getBoolean(CommonConfigurationKeys.INCREMENTAL_COMPILATION)) {
+            if (shouldGoToNextIcRound(moduleStructure, outputs, fir2IrActualizedResult, configuration)) {
+                throw IncrementalNextRoundException()
+            }
+        }
+
         // Serialize klib
         if (arguments.irProduceKlibDir || arguments.irProduceKlibFile) {
             serializeFirKlib(

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

@@ -17,6 +17,7 @@ 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.CompilerConfiguration
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.constant.EvaluatedConstTracker
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
@@ -38,10 +39,13 @@ import org.jetbrains.kotlin.fir.pipeline.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.serialization.FirKLibSerializerExtension
 import org.jetbrains.kotlin.fir.serialization.serializeSingleFirFile
+import org.jetbrains.kotlin.fir.session.KlibIcData
 import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 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.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.library.KotlinAbiVersion
 import org.jetbrains.kotlin.library.unresolvedDependencies
@@ -50,6 +54,7 @@ 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.io.File
 import java.nio.file.Paths
 
 fun compileModuleToAnalyzedFir(
@@ -58,7 +63,9 @@ fun compileModuleToAnalyzedFir(
     libraries: List<String>,
     friendLibraries: List<String>,
     messageCollector: MessageCollector,
-    diagnosticsReporter: BaseDiagnosticsCollector
+    diagnosticsReporter: BaseDiagnosticsCollector,
+    incrementalDataProvider: IncrementalDataProvider?,
+    lookupTracker: LookupTracker?,
 ): List<ModuleCompilerAnalyzedOutput>? {
     val renderDiagnosticNames = moduleStructure.compilerConfiguration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME)
 
@@ -83,7 +90,8 @@ fun compileModuleToAnalyzedFir(
 
     val sessionsWithSources = prepareJsSessions(
         ktFiles, moduleStructure.compilerConfiguration, escapedMainModuleName,
-        resolvedLibraries, dependencyList, extensionRegistrars, isCommonSourceForPsi, fileBelongsToModuleForPsi
+        resolvedLibraries, dependencyList, extensionRegistrars, isCommonSourceForPsi, fileBelongsToModuleForPsi,
+        lookupTracker, icData = incrementalDataProvider?.let { KlibIcData(it) }
     )
 
     val outputs = sessionsWithSources.map {
@@ -207,3 +215,51 @@ fun serializeFirKlib(
         )
     }
 }
+
+fun shouldGoToNextIcRound(
+    moduleStructure: ModulesStructure,
+    firOutputs: List<ModuleCompilerAnalyzedOutput>,
+    fir2IrActualizedResult: Fir2IrActualizedResult,
+    config: CompilerConfiguration,
+): Boolean {
+    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 metadataVersion = moduleStructure.compilerConfiguration.metadataVersion()
+
+    val actualizedExpectDeclarations = fir2IrActualizedResult.irActualizedResult.extractFirDeclarations()
+
+    val nextRoundChecker = config.get(JSConfigurationKeys.INCREMENTAL_NEXT_ROUND_CHECKER) ?: return false
+
+    for (ktFile in sourceFiles) {
+
+        val (firFile, session, scopeSession) = firFilesAndSessionsBySourceFile[ktFile]
+            ?: error("cannot find FIR file by source file ${ktFile.name} (${ktFile.path})")
+
+        val packageFragment = serializeSingleFirFile(
+            firFile,
+            session,
+            scopeSession,
+            actualizedExpectDeclarations,
+            FirKLibSerializerExtension(
+                session, metadataVersion,
+                ConstValueProviderImpl(fir2IrActualizedResult.components),
+                allowErrorTypes = false, exportKDoc = false
+            ),
+            moduleStructure.compilerConfiguration.languageVersionSettings,
+        )
+
+        // to minimize a number of IC rounds, we should inspect all proto for changes first,
+        // then go to a next round if needed, with all new dirty files
+        nextRoundChecker.checkProtoChanges(File(ktFile.path!!), packageFragment.toByteArray())
+    }
+
+    return nextRoundChecker.shouldGoToNextRound()
+}

compiler/cli/src/org/jetbrains/kotlin/cli/common/FirSessionConstructionUtils.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.session.*
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectFileSearchScope
+import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.library.KotlinLibrary
 import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
@@ -113,6 +114,8 @@ fun <F> prepareJsSessions(
     extensionRegistrars: List<FirExtensionRegistrar>,
     isCommonSource: (F) -> Boolean,
     fileBelongsToModule: (F, String) -> Boolean,
+    lookupTracker: LookupTracker?,
+    icData: KlibIcData?,
 ): List<SessionWithSources<F>> {
     return prepareSessions(
         files, configuration, rootModuleName, JsPlatforms.defaultJsPlatform, JsPlatformAnalyzerServices,
@@ -134,7 +137,8 @@ fun <F> prepareJsSessions(
             sessionProvider,
             extensionRegistrars,
             configuration.languageVersionSettings,
-            null,
+            lookupTracker,
+            icData = icData,
             registerExtraComponents = {},
             init = sessionConfigurator,
         )

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJsSessionFactory.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.FirPlatformDiagnosticSuppresso
 import org.jetbrains.kotlin.fir.analysis.js.checkers.FirJsPlatformDiagnosticSuppressor
 import org.jetbrains.kotlin.fir.checkers.registerJsCheckers
 import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
+import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
@@ -35,6 +36,7 @@ object FirJsSessionFactory : FirAbstractSessionFactory() {
         extensionRegistrars: List<FirExtensionRegistrar>,
         languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
         lookupTracker: LookupTracker?,
+        icData: KlibIcData? = null,
         registerExtraComponents: ((FirSession) -> Unit) = {},
         init: FirSessionConfigurator.() -> Unit
     ): FirSession {
@@ -52,10 +54,18 @@ object FirJsSessionFactory : FirAbstractSessionFactory() {
             },
             registerExtraCheckers = { it.registerJsCheckers() },
             createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _, _ -> declaredMemberScope } },
-            createProviders = { _, _, symbolProvider, generatedSymbolsProvider, syntheticFunctionInterfaceProvider, dependencies ->
+            createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider, syntheticFunctionInterfaceProvider, dependencies ->
                 listOfNotNull(
                     symbolProvider,
                     generatedSymbolsProvider,
+                    icData?.let {
+                        KlibIcCacheBasedSymbolProvider(
+                            session,
+                            SingleModuleDataProvider(moduleData),
+                            kotlinScopeProvider,
+                            it,
+                        )
+                    },
                     syntheticFunctionInterfaceProvider,
                     *dependencies.toTypedArray(),
                 )

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibBasedSymbolProvider.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.session
 
+import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.deserialization.*
@@ -20,6 +21,7 @@ import org.jetbrains.kotlin.metadata.deserialization.NameResolverImpl
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import org.jetbrains.kotlin.serialization.deserialization.getClassId
 import org.jetbrains.kotlin.utils.SmartList
 import java.nio.file.Paths
@@ -30,14 +32,17 @@ class KlibBasedSymbolProvider(
     kotlinScopeProvider: FirKotlinScopeProvider,
     private val resolvedLibraries: Collection<KotlinLibrary>,
     defaultDeserializationOrigin: FirDeclarationOrigin = FirDeclarationOrigin.Library
-) : AbstractFirDeserializedSymbolProvider(
+) : MetadataLibraryBasedSymbolProvider<KotlinLibrary>(
-    session, moduleDataProvider, kotlinScopeProvider, defaultDeserializationOrigin, KlibMetadataSerializerProtocol
+    session,
+    moduleDataProvider,
+    kotlinScopeProvider,
+    defaultDeserializationOrigin
 ) {
     private val moduleHeaders by lazy {
         resolvedLibraries.associate { it to parseModuleHeader(it.moduleHeaderData) }
     }
 
-    private val fragmentNamesInLibraries: Map<String, List<KotlinLibrary>> by lazy {
+    override val fragmentNamesInLibraries: Map<String, List<KotlinLibrary>> by lazy {
         buildMap<String, SmartList<KotlinLibrary>> {
             for ((library, header) in moduleHeaders) {
                 for (fragmentName in header.packageFragmentNameList) {
@@ -48,7 +53,7 @@ class KlibBasedSymbolProvider(
         }
     }
 
-    private val knownPackagesInLibraries: Set<FqName> by lazy {
+    override val knownPackagesInLibraries: Set<FqName> by lazy {
         buildSet<FqName> {
             for ((_, header) in moduleHeaders) {
                 for (fragmentName in header.packageFragmentNameList) {
@@ -62,124 +67,12 @@ class KlibBasedSymbolProvider(
         }
     }
 
-    private val annotationDeserializer = KlibBasedAnnotationDeserializer(session)
+    override fun moduleData(library: KotlinLibrary): FirModuleData? {
-    private val constDeserializer = FirConstDeserializer(session, KlibMetadataSerializerProtocol)
+        val libraryPath = Paths.get(library.libraryFile.path)
-    private val deserializationConfiguration = CompilerDeserializationConfiguration(session.languageVersionSettings)
+        return moduleDataProvider.getModuleData(libraryPath)
-    private val cachedFragments = mutableMapOf<KotlinLibrary, MutableMap<Pair<String, String>, ProtoBuf.PackageFragment>>()
-
-    private fun getPackageFragment(
-        resolvedLibrary: KotlinLibrary, packageStringName: String, packageMetadataPart: String
-    ): ProtoBuf.PackageFragment {
-        return cachedFragments.getOrPut(resolvedLibrary) {
-            mutableMapOf()
-        }.getOrPut(packageStringName to packageMetadataPart) {
-            parsePackageFragment(resolvedLibrary.packageMetadata(packageStringName, packageMetadataPart))
-        }
     }
 
-    override fun computePackagePartsInfos(packageFqName: FqName): List<PackagePartsCacheData> {
+    override fun createDeserializedContainerSource(
-        val packageStringName = if (packageFqName.isRoot) "" else packageFqName.asString()
-
-        val librariesWithFragment = fragmentNamesInLibraries[packageStringName] ?: return emptyList()
-
-        return librariesWithFragment.flatMap { resolvedLibrary ->
-            resolvedLibrary.packageMetadataParts(packageStringName).mapNotNull {
-                val fragment = getPackageFragment(resolvedLibrary, packageStringName, it)
-
-                val libraryPath = Paths.get(resolvedLibrary.libraryFile.path)
-                val moduleData = moduleDataProvider.getModuleData(libraryPath) ?: return@mapNotNull null
-                val packageProto = fragment.`package`
-
-                val nameResolver = NameResolverImpl(
-                    fragment.strings,
-                    fragment.qualifiedNames,
-                )
-
-                PackagePartsCacheData(
-                    packageProto,
-                    FirDeserializationContext.createForPackage(
-                        packageFqName, packageProto, nameResolver, moduleData,
-                        annotationDeserializer,
-                        constDeserializer,
-                        createDeserializedContainerSource(resolvedLibrary, packageFqName),
-                    ),
-                )
-            }
-        }
-    }
-
-    override fun computePackageSetWithNonClassDeclarations(): Set<String> = fragmentNamesInLibraries.keys
-
-    override fun knownTopLevelClassesInPackage(packageFqName: FqName): Set<String> =
-        buildSet {
-            forEachFragmentInPackage(packageFqName) { _, fragment, nameResolver ->
-                for (classNameId in fragment.getExtension(KlibMetadataProtoBuf.className).orEmpty()) {
-                    add(nameResolver.getClassId(classNameId).shortClassName.asString())
-                }
-            }
-        }
-
-    @OptIn(SymbolInternals::class)
-    override fun extractClassMetadata(classId: ClassId, parentContext: FirDeserializationContext?): ClassMetadataFindResult? {
-        forEachFragmentInPackage(classId.packageFqName) { resolvedLibrary, fragment, nameResolver ->
-            val finder = KlibMetadataClassDataFinder(fragment, nameResolver)
-            val classProto = finder.findClassData(classId)?.classProto ?: return@forEachFragmentInPackage
-
-            val libraryPath = Paths.get(resolvedLibrary.libraryFile.path)
-            val moduleData = moduleDataProvider.getModuleData(libraryPath) ?: return null
-
-            return ClassMetadataFindResult.NoMetadata { symbol ->
-                val source = createDeserializedContainerSource(resolvedLibrary,
-
-                    classId.packageFqName
-                )
-
-                deserializeClassToSymbol(
-                    classId,
-                    classProto,
-                    symbol,
-                    nameResolver,
-                    session,
-                    moduleData,
-                    annotationDeserializer,
-                    kotlinScopeProvider,
-                    KlibMetadataSerializerProtocol,
-                    parentContext,
-                    source,
-                    origin = defaultDeserializationOrigin,
-                    deserializeNestedClass = this::getClass,
-                )
-                symbol.fir.isNewPlaceForBodyGeneration = isNewPlaceForBodyGeneration(classProto)
-            }
-        }
-
-        return null
-    }
-
-    private inline fun forEachFragmentInPackage(
-        packageFqName: FqName,
-        f: (KotlinLibrary, ProtoBuf.PackageFragment, NameResolver) -> Unit
-    ) {
-        val packageStringName = packageFqName.asString()
-
-        val librariesWithFragment = fragmentNamesInLibraries[packageStringName] ?: return
-
-        for (resolvedLibrary in librariesWithFragment) {
-            for (packageMetadataPart in resolvedLibrary.packageMetadataParts(packageStringName)) {
-
-                val fragment = getPackageFragment(resolvedLibrary, packageStringName, packageMetadataPart)
-
-                val nameResolver = NameResolverImpl(
-                    fragment.strings,
-                    fragment.qualifiedNames,
-                )
-
-                f(resolvedLibrary, fragment, nameResolver)
-            }
-        }
-    }
-
-    private fun createDeserializedContainerSource(
         resolvedLibrary: KotlinLibrary,
         packageFqName: FqName
     ) = KlibDeserializedContainerSource(
@@ -188,14 +81,4 @@ class KlibBasedSymbolProvider(
         deserializationConfiguration,
         packageFqName
     )
-
-    override fun isNewPlaceForBodyGeneration(classProto: ProtoBuf.Class) = false
-
-    override fun getPackage(fqName: FqName): FqName? {
-        return if (fqName in knownPackagesInLibraries) {
-            fqName
-        } else {
-            null
-        }
-    }
 }

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibIcCacheBasedSymbolProvider.kt

@@ -0,0 +1,59 @@
+/*
+ * 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.fir.session
+
+
+import org.jetbrains.kotlin.fir.FirModuleData
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
+import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
+import org.jetbrains.kotlin.library.metadata.KlibDeserializedContainerSource
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+import org.jetbrains.kotlin.utils.SmartList
+
+class KlibIcCacheBasedSymbolProvider(
+    session: FirSession,
+    moduleDataProvider: SingleModuleDataProvider,
+    kotlinScopeProvider: FirKotlinScopeProvider,
+    private val icData: KlibIcData,
+    defaultDeserializationOrigin: FirDeclarationOrigin = FirDeclarationOrigin.Library
+) : MetadataLibraryBasedSymbolProvider<KlibIcData>(
+    session,
+    moduleDataProvider,
+    kotlinScopeProvider,
+    defaultDeserializationOrigin
+) {
+    override fun moduleData(library: KlibIcData): FirModuleData {
+        return moduleDataProvider.allModuleData.single()
+    }
+
+    override val fragmentNamesInLibraries: Map<String, List<KlibIcData>> by lazy {
+        buildMap<String, SmartList<KlibIcData>> {
+            for (fragmentName in icData.packageFragmentNameList) {
+                getOrPut(fragmentName) { SmartList() }
+                    .add(icData)
+            }
+        }
+    }
+
+    override val knownPackagesInLibraries: Set<FqName> by lazy {
+        buildSet<FqName> {
+            for (fragmentName in icData.packageFragmentNameList) {
+                var curPackage = FqName(fragmentName)
+                while (!curPackage.isRoot) {
+                    add(curPackage)
+                    curPackage = curPackage.parent()
+                }
+            }
+        }
+    }
+
+    override fun createDeserializedContainerSource(resolvedLibrary: KlibIcData, packageFqName: FqName): DeserializedContainerSource {
+        return KlibDeserializedContainerSource(false, "Package '$packageFqName'", false)
+    }
+}

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibIcData.kt

@@ -0,0 +1,40 @@
+/*
+ * 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.fir.session
+
+import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
+import org.jetbrains.kotlin.library.MetadataLibrary
+import org.jetbrains.kotlin.library.metadata.KlibMetadataProtoBuf
+import org.jetbrains.kotlin.library.metadata.parsePackageFragment
+
+class KlibIcData(incrementalData: IncrementalDataProvider) : MetadataLibrary {
+
+    private val parts: Map<String, Map<String, ByteArray>> by lazy {
+        val result = mutableMapOf<String, MutableMap<String, ByteArray>>()
+
+        incrementalData.compiledPackageParts.entries.forEach { (f, tv) ->
+            val proto = parsePackageFragment(tv.metadata)
+            val fqName = proto.getExtension(KlibMetadataProtoBuf.fqName)
+            result.getOrPut(fqName, ::mutableMapOf).put(f.name, tv.metadata)
+        }
+
+        result
+    }
+
+    val packageFragmentNameList: Collection<String>
+        get() = parts.keys
+
+    override val moduleHeaderData: ByteArray
+        get() = error("moduleHeaderData is not implemented")
+
+    override fun packageMetadataParts(fqName: String): Set<String> {
+        return parts[fqName]?.keys ?: emptySet()
+    }
+
+    override fun packageMetadata(fqName: String, partName: String): ByteArray {
+        return parts[fqName]?.get(partName) ?: error("Metadata not found for package $fqName part $partName")
+    }
+}

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/MetadataLibraryBasedSymbolProvider.kt

@@ -0,0 +1,177 @@
+/*
+ * Copyright 2010-2021 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.fir.session
+
+import org.jetbrains.kotlin.fir.FirModuleData
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.caches.FirCache
+import org.jetbrains.kotlin.fir.caches.firCachesFactory
+import org.jetbrains.kotlin.fir.caches.getValue
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.deserialization.*
+import org.jetbrains.kotlin.fir.isNewPlaceForBodyGeneration
+import org.jetbrains.kotlin.fir.languageVersionSettings
+import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
+import org.jetbrains.kotlin.fir.symbols.SymbolInternals
+import org.jetbrains.kotlin.library.KotlinLibrary
+import org.jetbrains.kotlin.library.MetadataLibrary
+import org.jetbrains.kotlin.library.metadata.*
+import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.NameResolver
+import org.jetbrains.kotlin.metadata.deserialization.NameResolverImpl
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+import org.jetbrains.kotlin.serialization.deserialization.getClassId
+import org.jetbrains.kotlin.utils.SmartList
+import java.nio.file.Paths
+
+abstract class MetadataLibraryBasedSymbolProvider<L : MetadataLibrary>(
+    session: FirSession,
+    moduleDataProvider: ModuleDataProvider,
+    kotlinScopeProvider: FirKotlinScopeProvider,
+    defaultDeserializationOrigin: FirDeclarationOrigin = FirDeclarationOrigin.Library
+) : AbstractFirDeserializedSymbolProvider(
+    session, moduleDataProvider, kotlinScopeProvider, defaultDeserializationOrigin, KlibMetadataSerializerProtocol
+) {
+    protected abstract fun moduleData(library: L): FirModuleData?
+
+    protected abstract val fragmentNamesInLibraries: Map<String, List<L>>
+
+    protected abstract val knownPackagesInLibraries: Set<FqName>
+
+    private val annotationDeserializer = KlibBasedAnnotationDeserializer(session)
+    private val constDeserializer = FirConstDeserializer(session, KlibMetadataSerializerProtocol)
+    protected val deserializationConfiguration = CompilerDeserializationConfiguration(session.languageVersionSettings)
+    private val cachedFragments = mutableMapOf<L, MutableMap<Pair<String, String>, ProtoBuf.PackageFragment>>()
+
+    private fun getPackageFragment(
+        resolvedLibrary: L, packageStringName: String, packageMetadataPart: String
+    ): ProtoBuf.PackageFragment {
+        return cachedFragments.getOrPut(resolvedLibrary) {
+            mutableMapOf()
+        }.getOrPut(packageStringName to packageMetadataPart) {
+            parsePackageFragment(resolvedLibrary.packageMetadata(packageStringName, packageMetadataPart))
+        }
+    }
+
+    override fun computePackagePartsInfos(packageFqName: FqName): List<PackagePartsCacheData> {
+        val packageStringName = if (packageFqName.isRoot) "" else packageFqName.asString()
+
+        val librariesWithFragment = fragmentNamesInLibraries[packageStringName] ?: return emptyList()
+
+        return librariesWithFragment.flatMap { resolvedLibrary ->
+            resolvedLibrary.packageMetadataParts(packageStringName).mapNotNull {
+                val fragment = getPackageFragment(resolvedLibrary, packageStringName, it)
+
+                val moduleData = moduleData(resolvedLibrary) ?: return@mapNotNull null
+                val packageProto = fragment.`package`
+
+                val nameResolver = NameResolverImpl(
+                    fragment.strings,
+                    fragment.qualifiedNames,
+                )
+
+                PackagePartsCacheData(
+                    packageProto,
+                    FirDeserializationContext.createForPackage(
+                        packageFqName, packageProto, nameResolver, moduleData,
+                        annotationDeserializer,
+                        constDeserializer,
+                        createDeserializedContainerSource(resolvedLibrary, packageFqName),
+                    ),
+                )
+            }
+        }
+    }
+
+    override fun computePackageSetWithNonClassDeclarations(): Set<String> = fragmentNamesInLibraries.keys
+
+    override fun knownTopLevelClassesInPackage(packageFqName: FqName): Set<String> =
+        buildSet {
+            forEachFragmentInPackage(packageFqName) { _, fragment, nameResolver ->
+                for (classNameId in fragment.getExtension(KlibMetadataProtoBuf.className).orEmpty()) {
+                    add(nameResolver.getClassId(classNameId).shortClassName.asString())
+                }
+            }
+        }
+
+    @OptIn(SymbolInternals::class)
+    override fun extractClassMetadata(classId: ClassId, parentContext: FirDeserializationContext?): ClassMetadataFindResult? {
+        forEachFragmentInPackage(classId.packageFqName) { resolvedLibrary, fragment, nameResolver ->
+            val finder = KlibMetadataClassDataFinder(fragment, nameResolver)
+            val classProto = finder.findClassData(classId)?.classProto ?: return@forEachFragmentInPackage
+
+            val moduleData = moduleData(resolvedLibrary) ?: return null
+
+            return ClassMetadataFindResult.NoMetadata { symbol ->
+                val source = createDeserializedContainerSource(
+                    resolvedLibrary,
+                    classId.packageFqName
+                )
+
+                deserializeClassToSymbol(
+                    classId,
+                    classProto,
+                    symbol,
+                    nameResolver,
+                    session,
+                    moduleData,
+                    annotationDeserializer,
+                    kotlinScopeProvider,
+                    KlibMetadataSerializerProtocol,
+                    parentContext,
+                    source,
+                    origin = defaultDeserializationOrigin,
+                    deserializeNestedClass = this::getClass,
+                )
+                symbol.fir.isNewPlaceForBodyGeneration = isNewPlaceForBodyGeneration(classProto)
+            }
+        }
+
+        return null
+    }
+
+    private inline fun forEachFragmentInPackage(
+        packageFqName: FqName,
+        f: (L, ProtoBuf.PackageFragment, NameResolver) -> Unit
+    ) {
+        val packageStringName = packageFqName.asString()
+
+        val librariesWithFragment = fragmentNamesInLibraries[packageStringName] ?: return
+
+        for (resolvedLibrary in librariesWithFragment) {
+            for (packageMetadataPart in resolvedLibrary.packageMetadataParts(packageStringName)) {
+
+                val fragment = getPackageFragment(resolvedLibrary, packageStringName, packageMetadataPart)
+
+                val nameResolver = NameResolverImpl(
+                    fragment.strings,
+                    fragment.qualifiedNames,
+                )
+
+                f(resolvedLibrary, fragment, nameResolver)
+            }
+        }
+    }
+
+    protected abstract fun createDeserializedContainerSource(
+        resolvedLibrary: L,
+        packageFqName: FqName
+    ): DeserializedContainerSource?
+
+    override fun isNewPlaceForBodyGeneration(classProto: ProtoBuf.Class) = false
+
+    override fun getPackage(fqName: FqName): FqName? {
+        return if (fqName in knownPackagesInLibraries) {
+            fqName
+        } else {
+            null
+        }
+    }
+}

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsKlibCompilerRunnerTest.kt

@@ -24,3 +24,12 @@ abstract class AbstractIncrementalJsKlibCompilerRunnerTest : AbstractIncremental
 abstract class AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest : AbstractIncrementalJsKlibCompilerRunnerTest() {
     override val scopeExpansionMode = CompileScopeExpansionMode.ALWAYS
 }
+
+abstract class AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest : AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest() {
+    override fun createCompilerArguments(destinationDir: File, testDir: File): K2JSCompilerArguments {
+        return super.createCompilerArguments(destinationDir, testDir).apply {
+            useK2 = true
+            languageVersion = "2.0"
+        }
+    }
+}

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsFirKlibCompilerWithScopeExpansionRunnerTestGenerated.java

@@ -0,0 +1,958 @@
+/*
+ * 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.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.GenerateTestsKt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@RunWith(JUnit3RunnerWithInners.class)
+public class IncrementalJsFirKlibCompilerWithScopeExpansionRunnerTestGenerated extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+    @TestMetadata("jps/jps-plugin/testData/incremental/pureKotlin")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class PureKotlin extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        @TestMetadata("accessingFunctionsViaPackagePart")
+        public void testAccessingFunctionsViaPackagePart() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/accessingFunctionsViaPackagePart/");
+        }
+
+        @TestMetadata("accessingPropertiesViaField")
+        public void testAccessingPropertiesViaField() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/accessingPropertiesViaField/");
+        }
+
+        @TestMetadata("addClass")
+        public void testAddClass() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/addClass/");
+        }
+
+        @TestMetadata("addFileWithFunctionOverload")
+        public void testAddFileWithFunctionOverload() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/addFileWithFunctionOverload/");
+        }
+
+        @TestMetadata("addMemberTypeAlias")
+        public void testAddMemberTypeAlias() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/addMemberTypeAlias/");
+        }
+
+        @TestMetadata("addTopLevelTypeAlias")
+        public void testAddTopLevelTypeAlias() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/addTopLevelTypeAlias/");
+        }
+
+        public void testAllFilesPresentInPureKotlin() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^(sealed|propertyRedeclaration|funRedeclaration|funVsConstructorOverloadConflict).*"), false);
+        }
+
+        @TestMetadata("annotations")
+        public void testAnnotations() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/annotations/");
+        }
+
+        @TestMetadata("anonymousObjectChanged")
+        public void testAnonymousObjectChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/anonymousObjectChanged/");
+        }
+
+        @TestMetadata("changeTypeImplicitlyWithCircularDependency")
+        public void testChangeTypeImplicitlyWithCircularDependency() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/changeTypeImplicitlyWithCircularDependency/");
+        }
+
+        @TestMetadata("changeTypealiasSinceK2")
+        public void testChangeTypealiasSinceK2() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/changeTypealiasSinceK2/");
+        }
+
+        @TestMetadata("changeWithRemovingUsage")
+        public void testChangeWithRemovingUsage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/changeWithRemovingUsage/");
+        }
+
+        @TestMetadata("checkConstants")
+        public void testCheckConstants() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/checkConstants/");
+        }
+
+        @TestMetadata("classInlineFunctionChanged")
+        public void testClassInlineFunctionChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/classInlineFunctionChanged/");
+        }
+
+        @TestMetadata("classObjectConstantChanged")
+        public void testClassObjectConstantChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/classObjectConstantChanged/");
+        }
+
+        @TestMetadata("classRecreated")
+        public void testClassRecreated() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/classRecreated/");
+        }
+
+        @TestMetadata("classRemoved")
+        public void testClassRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/classRemoved/");
+        }
+
+        @TestMetadata("classSignatureChanged")
+        public void testClassSignatureChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/classSignatureChanged/");
+        }
+
+        @TestMetadata("classSignatureUnchanged")
+        public void testClassSignatureUnchanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/classSignatureUnchanged/");
+        }
+
+        @TestMetadata("companionConstantChanged")
+        public void testCompanionConstantChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/companionConstantChanged/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedOtherPackage")
+        public void testCompilationErrorThenFixedOtherPackage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedOtherPackage/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedSamePackage")
+        public void testCompilationErrorThenFixedSamePackage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedSamePackage/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedWithPhantomPart")
+        public void testCompilationErrorThenFixedWithPhantomPart() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedWithPhantomPart2")
+        public void testCompilationErrorThenFixedWithPhantomPart2() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart2/");
+        }
+
+        @TestMetadata("compilationErrorThenFixedWithPhantomPart3")
+        public void testCompilationErrorThenFixedWithPhantomPart3() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart3/");
+        }
+
+        @TestMetadata("constantRemoved")
+        public void testConstantRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/constantRemoved/");
+        }
+
+        @TestMetadata("constantValueChanged")
+        public void testConstantValueChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/constantValueChanged/");
+        }
+
+        @TestMetadata("constantsUnchanged")
+        public void testConstantsUnchanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/constantsUnchanged/");
+        }
+
+        @TestMetadata("defaultArgumentInConstructorAdded")
+        public void testDefaultArgumentInConstructorAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorAdded/");
+        }
+
+        @TestMetadata("defaultArgumentInConstructorRemoved")
+        public void testDefaultArgumentInConstructorRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorRemoved/");
+        }
+
+        @TestMetadata("defaultValueAdded")
+        public void testDefaultValueAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueAdded/");
+        }
+
+        @TestMetadata("defaultValueChanged")
+        public void testDefaultValueChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueChanged/");
+        }
+
+        @TestMetadata("defaultValueInConstructorChanged")
+        public void testDefaultValueInConstructorChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorChanged/");
+        }
+
+        @TestMetadata("defaultValueInConstructorRemoved")
+        public void testDefaultValueInConstructorRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorRemoved/");
+        }
+
+        @TestMetadata("defaultValueRemoved1")
+        public void testDefaultValueRemoved1() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved1/");
+        }
+
+        @TestMetadata("defaultValueRemoved2")
+        public void testDefaultValueRemoved2() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved2/");
+        }
+
+        @TestMetadata("delegatedPropertyInlineExtensionAccessor")
+        public void testDelegatedPropertyInlineExtensionAccessor() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineExtensionAccessor/");
+        }
+
+        @TestMetadata("delegatedPropertyInlineMethodAccessor")
+        public void testDelegatedPropertyInlineMethodAccessor() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineMethodAccessor/");
+        }
+
+        @TestMetadata("dependencyClassReferenced")
+        public void testDependencyClassReferenced() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/dependencyClassReferenced/");
+        }
+
+        @TestMetadata("fileWithConstantRemoved")
+        public void testFileWithConstantRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/fileWithConstantRemoved/");
+        }
+
+        @TestMetadata("fileWithInlineFunctionRemoved")
+        public void testFileWithInlineFunctionRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/");
+        }
+
+        @TestMetadata("filesExchangePackages")
+        public void testFilesExchangePackages() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/filesExchangePackages/");
+        }
+
+        @TestMetadata("functionBecameInline")
+        public void testFunctionBecameInline() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/functionBecameInline/");
+        }
+
+        @TestMetadata("functionReferencingClass")
+        public void testFunctionReferencingClass() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/functionReferencingClass/");
+        }
+
+        @TestMetadata("independentClasses")
+        public void testIndependentClasses() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/independentClasses/");
+        }
+
+        @TestMetadata("inlineFunctionBecomesNonInline")
+        public void testInlineFunctionBecomesNonInline() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionBecomesNonInline/");
+        }
+
+        @TestMetadata("inlineFunctionUsageAdded")
+        public void testInlineFunctionUsageAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionUsageAdded/");
+        }
+
+        @TestMetadata("inlineFunctionsCircularDependency")
+        public void testInlineFunctionsCircularDependency() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionsCircularDependency/");
+        }
+
+        @TestMetadata("inlineFunctionsUnchanged")
+        public void testInlineFunctionsUnchanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineFunctionsUnchanged/");
+        }
+
+        @TestMetadata("inlineLinesChanged")
+        public void testInlineLinesChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineLinesChanged/");
+        }
+
+        @TestMetadata("inlineModifiedWithUsage")
+        public void testInlineModifiedWithUsage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineModifiedWithUsage/");
+        }
+
+        @TestMetadata("inlinePrivateFunctionAdded")
+        public void testInlinePrivateFunctionAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlinePrivateFunctionAdded/");
+        }
+
+        @TestMetadata("inlinePropertyInClass")
+        public void testInlinePropertyInClass() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlinePropertyInClass/");
+        }
+
+        @TestMetadata("inlinePropertyOnTopLevel")
+        public void testInlinePropertyOnTopLevel() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlinePropertyOnTopLevel/");
+        }
+
+        @TestMetadata("inlineSuspendFunctionChanged")
+        public void testInlineSuspendFunctionChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineSuspendFunctionChanged/");
+        }
+
+        @TestMetadata("inlineTwoFunctionsOneChanged")
+        public void testInlineTwoFunctionsOneChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineTwoFunctionsOneChanged/");
+        }
+
+        @TestMetadata("inlineUsedWhereDeclared")
+        public void testInlineUsedWhereDeclared() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/inlineUsedWhereDeclared/");
+        }
+
+        @TestMetadata("innerClassesFromSupertypes")
+        public void testInnerClassesFromSupertypes() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/innerClassesFromSupertypes/");
+        }
+
+        @TestMetadata("internalClassChanged")
+        public void testInternalClassChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalClassChanged/");
+        }
+
+        @TestMetadata("internalMemberInClassChanged")
+        public void testInternalMemberInClassChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalMemberInClassChanged/");
+        }
+
+        @TestMetadata("internalTypealias")
+        public void testInternalTypealias() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalTypealias/");
+        }
+
+        @TestMetadata("internalTypealiasConstructor")
+        public void testInternalTypealiasConstructor() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalTypealiasConstructor/");
+        }
+
+        @TestMetadata("internalTypealiasObject")
+        public void testInternalTypealiasObject() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/internalTypealiasObject/");
+        }
+
+        @TestMetadata("localClassChanged")
+        public void testLocalClassChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/localClassChanged/");
+        }
+
+        @TestMetadata("moveClass")
+        public void testMoveClass() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/moveClass/");
+        }
+
+        @TestMetadata("moveFileWithChangingPackage")
+        public void testMoveFileWithChangingPackage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/moveFileWithChangingPackage/");
+        }
+
+        @TestMetadata("moveFileWithoutChangingPackage")
+        public void testMoveFileWithoutChangingPackage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/moveFileWithoutChangingPackage/");
+        }
+
+        @TestMetadata("multiplePackagesModified")
+        public void testMultiplePackagesModified() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/multiplePackagesModified/");
+        }
+
+        @TestMetadata("objectConstantChanged")
+        public void testObjectConstantChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/objectConstantChanged/");
+        }
+
+        @TestMetadata("ourClassReferenced")
+        public void testOurClassReferenced() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/ourClassReferenced/");
+        }
+
+        @TestMetadata("overloadInlined")
+        public void testOverloadInlined() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/overloadInlined/");
+        }
+
+        @TestMetadata("packageConstantChanged")
+        public void testPackageConstantChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageConstantChanged/");
+        }
+
+        @TestMetadata("packageFileAdded")
+        public void testPackageFileAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileAdded/");
+        }
+
+        @TestMetadata("packageFileChangedPackage")
+        public void testPackageFileChangedPackage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileChangedPackage/");
+        }
+
+        @TestMetadata("packageFileChangedThenOtherRemoved")
+        public void testPackageFileChangedThenOtherRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileChangedThenOtherRemoved/");
+        }
+
+        @TestMetadata("packageFileRemoved")
+        public void testPackageFileRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFileRemoved/");
+        }
+
+        @TestMetadata("packageFilesChangedInTurn")
+        public void testPackageFilesChangedInTurn() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageFilesChangedInTurn/");
+        }
+
+        @TestMetadata("packageInlineFunctionAccessingField")
+        public void testPackageInlineFunctionAccessingField() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionAccessingField/");
+        }
+
+        @TestMetadata("packageInlineFunctionFromOurPackage")
+        public void testPackageInlineFunctionFromOurPackage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionFromOurPackage/");
+        }
+
+        @TestMetadata("packagePrivateOnlyChanged")
+        public void testPackagePrivateOnlyChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packagePrivateOnlyChanged/");
+        }
+
+        @TestMetadata("packageRecreated")
+        public void testPackageRecreated() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageRecreated/");
+        }
+
+        @TestMetadata("packageRecreatedAfterRenaming")
+        public void testPackageRecreatedAfterRenaming() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageRecreatedAfterRenaming/");
+        }
+
+        @TestMetadata("packageRemoved")
+        public void testPackageRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/packageRemoved/");
+        }
+
+        @TestMetadata("parameterWithDefaultValueAdded")
+        public void testParameterWithDefaultValueAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/parameterWithDefaultValueAdded/");
+        }
+
+        @TestMetadata("parameterWithDefaultValueRemoved")
+        public void testParameterWithDefaultValueRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/parameterWithDefaultValueRemoved/");
+        }
+
+        @TestMetadata("privateConstantsChanged")
+        public void testPrivateConstantsChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateConstantsChanged/");
+        }
+
+        @TestMetadata("privateMethodAdded")
+        public void testPrivateMethodAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateMethodAdded/");
+        }
+
+        @TestMetadata("privateMethodDeleted")
+        public void testPrivateMethodDeleted() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateMethodDeleted/");
+        }
+
+        @TestMetadata("privateMethodSignatureChanged")
+        public void testPrivateMethodSignatureChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateMethodSignatureChanged/");
+        }
+
+        @TestMetadata("privateSecondaryConstructorAdded")
+        public void testPrivateSecondaryConstructorAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorAdded/");
+        }
+
+        @TestMetadata("privateSecondaryConstructorDeleted")
+        public void testPrivateSecondaryConstructorDeleted() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorDeleted/");
+        }
+
+        @TestMetadata("privateValAccessorChanged")
+        public void testPrivateValAccessorChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValAccessorChanged/");
+        }
+
+        @TestMetadata("privateValAdded")
+        public void testPrivateValAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValAdded/");
+        }
+
+        @TestMetadata("privateValDeleted")
+        public void testPrivateValDeleted() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValDeleted/");
+        }
+
+        @TestMetadata("privateValSignatureChanged")
+        public void testPrivateValSignatureChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateValSignatureChanged/");
+        }
+
+        @TestMetadata("privateVarAdded")
+        public void testPrivateVarAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateVarAdded/");
+        }
+
+        @TestMetadata("privateVarDeleted")
+        public void testPrivateVarDeleted() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateVarDeleted/");
+        }
+
+        @TestMetadata("privateVarSignatureChanged")
+        public void testPrivateVarSignatureChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/privateVarSignatureChanged/");
+        }
+
+        @TestMetadata("publicPropertyWithPrivateSetter")
+        public void testPublicPropertyWithPrivateSetter() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/publicPropertyWithPrivateSetter/");
+        }
+
+        @TestMetadata("removeAndRestoreCompanion")
+        public void testRemoveAndRestoreCompanion() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanion/");
+        }
+
+        @TestMetadata("removeAndRestoreCompanionWithImplicitUsages")
+        public void testRemoveAndRestoreCompanionWithImplicitUsages() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanionWithImplicitUsages/");
+        }
+
+        @TestMetadata("removeClass")
+        public void testRemoveClass() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeClass/");
+        }
+
+        @TestMetadata("removeClassInDefaultPackage")
+        public void testRemoveClassInDefaultPackage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeClassInDefaultPackage/");
+        }
+
+        @TestMetadata("removeFileWithFunctionOverload")
+        public void testRemoveFileWithFunctionOverload() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeFileWithFunctionOverload/");
+        }
+
+        @TestMetadata("removeMemberTypeAlias")
+        public void testRemoveMemberTypeAlias() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeMemberTypeAlias/");
+        }
+
+        @TestMetadata("removeTopLevelTypeAlias")
+        public void testRemoveTopLevelTypeAlias() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeTopLevelTypeAlias/");
+        }
+
+        @TestMetadata("removeUnusedFile")
+        public void testRemoveUnusedFile() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/removeUnusedFile/");
+        }
+
+        @TestMetadata("renameClass")
+        public void testRenameClass() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/renameClass/");
+        }
+
+        @TestMetadata("renameFileWithClassesOnly")
+        public void testRenameFileWithClassesOnly() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/renameFileWithClassesOnly/");
+        }
+
+        @TestMetadata("renameFileWithFunctionOverload")
+        public void testRenameFileWithFunctionOverload() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/renameFileWithFunctionOverload/");
+        }
+
+        @TestMetadata("returnTypeChanged")
+        public void testReturnTypeChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/");
+        }
+
+        @TestMetadata("secondaryConstructorInlined")
+        public void testSecondaryConstructorInlined() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/");
+        }
+
+        @TestMetadata("sequentualAddingAndDeletingOfPropertyAndUsage")
+        public void testSequentualAddingAndDeletingOfPropertyAndUsage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/sequentualAddingAndDeletingOfPropertyAndUsage/");
+        }
+
+        @TestMetadata("serializedSubClassAndChangedInterfaces")
+        public void testSerializedSubClassAndChangedInterfaces() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/serializedSubClassAndChangedInterfaces/");
+        }
+
+        @TestMetadata("simpleClassDependency")
+        public void testSimpleClassDependency() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/simpleClassDependency/");
+        }
+
+        @TestMetadata("soleFileChangesPackage")
+        public void testSoleFileChangesPackage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/soleFileChangesPackage/");
+        }
+
+        @TestMetadata("subpackage")
+        public void testSubpackage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/subpackage/");
+        }
+
+        @TestMetadata("suspendWithStateMachine")
+        public void testSuspendWithStateMachine() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/suspendWithStateMachine/");
+        }
+
+        @TestMetadata("topLevelFunctionSameSignature")
+        public void testTopLevelFunctionSameSignature() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/topLevelFunctionSameSignature/");
+        }
+
+        @TestMetadata("topLevelMembersInTwoFiles")
+        public void testTopLevelMembersInTwoFiles() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/topLevelMembersInTwoFiles/");
+        }
+
+        @TestMetadata("topLevelPrivateValUsageAdded")
+        public void testTopLevelPrivateValUsageAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/topLevelPrivateValUsageAdded/");
+        }
+
+        @TestMetadata("traitClassObjectConstantChanged")
+        public void testTraitClassObjectConstantChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/traitClassObjectConstantChanged/");
+        }
+
+        @TestMetadata("valAddCustomAccessor")
+        public void testValAddCustomAccessor() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/valAddCustomAccessor/");
+        }
+
+        @TestMetadata("valRemoveCustomAccessor")
+        public void testValRemoveCustomAccessor() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/pureKotlin/valRemoveCustomAccessor/");
+        }
+    }
+
+    @TestMetadata("jps/jps-plugin/testData/incremental/classHierarchyAffected")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class ClassHierarchyAffected extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInClassHierarchyAffected() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^(secondaryConstructorAdded|withIntermediateBodiesChanged|companionObjectNameChanged).*"), false);
+        }
+
+        @TestMetadata("annotationFlagRemoved")
+        public void testAnnotationFlagRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/annotationFlagRemoved/");
+        }
+
+        @TestMetadata("annotationListChanged")
+        public void testAnnotationListChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/annotationListChanged/");
+        }
+
+        @TestMetadata("bridgeGenerated")
+        public void testBridgeGenerated() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/bridgeGenerated/");
+        }
+
+        @TestMetadata("classBecameFinal")
+        public void testClassBecameFinal() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classBecameFinal/");
+        }
+
+        @TestMetadata("classBecameInterface")
+        public void testClassBecameInterface() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classBecameInterface/");
+        }
+
+        @TestMetadata("classBecamePrivate")
+        public void testClassBecamePrivate() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classBecamePrivate/");
+        }
+
+        @TestMetadata("classMovedIntoOtherClass")
+        public void testClassMovedIntoOtherClass() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classMovedIntoOtherClass/");
+        }
+
+        @TestMetadata("classRemoved")
+        public void testClassRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classRemoved/");
+        }
+
+        @TestMetadata("classRemovedAndRestored")
+        public void testClassRemovedAndRestored() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/classRemovedAndRestored/");
+        }
+
+        @TestMetadata("companionObjectInheritedMemberChanged")
+        public void testCompanionObjectInheritedMemberChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectInheritedMemberChanged/");
+        }
+
+        @TestMetadata("companionObjectMemberChanged")
+        public void testCompanionObjectMemberChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectMemberChanged/");
+        }
+
+        @TestMetadata("companionObjectToSimpleObject")
+        public void testCompanionObjectToSimpleObject() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/companionObjectToSimpleObject/");
+        }
+
+        @TestMetadata("constructorVisibilityChanged")
+        public void testConstructorVisibilityChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/constructorVisibilityChanged/");
+        }
+
+        @TestMetadata("enumEntryAdded")
+        public void testEnumEntryAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/enumEntryAdded/");
+        }
+
+        @TestMetadata("enumEntryRemoved")
+        public void testEnumEntryRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved/");
+        }
+
+        @TestMetadata("enumMemberChanged")
+        public void testEnumMemberChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/enumMemberChanged/");
+        }
+
+        @TestMetadata("flagsAndMemberInDifferentClassesChanged")
+        public void testFlagsAndMemberInDifferentClassesChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInDifferentClassesChanged/");
+        }
+
+        @TestMetadata("flagsAndMemberInSameClassChanged")
+        public void testFlagsAndMemberInSameClassChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInSameClassChanged/");
+        }
+
+        @TestMetadata("implcitUpcast")
+        public void testImplcitUpcast() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/implcitUpcast/");
+        }
+
+        @TestMetadata("inferredTypeArgumentChanged")
+        public void testInferredTypeArgumentChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeArgumentChanged/");
+        }
+
+        @TestMetadata("inferredTypeChanged")
+        public void testInferredTypeChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeChanged/");
+        }
+
+        @TestMetadata("interfaceAnyMethods")
+        public void testInterfaceAnyMethods() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/interfaceAnyMethods/");
+        }
+
+        @TestMetadata("lambdaParameterAffected")
+        public void testLambdaParameterAffected() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/lambdaParameterAffected/");
+        }
+
+        @TestMetadata("methodAdded")
+        public void testMethodAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodAdded/");
+        }
+
+        @TestMetadata("methodAnnotationAdded")
+        public void testMethodAnnotationAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodAnnotationAdded/");
+        }
+
+        @TestMetadata("methodNullabilityChanged")
+        public void testMethodNullabilityChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodNullabilityChanged/");
+        }
+
+        @TestMetadata("methodParameterWithDefaultValueAdded")
+        public void testMethodParameterWithDefaultValueAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodParameterWithDefaultValueAdded/");
+        }
+
+        @TestMetadata("methodRemoved")
+        public void testMethodRemoved() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/methodRemoved/");
+        }
+
+        @TestMetadata("overrideExplicit")
+        public void testOverrideExplicit() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/overrideExplicit/");
+        }
+
+        @TestMetadata("overrideImplicit")
+        public void testOverrideImplicit() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/overrideImplicit/");
+        }
+
+        @TestMetadata("propertyNullabilityChanged")
+        public void testPropertyNullabilityChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/propertyNullabilityChanged/");
+        }
+
+        @TestMetadata("sealedClassImplAdded")
+        public void testSealedClassImplAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/sealedClassImplAdded/");
+        }
+
+        @TestMetadata("sealedClassIndirectImplAdded")
+        public void testSealedClassIndirectImplAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/sealedClassIndirectImplAdded/");
+        }
+
+        @TestMetadata("sealedClassNestedImplAdded")
+        public void testSealedClassNestedImplAdded() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/sealedClassNestedImplAdded/");
+        }
+
+        @TestMetadata("starProjectionUpperBoundChanged")
+        public void testStarProjectionUpperBoundChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/starProjectionUpperBoundChanged/");
+        }
+
+        @TestMetadata("supertypesListChanged")
+        public void testSupertypesListChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/supertypesListChanged/");
+        }
+
+        @TestMetadata("typeParameterListChanged")
+        public void testTypeParameterListChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/typeParameterListChanged/");
+        }
+
+        @TestMetadata("varianceChanged")
+        public void testVarianceChanged() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/classHierarchyAffected/varianceChanged/");
+        }
+    }
+
+    @TestMetadata("jps/jps-plugin/testData/incremental/js")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class Js extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInJs() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), null, true);
+        }
+
+        @TestMetadata("inlineFunctionLocalDeclarationChanges")
+        public void testInlineFunctionLocalDeclarationChanges() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges/");
+        }
+
+        @TestMetadata("jps/jps-plugin/testData/incremental/js/friendsModuleDisabled")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class FriendsModuleDisabled extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInFriendsModuleDisabled() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, true);
+            }
+
+            @TestMetadata("internalInlineFunctionIsChanged")
+            public void testInternalInlineFunctionIsChanged() throws Exception {
+                runTest("jps/jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged/");
+            }
+
+            @TestMetadata("jps/jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class InternalInlineFunctionIsChanged extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInInternalInlineFunctionIsChanged() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), null, true);
+                }
+            }
+        }
+
+        @TestMetadata("jps/jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class InlineFunctionLocalDeclarationChanges extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInInlineFunctionLocalDeclarationChanges() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), null, true);
+            }
+        }
+    }
+
+    @TestMetadata("jps/jps-plugin/testData/incremental/scopeExpansion")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class ScopeExpansion extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInScopeExpansion() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/scopeExpansion"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^protectedBecomesPublicAccessedTroughChild.*"), true);
+        }
+
+        @TestMetadata("changeTypeAliasAndUsage")
+        public void testChangeTypeAliasAndUsage() throws Exception {
+            runTest("jps/jps-plugin/testData/incremental/scopeExpansion/changeTypeAliasAndUsage/");
+        }
+
+        @TestMetadata("jps/jps-plugin/testData/incremental/scopeExpansion/changeTypeAliasAndUsage")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ChangeTypeAliasAndUsage extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInChangeTypeAliasAndUsage() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/scopeExpansion/changeTypeAliasAndUsage"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^protectedBecomesPublicAccessedTroughChild.*"), true);
+            }
+        }
+
+        @TestMetadata("jps/jps-plugin/testData/incremental/scopeExpansion/protectedBecomesPublicAccessedTroughChild")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ProtectedBecomesPublicAccessedTroughChild extends AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInProtectedBecomesPublicAccessedTroughChild() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/scopeExpansion/protectedBecomesPublicAccessedTroughChild"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^protectedBecomesPublicAccessedTroughChild.*"), true);
+            }
+        }
+    }
+}

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirJsSessionFactory.kt

@@ -64,6 +64,7 @@ object TestFirJsSessionFactory {
             extensionRegistrars,
             languageVersionSettings,
             lookupTracker,
+            icData = null,
             registerExtraComponents,
             sessionConfigurator
         )

compiler/util-klib-metadata/src/org/jetbrains/kotlin/library/metadata/KlibDeserializedContainerSource.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErr
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerAbiStability
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
-class KlibDeserializedContainerSource private constructor(
+class KlibDeserializedContainerSource(
     override val isPreReleaseInvisible: Boolean,
     override val presentableString: String,
     val isFromNativeInteropLibrary: Boolean

generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt

@@ -109,6 +109,18 @@ fun main(args: Array<String>) {
                 model("incremental/scopeExpansion", extension = null, excludeParentDirs = true)
             }
 
+            testClass<AbstractIncrementalJsFirKlibCompilerWithScopeExpansionRunnerTest> {
+                // IC of sealed interfaces are not supported in JS
+                // Some IC tests fail with K2
+                model("incremental/pureKotlin", extension = null, recursive = false,
+                      excludedPattern = "^(sealed|propertyRedeclaration|funRedeclaration|funVsConstructorOverloadConflict).*")
+                model("incremental/classHierarchyAffected", extension = null, recursive = false,
+                      excludedPattern = "^(secondaryConstructorAdded|withIntermediateBodiesChanged|companionObjectNameChanged).*")
+                model("incremental/js", extension = null, excludeParentDirs = true)
+                model("incremental/scopeExpansion", extension = null, excludeParentDirs = true,
+                      excludedPattern = "^protectedBecomesPublicAccessedTroughChild.*")
+            }
+
             testClass<AbstractIncrementalJsCompilerRunnerWithFriendModulesDisabledTest> {
                 model("incremental/js/friendsModuleDisabled", extension = null, recursive = false)
             }

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

@@ -63,7 +63,9 @@ abstract class FirAbstractInvalidationTest(
             libraries = libraries,
             friendLibraries = friendLibraries,
             messageCollector = messageCollector,
-            diagnosticsReporter = diagnosticsReporter
+            diagnosticsReporter = diagnosticsReporter,
+            incrementalDataProvider = null,
+            lookupTracker = null,
         )
 
         if (outputs != null) {

js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsPartialLinkageTestCase.kt

@@ -210,7 +210,9 @@ abstract class AbstractJsPartialLinkageTestCase(val compilerType: CompilerType)
             libraries = regularDependencies,
             friendLibraries = friendDependencies,
             messageCollector = messageCollector,
-            diagnosticsReporter = diagnosticsReporter
+            diagnosticsReporter = diagnosticsReporter,
+            incrementalDataProvider = null,
+            lookupTracker = null
         )
 
         if (outputs != null) {