diff --git a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt index 1cfec636e00..e7558d9752f 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt @@ -83,6 +83,17 @@ open class IncrementalJsCache( dirtySources.addAll(removedAndCompiledSources) } + fun compare(translatedFiles: Map, changesCollector: ChangesCollector) { + for ((srcFile, data) in translatedFiles) { + val oldProtoMap = translationResults[srcFile]?.metadata?.let { protoData(srcFile, it) } ?: emptyMap() + val newProtoMap = protoData(srcFile, data.metadata) + + for (classId in oldProtoMap.keys + newProtoMap.keys) { + changesCollector.collectProtoChanges(oldProtoMap[classId], newProtoMap[classId]) + } + } + } + fun compareAndUpdate(incrementalResults: IncrementalResultsConsumerImpl, changesCollector: ChangesCollector) { val translatedFiles = incrementalResults.packageParts diff --git a/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt b/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt index 6a40e16c54e..8d06a700d58 100644 --- a/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt +++ b/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt @@ -22,11 +22,13 @@ data class BuildLogFinder( private val isDataContainerBuildLogEnabled: Boolean = false, private val isGradleEnabled: Boolean = false, private val isJsEnabled: Boolean = false, - private val isJsIrEnabled: Boolean = false // TODO rename as it is used for metadata-only test + private val isJsIrEnabled: Boolean = false, // TODO rename as it is used for metadata-only test + private val isScopeExpansionEnabled: Boolean = false ) { companion object { private const val JS_LOG = "js-build.log" private const val JS_IR_LOG = "js-ir-build.log" + private const val SCOPE_EXPANDING_LOG = "build-with-scope-expansion.log" private const val GRADLE_LOG = "gradle-build.log" private const val DATA_CONTAINER_LOG = "data-container-version-build.log" const val JS_JPS_LOG = "js-jps-build.log" @@ -40,6 +42,7 @@ data class BuildLogFinder( val names = dir.list() ?: arrayOf() val files = names.filter { File(dir, it).isFile }.toSet() val matchedName = when { + isScopeExpansionEnabled && SCOPE_EXPANDING_LOG in files -> SCOPE_EXPANDING_LOG isJsIrEnabled && JS_IR_LOG in files -> JS_IR_LOG isJsEnabled && JS_LOG in files -> JS_LOG isGradleEnabled && GRADLE_LOG in files -> GRADLE_LOG 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 37cdaaa1c0a..4a189ecafcb 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 @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.config.IncrementalCompilation import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.incremental.components.ExpectActualTracker import org.jetbrains.kotlin.incremental.components.LookupTracker +import org.jetbrains.kotlin.incremental.js.IncrementalNextRoundChecker import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer import org.jetbrains.kotlin.ir.backend.js.* @@ -296,6 +297,7 @@ class K2JsIrCompiler : CLICompiler() { configuration.putIfNotNull(JSConfigurationKeys.INCREMENTAL_DATA_PROVIDER, services[IncrementalDataProvider::class.java]) configuration.putIfNotNull(JSConfigurationKeys.INCREMENTAL_RESULTS_CONSUMER, services[IncrementalResultsConsumer::class.java]) + configuration.putIfNotNull(JSConfigurationKeys.INCREMENTAL_NEXT_ROUND_CHECKER, services[IncrementalNextRoundChecker::class.java]) configuration.putIfNotNull(CommonConfigurationKeys.LOOKUP_TRACKER, services[LookupTracker::class.java]) configuration.putIfNotNull(CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER, services[ExpectActualTracker::class.java]) diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.kt index 123c05e4906..17775a1c551 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.kt @@ -33,6 +33,7 @@ import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion import org.jetbrains.kotlin.progress.CompilationCanceledException import org.jetbrains.kotlin.progress.CompilationCanceledStatus +import org.jetbrains.kotlin.progress.IncrementalNextRoundException import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus import org.jetbrains.kotlin.utils.KotlinPaths import org.jetbrains.kotlin.utils.PathUtil @@ -96,12 +97,12 @@ abstract class CLICompiler : CLITool() { return if (collector.hasErrors()) COMPILATION_ERROR else code } catch (e: CompilationCanceledException) { - collector.report(INFO, "Compilation was canceled", null) + collector.reportCompilationCancelled(e) return ExitCode.OK } catch (e: RuntimeException) { val cause = e.cause if (cause is CompilationCanceledException) { - collector.report(INFO, "Compilation was canceled", null) + collector.reportCompilationCancelled(cause) return ExitCode.OK } else { throw e @@ -119,6 +120,12 @@ abstract class CLICompiler : CLITool() { } } + private fun MessageCollector.reportCompilationCancelled(e: CompilationCanceledException) { + if (e !is IncrementalNextRoundException) { + report(INFO, "Compilation was canceled", null) + } + } + private fun setupCommonArguments(configuration: CompilerConfiguration, arguments: A) { configuration.setupCommonArguments(arguments, this::createMetadataVersion) } diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/CompileScopeExpansionMode.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/CompileScopeExpansionMode.kt new file mode 100644 index 00000000000..c5a877f66be --- /dev/null +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/CompileScopeExpansionMode.kt @@ -0,0 +1,11 @@ +/* + * Copyright 2010-2019 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 + +// todo: add ON_ERROR scope expansion mode +enum class CompileScopeExpansionMode { + ALWAYS, NEVER +} \ No newline at end of file diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt index 5ecc73789b3..3b8ee2c5bd4 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt @@ -163,7 +163,7 @@ abstract class IncrementalCompilerRunner< protected open fun preBuildHook(args: Args, compilationMode: CompilationMode) {} protected open fun postCompilationHook(exitCode: ExitCode) {} - protected open fun additionalDirtyFiles(caches: CacheManager, generatedFiles: List): Iterable = + protected open fun additionalDirtyFiles(caches: CacheManager, generatedFiles: List, services: Services): Iterable = emptyList() protected open fun additionalDirtyLookupSymbols(): Iterable = @@ -174,7 +174,8 @@ abstract class IncrementalCompilerRunner< lookupTracker: LookupTracker, expectActualTracker: ExpectActualTracker, caches: CacheManager, - compilationMode: CompilationMode + dirtySources: Set, + isIncremental: Boolean ): Services.Builder = Services.Builder().apply { register(LookupTracker::class.java, lookupTracker) @@ -227,7 +228,10 @@ abstract class IncrementalCompilerRunner< val text = dirtySources.joinToString(separator = System.getProperty("line.separator")) { it.canonicalPath } dirtySourcesSinceLastTimeFile.writeText(text) - val services = makeServices(args, lookupTracker, expectActualTracker, caches, compilationMode).build() + val services = makeServices( + args, lookupTracker, expectActualTracker, caches, + dirtySources.toSet(), compilationMode is CompilationMode.Incremental + ).build() args.reportOutputFiles = true val outputItemsCollector = OutputItemsCollectorImpl() @@ -237,20 +241,20 @@ abstract class IncrementalCompilerRunner< postCompilationHook(exitCode) reporter.reportCompileIteration(compilationMode is CompilationMode.Incremental, sourcesToCompile, exitCode) - if (exitCode != ExitCode.OK) break - - dirtySourcesSinceLastTimeFile.delete() val generatedFiles = outputItemsCollector.outputs.map(SimpleOutputItem::toGeneratedFile) if (compilationMode is CompilationMode.Incremental) { // todo: feels dirty, can this be refactored? val dirtySourcesSet = dirtySources.toHashSet() - val additionalDirtyFiles = additionalDirtyFiles(caches, generatedFiles).filter { it !in dirtySourcesSet } + val additionalDirtyFiles = additionalDirtyFiles(caches, generatedFiles, services).filter { it !in dirtySourcesSet } if (additionalDirtyFiles.isNotEmpty()) { dirtySources.addAll(additionalDirtyFiles) continue } } + if (exitCode != ExitCode.OK) break + + dirtySourcesSinceLastTimeFile.delete() caches.platformCache.updateComplementaryFiles(dirtySources, expectActualTracker) caches.inputsCache.registerOutputForSourceFiles(generatedFiles) diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt index 2da33057a1b..386b3420a51 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt @@ -26,10 +26,7 @@ import org.jetbrains.kotlin.config.IncrementalCompilation import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.incremental.components.ExpectActualTracker import org.jetbrains.kotlin.incremental.components.LookupTracker -import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider -import org.jetbrains.kotlin.incremental.js.IncrementalDataProviderFromCache -import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer -import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumerImpl +import org.jetbrains.kotlin.incremental.js.* import org.jetbrains.kotlin.incremental.multiproject.EmptyModulesApiHistory import org.jetbrains.kotlin.incremental.multiproject.ModulesApiHistory import org.jetbrains.kotlin.library.metadata.KlibMetadataSerializerProtocol @@ -41,7 +38,8 @@ fun makeJsIncrementally( sourceRoots: Iterable, args: K2JSCompilerArguments, messageCollector: MessageCollector = MessageCollector.NONE, - reporter: ICReporter = EmptyICReporter + reporter: ICReporter = EmptyICReporter, + scopeExpansion: CompileScopeExpansionMode = CompileScopeExpansionMode.NEVER ) { val allKotlinFiles = sourceRoots.asSequence().flatMap { it.walk() } .filter { it.isFile && it.extension.equals("kt", ignoreCase = true) }.toList() @@ -51,7 +49,8 @@ fun makeJsIncrementally( val compiler = IncrementalJsCompilerRunner( cachesDir, reporter, buildHistoryFile = buildHistoryFile, - modulesApiHistory = EmptyModulesApiHistory + modulesApiHistory = EmptyModulesApiHistory, + scopeExpansion = scopeExpansion ) compiler.compile(allKotlinFiles, args, messageCollector, providedChangedFiles = null) } @@ -72,7 +71,8 @@ class IncrementalJsCompilerRunner( workingDir: File, reporter: ICReporter, buildHistoryFile: File, - private val modulesApiHistory: ModulesApiHistory + private val modulesApiHistory: ModulesApiHistory, + private val scopeExpansion: CompileScopeExpansionMode = CompileScopeExpansionMode.NEVER ) : IncrementalCompilerRunner( workingDir, "caches-js", @@ -129,17 +129,19 @@ class IncrementalJsCompilerRunner( lookupTracker: LookupTracker, expectActualTracker: ExpectActualTracker, caches: IncrementalJsCachesManager, - compilationMode: CompilationMode + dirtySources: Set, + isIncremental: Boolean ): Services.Builder = - super.makeServices(args, lookupTracker, expectActualTracker, caches, compilationMode).apply { - register(IncrementalResultsConsumer::class.java, IncrementalResultsConsumerImpl()) - - if (compilationMode is CompilationMode.Incremental) { - register( - IncrementalDataProvider::class.java, - IncrementalDataProviderFromCache(caches.platformCache) - ) + super.makeServices(args, lookupTracker, expectActualTracker, caches, dirtySources, isIncremental).apply { + if (isIncremental) { + if (scopeExpansion == CompileScopeExpansionMode.ALWAYS) { + val nextRoundChecker = IncrementalNextRoundCheckerImpl(caches, dirtySources) + register(IncrementalNextRoundChecker::class.java, nextRoundChecker) + } + register(IncrementalDataProvider::class.java, IncrementalDataProviderFromCache(caches.platformCache)) } + + register(IncrementalResultsConsumer::class.java, IncrementalResultsConsumerImpl()) } override fun updateCaches( @@ -173,4 +175,52 @@ class IncrementalJsCompilerRunner( args.freeArgs = freeArgsBackup } } + + override fun additionalDirtyFiles( + caches: IncrementalJsCachesManager, + generatedFiles: List, + services: Services + ): Iterable { + val additionalDirtyFiles: Set = + when (scopeExpansion) { + CompileScopeExpansionMode.ALWAYS -> + (services[IncrementalNextRoundChecker::class.java] as IncrementalNextRoundCheckerImpl).newDirtySources + CompileScopeExpansionMode.NEVER -> + emptySet() + } + + return additionalDirtyFiles + super.additionalDirtyFiles(caches, generatedFiles, services) + } + + inner class IncrementalNextRoundCheckerImpl( + private val caches: IncrementalJsCachesManager, + private val sourcesToCompile: Set + ) : IncrementalNextRoundChecker { + val newDirtySources = HashSet() + + private val emptyByteArray = ByteArray(0) + private val translatedFiles = HashMap() + + override fun checkProtoChanges(sourceFile: File, packagePartMetadata: ByteArray) { + translatedFiles[sourceFile] = TranslationResultValue(packagePartMetadata, emptyByteArray, emptyByteArray) + } + + override fun shouldGoToNextRound(): Boolean { + val changesCollector = ChangesCollector() + // todo: split compare and update (or cache comparing) + caches.platformCache.compare(translatedFiles, changesCollector) + val (dirtyLookupSymbols, dirtyClassFqNames) = changesCollector.getDirtyData(listOf(caches.platformCache), reporter) + // todo unify with main cycle + newDirtySources.addAll(mapLookupSymbolsToFiles(caches.lookupCache, dirtyLookupSymbols, reporter, excludes = sourcesToCompile)) + newDirtySources.addAll( + mapClassesFqNamesToFiles( + listOf(caches.platformCache), + dirtyClassFqNames, + reporter, + excludes = sourcesToCompile + ) + ) + return newDirtySources.isNotEmpty() + } + } } \ No newline at end of file diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt index d7b92bfdd20..6cfd0260561 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt @@ -272,7 +272,8 @@ class IncrementalJvmCompilerRunner( override fun additionalDirtyFiles( caches: IncrementalJvmCachesManager, - generatedFiles: List + generatedFiles: List, + services: Services ): Iterable { val cache = caches.platformCache val result = HashSet() @@ -318,9 +319,10 @@ class IncrementalJvmCompilerRunner( lookupTracker: LookupTracker, expectActualTracker: ExpectActualTracker, caches: IncrementalJvmCachesManager, - compilationMode: CompilationMode + dirtySources: Set, + isIncremental: Boolean ): Services.Builder = - super.makeServices(args, lookupTracker, expectActualTracker, caches, compilationMode).apply { + super.makeServices(args, lookupTracker, expectActualTracker, caches, dirtySources, isIncremental).apply { val targetId = TargetId(args.moduleName!!, "java-production") val targetToCache = mapOf(targetId to caches.platformCache) val incrementalComponents = IncrementalCompilationComponentsImpl(targetToCache) diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsCompilerRunnerTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsCompilerRunnerTest.kt index 8c0ccad6289..d198baf44d6 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsCompilerRunnerTest.kt +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsCompilerRunnerTest.kt @@ -27,12 +27,15 @@ abstract class AbstractIncrementalJsCompilerRunnerTest : AbstractIncrementalComp override fun make(cacheDir: File, sourceRoots: Iterable, args: K2JSCompilerArguments): TestCompilationResult { val reporter = TestICReporter() val messageCollector = TestMessageCollector() - makeJsIncrementally(cacheDir, sourceRoots, args, reporter = reporter, messageCollector = messageCollector) + makeJsIncrementally(cacheDir, sourceRoots, args, messageCollector, reporter, scopeExpansionMode) return TestCompilationResult(reporter, messageCollector) } override val buildLogFinder: BuildLogFinder - get() = super.buildLogFinder.copy(isJsEnabled = true) + get() = super.buildLogFinder.copy( + isJsEnabled = true, + isScopeExpansionEnabled = scopeExpansionMode != CompileScopeExpansionMode.NEVER + ) override fun createCompilerArguments(destinationDir: File, testDir: File): K2JSCompilerArguments = K2JSCompilerArguments().apply { @@ -40,4 +43,6 @@ abstract class AbstractIncrementalJsCompilerRunnerTest : AbstractIncrementalComp sourceMap = true metaInfo = true } + + protected open val scopeExpansionMode = CompileScopeExpansionMode.NEVER } \ No newline at end of file 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 4e26595234b..28429370375 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 @@ -17,4 +17,8 @@ abstract class AbstractIncrementalJsKlibCompilerRunnerTest : AbstractIncremental override val buildLogFinder: BuildLogFinder get() = super.buildLogFinder.copy(isJsIrEnabled = true) +} + +abstract class AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest : AbstractIncrementalJsKlibCompilerRunnerTest() { + override val scopeExpansionMode = CompileScopeExpansionMode.ALWAYS } \ No newline at end of file diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java new file mode 100644 index 00000000000..837c552caad --- /dev/null +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java @@ -0,0 +1,894 @@ +/* + * Copyright 2010-2019 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.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@RunWith(JUnit3RunnerWithInners.class) +public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { + @TestMetadata("jps-plugin/testData/incremental/pureKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PureKotlin extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + @TestMetadata("accessingFunctionsViaPackagePart") + public void testAccessingFunctionsViaPackagePart() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/accessingFunctionsViaPackagePart/"); + } + + @TestMetadata("accessingPropertiesViaField") + public void testAccessingPropertiesViaField() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/accessingPropertiesViaField/"); + } + + @TestMetadata("addClass") + public void testAddClass() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/addClass/"); + } + + @TestMetadata("addFileWithFunctionOverload") + public void testAddFileWithFunctionOverload() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/addFileWithFunctionOverload/"); + } + + @TestMetadata("addMemberTypeAlias") + public void testAddMemberTypeAlias() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/addMemberTypeAlias/"); + } + + @TestMetadata("addTopLevelTypeAlias") + public void testAddTopLevelTypeAlias() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/addTopLevelTypeAlias/"); + } + + @TestMetadata("allConstants") + public void testAllConstants() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/allConstants/"); + } + + public void testAllFilesPresentInPureKotlin() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); + } + + @TestMetadata("annotations") + public void testAnnotations() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/annotations/"); + } + + @TestMetadata("anonymousObjectChanged") + public void testAnonymousObjectChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/anonymousObjectChanged/"); + } + + @TestMetadata("changeTypeImplicitlyWithCircularDependency") + public void testChangeTypeImplicitlyWithCircularDependency() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/changeTypeImplicitlyWithCircularDependency/"); + } + + @TestMetadata("changeWithRemovingUsage") + public void testChangeWithRemovingUsage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/changeWithRemovingUsage/"); + } + + @TestMetadata("classInlineFunctionChanged") + public void testClassInlineFunctionChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/classInlineFunctionChanged/"); + } + + @TestMetadata("classObjectConstantChanged") + public void testClassObjectConstantChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/classObjectConstantChanged/"); + } + + @TestMetadata("classRecreated") + public void testClassRecreated() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/classRecreated/"); + } + + @TestMetadata("classRemoved") + public void testClassRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/classRemoved/"); + } + + @TestMetadata("classSignatureChanged") + public void testClassSignatureChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/classSignatureChanged/"); + } + + @TestMetadata("classSignatureUnchanged") + public void testClassSignatureUnchanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/classSignatureUnchanged/"); + } + + @TestMetadata("compilationErrorThenFixedOtherPackage") + public void testCompilationErrorThenFixedOtherPackage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedOtherPackage/"); + } + + @TestMetadata("compilationErrorThenFixedSamePackage") + public void testCompilationErrorThenFixedSamePackage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedSamePackage/"); + } + + @TestMetadata("compilationErrorThenFixedWithPhantomPart") + public void testCompilationErrorThenFixedWithPhantomPart() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart/"); + } + + @TestMetadata("compilationErrorThenFixedWithPhantomPart2") + public void testCompilationErrorThenFixedWithPhantomPart2() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart2/"); + } + + @TestMetadata("compilationErrorThenFixedWithPhantomPart3") + public void testCompilationErrorThenFixedWithPhantomPart3() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/compilationErrorThenFixedWithPhantomPart3/"); + } + + @TestMetadata("constantRemoved") + public void testConstantRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/constantRemoved/"); + } + + @TestMetadata("constantValueChanged") + public void testConstantValueChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/constantValueChanged/"); + } + + @TestMetadata("constantsUnchanged") + public void testConstantsUnchanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/constantsUnchanged/"); + } + + @TestMetadata("defaultArgumentInConstructorAdded") + public void testDefaultArgumentInConstructorAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorAdded/"); + } + + @TestMetadata("defaultArgumentInConstructorRemoved") + public void testDefaultArgumentInConstructorRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/defaultArgumentInConstructorRemoved/"); + } + + @TestMetadata("defaultValueAdded") + public void testDefaultValueAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueAdded/"); + } + + @TestMetadata("defaultValueChanged") + public void testDefaultValueChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueChanged/"); + } + + @TestMetadata("defaultValueInConstructorChanged") + public void testDefaultValueInConstructorChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorChanged/"); + } + + @TestMetadata("defaultValueInConstructorRemoved") + public void testDefaultValueInConstructorRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueInConstructorRemoved/"); + } + + @TestMetadata("defaultValueRemoved1") + public void testDefaultValueRemoved1() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved1/"); + } + + @TestMetadata("defaultValueRemoved2") + public void testDefaultValueRemoved2() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/defaultValueRemoved2/"); + } + + @TestMetadata("delegatedPropertyInlineExtensionAccessor") + public void testDelegatedPropertyInlineExtensionAccessor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineExtensionAccessor/"); + } + + @TestMetadata("delegatedPropertyInlineMethodAccessor") + public void testDelegatedPropertyInlineMethodAccessor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/delegatedPropertyInlineMethodAccessor/"); + } + + @TestMetadata("dependencyClassReferenced") + public void testDependencyClassReferenced() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/dependencyClassReferenced/"); + } + + @TestMetadata("fileWithConstantRemoved") + public void testFileWithConstantRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/fileWithConstantRemoved/"); + } + + @TestMetadata("fileWithInlineFunctionRemoved") + public void testFileWithInlineFunctionRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/"); + } + + @TestMetadata("filesExchangePackages") + public void testFilesExchangePackages() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/filesExchangePackages/"); + } + + @TestMetadata("funRedeclaration") + public void testFunRedeclaration() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/funRedeclaration/"); + } + + @TestMetadata("funVsConstructorOverloadConflict") + public void testFunVsConstructorOverloadConflict() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/"); + } + + @TestMetadata("functionBecameInline") + public void testFunctionBecameInline() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/functionBecameInline/"); + } + + @TestMetadata("functionReferencingClass") + public void testFunctionReferencingClass() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/functionReferencingClass/"); + } + + @TestMetadata("independentClasses") + public void testIndependentClasses() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/independentClasses/"); + } + + @TestMetadata("inlineFunctionBecomesNonInline") + public void testInlineFunctionBecomesNonInline() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlineFunctionBecomesNonInline/"); + } + + @TestMetadata("inlineFunctionUsageAdded") + public void testInlineFunctionUsageAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlineFunctionUsageAdded/"); + } + + @TestMetadata("inlineFunctionsCircularDependency") + public void testInlineFunctionsCircularDependency() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlineFunctionsCircularDependency/"); + } + + @TestMetadata("inlineFunctionsUnchanged") + public void testInlineFunctionsUnchanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlineFunctionsUnchanged/"); + } + + @TestMetadata("inlineLinesChanged") + public void testInlineLinesChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlineLinesChanged/"); + } + + @TestMetadata("inlineModifiedWithUsage") + public void testInlineModifiedWithUsage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlineModifiedWithUsage/"); + } + + @TestMetadata("inlinePrivateFunctionAdded") + public void testInlinePrivateFunctionAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlinePrivateFunctionAdded/"); + } + + @TestMetadata("inlinePropertyInClass") + public void testInlinePropertyInClass() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlinePropertyInClass/"); + } + + @TestMetadata("inlinePropertyOnTopLevel") + public void testInlinePropertyOnTopLevel() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlinePropertyOnTopLevel/"); + } + + @TestMetadata("inlineSuspendFunctionChanged") + public void testInlineSuspendFunctionChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlineSuspendFunctionChanged/"); + } + + @TestMetadata("inlineTwoFunctionsOneChanged") + public void testInlineTwoFunctionsOneChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlineTwoFunctionsOneChanged/"); + } + + @TestMetadata("inlineUsedWhereDeclared") + public void testInlineUsedWhereDeclared() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/inlineUsedWhereDeclared/"); + } + + @TestMetadata("internalClassChanged") + public void testInternalClassChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/internalClassChanged/"); + } + + @TestMetadata("internalMemberInClassChanged") + public void testInternalMemberInClassChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/internalMemberInClassChanged/"); + } + + @TestMetadata("internalTypealias") + public void testInternalTypealias() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/internalTypealias/"); + } + + @TestMetadata("internalTypealiasConstructor") + public void testInternalTypealiasConstructor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/internalTypealiasConstructor/"); + } + + @TestMetadata("internalTypealiasObject") + public void testInternalTypealiasObject() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/internalTypealiasObject/"); + } + + @TestMetadata("localClassChanged") + public void testLocalClassChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/localClassChanged/"); + } + + @TestMetadata("moveClass") + public void testMoveClass() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/moveClass/"); + } + + @TestMetadata("moveFileWithChangingPackage") + public void testMoveFileWithChangingPackage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/moveFileWithChangingPackage/"); + } + + @TestMetadata("moveFileWithoutChangingPackage") + public void testMoveFileWithoutChangingPackage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/moveFileWithoutChangingPackage/"); + } + + @TestMetadata("multiplePackagesModified") + public void testMultiplePackagesModified() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/multiplePackagesModified/"); + } + + @TestMetadata("objectConstantChanged") + public void testObjectConstantChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/objectConstantChanged/"); + } + + @TestMetadata("ourClassReferenced") + public void testOurClassReferenced() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/ourClassReferenced/"); + } + + @TestMetadata("overloadInlined") + public void testOverloadInlined() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/overloadInlined/"); + } + + @TestMetadata("packageConstantChanged") + public void testPackageConstantChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageConstantChanged/"); + } + + @TestMetadata("packageFileAdded") + public void testPackageFileAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageFileAdded/"); + } + + @TestMetadata("packageFileChangedPackage") + public void testPackageFileChangedPackage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageFileChangedPackage/"); + } + + @TestMetadata("packageFileChangedThenOtherRemoved") + public void testPackageFileChangedThenOtherRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageFileChangedThenOtherRemoved/"); + } + + @TestMetadata("packageFileRemoved") + public void testPackageFileRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageFileRemoved/"); + } + + @TestMetadata("packageFilesChangedInTurn") + public void testPackageFilesChangedInTurn() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageFilesChangedInTurn/"); + } + + @TestMetadata("packageInlineFunctionAccessingField") + public void testPackageInlineFunctionAccessingField() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionAccessingField/"); + } + + @TestMetadata("packageInlineFunctionFromOurPackage") + public void testPackageInlineFunctionFromOurPackage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageInlineFunctionFromOurPackage/"); + } + + @TestMetadata("packagePrivateOnlyChanged") + public void testPackagePrivateOnlyChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packagePrivateOnlyChanged/"); + } + + @TestMetadata("packageRecreated") + public void testPackageRecreated() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageRecreated/"); + } + + @TestMetadata("packageRecreatedAfterRenaming") + public void testPackageRecreatedAfterRenaming() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageRecreatedAfterRenaming/"); + } + + @TestMetadata("packageRemoved") + public void testPackageRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/packageRemoved/"); + } + + @TestMetadata("privateConstantsChanged") + public void testPrivateConstantsChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateConstantsChanged/"); + } + + @TestMetadata("privateMethodAdded") + public void testPrivateMethodAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateMethodAdded/"); + } + + @TestMetadata("privateMethodDeleted") + public void testPrivateMethodDeleted() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateMethodDeleted/"); + } + + @TestMetadata("privateMethodSignatureChanged") + public void testPrivateMethodSignatureChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateMethodSignatureChanged/"); + } + + @TestMetadata("privateSecondaryConstructorAdded") + public void testPrivateSecondaryConstructorAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorAdded/"); + } + + @TestMetadata("privateSecondaryConstructorDeleted") + public void testPrivateSecondaryConstructorDeleted() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateSecondaryConstructorDeleted/"); + } + + @TestMetadata("privateValAccessorChanged") + public void testPrivateValAccessorChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateValAccessorChanged/"); + } + + @TestMetadata("privateValAdded") + public void testPrivateValAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateValAdded/"); + } + + @TestMetadata("privateValDeleted") + public void testPrivateValDeleted() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateValDeleted/"); + } + + @TestMetadata("privateValSignatureChanged") + public void testPrivateValSignatureChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateValSignatureChanged/"); + } + + @TestMetadata("privateVarAdded") + public void testPrivateVarAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateVarAdded/"); + } + + @TestMetadata("privateVarDeleted") + public void testPrivateVarDeleted() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateVarDeleted/"); + } + + @TestMetadata("privateVarSignatureChanged") + public void testPrivateVarSignatureChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/privateVarSignatureChanged/"); + } + + @TestMetadata("propertyRedeclaration") + public void testPropertyRedeclaration() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/"); + } + + @TestMetadata("publicPropertyWithPrivateSetter") + public void testPublicPropertyWithPrivateSetter() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/publicPropertyWithPrivateSetter/"); + } + + @TestMetadata("removeAndRestoreCompanion") + public void testRemoveAndRestoreCompanion() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanion/"); + } + + @TestMetadata("removeAndRestoreCompanionWithImplicitUsages") + public void testRemoveAndRestoreCompanionWithImplicitUsages() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/removeAndRestoreCompanionWithImplicitUsages/"); + } + + @TestMetadata("removeClass") + public void testRemoveClass() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/removeClass/"); + } + + @TestMetadata("removeClassInDefaultPackage") + public void testRemoveClassInDefaultPackage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/removeClassInDefaultPackage/"); + } + + @TestMetadata("removeFileWithFunctionOverload") + public void testRemoveFileWithFunctionOverload() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/removeFileWithFunctionOverload/"); + } + + @TestMetadata("removeMemberTypeAlias") + public void testRemoveMemberTypeAlias() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/removeMemberTypeAlias/"); + } + + @TestMetadata("removeTopLevelTypeAlias") + public void testRemoveTopLevelTypeAlias() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/removeTopLevelTypeAlias/"); + } + + @TestMetadata("removeUnusedFile") + public void testRemoveUnusedFile() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/removeUnusedFile/"); + } + + @TestMetadata("renameClass") + public void testRenameClass() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/renameClass/"); + } + + @TestMetadata("renameFileWithFunctionOverload") + public void testRenameFileWithFunctionOverload() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/renameFileWithFunctionOverload/"); + } + + @TestMetadata("returnTypeChanged") + public void testReturnTypeChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); + } + + @TestMetadata("secondaryConstructorInlined") + public void testSecondaryConstructorInlined() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); + } + + @TestMetadata("simpleClassDependency") + public void testSimpleClassDependency() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/simpleClassDependency/"); + } + + @TestMetadata("soleFileChangesPackage") + public void testSoleFileChangesPackage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/soleFileChangesPackage/"); + } + + @TestMetadata("subpackage") + public void testSubpackage() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/subpackage/"); + } + + @TestMetadata("suspendWithStateMachine") + public void testSuspendWithStateMachine() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/suspendWithStateMachine/"); + } + + @TestMetadata("topLevelFunctionSameSignature") + public void testTopLevelFunctionSameSignature() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/topLevelFunctionSameSignature/"); + } + + @TestMetadata("topLevelMembersInTwoFiles") + public void testTopLevelMembersInTwoFiles() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/topLevelMembersInTwoFiles/"); + } + + @TestMetadata("topLevelPrivateValUsageAdded") + public void testTopLevelPrivateValUsageAdded() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/topLevelPrivateValUsageAdded/"); + } + + @TestMetadata("traitClassObjectConstantChanged") + public void testTraitClassObjectConstantChanged() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/traitClassObjectConstantChanged/"); + } + + @TestMetadata("valAddCustomAccessor") + public void testValAddCustomAccessor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/valAddCustomAccessor/"); + } + + @TestMetadata("valRemoveCustomAccessor") + public void testValRemoveCustomAccessor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/valRemoveCustomAccessor/"); + } + } + + @TestMetadata("jps-plugin/testData/incremental/classHierarchyAffected") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassHierarchyAffected extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInClassHierarchyAffected() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); + } + + @TestMetadata("annotationFlagRemoved") + public void testAnnotationFlagRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/annotationFlagRemoved/"); + } + + @TestMetadata("annotationListChanged") + public void testAnnotationListChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/annotationListChanged/"); + } + + @TestMetadata("bridgeGenerated") + public void testBridgeGenerated() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/bridgeGenerated/"); + } + + @TestMetadata("classBecameFinal") + public void testClassBecameFinal() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/classBecameFinal/"); + } + + @TestMetadata("classBecameInterface") + public void testClassBecameInterface() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/classBecameInterface/"); + } + + @TestMetadata("classBecamePrivate") + public void testClassBecamePrivate() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/classBecamePrivate/"); + } + + @TestMetadata("classMovedIntoOtherClass") + public void testClassMovedIntoOtherClass() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/classMovedIntoOtherClass/"); + } + + @TestMetadata("classRemoved") + public void testClassRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/classRemoved/"); + } + + @TestMetadata("classRemovedAndRestored") + public void testClassRemovedAndRestored() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/classRemovedAndRestored/"); + } + + @TestMetadata("companionObjectInheritedMemberChanged") + public void testCompanionObjectInheritedMemberChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectInheritedMemberChanged/"); + } + + @TestMetadata("companionObjectMemberChanged") + public void testCompanionObjectMemberChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectMemberChanged/"); + } + + @TestMetadata("companionObjectNameChanged") + public void testCompanionObjectNameChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectNameChanged/"); + } + + @TestMetadata("companionObjectToSimpleObject") + public void testCompanionObjectToSimpleObject() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectToSimpleObject/"); + } + + @TestMetadata("constructorVisibilityChanged") + public void testConstructorVisibilityChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/constructorVisibilityChanged/"); + } + + @TestMetadata("enumEntryAdded") + public void testEnumEntryAdded() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/enumEntryAdded/"); + } + + @TestMetadata("enumEntryRemoved") + public void testEnumEntryRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved/"); + } + + @TestMetadata("enumMemberChanged") + public void testEnumMemberChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/enumMemberChanged/"); + } + + @TestMetadata("flagsAndMemberInDifferentClassesChanged") + public void testFlagsAndMemberInDifferentClassesChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInDifferentClassesChanged/"); + } + + @TestMetadata("flagsAndMemberInSameClassChanged") + public void testFlagsAndMemberInSameClassChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInSameClassChanged/"); + } + + @TestMetadata("implcitUpcast") + public void testImplcitUpcast() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/implcitUpcast/"); + } + + @TestMetadata("inferredTypeArgumentChanged") + public void testInferredTypeArgumentChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeArgumentChanged/"); + } + + @TestMetadata("inferredTypeChanged") + public void testInferredTypeChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeChanged/"); + } + + @TestMetadata("lambdaParameterAffected") + public void testLambdaParameterAffected() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/lambdaParameterAffected/"); + } + + @TestMetadata("methodAdded") + public void testMethodAdded() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodAdded/"); + } + + @TestMetadata("methodAnnotationAdded") + public void testMethodAnnotationAdded() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodAnnotationAdded/"); + } + + @TestMetadata("methodNullabilityChanged") + public void testMethodNullabilityChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodNullabilityChanged/"); + } + + @TestMetadata("methodParameterWithDefaultValueAdded") + public void testMethodParameterWithDefaultValueAdded() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodParameterWithDefaultValueAdded/"); + } + + @TestMetadata("methodRemoved") + public void testMethodRemoved() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/methodRemoved/"); + } + + @TestMetadata("overrideExplicit") + public void testOverrideExplicit() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/overrideExplicit/"); + } + + @TestMetadata("overrideImplicit") + public void testOverrideImplicit() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/overrideImplicit/"); + } + + @TestMetadata("propertyNullabilityChanged") + public void testPropertyNullabilityChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/propertyNullabilityChanged/"); + } + + @TestMetadata("sealedClassImplAdded") + public void testSealedClassImplAdded() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassImplAdded/"); + } + + @TestMetadata("sealedClassIndirectImplAdded") + public void testSealedClassIndirectImplAdded() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassIndirectImplAdded/"); + } + + @TestMetadata("sealedClassNestedImplAdded") + public void testSealedClassNestedImplAdded() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassNestedImplAdded/"); + } + + @TestMetadata("secondaryConstructorAdded") + public void testSecondaryConstructorAdded() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/secondaryConstructorAdded/"); + } + + @TestMetadata("starProjectionUpperBoundChanged") + public void testStarProjectionUpperBoundChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/starProjectionUpperBoundChanged/"); + } + + @TestMetadata("supertypesListChanged") + public void testSupertypesListChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/supertypesListChanged/"); + } + + @TestMetadata("typeParameterListChanged") + public void testTypeParameterListChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/typeParameterListChanged/"); + } + + @TestMetadata("varianceChanged") + public void testVarianceChanged() throws Exception { + runTest("jps-plugin/testData/incremental/classHierarchyAffected/varianceChanged/"); + } + } + + @TestMetadata("jps-plugin/testData/incremental/js") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Js extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInJs() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true); + } + + @TestMetadata("inlineFunctionLocalDeclarationChanges") + public void testInlineFunctionLocalDeclarationChanges() throws Exception { + runTest("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges/"); + } + + @TestMetadata("jps-plugin/testData/incremental/js/friendsModuleDisabled") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FriendsModuleDisabled extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInFriendsModuleDisabled() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true); + } + + @TestMetadata("internalInlineFunctionIsChanged") + public void testInternalInlineFunctionIsChanged() throws Exception { + runTest("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged/"); + } + + @TestMetadata("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InternalInlineFunctionIsChanged extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInInternalInlineFunctionIsChanged() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true); + } + } + } + + @TestMetadata("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineFunctionLocalDeclarationChanges extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInInlineFunctionLocalDeclarationChanges() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true); + } + } + } +} diff --git a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt b/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt index ccad12cb796..32fccfe1b9c 100644 --- a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt +++ b/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.ir.backend.js import com.intellij.openapi.project.Project import com.intellij.openapi.vfs.VfsUtilCore import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.analyzer.AnalysisResult import org.jetbrains.kotlin.backend.common.LoggingContext import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext @@ -19,6 +20,8 @@ import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataVe import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity import org.jetbrains.kotlin.cli.common.messages.MessageCollector import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.descriptors.DeclarationDescriptor @@ -42,7 +45,8 @@ import org.jetbrains.kotlin.library.impl.buildKoltinLibrary import org.jetbrains.kotlin.library.impl.createKotlinLibrary import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult import org.jetbrains.kotlin.library.resolver.TopologicalLibraryOrder -import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.metadata.ProtoBuf +import org.jetbrains.kotlin.progress.IncrementalNextRoundException import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration @@ -54,6 +58,8 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.utils.DFS import java.io.File +import java.util.* +import kotlin.collections.ArrayList import org.jetbrains.kotlin.konan.file.File as KFile @@ -357,12 +363,16 @@ private class ModulesStructure( ) } - val analysisResult = analyzerWithCompilerReport.analysisResult + ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() + val analysisResult = analyzerWithCompilerReport.analysisResult + if (IncrementalCompilation.isEnabledForJs()) { + /** can throw [IncrementalNextRoundException] */ + compareMetadataAndGoToNextICRoundIfNeeded(analysisResult, compilerConfiguration, files) + } if (analyzerWithCompilerReport.hasErrors() || analysisResult !is JsAnalysisResult) throw JsIrCompilationError - ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() TopDownAnalyzerFacadeForJSIR.checkForErrors(files, analysisResult.bindingContext) return analysisResult @@ -424,24 +434,7 @@ fun serializeModuleIntoKlib( JsIrModuleSerializer(emptyLoggingContext, moduleFragment.irBuiltins, descriptorTable, skipExpects = !configuration.klibMpp, expectDescriptorToSymbol = expectDescriptorToSymbol).serializedIrModule(moduleFragment) val moduleDescriptor = moduleFragment.descriptor - - val metadataVersion = configuration.metadataVersion - val languageVersionSettings = configuration.languageVersionSettings - - val metadataSerializer = KlibMetadataIncrementalSerializer( - languageVersionSettings, - metadataVersion, - descriptorTable, - skipExpects = !configuration.klibMpp - ) - - fun serializeScope(fqName: FqName, memberScope: Collection): ByteArray { - return metadataSerializer.serializePackageFragment( - moduleDescriptor, - memberScope, - fqName - ).toByteArray() - } + val metadataSerializer = KlibMetadataIncrementalSerializer(configuration, descriptorTable) val incrementalResultsConsumer = configuration.get(JSConfigurationKeys.INCREMENTAL_RESULTS_CONSUMER) val empty = ByteArray(0) @@ -464,9 +457,8 @@ fun serializeModuleIntoKlib( Ir: ${binaryFile.path} """.trimMargin() } - val memberScope = ktFile.declarations.map { getDescriptorForElement(bindingContext, it) } - val packageFragment = serializeScope(ktFile.packageFqName, memberScope) - val compiledKotlinFile = KotlinFileSerializedData(packageFragment, binaryFile) + val packageFragment = metadataSerializer.serializeScope(ktFile, bindingContext, moduleDescriptor) + val compiledKotlinFile = KotlinFileSerializedData(packageFragment.toByteArray(), binaryFile) additionalFiles += compiledKotlinFile processCompiledFileData(VfsUtilCore.virtualToIoFile(ktFile.virtualFile), compiledKotlinFile) @@ -511,3 +503,55 @@ fun serializeModuleIntoKlib( versions = versions ) } + +private fun KlibMetadataIncrementalSerializer.serializeScope( + ktFile: KtFile, + bindingContext: BindingContext, + moduleDescriptor: ModuleDescriptor +): ProtoBuf.PackageFragment { + val memberScope = ktFile.declarations.map { getDescriptorForElement(bindingContext, it) } + return serializePackageFragment(moduleDescriptor, memberScope, ktFile.packageFqName) +} + +private fun compareMetadataAndGoToNextICRoundIfNeeded( + analysisResult: AnalysisResult, + config: CompilerConfiguration, + files: List +) { + val nextRoundChecker = config.get(JSConfigurationKeys.INCREMENTAL_NEXT_ROUND_CHECKER) ?: return + val bindingContext = analysisResult.bindingContext + val serializer = KlibMetadataIncrementalSerializer(config, FakeDescriptorTable()) + for (ktFile in files) { + val packageFragment = serializer.serializeScope(ktFile, bindingContext, analysisResult.moduleDescriptor) + // 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(VfsUtilCore.virtualToIoFile(ktFile.virtualFile), packageFragment.toByteArray()) + } + + if (nextRoundChecker.shouldGoToNextRound()) throw IncrementalNextRoundException() +} + +/** + * A hack to serialize metadata to compare it with cached proto before frontend errors are reported. + * DescriptorUniqId is not used during comparison, so fake IDs can be used to satisfy [KlibMetadataIncrementalSerializer] interface. + */ +private class FakeDescriptorTable : DescriptorTable { + private val descriptors = mutableMapOf() + + override fun put(descriptor: DeclarationDescriptor, uniqId: UniqId) { + throw NotImplementedError("FakeDescriptorTable#put is not expected to be called!") + } + + override fun get(descriptor: DeclarationDescriptor): Long = + descriptors.getOrPut(descriptor) { descriptors.size.toLong() } +} + +private fun KlibMetadataIncrementalSerializer( + configuration: CompilerConfiguration, + descriptorTable: DescriptorTable +) = KlibMetadataIncrementalSerializer( + languageVersionSettings = configuration.languageVersionSettings, + metadataVersion = configuration.metadataVersion, + descriptorTable = descriptorTable, + skipExpects = !configuration.klibMpp +) \ No newline at end of file diff --git a/compiler/util/src/org/jetbrains/kotlin/progress/CancelationStatus.kt b/compiler/util/src/org/jetbrains/kotlin/progress/CancelationStatus.kt index ffe7e178918..d5793eda3bb 100644 --- a/compiler/util/src/org/jetbrains/kotlin/progress/CancelationStatus.kt +++ b/compiler/util/src/org/jetbrains/kotlin/progress/CancelationStatus.kt @@ -19,7 +19,9 @@ package org.jetbrains.kotlin.progress import com.intellij.openapi.progress.ProcessCanceledException import com.intellij.openapi.progress.ProgressIndicatorProvider -class CompilationCanceledException : ProcessCanceledException() +open class CompilationCanceledException : ProcessCanceledException() + +class IncrementalNextRoundException : CompilationCanceledException() interface CompilationCanceledStatus { fun checkCanceled(): Unit diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 6b8b8104433..51f3c96ff63 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -1230,6 +1230,12 @@ fun main(args: Array) { model("incremental/js", extension = null, excludeParentDirs = true) } + testClass { + model("incremental/pureKotlin", extension = null, recursive = false) + model("incremental/classHierarchyAffected", extension = null, recursive = false) + model("incremental/js", extension = null, excludeParentDirs = true) + } + testClass { model("incremental/js/friendsModuleDisabled", extension = null, recursive = false) } diff --git a/jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved/build-with-scope-expansion.log b/jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved/build-with-scope-expansion.log new file mode 100644 index 00000000000..9997e126b95 --- /dev/null +++ b/jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved/build-with-scope-expansion.log @@ -0,0 +1,22 @@ +================ Step #1 ================= + +Compiling files: + src/Enum.kt + src/getRandomEnumEntry.kt + src/use.kt + src/useEnumImplicitly.kt +End of files +Exit code: ABORT +------------------------------------------ +COMPILATION FAILED +Unresolved reference: C + +================ Step #2 ================= + +Compiling files: + src/Enum.kt + src/getRandomEnumEntry.kt + src/use.kt + src/useEnumImplicitly.kt +End of files +Exit code: OK \ No newline at end of file diff --git a/jps-plugin/testData/incremental/classHierarchyAffected/secondaryConstructorAdded/build-with-scope-expansion.log b/jps-plugin/testData/incremental/classHierarchyAffected/secondaryConstructorAdded/build-with-scope-expansion.log new file mode 100644 index 00000000000..26cfbf6c4f3 --- /dev/null +++ b/jps-plugin/testData/incremental/classHierarchyAffected/secondaryConstructorAdded/build-with-scope-expansion.log @@ -0,0 +1,26 @@ +================ Step #1 ================= + +Compiling files: + src/A.kt + src/AChild.kt + src/AConstructorFunction.kt + src/createAFromInt.kt + src/createAFromString.kt + src/useA.kt +End of files +Exit code: ABORT +------------------------------------------ +COMPILATION FAILED +Conflicting overloads: public constructor A(x: String) defined in A, public fun A(x: String): A defined in root package + +================ Step #2 ================= + +Compiling files: + src/A.kt + src/AChild.kt + src/createAFromInt.kt + src/createAFromString.kt + src/useA.kt +End of files +Exit code: OK +------------------------------------------ \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/funRedeclaration/build-with-scope-expansion.log b/jps-plugin/testData/incremental/pureKotlin/funRedeclaration/build-with-scope-expansion.log new file mode 100644 index 00000000000..bcf759c201e --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/funRedeclaration/build-with-scope-expansion.log @@ -0,0 +1,10 @@ +================ Step #1 ================= + +Compiling files: + src/fun1.kt + src/fun2.kt +End of files +Exit code: ABORT +------------------------------------------ +COMPILATION FAILED +Conflicting overloads: public fun function(): Unit defined in test in file fun2.kt, public fun function(): Unit defined in test \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/funRedeclaration/dummy.kt b/jps-plugin/testData/incremental/pureKotlin/funRedeclaration/dummy.kt new file mode 100644 index 00000000000..789dc274f72 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/funRedeclaration/dummy.kt @@ -0,0 +1,3 @@ +package test + +fun dummy() {} \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/build-with-scope-expansion.log b/jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/build-with-scope-expansion.log new file mode 100644 index 00000000000..b7b4c165c73 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/build-with-scope-expansion.log @@ -0,0 +1,10 @@ +================ Step #1 ================= + +Compiling files: + src/fun1.kt + src/fun2.kt +End of files +Exit code: ABORT +------------------------------------------ +COMPILATION FAILED +Conflicting overloads: public constructor function() defined in test.function, public fun function(): Unit defined in test \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/dummy.kt b/jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/dummy.kt new file mode 100644 index 00000000000..789dc274f72 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/funVsConstructorOverloadConflict/dummy.kt @@ -0,0 +1,3 @@ +package test + +fun dummy() {} \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/build-with-scope-expansion.log b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/build-with-scope-expansion.log new file mode 100644 index 00000000000..d8e58d77555 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/build-with-scope-expansion.log @@ -0,0 +1,10 @@ +================ Step #1 ================= + +Compiling files: + src/prop1.kt + src/prop2.kt +End of files +Exit code: ABORT +------------------------------------------ +COMPILATION FAILED +Conflicting declarations: public val prop1: Int, public val prop1: Int \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/build.log b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/build.log index 7839df62fd5..144f50805ea 100644 --- a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/build.log +++ b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/build.log @@ -10,4 +10,4 @@ End of files Exit code: ABORT ------------------------------------------ COMPILATION FAILED -Conflicting declarations: public val property: Int, public val property: Int \ No newline at end of file +Conflicting declarations: public val prop1: Int, public val prop1: Int \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/dummy.kt b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/dummy.kt new file mode 100644 index 00000000000..c80484f5633 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/dummy.kt @@ -0,0 +1,5 @@ +package test + +fun dummy() { + +} \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop1.kt b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop1.kt index 14b9ceec2ef..1c855edd0ac 100644 --- a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop1.kt +++ b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop1.kt @@ -1,3 +1,3 @@ package test -val property = 1 \ No newline at end of file +val prop1 = 1 \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop2.kt b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop2.kt index a46bb3499d4..461b5d22caf 100644 --- a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop2.kt +++ b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop2.kt @@ -1,5 +1,3 @@ package test -fun dummy() { - -} +val prop2 = 2 diff --git a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop2.kt.new b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop2.kt.new index 4a10a872d00..2f68bba3b00 100644 --- a/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop2.kt.new +++ b/jps-plugin/testData/incremental/pureKotlin/propertyRedeclaration/prop2.kt.new @@ -1,7 +1,4 @@ package test -fun dummy() { - -} - -val property = 1 \ No newline at end of file +val prop1 = 1 +val prop2 = 2 \ No newline at end of file diff --git a/js/js.frontend/src/org/jetbrains/kotlin/incremental/js/IncrementalResultsConsumer.kt b/js/js.frontend/src/org/jetbrains/kotlin/incremental/js/IncrementalResultsConsumer.kt index c5db73ea1f9..716156c10c8 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/incremental/js/IncrementalResultsConsumer.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/incremental/js/IncrementalResultsConsumer.kt @@ -54,6 +54,11 @@ interface IncrementalResultsConsumer { ) } +interface IncrementalNextRoundChecker { + fun checkProtoChanges(sourceFile: File, packagePartMetadata: ByteArray) + fun shouldGoToNextRound(): Boolean +} + class JsInlineFunctionHash(val sourceFilePath: String, val fqName: String, val inlineFunctionMd5Hash: Long): Serializable class FunctionWithSourceInfo(val expression: Any, val line: Int, val column: Int) { @@ -61,7 +66,7 @@ class FunctionWithSourceInfo(val expression: Any, val line: Int, val column: Int get() = "($line:$column)$expression".toByteArray().md5() } -class IncrementalResultsConsumerImpl : IncrementalResultsConsumer { +open class IncrementalResultsConsumerImpl : IncrementalResultsConsumer { lateinit var headerMetadata: ByteArray private set diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/config/JSConfigurationKeys.java b/js/js.frontend/src/org/jetbrains/kotlin/js/config/JSConfigurationKeys.java index f835853e554..dd26445c753 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/config/JSConfigurationKeys.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/config/JSConfigurationKeys.java @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.js.config; import org.jetbrains.kotlin.config.CompilerConfigurationKey; +import org.jetbrains.kotlin.incremental.js.IncrementalNextRoundChecker; import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider; import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer; import org.jetbrains.kotlin.serialization.js.ModuleKind; @@ -65,6 +66,9 @@ public class JSConfigurationKeys { public static final CompilerConfigurationKey INCREMENTAL_RESULTS_CONSUMER = CompilerConfigurationKey.create("incremental results consumer"); + public static final CompilerConfigurationKey INCREMENTAL_NEXT_ROUND_CHECKER = + CompilerConfigurationKey.create("incremental compilation next round checker"); + public static final CompilerConfigurationKey FRIEND_PATHS_DISABLED = CompilerConfigurationKey.create("disable support for friend paths");