diff --git a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt index d6335d23928..38e286a8446 100644 --- a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt +++ b/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() { 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( diff --git a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt index 9441ed947bf..c950939404b 100644 --- a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt +++ b/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, friendLibraries: List, messageCollector: MessageCollector, - diagnosticsReporter: BaseDiagnosticsCollector + diagnosticsReporter: BaseDiagnosticsCollector, + incrementalDataProvider: IncrementalDataProvider?, + lookupTracker: LookupTracker?, ): List? { 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, + fir2IrActualizedResult: Fir2IrActualizedResult, + config: CompilerConfiguration, +): Boolean { + val sourceFiles = mutableListOf() + val firFilesAndSessionsBySourceFile = mutableMapOf>() + + 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() +} \ No newline at end of file diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/common/FirSessionConstructionUtils.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/common/FirSessionConstructionUtils.kt index 46faee117cd..a8dd22a652b 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/common/FirSessionConstructionUtils.kt +++ b/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 prepareJsSessions( extensionRegistrars: List, isCommonSource: (F) -> Boolean, fileBelongsToModule: (F, String) -> Boolean, + lookupTracker: LookupTracker?, + icData: KlibIcData?, ): List> { return prepareSessions( files, configuration, rootModuleName, JsPlatforms.defaultJsPlatform, JsPlatformAnalyzerServices, @@ -134,7 +137,8 @@ fun prepareJsSessions( sessionProvider, extensionRegistrars, configuration.languageVersionSettings, - null, + lookupTracker, + icData = icData, registerExtraComponents = {}, init = sessionConfigurator, ) diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJsSessionFactory.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJsSessionFactory.kt index 75d8d64301b..40a96d0573e 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJsSessionFactory.kt +++ b/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, 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(), ) diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibBasedSymbolProvider.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibBasedSymbolProvider.kt index f6f02409644..46d1dac3197 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibBasedSymbolProvider.kt +++ b/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, defaultDeserializationOrigin: FirDeclarationOrigin = FirDeclarationOrigin.Library -) : AbstractFirDeserializedSymbolProvider( - session, moduleDataProvider, kotlinScopeProvider, defaultDeserializationOrigin, KlibMetadataSerializerProtocol +) : MetadataLibraryBasedSymbolProvider( + session, + moduleDataProvider, + kotlinScopeProvider, + defaultDeserializationOrigin ) { private val moduleHeaders by lazy { resolvedLibraries.associate { it to parseModuleHeader(it.moduleHeaderData) } } - private val fragmentNamesInLibraries: Map> by lazy { + override val fragmentNamesInLibraries: Map> by lazy { buildMap> { for ((library, header) in moduleHeaders) { for (fragmentName in header.packageFragmentNameList) { @@ -48,7 +53,7 @@ class KlibBasedSymbolProvider( } } - private val knownPackagesInLibraries: Set by lazy { + override val knownPackagesInLibraries: Set by lazy { buildSet { for ((_, header) in moduleHeaders) { for (fragmentName in header.packageFragmentNameList) { @@ -62,124 +67,12 @@ class KlibBasedSymbolProvider( } } - private val annotationDeserializer = KlibBasedAnnotationDeserializer(session) - private val constDeserializer = FirConstDeserializer(session, KlibMetadataSerializerProtocol) - private val deserializationConfiguration = CompilerDeserializationConfiguration(session.languageVersionSettings) - private val cachedFragments = mutableMapOf, 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 moduleData(library: KotlinLibrary): FirModuleData? { + val libraryPath = Paths.get(library.libraryFile.path) + return moduleDataProvider.getModuleData(libraryPath) } - override fun computePackagePartsInfos(packageFqName: FqName): List { - 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 = fragmentNamesInLibraries.keys - - override fun knownTopLevelClassesInPackage(packageFqName: FqName): Set = - 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( + override 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 - } - } } diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibIcCacheBasedSymbolProvider.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibIcCacheBasedSymbolProvider.kt new file mode 100644 index 00000000000..62b554f9ab2 --- /dev/null +++ b/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( + session, + moduleDataProvider, + kotlinScopeProvider, + defaultDeserializationOrigin +) { + override fun moduleData(library: KlibIcData): FirModuleData { + return moduleDataProvider.allModuleData.single() + } + + override val fragmentNamesInLibraries: Map> by lazy { + buildMap> { + for (fragmentName in icData.packageFragmentNameList) { + getOrPut(fragmentName) { SmartList() } + .add(icData) + } + } + } + + override val knownPackagesInLibraries: Set by lazy { + buildSet { + 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) + } +} \ No newline at end of file diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibIcData.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/KlibIcData.kt new file mode 100644 index 00000000000..50da41b9f30 --- /dev/null +++ b/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> by lazy { + val result = mutableMapOf>() + + 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 + get() = parts.keys + + override val moduleHeaderData: ByteArray + get() = error("moduleHeaderData is not implemented") + + override fun packageMetadataParts(fqName: String): Set { + 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") + } +} \ No newline at end of file diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/MetadataLibraryBasedSymbolProvider.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/MetadataLibraryBasedSymbolProvider.kt new file mode 100644 index 00000000000..059cfe44a53 --- /dev/null +++ b/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( + 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> + + protected abstract val knownPackagesInLibraries: Set + + private val annotationDeserializer = KlibBasedAnnotationDeserializer(session) + private val constDeserializer = FirConstDeserializer(session, KlibMetadataSerializerProtocol) + protected val deserializationConfiguration = CompilerDeserializationConfiguration(session.languageVersionSettings) + private val cachedFragments = mutableMapOf, 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 { + 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 = fragmentNamesInLibraries.keys + + override fun knownTopLevelClassesInPackage(packageFqName: FqName): Set = + 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 + } + } +} diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsKlibCompilerRunnerTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsKlibCompilerRunnerTest.kt index a18428e1819..0c98f704402 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsKlibCompilerRunnerTest.kt +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsKlibCompilerRunnerTest.kt @@ -23,4 +23,13 @@ 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" + } + } } \ No newline at end of file diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsFirKlibCompilerWithScopeExpansionRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsFirKlibCompilerWithScopeExpansionRunnerTestGenerated.java new file mode 100644 index 00000000000..9e9ba8a835a --- /dev/null +++ b/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); + } + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirJsSessionFactory.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirJsSessionFactory.kt index 54101dadd5c..d06be1c3a9d 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirJsSessionFactory.kt +++ b/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 ) diff --git a/compiler/util-klib-metadata/src/org/jetbrains/kotlin/library/metadata/KlibDeserializedContainerSource.kt b/compiler/util-klib-metadata/src/org/jetbrains/kotlin/library/metadata/KlibDeserializedContainerSource.kt index 7b32674a714..e9061b43050 100644 --- a/compiler/util-klib-metadata/src/org/jetbrains/kotlin/library/metadata/KlibDeserializedContainerSource.kt +++ b/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 diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 364b75b0d15..906bf959dad 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -109,6 +109,18 @@ fun main(args: Array) { model("incremental/scopeExpansion", extension = null, excludeParentDirs = true) } + testClass { + // 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 { model("incremental/js/friendsModuleDisabled", extension = null, recursive = false) } diff --git a/js/js.tests/test/org/jetbrains/kotlin/incremental/FirAbstractInvalidationTest.kt b/js/js.tests/test/org/jetbrains/kotlin/incremental/FirAbstractInvalidationTest.kt index 1cdf25094a8..eed473c7b01 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/incremental/FirAbstractInvalidationTest.kt +++ b/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) { diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsPartialLinkageTestCase.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsPartialLinkageTestCase.kt index c4e0dbc12b1..bb0ecc88b07 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsPartialLinkageTestCase.kt +++ b/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) {