diff --git a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt index c5d84f90002..eb2b44f4111 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.load.kotlin.ModuleMapping import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto +import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.jvm.JvmClassName import org.jetbrains.kotlin.serialization.jvm.BitEncoding @@ -54,6 +55,7 @@ open class IncrementalJvmCache( private val DIRTY_OUTPUT_CLASSES = "dirty-output-classes" private val INLINE_FUNCTIONS = "inline-functions" private val INTERNAL_NAME_TO_SOURCE = "internal-name-to-source" + private val JAVA_SOURCES_PROTO_MAP = "java-sources-proto-map" private val MODULE_MAPPING_FILE_NAME = "." + ModuleMapping.MAPPING_FILE_EXT } @@ -68,6 +70,7 @@ open class IncrementalJvmCache( private val inlineFunctionsMap = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile)) // todo: try to use internal names only? private val internalNameToSource = registerMap(InternalNameToSourcesMap(INTERNAL_NAME_TO_SOURCE.storageFile)) + private val javaSourcesProtoMap = registerMap(JavaSourcesProtoMap(JAVA_SOURCES_PROTO_MAP.storageFile)) private val outputDir by lazy(LazyThreadSafetyMode.NONE) { requireNotNull(targetOutputDir) { "Target is expected to have output directory" } } @@ -169,6 +172,28 @@ open class IncrementalJvmCache( } } + fun saveJavaClassProto(source: File, serializedJavaClass: SerializedJavaClass, collector: ChangesCollector) { + val jvmClassName = JvmClassName.byClassId(serializedJavaClass.classId) + javaSourcesProtoMap.process(jvmClassName, serializedJavaClass, collector) + sourceToClassesMap.add(source, jvmClassName) + val (proto, nameResolver) = serializedJavaClass.toProtoData() + addToClassStorage(proto, nameResolver, source) + + dirtyOutputClassesMap.notDirty(jvmClassName.internalName) + } + + fun getObsoleteJavaClasses(): Collection = + dirtyOutputClassesMap.getDirtyOutputClasses() + .mapNotNull { + javaSourcesProtoMap[it]?.classId + } + + fun isJavaClassToTrack(classId: ClassId): Boolean { + val jvmClassName = JvmClassName.byClassId(classId) + return dirtyOutputClassesMap.isDirty(jvmClassName.internalName) || + javaSourcesProtoMap[jvmClassName.internalName] == null + } + fun clearCacheForRemovedClasses(changesCollector: ChangesCollector) { val dirtyClasses = dirtyOutputClassesMap .getDirtyOutputClasses() @@ -203,6 +228,7 @@ open class IncrementalJvmCache( constantsMap.remove(it) inlineFunctionsMap.remove(it) internalNameToSource.remove(it.internalName) + javaSourcesProtoMap.remove(it, changesCollector) } removeAllFromClassStorage(dirtyClasses.map { it.fqNameForClassNameWithoutDollars }) @@ -298,6 +324,29 @@ open class IncrementalJvmCache( } } + private inner class JavaSourcesProtoMap(storageFile: File) : BasicStringMap(storageFile, JavaClassProtoMapValueExternalizer) { + fun process(jvmClassName: JvmClassName, newData: SerializedJavaClass, changesCollector: ChangesCollector) { + val key = jvmClassName.internalName + val oldData = storage[key] + storage[key] = newData + + changesCollector.collectProtoChanges(oldData?.toProtoData(), newData.toProtoData()) + } + + fun remove(className: JvmClassName, changesCollector: ChangesCollector) { + val key = className.internalName + val oldValue = storage[key] ?: return + storage.remove(key) + + changesCollector.collectProtoChanges(oldValue.toProtoData(), newData = null) + } + + operator fun get(internalName: String) = storage[internalName] + + override fun dumpValue(value: SerializedJavaClass): String = + java.lang.Long.toHexString(value.proto.toByteArray().md5()) + } + // todo: reuse code with InlineFunctionsMap? private inner class ConstantsMap(storageFile: File) : BasicStringMap>(storageFile, ConstantsMapExternalizer) { private fun getConstantsMap(bytes: ByteArray): Map { diff --git a/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.kt b/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.kt new file mode 100644 index 00000000000..a491ef277b2 --- /dev/null +++ b/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.kt @@ -0,0 +1,135 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.incremental + +import com.intellij.psi.PsiJavaFile +import com.intellij.util.io.DataExternalizer +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies +import org.jetbrains.kotlin.load.java.JavaClassesTracker +import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite +import org.jetbrains.kotlin.resolve.descriptorUtil.classId +import org.jetbrains.kotlin.resolve.source.PsiSourceElement +import org.jetbrains.kotlin.serialization.DescriptorSerializer +import org.jetbrains.kotlin.serialization.ProtoBuf +import org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf +import org.jetbrains.kotlin.serialization.deserialization.NameResolverImpl +import org.jetbrains.kotlin.serialization.java.JavaClassProtoBuf +import org.jetbrains.kotlin.utils.addToStdlib.safeAs +import org.jetbrains.kotlin.utils.sure +import java.io.DataInput +import java.io.DataOutput +import java.io.File + +class JavaClassesTrackerImpl(private val cache: IncrementalJvmCache) : JavaClassesTracker { + private val classToSourceSerialized: MutableMap = hashMapOf() + + val javaClassesUpdates: Collection + get() = classToSourceSerialized.values + + private val classDescriptors: MutableList = mutableListOf() + + override fun reportClass(classDescriptor: JavaClassDescriptor) { + val classId = classDescriptor.classId!! + if (!cache.isJavaClassToTrack(classId) || classDescriptor.javaSourceFile == null) return + + classDescriptors.add(classDescriptor) + } + + override fun onCompletedAnalysis(module: ModuleDescriptor) { + for (classId in cache.getObsoleteJavaClasses()) { + // Just force the loading obsolete classes + // We assume here that whenever an LazyJavaClassDescriptor instances is created + // it's being passed to JavaClassesTracker::reportClass + module.findClassAcrossModuleDependencies(classId) + } + + for (classDescriptor in classDescriptors.toList()) { + classToSourceSerialized[classDescriptor.classId!!] = + classDescriptor.convertToProto() + } + } +} + +private val JavaClassDescriptor.javaSourceFile: File? + get() = source.safeAs() + ?.psi?.containingFile?.takeIf { it is PsiJavaFile } + ?.virtualFile?.path?.let(::File) + +fun JavaClassDescriptor.convertToProto(): SerializedJavaClassWithSource { + val file = javaSourceFile.sure { "convertToProto should only be called for source based classes" } + + val extension = JavaClassesSerializerExtension() + val serializer = DescriptorSerializer.createTopLevel(extension) + val classProto = serializer.classProto(this).build() + + val (stringTable, qualifiedNameTable) = extension.stringTable.buildProto() + + return SerializedJavaClassWithSource(file, SerializedJavaClass(classProto, stringTable, qualifiedNameTable)) +} + +class SerializedJavaClass( + val proto: ProtoBuf.Class, + val stringTable: ProtoBuf.StringTable, + val qualifiedNameTable: ProtoBuf.QualifiedNameTable +) { + val classId: ClassId + get() = NameResolverImpl(stringTable, qualifiedNameTable).getClassId(proto.fqName) +} + +data class SerializedJavaClassWithSource( + val source: File, + val proto: SerializedJavaClass +) + +fun SerializedJavaClass.toProtoData() = ClassProtoData(proto, NameResolverImpl(stringTable, qualifiedNameTable)) + +val JAVA_CLASS_PROTOBUF_REGISTRY = + ExtensionRegistryLite.newInstance() + .also(JavaClassProtoBuf::registerAllExtensions) + // Built-ins extensions are used for annotations' serialization + .also(BuiltInsProtoBuf::registerAllExtensions) + +object JavaClassProtoMapValueExternalizer : DataExternalizer { + override fun save(output: DataOutput, value: SerializedJavaClass) { + output.writeBytesWithSize(value.proto.toByteArray()) + output.writeBytesWithSize(value.stringTable.toByteArray()) + output.writeBytesWithSize(value.qualifiedNameTable.toByteArray()) + } + + private fun DataOutput.writeBytesWithSize(bytes: ByteArray) { + writeInt(bytes.size) + write(bytes) + } + + private fun DataInput.readBytesWithSize(): ByteArray { + val bytesLength = readInt() + return ByteArray(bytesLength).also { + readFully(it, 0, bytesLength) + } + } + + override fun read(input: DataInput): SerializedJavaClass { + val proto = ProtoBuf.Class.parseFrom(input.readBytesWithSize(), JAVA_CLASS_PROTOBUF_REGISTRY) + val stringTable = ProtoBuf.StringTable.parseFrom(input.readBytesWithSize(), JAVA_CLASS_PROTOBUF_REGISTRY) + val qualifiedNameTable = ProtoBuf.QualifiedNameTable.parseFrom(input.readBytesWithSize(), JAVA_CLASS_PROTOBUF_REGISTRY) + + return SerializedJavaClass(proto, stringTable, qualifiedNameTable) + } +} diff --git a/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt b/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt index 4e69fc39ad2..ede8d6c7f56 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt @@ -79,7 +79,8 @@ fun makeCompileServices( fun updateIncrementalCache( generatedFiles: Iterable, cache: IncrementalJvmCache, - changesCollector: ChangesCollector + changesCollector: ChangesCollector, + javaChangesTracker: JavaClassesTrackerImpl? ) { for (generatedFile in generatedFiles) { when { @@ -88,6 +89,11 @@ fun updateIncrementalCache( } } + javaChangesTracker?.javaClassesUpdates?.forEach { + (source, serializedJavaClass) -> + cache.saveJavaClassProto(source, serializedJavaClass, changesCollector) + } + cache.clearCacheForRemovedClasses(changesCollector) } @@ -173,7 +179,7 @@ fun mapClassesFqNamesToFiles( for (cache in caches) { for (dirtyClassFqName in classesFqNames) { val srcFile = cache.getSourceFileIfClass(dirtyClassFqName) - if (srcFile == null || srcFile in excludes) continue + if (srcFile == null || srcFile in excludes || srcFile.isJavaFile()) continue reporter.report { ("Class $dirtyClassFqName caused recompilation of: ${reporter.pathsAsString(srcFile)}") } dirtyFiles.add(srcFile) diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/ChangedJavaFilesProcessor.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/ChangedJavaFilesProcessor.kt deleted file mode 100644 index db051d938c1..00000000000 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/ChangedJavaFilesProcessor.kt +++ /dev/null @@ -1,81 +0,0 @@ -/* - * Copyright 2010-2016 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.incremental - -import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import com.intellij.lang.java.JavaLanguage -import com.intellij.openapi.util.Disposer -import com.intellij.psi.PsiClass -import com.intellij.psi.PsiFile -import com.intellij.psi.PsiFileFactory -import com.intellij.psi.PsiJavaFile -import org.jetbrains.kotlin.config.CompilerConfiguration -import java.io.File -import java.util.* - -internal class ChangedJavaFilesProcessor(private val reporter: ICReporter) { - private val allSymbols = HashSet() - private val javaLang = JavaLanguage.INSTANCE - private val psiFileFactory: PsiFileFactory by lazy { - val rootDisposable = Disposer.newDisposable() - val configuration = CompilerConfiguration() - val environment = KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) - val project = environment.project - PsiFileFactory.getInstance(project) - } - - val allChangedSymbols: Collection - get() = allSymbols - - fun process(filesDiff: ChangedFiles.Known): ChangesEither { - val modifiedJava = filesDiff.modified.filter(File::isJavaFile) - val removedJava = filesDiff.removed.filter(File::isJavaFile) - - if (removedJava.any()) { - reporter.report { "Some java files are removed: [${removedJava.joinToString()}]" } - return ChangesEither.Unknown() - } - - val symbols = HashSet() - for (javaFile in modifiedJava) { - assert(javaFile.extension.equals("java", ignoreCase = true)) - - val psiFile = javaFile.psiFile() - if (psiFile !is PsiJavaFile) { - reporter.report { "Expected PsiJavaFile, got ${psiFile?.javaClass}" } - return ChangesEither.Unknown() - } - - psiFile.classes.forEach { it.addLookupSymbols(symbols) } - } - allSymbols.addAll(symbols) - return ChangesEither.Known(lookupSymbols = symbols) - } - - private fun PsiClass.addLookupSymbols(symbols: MutableSet) { - val fqn = qualifiedName.orEmpty() - - symbols.add(LookupSymbol(name.orEmpty(), if (fqn == name) "" else fqn.removeSuffix("." + name!!))) - methods.forEach { symbols.add(LookupSymbol(it.name, fqn)) } - fields.forEach { symbols.add(LookupSymbol(it.name.orEmpty(), fqn)) } - innerClasses.forEach { it.addLookupSymbols(symbols) } - } - - private fun File.psiFile(): PsiFile? = - psiFileFactory.createFileFromText(nameWithoutExtension, javaLang, readText()) -} \ 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 955692565a9..c9e0b00b531 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 @@ -31,8 +31,7 @@ import org.jetbrains.kotlin.incremental.multiproject.ChangesRegistry import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.progress.CompilationCanceledStatus import java.io.File -import java.util.ArrayList -import java.util.HashSet +import java.util.* abstract class IncrementalCompilerRunner< Args : CommonCompilerArguments, @@ -143,8 +142,6 @@ abstract class IncrementalCompilerRunner< protected open fun postCompilationHook(exitCode: ExitCode) {} protected open fun additionalDirtyFiles(caches: CacheManager, generatedFiles: List): Iterable = emptyList() - protected open fun additionalDirtyLookupSymbols(): Iterable = - emptyList() protected open fun makeServices( args: Args, @@ -187,7 +184,7 @@ abstract class IncrementalCompilerRunner< var exitCode = ExitCode.OK val allGeneratedFiles = hashSetOf() - while (dirtySources.any()) { + while (dirtySources.any() || runWithNoDirtyKotlinSources(caches)) { caches.platformCache.markDirty(dirtySources) caches.inputsCache.removeOutputForSourceFiles(dirtySources) @@ -248,9 +245,6 @@ abstract class IncrementalCompilerRunner< if (exitCode == ExitCode.OK) { BuildInfo.write(currentBuildInfo, lastBuildInfoFile) } - if (exitCode == ExitCode.OK && compilationMode is CompilationMode.Incremental) { - buildDirtyLookupSymbols.addAll(additionalDirtyLookupSymbols()) - } val dirtyData = DirtyData(buildDirtyLookupSymbols, buildDirtyFqNames) processChangesAfterBuild(compilationMode, currentBuildInfo, dirtyData) @@ -262,6 +256,8 @@ abstract class IncrementalCompilerRunner< return exitCode } + open fun runWithNoDirtyKotlinSources(caches: CacheManager): Boolean = false + protected open fun processChangesAfterBuild(compilationMode: CompilationMode, currentBuildInfo: BuildInfo, dirtyData: DirtyData) { if (changesRegistry == null) return @@ -283,4 +279,4 @@ abstract class IncrementalCompilerRunner< override fun checkCanceled() { } } -} \ 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 9ff1d587dd8..e2e8660a832 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 @@ -31,14 +31,12 @@ import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.incremental.multiproject.ArtifactChangesProvider import org.jetbrains.kotlin.incremental.multiproject.ChangesRegistry +import org.jetbrains.kotlin.load.java.JavaClassesTracker import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.resolve.jvm.JvmClassName import java.io.File -import java.util.* -import kotlin.collections.HashSet fun makeIncrementally( cachesDir: File, @@ -110,8 +108,6 @@ class IncrementalJvmCompilerRunner( override fun destinationDir(args: K2JVMCompilerArguments): File = args.destinationAsFile - private var javaFilesProcessor = ChangedJavaFilesProcessor(reporter) - override fun calculateSourcesToCompile(caches: IncrementalJvmCachesManager, changedFiles: ChangedFiles.Known, args: K2JVMCompilerArguments): CompilationMode { val dirtyFiles = getDirtyFiles(changedFiles) @@ -170,23 +166,22 @@ class IncrementalJvmCompilerRunner( return CompilationMode.Rebuild { "could not get changes from modified classpath entries: ${reporter.pathsAsString(modifiedClasspathEntries)}" } } - val javaFilesChanges = javaFilesProcessor.process(changedFiles) - val affectedJavaSymbols = when (javaFilesChanges) { - is ChangesEither.Known -> javaFilesChanges.lookupSymbols - is ChangesEither.Unknown -> return CompilationMode.Rebuild { "Could not get changes for java files" } - } + processChangedJava(changedFiles, caches) if ((changedFiles.modified + changedFiles.removed).any { it.extension.toLowerCase() == "xml" }) { return CompilationMode.Rebuild { "XML resource files were changed" } } - markDirtyBy(affectedJavaSymbols) markDirtyBy(classpathChanges.lookupSymbols) markDirtyBy(classpathChanges.fqNames) return CompilationMode.Incremental(dirtyFiles) } + private fun processChangedJava(changedFiles: ChangedFiles.Known, caches: IncrementalJvmCachesManager) { + caches.platformCache.markDirty((changedFiles.modified + changedFiles.removed).filter(File::isJavaFile)) + } + private fun getClasspathChanges( modifiedClasspath: List, lastBuildInfo: BuildInfo? @@ -249,9 +244,15 @@ class IncrementalJvmCompilerRunner( generatedFiles: List, changesCollector: ChangesCollector ) { - updateIncrementalCache(generatedFiles, caches.platformCache, changesCollector) + updateIncrementalCache( + generatedFiles, caches.platformCache, changesCollector, + services[JavaClassesTracker::class.java] as? JavaClassesTrackerImpl + ) } + override fun runWithNoDirtyKotlinSources(caches: IncrementalJvmCachesManager): Boolean = + caches.platformCache.getObsoleteJavaClasses().isNotEmpty() + override fun additionalDirtyFiles( caches: IncrementalJvmCachesManager, generatedFiles: List @@ -292,9 +293,6 @@ class IncrementalJvmCompilerRunner( return result } - override fun additionalDirtyLookupSymbols(): Iterable = - javaFilesProcessor.allChangedSymbols - override fun processChangesAfterBuild(compilationMode: CompilationMode, currentBuildInfo: BuildInfo, dirtyData: DirtyData) { super.processChangesAfterBuild(compilationMode, currentBuildInfo, dirtyData) @@ -323,6 +321,8 @@ class IncrementalJvmCompilerRunner( val targetToCache = mapOf(targetId to caches.platformCache) val incrementalComponents = IncrementalCompilationComponentsImpl(targetToCache) register(IncrementalCompilationComponents::class.java, incrementalComponents) + val changesTracker = JavaClassesTrackerImpl(caches.platformCache) + register(JavaClassesTracker::class.java, changesTracker) } override fun runCompiler( diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java index 34eace2fabd..8027798b08c 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java @@ -1108,18 +1108,42 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true); } + @TestMetadata("changeFieldType") + public void testChangeFieldType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/"); + doTest(fileName); + } + @TestMetadata("changeNotUsedSignature") public void testChangeNotUsedSignature() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature/"); doTest(fileName); } + @TestMetadata("changePropertyOverrideType") + public void testChangePropertyOverrideType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/"); + doTest(fileName); + } + @TestMetadata("changeSignature") public void testChangeSignature() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/"); doTest(fileName); } + @TestMetadata("changeSignaturePackagePrivate") + public void testChangeSignaturePackagePrivate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/"); + doTest(fileName); + } + + @TestMetadata("changeSignatureStatic") + public void testChangeSignatureStatic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/"); + doTest(fileName); + } + @TestMetadata("constantChanged") public void testConstantChanged() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/"); @@ -1180,6 +1204,12 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement doTest(fileName); } + @TestMetadata("mixedInheritance") + public void testMixedInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/"); + doTest(fileName); + } + @TestMetadata("notChangeSignature") public void testNotChangeSignature() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature/"); @@ -1472,4 +1502,31 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } } } + + @TestMetadata("jps-plugin/testData/incremental/incrementalJvmCompilerOnly") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class IncrementalJvmCompilerOnly extends AbstractIncrementalJvmCompilerRunnerTest { + @TestMetadata("addAnnotationToJavaClass") + public void testAddAnnotationToJavaClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/"); + doTest(fileName); + } + + @TestMetadata("addNestedClass") + public void testAddNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/"); + doTest(fileName); + } + + public void testAllFilesPresentInIncrementalJvmCompilerOnly() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true); + } + + @TestMetadata("changeAnnotationInJavaClass") + public void testChangeAnnotationInJavaClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/"); + doTest(fileName); + } + } } diff --git a/compiler/util/src/org/jetbrains/kotlin/config/Services.kt b/compiler/util/src/org/jetbrains/kotlin/config/Services.kt index f7213c6222f..0118fa4fd32 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/Services.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/Services.kt @@ -24,7 +24,7 @@ class Services private constructor(private val map: Map, Any>) { val EMPTY: Services = Builder().build() } - fun get(interfaceClass: Class): T? { + operator fun get(interfaceClass: Class): T? { @Suppress("UNCHECKED_CAST") return map[interfaceClass] as T? } diff --git a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 5422fa0e13a..3c6d4844137 100755 --- a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -913,6 +913,7 @@ fun main(args: Array) { model("incremental/classHierarchyAffected", extension = null, recursive = false) model("incremental/inlineFunCallSite", extension = null, excludeParentDirs = true) model("incremental/withJava", extension = null, excludeParentDirs = true) + model("incremental/incrementalJvmCompilerOnly", extension = null, excludeParentDirs = true) } testClass { diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJpsTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJpsTestGenerated.java index 399a3e99ad4..5049812c42f 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJpsTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJpsTestGenerated.java @@ -949,18 +949,42 @@ public class IncrementalJpsTestGenerated extends AbstractIncrementalJpsTest { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true); } + @TestMetadata("changeFieldType") + public void testChangeFieldType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/"); + doTest(fileName); + } + @TestMetadata("changeNotUsedSignature") public void testChangeNotUsedSignature() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature/"); doTest(fileName); } + @TestMetadata("changePropertyOverrideType") + public void testChangePropertyOverrideType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/"); + doTest(fileName); + } + @TestMetadata("changeSignature") public void testChangeSignature() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/"); doTest(fileName); } + @TestMetadata("changeSignaturePackagePrivate") + public void testChangeSignaturePackagePrivate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/"); + doTest(fileName); + } + + @TestMetadata("changeSignatureStatic") + public void testChangeSignatureStatic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/"); + doTest(fileName); + } + @TestMetadata("constantChanged") public void testConstantChanged() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/"); @@ -1021,6 +1045,12 @@ public class IncrementalJpsTestGenerated extends AbstractIncrementalJpsTest { doTest(fileName); } + @TestMetadata("mixedInheritance") + public void testMixedInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/"); + doTest(fileName); + } + @TestMetadata("notChangeSignature") public void testNotChangeSignature() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature/"); diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt index 7d01489d09a..9f8eaab5889 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt @@ -333,7 +333,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { val changesCollector = ChangesCollector() for ((target, files) in generatedFiles) { - updateIncrementalCache(files, incrementalCaches[target]!!, changesCollector) + updateIncrementalCache(files, incrementalCaches[target]!!, changesCollector, null) } updateLookupStorage(chunk, lookupTracker, dataManager, dirtyFilesHolder, filesToCompile) diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/Ann.java b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/Ann.java new file mode 100644 index 00000000000..27d2ec71ec8 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/Ann.java @@ -0,0 +1,2 @@ +public @interface Ann { +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/JavaClass.java b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/JavaClass.java new file mode 100644 index 00000000000..32f679b68e0 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/JavaClass.java @@ -0,0 +1,3 @@ +public class JavaClass { + public String foo() { return null; } +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/JavaClass.java.new b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/JavaClass.java.new new file mode 100644 index 00000000000..5ee4a7132ae --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/JavaClass.java.new @@ -0,0 +1,4 @@ +@Ann +public class JavaClass { + public String foo() { return null; } +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/build.log b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/build.log new file mode 100644 index 00000000000..a9eded761f6 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/build.log @@ -0,0 +1,20 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/JavaClass.class +End of files +Exit code: NOTHING_DONE +------------------------------------------ +Compiling files: + src/JavaClass.java +End of files +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/UsageKt.class +End of files +Compiling files: + src/usage.kt +End of files +Exit code: ABORT +------------------------------------------ +SUCCESS diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/notUsage.kt b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/notUsage.kt new file mode 100644 index 00000000000..f3b2ebc5254 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/notUsage.kt @@ -0,0 +1,3 @@ +fun foo() { + +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/usage.kt b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/usage.kt new file mode 100644 index 00000000000..89852aeef90 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass/usage.kt @@ -0,0 +1,3 @@ +fun bar() { + JavaClass().foo() +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/JavaClass.java b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/JavaClass.java new file mode 100644 index 00000000000..32f679b68e0 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/JavaClass.java @@ -0,0 +1,3 @@ +public class JavaClass { + public String foo() { return null; } +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/JavaClass.java.new b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/JavaClass.java.new new file mode 100644 index 00000000000..256f16bda6d --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/JavaClass.java.new @@ -0,0 +1,5 @@ +public class JavaClass { + public String foo() { return null; } + public static class Nested { + } +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/build.log b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/build.log new file mode 100644 index 00000000000..90b32c84535 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/build.log @@ -0,0 +1,21 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/JavaClass.class +End of files +Exit code: NOTHING_DONE +------------------------------------------ +Compiling files: + src/JavaClass.java +End of files +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/UsageKt.class +End of files +Compiling files: + src/usage.kt +End of files +Exit code: ABORT +------------------------------------------ +COMPILATION FAILED +Unresolved reference: Nested diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/notUsage.kt b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/notUsage.kt new file mode 100644 index 00000000000..86fd98ec6cf --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/notUsage.kt @@ -0,0 +1,5 @@ +import test.* + +fun foo(x: Nested) { + JavaClass().foo() +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/test.kt b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/test.kt new file mode 100644 index 00000000000..99c2123ba39 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/test.kt @@ -0,0 +1,3 @@ +package test + +class Nested diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/usage.kt b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/usage.kt new file mode 100644 index 00000000000..26c7031039a --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass/usage.kt @@ -0,0 +1,6 @@ +import test.* +import JavaClass.* + +fun bar(x: Nested) { + JavaClass().foo() +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/Ann.java b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/Ann.java new file mode 100644 index 00000000000..4264b9bfa93 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/Ann.java @@ -0,0 +1,3 @@ +public @interface Ann { + String value() default "1"; +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/JavaClass.java b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/JavaClass.java new file mode 100644 index 00000000000..5ee4a7132ae --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/JavaClass.java @@ -0,0 +1,4 @@ +@Ann +public class JavaClass { + public String foo() { return null; } +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/JavaClass.java.new b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/JavaClass.java.new new file mode 100644 index 00000000000..95bbfc31433 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/JavaClass.java.new @@ -0,0 +1,4 @@ +@Ann("") +public class JavaClass { + public String foo() { return null; } +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/build.log b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/build.log new file mode 100644 index 00000000000..a9eded761f6 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/build.log @@ -0,0 +1,20 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/JavaClass.class +End of files +Exit code: NOTHING_DONE +------------------------------------------ +Compiling files: + src/JavaClass.java +End of files +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/UsageKt.class +End of files +Compiling files: + src/usage.kt +End of files +Exit code: ABORT +------------------------------------------ +SUCCESS diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/notUsage.kt b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/notUsage.kt new file mode 100644 index 00000000000..f3b2ebc5254 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/notUsage.kt @@ -0,0 +1,3 @@ +fun foo() { + +} diff --git a/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/usage.kt b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/usage.kt new file mode 100644 index 00000000000..89852aeef90 --- /dev/null +++ b/jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass/usage.kt @@ -0,0 +1,3 @@ +fun bar() { + JavaClass().foo() +} diff --git a/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove/gradle-build.log b/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove/gradle-build.log deleted file mode 100644 index b43d089d40e..00000000000 --- a/jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove/gradle-build.log +++ /dev/null @@ -1,14 +0,0 @@ -================ Step #1 ================= -Compiling files: - src/TheClass.kt - src/other.kt -End of files -Exit code: OK ------------------------------------------- - -================ Step #2 ================= - -Compiling files: -End of files -Exit code: OK ------------------------------------------- diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/JavaClass.java b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/JavaClass.java new file mode 100644 index 00000000000..2fb012bd6ff --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/JavaClass.java @@ -0,0 +1,4 @@ +public class JavaClass { + public String stringField; + public int intField; +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/JavaClass.java.new b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/JavaClass.java.new new file mode 100644 index 00000000000..aef7f23f0b7 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/JavaClass.java.new @@ -0,0 +1,4 @@ +public class JavaClass { + public CharSequence stringField; + public int intField; +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/build.log b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/build.log new file mode 100644 index 00000000000..6acfcd2c480 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/build.log @@ -0,0 +1,19 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/JavaClass.class +End of files +Exit code: NOTHING_DONE +------------------------------------------ +Compiling files: + src/JavaClass.java +End of files +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/UsageKt.class +End of files +Compiling files: + src/usage.kt +End of files +Exit code: OK +------------------------------------------ diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/notUsage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/notUsage.kt new file mode 100644 index 00000000000..0775e74e344 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/notUsage.kt @@ -0,0 +1,3 @@ +fun main(args: Array) { + JavaClass().intField +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/usage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/usage.kt new file mode 100644 index 00000000000..6ab667aca2e --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType/usage.kt @@ -0,0 +1,3 @@ +fun main(args: Array) { + JavaClass().stringField +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/JavaClass.java b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/JavaClass.java new file mode 100644 index 00000000000..3fb1d4bce6c --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/JavaClass.java @@ -0,0 +1,4 @@ +public class JavaClass implements KotlinInterface { + public CharSequence getX() { return ""; } + public int getY() { return 1; } +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/JavaClass.java.new b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/JavaClass.java.new new file mode 100644 index 00000000000..b0f7c82af7b --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/JavaClass.java.new @@ -0,0 +1,4 @@ +public class JavaClass implements KotlinInterface { + public String getX() { return ""; } + public int getY() { return 1; } +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/KotlinInterface.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/KotlinInterface.kt new file mode 100644 index 00000000000..de997e81c85 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/KotlinInterface.kt @@ -0,0 +1,4 @@ +interface KotlinInterface { + val x: CharSequence + val y: Int +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/build.log b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/build.log new file mode 100644 index 00000000000..6acfcd2c480 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/build.log @@ -0,0 +1,19 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/JavaClass.class +End of files +Exit code: NOTHING_DONE +------------------------------------------ +Compiling files: + src/JavaClass.java +End of files +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/UsageKt.class +End of files +Compiling files: + src/usage.kt +End of files +Exit code: OK +------------------------------------------ diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/notUsage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/notUsage.kt new file mode 100644 index 00000000000..816c2d509b9 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/notUsage.kt @@ -0,0 +1,3 @@ +fun main(args: Array) { + JavaClass().y +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/usage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/usage.kt new file mode 100644 index 00000000000..32b02fc7c9e --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType/usage.kt @@ -0,0 +1,3 @@ +fun main(args: Array) { + JavaClass().x +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/JavaClass.java b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/JavaClass.java index 15f4844a8da..55262a600a8 100644 --- a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/JavaClass.java +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/JavaClass.java @@ -1,4 +1,7 @@ public class JavaClass { - public static void foo() { + public void foo() { + } + + public void bar() { } } diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/JavaClass.java.new b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/JavaClass.java.new index 78acfa5f44b..8b1a8ec8c44 100644 --- a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/JavaClass.java.new +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/JavaClass.java.new @@ -1,5 +1,8 @@ public class JavaClass { - public static String foo() { - return ":)"; + public String foo() { + return ""; + } + + public void bar() { } } diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/notUsage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/notUsage.kt new file mode 100644 index 00000000000..30fa9af22de --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/notUsage.kt @@ -0,0 +1,3 @@ +fun main(args: Array) { + JavaClass().bar() +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/usage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/usage.kt index 43c9b8575bc..4195e7d27c9 100644 --- a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/usage.kt +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature/usage.kt @@ -1,3 +1,3 @@ fun main(args: Array) { - JavaClass.foo() + JavaClass().foo() } diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/JavaClass.java b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/JavaClass.java new file mode 100644 index 00000000000..55262a600a8 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/JavaClass.java @@ -0,0 +1,7 @@ +public class JavaClass { + public void foo() { + } + + public void bar() { + } +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/JavaClass.java.new b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/JavaClass.java.new new file mode 100644 index 00000000000..4ffae8c6aff --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/JavaClass.java.new @@ -0,0 +1,7 @@ +public class JavaClass { + void foo() { + } + + public void bar() { + } +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/build.log b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/build.log new file mode 100644 index 00000000000..6acfcd2c480 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/build.log @@ -0,0 +1,19 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/JavaClass.class +End of files +Exit code: NOTHING_DONE +------------------------------------------ +Compiling files: + src/JavaClass.java +End of files +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/UsageKt.class +End of files +Compiling files: + src/usage.kt +End of files +Exit code: OK +------------------------------------------ diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/notUsage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/notUsage.kt new file mode 100644 index 00000000000..30fa9af22de --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/notUsage.kt @@ -0,0 +1,3 @@ +fun main(args: Array) { + JavaClass().bar() +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/usage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/usage.kt new file mode 100644 index 00000000000..4195e7d27c9 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate/usage.kt @@ -0,0 +1,3 @@ +fun main(args: Array) { + JavaClass().foo() +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/JavaClass.java b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/JavaClass.java new file mode 100644 index 00000000000..ef47ee18a36 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/JavaClass.java @@ -0,0 +1,7 @@ +public class JavaClass { + public static void foo() { + } + + public static void bar() { + } +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/JavaClass.java.new b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/JavaClass.java.new new file mode 100644 index 00000000000..85b72351fb8 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/JavaClass.java.new @@ -0,0 +1,8 @@ +public class JavaClass { + public static String foo() { + return ""; + } + + public static void bar() { + } +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/build.log b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/build.log new file mode 100644 index 00000000000..6acfcd2c480 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/build.log @@ -0,0 +1,19 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/JavaClass.class +End of files +Exit code: NOTHING_DONE +------------------------------------------ +Compiling files: + src/JavaClass.java +End of files +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/UsageKt.class +End of files +Compiling files: + src/usage.kt +End of files +Exit code: OK +------------------------------------------ diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/notUsage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/notUsage.kt new file mode 100644 index 00000000000..bc792c0d8e0 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/notUsage.kt @@ -0,0 +1,3 @@ +fun main(args: Array) { + JavaClass.bar() +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/usage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/usage.kt new file mode 100644 index 00000000000..43c9b8575bc --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic/usage.kt @@ -0,0 +1,3 @@ +fun main(args: Array) { + JavaClass.foo() +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged/gradle-build.log b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged/gradle-build.log deleted file mode 100644 index 6d26dbae105..00000000000 --- a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged/gradle-build.log +++ /dev/null @@ -1,7 +0,0 @@ -================ Step #1 ================= - -Compiling files: - src/JavaClass.java - src/usage.kt -End of files -Exit code: OK diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/BaseClass.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/BaseClass.kt new file mode 100644 index 00000000000..8fa9925a116 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/BaseClass.kt @@ -0,0 +1,3 @@ +open class BaseClass { + fun foo() {} +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/BaseClass.kt.new b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/BaseClass.kt.new new file mode 100644 index 00000000000..c7e93e93b63 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/BaseClass.kt.new @@ -0,0 +1,3 @@ +open class BaseClass { + fun foo(): String = "OK" +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/DerivedClass1.java b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/DerivedClass1.java new file mode 100644 index 00000000000..0e7c4187368 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/DerivedClass1.java @@ -0,0 +1,2 @@ +public class DerivedClass1 extends BaseClass { +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/DerivedClass2.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/DerivedClass2.kt new file mode 100644 index 00000000000..ba353e5d6d0 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/DerivedClass2.kt @@ -0,0 +1,2 @@ +class DerivedClass2 : DerivedClass1() { +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/build.log b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/build.log new file mode 100644 index 00000000000..268087eb177 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/build.log @@ -0,0 +1,33 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/BaseClass.class +End of files +Compiling files: + src/BaseClass.kt +End of files +Marked as dirty by Kotlin: + src/usage1.kt + src/usage2.kt + src/usage3.kt +Exit code: ADDITIONAL_PASS_REQUIRED +------------------------------------------ +Cleaning output files: + out/production/module/DerivedClass1.class + out/production/module/DerivedClass2.class + out/production/module/META-INF/module.kotlin_module + out/production/module/Usage1Kt.class + out/production/module/Usage2Kt.class + out/production/module/Usage3Kt.class +End of files +Compiling files: + src/DerivedClass2.kt + src/usage1.kt + src/usage2.kt + src/usage3.kt +End of files +Exit code: OK +------------------------------------------ +Compiling files: + src/DerivedClass1.java +End of files diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/notUsage.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/notUsage.kt new file mode 100644 index 00000000000..00cb76cc63f --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/notUsage.kt @@ -0,0 +1,3 @@ +fun main4() { + DerivedClass2().hashCode() +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/usage1.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/usage1.kt new file mode 100644 index 00000000000..2c98c32f046 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/usage1.kt @@ -0,0 +1,3 @@ +fun main1() { + BaseClass().foo() +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/usage2.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/usage2.kt new file mode 100644 index 00000000000..6cad6289ec2 --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/usage2.kt @@ -0,0 +1,3 @@ +fun main2() { + DerivedClass1().foo() +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/usage3.kt b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/usage3.kt new file mode 100644 index 00000000000..b7abe85577c --- /dev/null +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance/usage3.kt @@ -0,0 +1,3 @@ +fun main3() { + DerivedClass2().foo() +} diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature/gradle-build.log b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature/gradle-build.log deleted file mode 100644 index 5b9396ca2b1..00000000000 --- a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature/gradle-build.log +++ /dev/null @@ -1,6 +0,0 @@ -================ Step #1 ================= - -Compiling files: - src/JavaClass.java - src/usage.kt -End of files