From 1989e8f094c8bfd758085cbb75fae181c539c1eb Mon Sep 17 00:00:00 2001 From: Ilya Chernikov Date: Mon, 26 Feb 2024 11:04:59 +0100 Subject: [PATCH] IC tests: add infrastructure for K1/K2 lookups comparison Adapt lookup tests to allow running K1 and K2 on the same testdata and compare the lookups recorded. --- .../testingUtils/BuildLogFinder.kt | 2 +- .../incrementalModificationUtils.kt | 86 +++++++++++++----- ...ctIncrementalK1JsKlibCompilerRunnerTest.kt | 1 + ...alK1JsKlibMultiModuleCompilerRunnerTest.kt | 2 +- ...tractIncrementalK1JvmCompilerRunnerTest.kt | 3 + .../kotlin/jps/GenerateJpsPluginTests.kt | 3 + .../build/AbstractIncrementalK1JvmJpsTest.kt | 4 + .../jps/build/AbstractLookupTrackerTest.kt | 88 ++++++++++++++----- .../K1JvmLookupTrackerTestGenerated.java | 86 ++++++++++++++++++ .../lookupTracker/jvm/SAM/build.log | 6 +- .../lookupTracker/jvm/SAM/fir-build.log | 7 ++ .../lookupTracker/jvm/SAM/usages.K1.kt | 14 +++ .../jvm/classifierMembers/build.log | 8 +- .../jvm/classifierMembers/constraints.K1.kt | 7 ++ .../jvm/classifierMembers/fir-build.log | 21 +++++ .../jvm/classifierMembers/foo.K1.kt | 69 +++++++++++++++ .../jvm/classifierMembers/usages.K1.kt | 50 +++++++++++ .../jvm/classifierMembers/usages.K1.kt.new.2 | 54 ++++++++++++ .../jvm/conventions/comparison.K1.kt | 18 ++++ .../jvm/conventions/declarations.K1.kt | 35 ++++++++ .../jvm/conventions/delegateProperty.K1.kt | 30 +++++++ .../jvm/conventions/mathematicalLike.K1.kt | 24 +++++ .../lookupTracker/jvm/conventions/other.K1.kt | 16 ++++ .../jvm/expressionType/genericType.K1.kt | 15 ++++ .../jvm/expressionType/inferredType.K1.kt | 19 ++++ .../expressionType/lambdaParameterType.K1.kt | 11 +++ .../lookupTracker/jvm/java/build.log | 4 +- .../lookupTracker/jvm/java/fir-build.log | 6 ++ .../lookupTracker/jvm/java/usages.K1.kt | 45 ++++++++++ .../lookupTracker/jvm/jvmNameChanged/A.K1.kt | 6 ++ .../jvm/jvmNameChanged/A.K1.kt.new | 6 ++ .../jvm/jvmNameChanged/useAChild.K1.kt | 5 ++ .../jvm/localDeclarations/locals.K1.kt | 49 +++++++++++ .../jvm/packageDeclarations/foo1.K1.kt | 17 ++++ .../lookupTracker/jvm/simple/main.K1.kt | 6 ++ .../jvm/syntheticProperties/KotlinClass.K1.kt | 8 ++ .../jvm/syntheticProperties/build.log | 24 ++--- .../jvm/syntheticProperties/fir-build.log | 21 +++++ .../jvm/syntheticProperties/usages.K1.kt | 30 +++++++ .../jvm/typeAliasAndUsage/usage.K1.kt | 5 ++ 40 files changed, 838 insertions(+), 73 deletions(-) create mode 100644 jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/K1JvmLookupTrackerTestGenerated.java create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/fir-build.log create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/usages.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/constraints.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/fir-build.log create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/foo.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.K1.kt.new.2 create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/comparison.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/declarations.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/delegateProperty.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/mathematicalLike.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/other.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/genericType.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/inferredType.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/lambdaParameterType.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/fir-build.log create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/usages.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/A.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/A.K1.kt.new create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/useAChild.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/localDeclarations/locals.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/packageDeclarations/foo1.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/simple/main.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/KotlinClass.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/fir-build.log create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/usages.K1.kt create mode 100644 jps/jps-plugin/testData/incremental/lookupTracker/jvm/typeAliasAndUsage/usage.K1.kt 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 d1ad0a5f2eb..4281dc26375 100644 --- a/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt +++ b/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/BuildLogFinder.kt @@ -24,7 +24,7 @@ data class BuildLogFinder( private val isJsEnabled: Boolean = false, private val isScopeExpansionEnabled: Boolean = false, private val isKlibEnabled: Boolean = false, - private val isFirEnabled: Boolean = false, + private val isFirEnabled: Boolean = true, private val isJpsBuild: Boolean = false, ) { companion object { diff --git a/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/incrementalModificationUtils.kt b/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/incrementalModificationUtils.kt index 6e19a4e8f1e..65dae4401e3 100644 --- a/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/incrementalModificationUtils.kt +++ b/build-common/test/org/jetbrains/kotlin/incremental/testingUtils/incrementalModificationUtils.kt @@ -18,7 +18,6 @@ package org.jetbrains.kotlin.incremental.testingUtils import com.intellij.openapi.util.io.FileUtil import java.io.File -import java.util.* import kotlin.math.max private val COMMANDS = listOf("new", "touch", "delete") @@ -30,28 +29,59 @@ enum class TouchPolicy { CHECKSUM } -fun copyTestSources(testDataDir: File, sourceDestinationDir: File, filePrefix: String): Map { - val mapping = hashMapOf() - FileUtil.copyDir(testDataDir, sourceDestinationDir) { - it.isDirectory || it.name.startsWith(filePrefix) && (it.name.endsWith(".kt") || it.name.endsWith(".java")) +/** + * Optional suffix (first filename extension) that could be inserted before first "regular" extension + */ +enum class OptionalVariantSuffix { + None, + K1, + K2; + + companion object { + /** + * A regex used to recognize a variant suffix in the filename. + * Note: Should match all possible suffixes, but "None", and should be compatible with comparison logic in `genVariantMatchingName` + */ + val anySuffixRegex = Regex(".(K[12]).") } +} - for (file in sourceDestinationDir.walk()) { - if (!file.isFile) continue +fun String.genVariantMatchingName(expectedOptionalVariant: OptionalVariantSuffix): String? { + if (expectedOptionalVariant == OptionalVariantSuffix.None) return this + val variantMatch = OptionalVariantSuffix.anySuffixRegex.find(this) ?: return this + if (variantMatch.groups[1]?.value != expectedOptionalVariant.name) return null + return removeRange(variantMatch.range.first, variantMatch.range.last) +} - val renamedFile = - if (filePrefix.isEmpty()) { - file - } - else { - File(sourceDestinationDir, file.name.removePrefix(filePrefix)).apply { - file.renameTo(this) +fun copyTestSources( + testDataDir: File, + sourceDestinationDir: File, + filePrefix: String, + optionalVariantSuffix: OptionalVariantSuffix = OptionalVariantSuffix.None, +): Map { + val mapping = hashMapOf() + + fun copyDir(fromDir: File, toDir: File) { + FileUtil.ensureExists(toDir) + for (file in fromDir.listFiles().orEmpty()) { + if (file.isDirectory) { + copyDir(file, File(toDir, file.name)) + } else if (file.name.endsWith(".kt") || file.name.endsWith(".java")) { + val nameWithoutVariant = file.name.genVariantMatchingName(optionalVariantSuffix) ?: continue // prefixed but with different variant + if (nameWithoutVariant.startsWith(filePrefix)) { + val targetFile = File(toDir, nameWithoutVariant.substring(filePrefix.length)) + if (nameWithoutVariant != file.name /* variant-prefixed file replaces the one without a variant prefix */ || + !mapping.containsKey(targetFile) + ) { + FileUtil.copy(file, targetFile) + mapping[targetFile] = file + } } } - - mapping[renamedFile] = File(testDataDir, file.name) + } } + copyDir(testDataDir, sourceDestinationDir) return mapping } @@ -59,7 +89,8 @@ fun getModificationsToPerform( testDataDir: File, moduleNames: Collection?, allowNoFilesWithSuffixInTestData: Boolean, - touchPolicy: TouchPolicy + touchPolicy: TouchPolicy, + optionalVariantSuffix: OptionalVariantSuffix = OptionalVariantSuffix.None, ): List> { fun getModificationsForIteration(newSuffix: String, touchSuffix: String, deleteSuffix: String): List { @@ -92,21 +123,30 @@ fun getModificationsToPerform( deleteSuffix to { path, _ -> DeleteFile(path) } ) - val modifications = ArrayList() + val modifications = LinkedHashMap() for (file in testDataDir.walkTopDown()) { if (!file.isFile) continue - val relativeFilePath = file.toRelativeString(testDataDir) - val (suffix, createModification) = rules.entries.firstOrNull { file.path.endsWith(it.key) } ?: continue - val (moduleName, fileName) = splitToModuleNameAndFileName(relativeFilePath) + // NOTE: the code do not allow to combine module prefixes with directory structure + val relativeFilePath = file.toRelativeString(testDataDir) + val relativeFilePathWithoutVariant = + relativeFilePath.genVariantMatchingName(optionalVariantSuffix) ?: continue + + val (moduleName, fileName) = splitToModuleNameAndFileName(relativeFilePathWithoutVariant) val srcDir = moduleName?.let { "$it/src" } ?: "src" - modifications.add(createModification(srcDir + "/" + fileName.removeSuffix(suffix), file)) + val targetPath = srcDir + "/" + fileName.removeSuffix(suffix) + + if (relativeFilePathWithoutVariant != relativeFilePath /* variant-prefixed file replaces the one without a variant prefix */ || + !modifications.containsKey(targetPath) + ) { + modifications[targetPath] = createModification(targetPath, file) + } } - return modifications + return modifications.values.toList() } val haveFilesWithoutNumbers = testDataDir.walkTopDown().any { it.name.matches(".+\\.($COMMANDS_AS_REGEX_PART)$".toRegex()) } diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JsKlibCompilerRunnerTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JsKlibCompilerRunnerTest.kt index da8778f4dab..28cac947aa2 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JsKlibCompilerRunnerTest.kt +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JsKlibCompilerRunnerTest.kt @@ -22,6 +22,7 @@ abstract class AbstractIncrementalK1JsKlibCompilerRunnerTest : AbstractIncrement override val buildLogFinder: BuildLogFinder get() = super.buildLogFinder.copy( + isFirEnabled = false, isKlibEnabled = true, isJsEnabled = true, isScopeExpansionEnabled = scopeExpansionMode != CompileScopeExpansionMode.NEVER, diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JsKlibMultiModuleCompilerRunnerTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JsKlibMultiModuleCompilerRunnerTest.kt index 3b2ed76cdcb..13f7d47b382 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JsKlibMultiModuleCompilerRunnerTest.kt +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JsKlibMultiModuleCompilerRunnerTest.kt @@ -29,7 +29,7 @@ abstract class AbstractIncrementalK1JsKlibMultiModuleCompilerRunnerTest : } override val buildLogFinder: BuildLogFinder - get() = super.buildLogFinder.copy(isKlibEnabled = true) + get() = super.buildLogFinder.copy(isFirEnabled = false, isKlibEnabled = true) override fun makeForSingleModule( moduleCacheDir: File, diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JvmCompilerRunnerTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JvmCompilerRunnerTest.kt index bd738d1a2f4..09d8d601479 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JvmCompilerRunnerTest.kt +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalK1JvmCompilerRunnerTest.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.incremental import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments import org.jetbrains.kotlin.config.LanguageVersion +import org.jetbrains.kotlin.incremental.testingUtils.BuildLogFinder import java.io.File abstract class AbstractIncrementalK1JvmCompilerRunnerTest : AbstractIncrementalJvmCompilerRunnerTest() { @@ -17,4 +18,6 @@ abstract class AbstractIncrementalK1JvmCompilerRunnerTest : AbstractIncrementalJ } } + override val buildLogFinder: BuildLogFinder + get() = super.buildLogFinder.copy(isFirEnabled = false) } \ No newline at end of file diff --git a/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/GenerateJpsPluginTests.kt b/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/GenerateJpsPluginTests.kt index 529779a42ce..c764cc684f6 100644 --- a/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/GenerateJpsPluginTests.kt +++ b/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/GenerateJpsPluginTests.kt @@ -90,6 +90,9 @@ fun main(args: Array) { testClass { model("incremental/lookupTracker/jvm", extension = null, recursive = false) } + testClass { + model("incremental/lookupTracker/jvm", extension = null, recursive = false) + } testClass { // todo: investigate why lookups are different from non-klib js model("incremental/lookupTracker/jsKlib", extension = null, recursive = false) diff --git a/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalK1JvmJpsTest.kt b/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalK1JvmJpsTest.kt index 308d2861a72..80c81f32692 100644 --- a/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalK1JvmJpsTest.kt +++ b/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalK1JvmJpsTest.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.jps.build import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments import org.jetbrains.kotlin.config.LanguageVersion +import org.jetbrains.kotlin.incremental.testingUtils.BuildLogFinder abstract class AbstractIncrementalK1JvmJpsTest( allowNoFilesWithSuffixInTestData: Boolean = false @@ -17,4 +18,7 @@ abstract class AbstractIncrementalK1JvmJpsTest( } super.updateCommandLineArguments(arguments) } + + override val buildLogFinder: BuildLogFinder + get() = super.buildLogFinder.copy(isFirEnabled = false) } diff --git a/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/AbstractLookupTrackerTest.kt b/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/AbstractLookupTrackerTest.kt index be9ef714a11..50b3f8fe084 100644 --- a/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/AbstractLookupTrackerTest.kt +++ b/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/AbstractLookupTrackerTest.kt @@ -21,14 +21,16 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.incremental.isKotlinFile import org.jetbrains.kotlin.incremental.js.* import org.jetbrains.kotlin.incremental.makeModuleFile -import org.jetbrains.kotlin.incremental.testingUtils.TouchPolicy -import org.jetbrains.kotlin.incremental.testingUtils.copyTestSources -import org.jetbrains.kotlin.incremental.testingUtils.getModificationsToPerform +import org.jetbrains.kotlin.incremental.testingUtils.* import org.jetbrains.kotlin.incremental.utils.TestLookupTracker import org.jetbrains.kotlin.incremental.utils.TestMessageCollector import org.jetbrains.kotlin.jps.build.fixtures.EnableICFixture import org.jetbrains.kotlin.jps.incremental.createTestingCompilerEnvironment import org.jetbrains.kotlin.jps.incremental.runJSCompiler +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.kotlinPathsForDistDirectoryForTests import org.jetbrains.kotlin.utils.JsMetadataVersion @@ -66,6 +68,10 @@ abstract class AbstractJvmLookupTrackerTest : AbstractLookupTrackerTest() { } } + open fun configureAdditionalArgs(args: K2JVMCompilerArguments) { + args.useFirLT = false + } + override fun runCompiler(filesToCompile: Iterable, env: JpsCompilerEnvironment): Any? { val moduleFile = makeModuleFile( name = "test", @@ -82,8 +88,8 @@ abstract class AbstractJvmLookupTrackerTest : AbstractLookupTrackerTest() { disableDefaultScriptingPlugin = true buildFile = moduleFile.canonicalPath reportOutputFiles = true - useFirLT = false } + configureAdditionalArgs(args) val argsArray = ArgumentUtils.convertArgumentsToStringList(args).toTypedArray() try { @@ -100,6 +106,24 @@ abstract class AbstractJvmLookupTrackerTest : AbstractLookupTrackerTest() { } } +abstract class AbstractK1JvmLookupTrackerTest : AbstractJvmLookupTrackerTest() { + + override var filterBuiltins = true + override var distinguishPackageAndClassLookups = false + + override fun setUp() { + super.setUp() + optionalVariantSuffix = OptionalVariantSuffix.K1 + } + + override fun configureAdditionalArgs(args: K2JVMCompilerArguments) { + args.languageVersion = "1.9" + } + + override val buildLogFinder: BuildLogFinder + get() = BuildLogFinder(isGradleEnabled = false, isFirEnabled = false) +} + abstract class AbstractJsKlibLookupTrackerTest : AbstractJsLookupTrackerTest() { override fun configureAdditionalArgs(args: K2JSCompilerArguments) { args.irProduceKlibDir = true @@ -181,6 +205,9 @@ abstract class AbstractLookupTrackerTest : TestWithWorkingDir() { protected lateinit var srcDir: File protected lateinit var outDir: File private val enableICFixture = EnableICFixture() + protected var optionalVariantSuffix: OptionalVariantSuffix = OptionalVariantSuffix.K2 + protected open var filterBuiltins = false + protected open var distinguishPackageAndClassLookups = true override fun setUp() { super.setUp() @@ -200,6 +227,9 @@ abstract class AbstractLookupTrackerTest : TestWithWorkingDir() { protected abstract fun processCompilationResults(outputItemsCollector: OutputItemsCollectorImpl, services: Services) protected abstract fun runCompiler(filesToCompile: Iterable, env: JpsCompilerEnvironment): Any? + protected open val buildLogFinder: BuildLogFinder + get() = BuildLogFinder(isGradleEnabled = false) + fun doTest(path: String) { val sb = StringBuilder() fun StringBuilder.indentln(string: String) { @@ -228,13 +258,14 @@ abstract class AbstractLookupTrackerTest : TestWithWorkingDir() { } val testDir = File(path) - val workToOriginalFileMap = HashMap(copyTestSources(testDir, srcDir, filePrefix = "")) + val workToOriginalFileMap = HashMap(copyTestSources(testDir, srcDir, filePrefix = "", optionalVariantSuffix = optionalVariantSuffix)) var dirtyFiles = srcDir.walk().filterTo(HashSet()) { it.isKotlinFile(setOf("kt", "kts")) } val steps = getModificationsToPerform( testDir, moduleNames = null, allowNoFilesWithSuffixInTestData = true, - touchPolicy = TouchPolicy.CHECKSUM + touchPolicy = TouchPolicy.CHECKSUM, + optionalVariantSuffix = optionalVariantSuffix ) .filter { it.isNotEmpty() } @@ -255,8 +286,9 @@ abstract class AbstractLookupTrackerTest : TestWithWorkingDir() { } } - val expectedBuildLog = File(testDir, "build.log") - UsefulTestCase.assertSameLinesWithFile(expectedBuildLog.canonicalPath, sb.toString()) + buildLogFinder.findBuildLog(testDir)?.let { expectedBuildLog -> + UsefulTestCase.assertSameLinesWithFile(expectedBuildLog.canonicalPath, sb.toString()) + } assertEquals(steps.size + 1, filesToLookups.size) for ((i, lookupsAtStepI) in filesToLookups.withIndex()) { @@ -317,23 +349,33 @@ abstract class AbstractLookupTrackerTest : TestWithWorkingDir() { val end = column - 1 parts.add(lineContent.subSequence(start, end)) - val lookups = lookupsFromColumn.mapTo(sortedSetOf()) { lookupInfo -> - val rest = lineContent.substring(end) + lookupsFromColumn.mapNotNullTo(sortedSetOf()) { lookupInfo -> + if (filterBuiltins && + ClassId(FqName(lookupInfo.scopeFqName), Name.identifier(lookupInfo.name)) in StandardClassIds.allBuiltinTypes + ) { + null + } else { + val rest = lineContent.substring(end) - val name = - when { - rest.startsWith(lookupInfo.name) || // same name - rest.startsWith("$" + lookupInfo.name) || // backing field - DECLARATION_STARTS_WITH.any { rest.startsWith(it) } // it's declaration - -> "" - else -> "(" + lookupInfo.name + ")" - } + val name = + when { + rest.startsWith(lookupInfo.name) || // same name + rest.startsWith("$" + lookupInfo.name) || // backing field + DECLARATION_STARTS_WITH.any { rest.startsWith(it) } // it's declaration + -> "" + else -> "(" + lookupInfo.name + ")" + } - lookupInfo.scopeKind.toString()[0].lowercaseChar() - .toString() + ":" + lookupInfo.scopeFqName.let { it.ifEmpty { "" } } + name - }.joinToString(separator = " ", prefix = "/*", postfix = "*/") - - parts.add(lookups) + val prefix = + if (distinguishPackageAndClassLookups) lookupInfo.scopeKind.toString()[0].lowercaseChar().toString() + else "p" + prefix + ":" + lookupInfo.scopeFqName.let { it.ifEmpty { "" } } + name + } + }.takeIf { it.isNotEmpty() } + ?.joinToString(separator = " ", prefix = "/*", postfix = "*/") + ?.also { + parts.add(it) + } start = end } diff --git a/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/K1JvmLookupTrackerTestGenerated.java b/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/K1JvmLookupTrackerTestGenerated.java new file mode 100644 index 00000000000..c0f6c441af6 --- /dev/null +++ b/jps/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/K1JvmLookupTrackerTestGenerated.java @@ -0,0 +1,86 @@ +/* + * Copyright 2010-2024 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.jps.build; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.jps.GenerateJpsPluginTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("jps/jps-plugin/testData/incremental/lookupTracker/jvm") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class K1JvmLookupTrackerTestGenerated extends AbstractK1JvmLookupTrackerTest { + private void runTest(String testDataFilePath) { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInJvm() { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps/jps-plugin/testData/incremental/lookupTracker/jvm"), Pattern.compile("^([^\\.]+)$"), null, false); + } + + @TestMetadata("classifierMembers") + public void testClassifierMembers() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/"); + } + + @TestMetadata("conventions") + public void testConventions() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/"); + } + + @TestMetadata("expressionType") + public void testExpressionType() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/"); + } + + @TestMetadata("java") + public void testJava() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/"); + } + + @TestMetadata("jvmNameChanged") + public void testJvmNameChanged() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/"); + } + + @TestMetadata("localDeclarations") + public void testLocalDeclarations() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/localDeclarations/"); + } + + @TestMetadata("packageDeclarations") + public void testPackageDeclarations() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/packageDeclarations/"); + } + + @TestMetadata("SAM") + public void testSAM() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/"); + } + + @TestMetadata("simple") + public void testSimple() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/simple/"); + } + + @TestMetadata("syntheticProperties") + public void testSyntheticProperties() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/"); + } + + @TestMetadata("typeAliasAndUsage") + public void testTypeAliasAndUsage() { + runTest("jps/jps-plugin/testData/incremental/lookupTracker/jvm/typeAliasAndUsage/"); + } +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/build.log b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/build.log index 99297e92279..43e6a28a6c4 100644 --- a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/build.log +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/build.log @@ -2,6 +2,6 @@ Compiling files: src/usages.kt Exit code: COMPILATION_ERROR - No value passed for parameter 'x'. - No value passed for parameter 'x'. - No value passed for parameter 'function'. \ No newline at end of file + No value passed for parameter 'x' + No value passed for parameter 'x' + No value passed for parameter 'function' \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/fir-build.log b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/fir-build.log new file mode 100644 index 00000000000..99297e92279 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/fir-build.log @@ -0,0 +1,7 @@ +==== INITIAL BUILD ==== +Compiling files: + src/usages.kt +Exit code: COMPILATION_ERROR + No value passed for parameter 'x'. + No value passed for parameter 'x'. + No value passed for parameter 'function'. \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/usages.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/usages.K1.kt new file mode 100644 index 00000000000..f2f018a40a8 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/SAM/usages.K1.kt @@ -0,0 +1,14 @@ +package foo +/*p:bar(C)*/import bar.C +/*p:bar(SAMInterface)*/import bar.SAMInterface + +/*p:foo*/fun foo(c: /*p:bar*/C) /*p:bar(SAMInterface)*/{ + /*p:bar(C)*/c./*p:bar.C p:bar.C(getFOO) p:bar.C(getFoo) p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/foo() + /*p:bar(C)*/c./*p:bar.C p:bar.SAMInterface()*/foo /*p:kotlin(Function1)*/{ } + + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/C./*p:bar.C*/bar() + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/C./*p:bar.C p:bar.SAMInterface()*/bar /*p:kotlin(Function1)*/{} + + /*p:bar p:bar.SAMInterface() p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/SAMInterface() + /*p:bar p:bar.SAMInterface()*/SAMInterface /*p:kotlin(Function1)*/{} +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/build.log b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/build.log index c910944c25d..536cf259677 100644 --- a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/build.log +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/build.log @@ -15,7 +15,7 @@ Exit code: OK Compiling files: src/usages.kt Exit code: COMPILATION_ERROR - Unresolved reference 'vala'. - Unresolved reference 'vara'. - Unresolved reference 'foo'. - Unresolved reference 'bar'. \ No newline at end of file + Unresolved reference: vala + Unresolved reference: vara + Unresolved reference: foo + Unresolved reference: bar \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/constraints.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/constraints.K1.kt new file mode 100644 index 00000000000..400f192507b --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/constraints.K1.kt @@ -0,0 +1,7 @@ +package foo + +import bar.* + +/*p:foo*/fun , C, D> test() + where C : /*p:foo p:kotlin*/Number, C : /*p:foo p:kotlin*/Comparable, D : B +{} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/fir-build.log b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/fir-build.log new file mode 100644 index 00000000000..c910944c25d --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/fir-build.log @@ -0,0 +1,21 @@ +==== INITIAL BUILD ==== +Compiling files: + src/bar.kt + src/constraints.kt + src/foo.kt + src/usages.kt +Exit code: OK + +==== STEP 1 ==== +Compiling files: + src/usages.kt +Exit code: OK + +==== STEP 2 ==== +Compiling files: + src/usages.kt +Exit code: COMPILATION_ERROR + Unresolved reference 'vala'. + Unresolved reference 'vara'. + Unresolved reference 'foo'. + Unresolved reference 'bar'. \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/foo.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/foo.K1.kt new file mode 100644 index 00000000000..3c07033a35c --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/foo.K1.kt @@ -0,0 +1,69 @@ +package foo + +/*p:foo*/class A { + val a = 1 + var b = "" + + val c: /*p:foo p:foo.A p:foo.A.Companion*/String + get() = /*p:foo.A*/b + + var d: /*p:foo p:foo.A p:foo.A.Companion*/String = "ddd" + get() = field + set(v) { field = v } + + fun foo() { + /*p:foo.A*/a + /*p:foo.A*/foo() + /*p:foo(A)*/this./*p:foo.A*/a + /*p:foo(A)*/this./*p:foo.A*/foo() + /*p:foo p:foo.A p:foo.A(getBAZ) p:foo.A(getBaz) p:foo.A.Companion p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/baz() + /*p:foo p:foo.A p:foo.A.Companion p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/Companion./*p:foo.A.Companion*/a + /*p:foo p:foo.A p:foo.A.Companion p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/O./*p:foo.A.O*/v = "OK" + } + + class B { + val a = 1 + + companion object CO { + fun bar(a: /*p:foo p:foo.A p:foo.A.B p:foo.A.B.CO p:foo.A.Companion*/Int) {} + } + } + + inner class C + + companion object { + val a = 1 + fun baz() {} + } + + object O { + var v = "vvv" + } +} + +/*p:foo*/interface I { + var a: /*p:foo p:foo.I*/Int + fun foo() + + class NI +} + +/*p:foo*/object Obj : /*p:foo*/I { + override var a = 1 + override fun foo() {} + val b = 1 + fun bar(): /*p:foo p:foo.Obj*/I = /*p:foo(I) p:kotlin(Nothing)*/null as /*p:foo p:foo.Obj*/I +} + +/*p:foo*/enum class E { + X, + Y; + + val a = 1 + fun foo() { + /*p:foo.E*/a + /*p:foo p:foo.E p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/Y./*p:foo.E*/a + /*p:foo.E*/foo() + /*p:foo p:foo.E p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/X./*p:foo.E*/foo() + } +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.K1.kt new file mode 100644 index 00000000000..4bd61ed88c4 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.K1.kt @@ -0,0 +1,50 @@ +package foo + +import bar.* + +/*p:foo*/fun usages(i: /*p:foo*/I) /*p:foo(E)*/{ + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/a + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/b + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/c + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/d = "new value" + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/foo() + /*p:foo*/A./*p:foo.A p:foo.A.B.CO(invoke) p:foo.A.Companion*/B()./*p:foo.A.B*/a + /*p:foo*/A./*p:foo.A*/B./*p:foo.A.B p:foo.A.B.CO*/bar(1) + /*p:foo*/A./*p:foo.A*/B./*p:foo.A.B*/CO./*p:foo.A.B.CO*/bar(1) + /*p:foo p:foo.A(Companion)*/A + /*p:foo*/A./*p:foo.A p:foo.A.Companion*/a + /*p:foo*/A./*p:foo.A p:foo.A.Companion*/baz() + /*p:foo p:foo.A(Companion)*/A./*p:foo.A p:foo.A.Companion*/Companion + /*p:foo*/A./*p:foo.A*/Companion./*p:foo.A.Companion*/baz() + /*p:foo p:foo.A(O)*/A./*p:foo.A p:foo.A.Companion*/O + /*p:foo*/A./*p:foo.A*/O./*p:foo.A.O*/v = "OK" + + /*p:foo(I)*/i./*p:foo.I*/a = 2 + /*p:foo*/Obj./*p:foo.Obj*/a + /*p:foo*/Obj./*p:foo.Obj*/foo() + var ii: /*p:foo*/I = /*p:foo*/Obj + /*p:foo(I)*/ii./*p:foo.I*/a + /*p:foo(I)*/ii./*p:foo.I*/foo() + /*p:foo*/Obj./*p:foo.Obj*/b + val iii = /*p:foo p:foo(I)*/Obj./*p:foo.Obj*/bar() + /*p:foo(I)*/iii./*p:foo.I*/foo() + + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/X + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/X./*p:foo.E*/a + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/Y./*p:foo.E*/foo() + /*p:bar p:foo p:java.lang p:kotlin p:kotlin(Array) p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/values() + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/valueOf("") +} + +/*p:foo*/fun classifiers( + a: /*p:foo*/A, + ab: /*p:foo*/A./*p:foo.A*/B, + ac: /*p:foo*/A./*p:foo.A*/C, + abCo: /*p:foo*/A./*p:foo.A*/B./*p:foo.A.B*/CO, + aCompanion: /*p:foo*/A./*p:foo.A*/Companion, + aO: /*p:foo*/A./*p:foo.A*/O, + i: /*p:foo*/I, + ni: /*p:foo*/I./*p:foo.I*/NI, + obj: /*p:foo*/Obj, + e: /*p:foo*/E +) {} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.K1.kt.new.2 b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.K1.kt.new.2 new file mode 100644 index 00000000000..ad76762a775 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.K1.kt.new.2 @@ -0,0 +1,54 @@ +package foo + +import bar.* + +/*p:foo*/fun usages(i: /*p:foo*/I) { + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/a + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/b + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/c + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/d = "new value" + /*p:foo p:foo(invoke) p:foo.A.Companion(invoke)*/A()./*p:foo.A*/foo() + /*p:foo*/A./*p:foo.A p:foo.A.B.CO(invoke) p:foo.A.Companion*/B()./*p:foo.A.B*/a + /*p:foo*/A./*p:foo.A*/B./*p:foo.A.B p:foo.A.B.CO*/bar(1) + /*p:foo*/A./*p:foo.A*/B./*p:foo.A.B*/CO./*p:foo.A.B.CO*/bar(1) + /*p:foo p:foo.A(Companion)*/A + /*p:foo*/A./*p:foo.A p:foo.A.Companion*/a + /*p:foo*/A./*p:foo.A p:foo.A.Companion*/baz() + /*p:foo p:foo.A(Companion)*/A./*p:foo.A p:foo.A.Companion*/Companion + /*p:foo*/A./*p:foo.A*/Companion./*p:foo.A.Companion*/baz() + /*p:foo p:foo.A(O)*/A./*p:foo.A p:foo.A.Companion*/O + /*p:foo*/A./*p:foo.A*/O./*p:foo.A.O*/v = "OK" + /*p:foo*/A./*p:bar p:foo p:foo.A p:foo.A.Companion p:foo.A.Companion(getVALA) p:foo.A.Companion(getVala) p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/vala + /*p:foo*/A./*p:bar p:foo p:foo.A p:foo.A.Companion p:foo.A.Companion(getVARA) p:foo.A.Companion(getVara) p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/vara() + + /*p:foo(I)*/i./*p:foo.I*/a = 2 + /*p:foo*/Obj./*p:foo.Obj*/a + /*p:foo*/Obj./*p:foo.Obj*/foo() + var ii: /*p:foo*/I = /*p:foo*/Obj + /*p:foo(I)*/ii./*p:foo.I*/a + /*p:foo(I)*/ii./*p:foo.I*/foo() + /*p:foo*/Obj./*p:foo.Obj*/b + val iii = /*p:foo p:foo(I)*/Obj./*p:foo.Obj*/bar() + /*p:foo(I)*/iii./*p:foo.I*/foo() + + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/X + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/X./*p:foo.E*/a + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/Y./*p:foo.E*/foo() + /*p:bar p:foo p:java.lang p:kotlin p:kotlin(Array) p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/values() + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/valueOf("") + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/foo + /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:foo.E*/bar() +} + +/*p:foo*/fun classifiers( + a: /*p:foo*/A, + ab: /*p:foo*/A./*p:foo.A*/B, + ac: /*p:foo*/A./*p:foo.A*/C, + abCo: /*p:foo*/A./*p:foo.A*/B./*p:foo.A.B*/CO, + aCompanion: /*p:foo*/A./*p:foo.A*/Companion, + aO: /*p:foo*/A./*p:foo.A*/O, + i: /*p:foo*/I, + ni: /*p:foo*/I./*p:foo.I*/NI, + obj: /*p:foo*/Obj, + e: /*p:foo*/E +) {} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/comparison.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/comparison.K1.kt new file mode 100644 index 00000000000..c93675adaa4 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/comparison.K1.kt @@ -0,0 +1,18 @@ +package foo.bar + +/*p:foo.bar*/fun testComparisons(a: /*p:foo.bar*/A, b: /*p:foo.bar*/Int, c: /*p:foo.bar*/Any, na: /*p:foo.bar*/A?) { + /*p:foo.bar(A)*/a /*p:foo.bar.A(equals)*/== c + /*p:foo.bar(A)*/a /*p:foo.bar.A(equals)*/!= c + /*p:foo.bar(A)*/na /*p:foo.bar.A(equals)*/== /*p:foo.bar(A)*/a + /*p:foo.bar(A)*/na /*p:foo.bar.A(equals)*/== /*p:kotlin(Nothing)*/null + + /*p:foo.bar(A)*/a /*p:foo.bar.A(compareTo)*/> b + /*p:foo.bar(A)*/a /*p:foo.bar.A(compareTo)*/< b + /*p:foo.bar(A)*/a /*p:foo.bar.A(compareTo)*/>= b + /*p:foo.bar(A)*/a /*p:foo.bar.A(compareTo)*/<= b + + /*p:foo.bar(A)*/a /*p:foo.bar(compareTo) p:foo.bar.A(compareTo) p:foo.bar.A(getCOMPARETo) p:foo.bar.A(getCompareTo)*/> c + /*p:foo.bar(A)*/a /*p:foo.bar(compareTo) p:foo.bar.A(compareTo) p:foo.bar.A(getCOMPARETo) p:foo.bar.A(getCompareTo)*/< c + /*p:foo.bar(A)*/a /*p:foo.bar(compareTo) p:foo.bar.A(compareTo) p:foo.bar.A(getCOMPARETo) p:foo.bar.A(getCompareTo)*/>= c + /*p:foo.bar(A)*/a /*p:foo.bar(compareTo) p:foo.bar.A(compareTo) p:foo.bar.A(getCOMPARETo) p:foo.bar.A(getCompareTo)*/<= c +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/declarations.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/declarations.K1.kt new file mode 100644 index 00000000000..a2913184e5c --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/declarations.K1.kt @@ -0,0 +1,35 @@ +package foo.bar + +/*p:foo.bar*/class A { + operator fun plus(a: /*p:foo.bar p:foo.bar.A*/Int) = /*p:foo.bar(A)*/this + operator fun timesAssign(a: /*p:foo.bar p:foo.bar.A*/Any?) {} + operator fun inc(): /*p:foo.bar p:foo.bar.A*/A = /*p:foo.bar(A)*/this + + operator fun get(i: /*p:foo.bar p:foo.bar.A*/Int) = 1 + operator fun contains(a: /*p:foo.bar p:foo.bar.A*/Int): /*p:foo.bar p:foo.bar.A*/Boolean = false + operator fun invoke() {} + + operator fun compareTo(a: /*p:foo.bar p:foo.bar.A*/Int) = 0 + + operator fun component1() = /*p:foo.bar(A)*/this + + operator fun iterator() = /*p:foo.bar(A)*/this + operator fun next() = /*p:foo.bar(A)*/this +} + +/*p:foo.bar*/operator fun /*p:foo.bar*/A.minus(a: /*p:foo.bar*/Int) = /*p:foo.bar(A)*/this +/*p:foo.bar*/operator fun /*p:foo.bar*/A.divAssign(a: /*p:foo.bar*/Any?) {} +/*p:foo.bar*/operator fun /*p:foo.bar*/A.dec(): /*p:foo.bar*/A = /*p:foo.bar(A)*/this + +/*p:foo.bar*/operator fun /*p:foo.bar*/A.not() {} + +/*p:foo.bar*/operator fun /*p:foo.bar*/A.set(i: /*p:foo.bar*/Int, v: /*p:foo.bar*/Int) {} +/*p:foo.bar*/operator fun /*p:foo.bar*/A.contains(a: /*p:foo.bar*/Any): /*p:foo.bar*/Boolean = true +/*p:foo.bar*/operator fun /*p:foo.bar*/A.invoke(i: /*p:foo.bar*/Int) {} + +/*p:foo.bar*/operator fun /*p:foo.bar*/A.compareTo(a: /*p:foo.bar*/Any) = 0 + +/*p:foo.bar*/operator fun /*p:foo.bar*/A.component2() = /*p:foo.bar(A)*/this + +/*p:foo.bar*/operator fun /*p:foo.bar*/A?.iterator() = /*p:foo.bar(A)*/this!! +/*p:foo.bar*/operator fun /*p:foo.bar*/A.hasNext(): /*p:foo.bar*/Boolean = false diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/delegateProperty.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/delegateProperty.K1.kt new file mode 100644 index 00000000000..0cd17f2f9d0 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/delegateProperty.K1.kt @@ -0,0 +1,30 @@ +package foo.bar + +/*p:kotlin.reflect(KProperty)*/import kotlin.reflect.KProperty + +/*p:foo.bar*/class D1 { + operator fun getValue(t: /*p:foo.bar p:foo.bar.D1*/Any?, p: /*p:foo.bar.D1 p:kotlin.reflect*/KProperty<*>) = 1 +} + +/*p:foo.bar*/operator fun /*p:foo.bar*/D1.setValue(t: /*p:foo.bar*/Any?, p: /*p:kotlin.reflect*/KProperty<*>, v: /*p:foo.bar*/Int) {} + +/*p:foo.bar(D2)*/open class D2 { + operator fun setValue(t: /*p:foo.bar p:foo.bar.D2*/Any?, p: /*p:foo.bar.D2 p:kotlin.reflect*/KProperty<*>, v: /*p:foo.bar p:foo.bar.D2*/Int) {} +} + +/*p:foo.bar*/operator fun /*p:foo.bar*/D2.getValue(t: /*p:foo.bar*/Any?, p: /*p:kotlin.reflect*/KProperty<*>) = 1 +/*p:foo.bar*/operator fun /*p:foo.bar*/D2.provideDelegate(p: /*p:foo.bar*/Any?, k: /*p:foo.bar*/Any) = /*p:foo.bar(D2)*/this + +/*p:foo.bar*/class D3 : /*p:foo.bar*/D2() { + operator fun provideDelegate(p: /*p:foo.bar p:foo.bar.D2 p:foo.bar.D3*/Any?, k: /*p:foo.bar p:foo.bar.D2 p:foo.bar.D3*/Any) = /*p:foo.bar(D3)*/this +} + + +/*p:foo.bar*/val x1 by /*p:foo.bar p:foo.bar(provideDelegate) p:foo.bar.D1(getPROVIDEDelegate) p:foo.bar.D1(getProvideDelegate) p:foo.bar.D1(getValue) p:foo.bar.D1(provideDelegate) p:java.lang(provideDelegate) p:kotlin(provideDelegate) p:kotlin.annotation(provideDelegate) p:kotlin.collections(provideDelegate) p:kotlin.comparisons(provideDelegate) p:kotlin.io(provideDelegate) p:kotlin.jvm(provideDelegate) p:kotlin.ranges(provideDelegate) p:kotlin.sequences(provideDelegate) p:kotlin.text(provideDelegate)*/D1() +/*p:foo.bar*/var y1 by /*p:foo.bar p:foo.bar(provideDelegate) p:foo.bar(setValue) p:foo.bar.D1(getPROVIDEDelegate) p:foo.bar.D1(getProvideDelegate) p:foo.bar.D1(getSETValue) p:foo.bar.D1(getSetValue) p:foo.bar.D1(getValue) p:foo.bar.D1(provideDelegate) p:foo.bar.D1(setValue) p:java.lang(provideDelegate) p:kotlin(provideDelegate) p:kotlin.annotation(provideDelegate) p:kotlin.collections(provideDelegate) p:kotlin.comparisons(provideDelegate) p:kotlin.io(provideDelegate) p:kotlin.jvm(provideDelegate) p:kotlin.ranges(provideDelegate) p:kotlin.sequences(provideDelegate) p:kotlin.text(provideDelegate)*/D1() + +/*p:foo.bar*/val x2 by /*p:foo.bar p:foo.bar(getValue) p:foo.bar(provideDelegate) p:foo.bar.D2(getGETValue) p:foo.bar.D2(getGetValue) p:foo.bar.D2(getPROVIDEDelegate) p:foo.bar.D2(getProvideDelegate) p:foo.bar.D2(getValue) p:foo.bar.D2(provideDelegate)*/D2() +/*p:foo.bar*/var y2 by /*p:foo.bar p:foo.bar(getValue) p:foo.bar(provideDelegate) p:foo.bar.D2(getGETValue) p:foo.bar.D2(getGetValue) p:foo.bar.D2(getPROVIDEDelegate) p:foo.bar.D2(getProvideDelegate) p:foo.bar.D2(getValue) p:foo.bar.D2(provideDelegate) p:foo.bar.D2(setValue)*/D2() + +/*p:foo.bar*/val x3 by /*p:foo.bar p:foo.bar(getValue) p:foo.bar.D2(getValue) p:foo.bar.D2(provideDelegate) p:foo.bar.D3(getGETValue) p:foo.bar.D3(getGetValue) p:foo.bar.D3(getValue) p:foo.bar.D3(provideDelegate)*/D3() +/*p:foo.bar*/var y3 by /*p:foo.bar p:foo.bar(getValue) p:foo.bar.D2(getValue) p:foo.bar.D2(provideDelegate) p:foo.bar.D2(setValue) p:foo.bar.D3(getGETValue) p:foo.bar.D3(getGetValue) p:foo.bar.D3(getValue) p:foo.bar.D3(provideDelegate) p:foo.bar.D3(setValue)*/D3() diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/mathematicalLike.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/mathematicalLike.K1.kt new file mode 100644 index 00000000000..d21eb16b743 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/mathematicalLike.K1.kt @@ -0,0 +1,24 @@ +package foo.bar + +/*p:foo.bar*/fun testOperators(a: /*p:foo.bar*/A, b: /*p:foo.bar*/Int) { + var d = /*p:foo.bar(A)*/a + + /*p:foo.bar(A)*/d/*p:foo.bar.A(inc)*/++ + /*p:foo.bar(A) p:foo.bar.A(inc)*/++/*p:foo.bar(A)*/d + /*p:foo.bar(A)*/d/*p:foo.bar(dec) p:foo.bar.A(dec) p:foo.bar.A(getDEC) p:foo.bar.A(getDec)*/-- + /*p:foo.bar(A) p:foo.bar(dec) p:foo.bar.A(dec) p:foo.bar.A(getDEC) p:foo.bar.A(getDec)*/--/*p:foo.bar(A)*/d + + /*p:foo.bar(A)*/a /*p:foo.bar.A(plus)*/+ b + /*p:foo.bar(A)*/a /*p:foo.bar(minus) p:foo.bar.A(getMINUS) p:foo.bar.A(getMinus) p:foo.bar.A(minus)*/- b + /*p:foo.bar(not) p:foo.bar.A(getNOT) p:foo.bar.A(getNot) p:foo.bar.A(not)*/!/*p:foo.bar(A)*/a + + // for val + /*p:foo.bar(A)*/a /*p:foo.bar.A(timesAssign)*/*= b + /*p:foo.bar(A)*/a /*p:foo.bar(divAssign) p:foo.bar.A(divAssign) p:foo.bar.A(getDIVAssign) p:foo.bar.A(getDivAssign)*//= b + + // for var + /*p:foo.bar(A)*/d /*p:foo.bar(plusAssign) p:foo.bar.A(getPLUSAssign) p:foo.bar.A(getPlusAssign) p:foo.bar.A(plus) p:foo.bar.A(plusAssign) p:java.lang(plusAssign) p:kotlin(plusAssign) p:kotlin.annotation(plusAssign) p:kotlin.collections(plusAssign) p:kotlin.comparisons(plusAssign) p:kotlin.io(plusAssign) p:kotlin.jvm(plusAssign) p:kotlin.ranges(plusAssign) p:kotlin.sequences(plusAssign) p:kotlin.text(plusAssign)*/+= b + /*p:foo.bar(A)*/d /*p:foo.bar(minus) p:foo.bar(minusAssign) p:foo.bar.A(getMINUS) p:foo.bar.A(getMINUSAssign) p:foo.bar.A(getMinus) p:foo.bar.A(getMinusAssign) p:foo.bar.A(minus) p:foo.bar.A(minusAssign) p:java.lang(minusAssign) p:kotlin(minusAssign) p:kotlin.annotation(minusAssign) p:kotlin.collections(minusAssign) p:kotlin.comparisons(minusAssign) p:kotlin.io(minusAssign) p:kotlin.jvm(minusAssign) p:kotlin.ranges(minusAssign) p:kotlin.sequences(minusAssign) p:kotlin.text(minusAssign)*/-= b + /*p:foo.bar(A)*/d /*p:foo.bar(times) p:foo.bar.A(getTIMES) p:foo.bar.A(getTimes) p:foo.bar.A(times) p:foo.bar.A(timesAssign) p:java.lang(times) p:kotlin(times) p:kotlin.annotation(times) p:kotlin.collections(times) p:kotlin.comparisons(times) p:kotlin.io(times) p:kotlin.jvm(times) p:kotlin.ranges(times) p:kotlin.sequences(times) p:kotlin.text(times)*/*= b + /*p:foo.bar(A)*/d /*p:foo.bar(div) p:foo.bar(divAssign) p:foo.bar.A(div) p:foo.bar.A(divAssign) p:foo.bar.A(getDIV) p:foo.bar.A(getDIVAssign) p:foo.bar.A(getDiv) p:foo.bar.A(getDivAssign) p:java.lang(div) p:kotlin(div) p:kotlin.annotation(div) p:kotlin.collections(div) p:kotlin.comparisons(div) p:kotlin.io(div) p:kotlin.jvm(div) p:kotlin.ranges(div) p:kotlin.sequences(div) p:kotlin.text(div)*//= b +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/other.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/other.K1.kt new file mode 100644 index 00000000000..14d24dd7d25 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/conventions/other.K1.kt @@ -0,0 +1,16 @@ +package foo.bar + +/*p:foo.bar*/fun testOther(a: /*p:foo.bar*/A, b: /*p:foo.bar*/Int, c: /*p:foo.bar*/Any, na: /*p:foo.bar*/A?) { + /*p:foo.bar(A) p:foo.bar(set) p:foo.bar.A(getSET) p:foo.bar.A(getSet) p:foo.bar.A(set)*/a[1] = /*p:foo.bar(A) p:foo.bar.A(get)*/a[2] + + b /*p:foo.bar.A(contains)*/in /*p:foo.bar(A)*/a + "s" /*p:foo.bar(contains) p:foo.bar.A(contains) p:foo.bar.A(getCONTAINS) p:foo.bar.A(getContains)*/!in /*p:foo.bar(A)*/a + + /*p:foo.bar.A(invoke)*/a() + /*p:foo.bar p:foo.bar(invoke) p:foo.bar.A(invoke)*/a(1) + + val (/*p:foo.bar.A(component1)*/h, /*p:foo.bar(component2) p:foo.bar.A(component2) p:foo.bar.A(getComponent2)*/t) = /*p:foo.bar(A)*/a; + + for ((/*p:foo.bar.A(component1)*/f, /*p:foo.bar(component2) p:foo.bar.A(component2) p:foo.bar.A(getComponent2)*/s) in /*p:foo.bar(A) p:foo.bar(hasNext) p:foo.bar.A(getHASNext) p:foo.bar.A(getHasNext) p:foo.bar.A(hasNext) p:foo.bar.A(iterator) p:foo.bar.A(next)*/a); + for ((/*p:foo.bar.A(component1)*/f, /*p:foo.bar(component2) p:foo.bar.A(component2) p:foo.bar.A(getComponent2)*/s) in /*p:foo.bar(A) p:foo.bar(hasNext) p:foo.bar(iterator) p:foo.bar.A(getHASNext) p:foo.bar.A(getHasNext) p:foo.bar.A(getITERATOR) p:foo.bar.A(getIterator) p:foo.bar.A(hasNext) p:foo.bar.A(iterator) p:foo.bar.A(next)*/na); +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/genericType.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/genericType.K1.kt new file mode 100644 index 00000000000..7ea9ee39aef --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/genericType.K1.kt @@ -0,0 +1,15 @@ +package foo + +// From KT-10772 Problem with daemon on Idea 15.0.3 & 1-dev-25 + +/*p:foo*/fun identity(): (T) -> T = /*p:kotlin(Function1) p:kotlin(Nothing)*/null as (T) -> T + +/*p:foo*/fun compute(f: () -> T) { + val result = f() +} + +/*p:foo*/class Bar(val t: T) { + init { + val a = /*p:foo.Bar p:foo.Bar(T)*/t + } +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/inferredType.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/inferredType.K1.kt new file mode 100644 index 00000000000..7bc5b359e03 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/inferredType.K1.kt @@ -0,0 +1,19 @@ +package foo + +/*p:foo(A)*/open class A +/*p:foo*/class B : /*p:foo*/A() + +/*p:foo*/fun getA() = /*p:foo*/A() +/*p:foo*/fun getB() = /*p:foo*/B() + +/*p:foo*/fun getListOfA() = /*p:foo p:foo(A) p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.collections(List) p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/listOf(/*p:foo*/A()) +/*p:foo*/fun getListOfB() = /*p:foo p:foo(B) p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.collections(List) p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/listOf(/*p:foo*/B()) + +/*p:foo*/fun useListOfA(a: /*p:foo p:kotlin.collections*/List) {} +/*p:foo*/fun useListOfB(b: /*p:foo p:kotlin.collections*/List) {} + +/*p:foo*/fun testInferredType() { + /*p:foo*/useListOfA(/*p:foo p:foo(A) p:kotlin.collections(List)*/getListOfA()) + /*p:foo*/useListOfA(/*p:foo p:foo(B) p:kotlin.collections(List)*/getListOfB()) + /*p:foo*/useListOfB(/*p:foo p:foo(B) p:kotlin.collections(List)*/getListOfB()) +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/lambdaParameterType.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/lambdaParameterType.K1.kt new file mode 100644 index 00000000000..813b778c839 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/lambdaParameterType.K1.kt @@ -0,0 +1,11 @@ +package foo + +/*p:foo*/class C + +/*p:foo*/fun lambdaConsumer(fn: (/*p:foo*/A)->/*p:foo*/Unit) {} +/*p:foo*/fun extensionConsumer(fn: /*p:foo*/A.()->/*p:foo*/Unit) {} + +/*p:foo*/fun testLambdaParameterType() { + /*p:foo*/lambdaConsumer /*p:foo(A) p:kotlin(Function1)*/{ /*p:foo(A)*/it } + /*p:foo*/extensionConsumer /*p:foo(A) p:kotlin(Function1)*/{ /*p:foo(A)*/this } +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/build.log b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/build.log index 658cff6795c..1c3639643d7 100644 --- a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/build.log +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/build.log @@ -2,5 +2,5 @@ Compiling files: src/usages.kt Exit code: COMPILATION_ERROR - Unresolved reference 'IS'. - Unresolved reference 'IS'. \ No newline at end of file + Unresolved reference: IS + Unresolved reference: IS \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/fir-build.log b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/fir-build.log new file mode 100644 index 00000000000..658cff6795c --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/fir-build.log @@ -0,0 +1,6 @@ +==== INITIAL BUILD ==== +Compiling files: + src/usages.kt +Exit code: COMPILATION_ERROR + Unresolved reference 'IS'. + Unresolved reference 'IS'. \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/usages.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/usages.K1.kt new file mode 100644 index 00000000000..5c944736ebc --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/java/usages.K1.kt @@ -0,0 +1,45 @@ +package foo + +/*p:bar(C)*/import bar.C +import baz.* + +/*p:foo*/fun usages() { + val c = /*p:bar*/C() + + /*p:bar(C)*/c./*p:bar.C*/field + /*p:bar(C)*/c./*p:bar.C*/field = 2 + /*p:bar(C)*/c./*p:bar.C*/func() + /*p:bar(C) p:bar.C(B)*/c./*p:bar.C*/B() + + /*p:bar p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/C./*p:bar.C*/sfield + /*p:bar p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/C./*p:bar.C*/sfield = "new" + /*p:bar p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/C./*p:bar.C*/sfunc() + /*p:bar p:bar.C(S) p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/C./*p:bar.C*/S() + + // inherited from I + /*p:bar(C)*/c./*p:bar.C*/ifunc() + /*p:bar p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/C./*p:bar.C*/isfield + // expected error: Unresolved reference: IS + /*p:bar p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/C./*p:bar.C*/IS() + + + val i: /*p:foo*/I = /*p:bar(C)*/c + /*p:foo(I)*/i./*p:foo.I*/ifunc() + + /*p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/I./*p:foo.I*/isfield + /*p:baz p:foo p:foo.I(IS) p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/I./*p:foo.I*/IS() + + /*p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:baz.E*/F + /*p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:baz.E*/F./*p:baz.E*/field + /*p:baz p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/E./*p:baz.E*/S./*p:baz.E*/func() +} + +/*p:foo*/fun classifiers( + c: /*p:bar*/C, + b: /*p:bar*/C./*p:bar.C*/B, + s: /*p:bar*/C./*p:bar.C*/S, + cis: /*p:bar*/C./*p:bar.C*/IS, + i: /*p:foo*/I, + iis: /*p:foo*/I./*p:foo.I*/IS, + e: /*p:baz p:foo*/E +) {} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/A.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/A.K1.kt new file mode 100644 index 00000000000..463469d362f --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/A.K1.kt @@ -0,0 +1,6 @@ +package foo + +/*p:foo(A)*/open class A { + @/*p:foo p:foo.A p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/JvmName("g") + fun f() {} +} \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/A.K1.kt.new b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/A.K1.kt.new new file mode 100644 index 00000000000..bf1ee6b1bc8 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/A.K1.kt.new @@ -0,0 +1,6 @@ +package foo + +/*p:foo(A)*/open class A { + @/*p:foo p:foo.A p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/JvmName("h") + fun f() {} +} \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/useAChild.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/useAChild.K1.kt new file mode 100644 index 00000000000..b4b27df80fa --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/jvmNameChanged/useAChild.K1.kt @@ -0,0 +1,5 @@ +package foo + +/*p:foo*/fun useAChild(a: /*p:foo*/AChild) { + /*p:foo(AChild)*/a./*p:foo.A p:foo.AChild*/f() +} \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/localDeclarations/locals.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/localDeclarations/locals.K1.kt new file mode 100644 index 00000000000..88ccf7e6b7b --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/localDeclarations/locals.K1.kt @@ -0,0 +1,49 @@ +package local.declarations + +import bar.* + +/*p:local.declarations*/fun f(p: /*p:local.declarations*/Any) { + p.toString() + + val a = 1 + val b = a + fun localFun() = b + fun /*p:local.declarations*/Int.localExtFun() = localFun() + + abstract class LocalI { + abstract var a: /*p:local.declarations*/Int + abstract fun foo() + } + + class LocalC : LocalI() { + override var a = 1 + + override fun foo() {} + + var b = "bbb" + + fun bar() = b + } + + val o = object { + val a = "aaa" + fun foo(): LocalI = /*p:kotlin(Nothing)*/null as LocalI + } + + localFun() + 1./*p:kotlin.Int(getLOCALExtFun) p:kotlin.Int(getLocalExtFun)*/localExtFun() + + val c = LocalC() + c.a + c.b + c.foo() + c.bar() + + val i: LocalI = c + i.a + i.foo() + + o.a + val ii = o.foo() + ii.a +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/packageDeclarations/foo1.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/packageDeclarations/foo1.K1.kt new file mode 100644 index 00000000000..df5b2d9ed0f --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/packageDeclarations/foo1.K1.kt @@ -0,0 +1,17 @@ +package foo + +import bar.* +/*p:baz(C)*/import baz.C + +/*p:foo*/val a = /*p:bar p:foo*/A() +/*p:foo*/var b: /*p:bar p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/baz./*p:baz*/B = /*p:bar p:baz(B) p:foo p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/baz./*p:baz*/B() + +/*p:foo*/fun function(p: /*p:bar p:foo*/B): /*p:bar p:foo*/B /*p:kotlin(Nothing)*/{ + /*p:bar(A) p:foo*/a + /*p:kotlin(Nothing)*/return /*p:bar p:foo*/B() +} + +/*p:foo*/fun /*p:foo*/MyClass.extFunc(p: /**p:foo p:bar*//*p:foo p:kotlin*/Array, e: /*p:foo*/MyEnum, c: /**???*//*p:baz*/C): /*p:foo*/MyInterface /*p:kotlin(Nothing)*/{ + /*p:bar p:baz(B) p:foo p:foo.MyClass p:foo.MyClass(getB) p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/b + /*p:kotlin(Nothing)*/return /*p:bar p:foo p:foo.MyClass p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/MyClass() +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/simple/main.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/simple/main.K1.kt new file mode 100644 index 00000000000..c97ea456f9e --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/simple/main.K1.kt @@ -0,0 +1,6 @@ +package foo.bar + +/*p:foo.bar*/fun main(args: /*p:foo.bar p:kotlin*/Array) { + val f: /*p:foo.bar p:kotlin*/Array + val s: /*p:foo.bar*/String +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/KotlinClass.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/KotlinClass.K1.kt new file mode 100644 index 00000000000..d61e7a8018a --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/KotlinClass.K1.kt @@ -0,0 +1,8 @@ +package foo + +/*p:(JavaClass)*/import JavaClass + +/*p:foo*/class KotlinClass : /*p:*/JavaClass() { + override fun getFoo() = 2 + fun setFoo(i: /*p:JavaClass p:foo p:foo.KotlinClass*/Int) {} +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/build.log b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/build.log index 4ace544b6cd..28132674392 100644 --- a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/build.log +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/build.log @@ -3,19 +3,11 @@ Compiling files: src/KotlinClass.kt src/usages.kt Exit code: COMPILATION_ERROR - Unresolved reference 'setFoo'. - 'val' cannot be reassigned. - Overload resolution ambiguity between candidates: -var bazBaz: Int -val bazBaz: Int - Overload resolution ambiguity between candidates: -var bazBaz: Int -val bazBaz: Int - Unresolved reference 'boo'. - Overload resolution ambiguity between candidates: -var bazBaz: Int -val bazBaz: Int - Overload resolution ambiguity between candidates: -var bazBaz: Int -val bazBaz: Int - Unresolved reference 'boo'. \ No newline at end of file + Unresolved reference: setFoo + Val cannot be reassigned + Unresolved reference: bazBaz + Unresolved reference: bazBaz + Unresolved reference: boo + Unresolved reference: bazBaz + Unresolved reference: bazBaz + Unresolved reference: boo \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/fir-build.log b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/fir-build.log new file mode 100644 index 00000000000..4ace544b6cd --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/fir-build.log @@ -0,0 +1,21 @@ +==== INITIAL BUILD ==== +Compiling files: + src/KotlinClass.kt + src/usages.kt +Exit code: COMPILATION_ERROR + Unresolved reference 'setFoo'. + 'val' cannot be reassigned. + Overload resolution ambiguity between candidates: +var bazBaz: Int +val bazBaz: Int + Overload resolution ambiguity between candidates: +var bazBaz: Int +val bazBaz: Int + Unresolved reference 'boo'. + Overload resolution ambiguity between candidates: +var bazBaz: Int +val bazBaz: Int + Overload resolution ambiguity between candidates: +var bazBaz: Int +val bazBaz: Int + Unresolved reference 'boo'. \ No newline at end of file diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/usages.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/usages.K1.kt new file mode 100644 index 00000000000..e7dd774fb21 --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/usages.K1.kt @@ -0,0 +1,30 @@ +package foo.bar + +/*p:(JavaClass)*/import JavaClass +/*p:foo(KotlinClass)*/import foo.KotlinClass + +/*p:foo.bar*/fun test() { + val j = /*p:*/JavaClass() + val k = /*p:foo*/KotlinClass() + + /*p:(JavaClass)*/j./*p:JavaClass*/getFoo() + /*p:(JavaClass)*/j./*p:JavaClass p:JavaClass(getSETFoo) p:JavaClass(getSetFoo) p:foo.bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/setFoo(2) + /*p:(JavaClass)*/j./*p:JavaClass p:JavaClass(getFOO) p:JavaClass(getFoo) p:JavaClass(setFoo)*/foo = 2 + /*p:(JavaClass)*/j./*p:JavaClass p:JavaClass(getFOO) p:JavaClass(getFoo) p:JavaClass(setFoo)*/foo + /*p:(JavaClass)*/j./*p:JavaClass p:JavaClass(getBAR) p:JavaClass(getBar) p:JavaClass(setBar)*/bar + /*p:(JavaClass)*/j./*p:JavaClass p:JavaClass(getBAR) p:JavaClass(getBar) p:JavaClass(setBar)*/bar = "" + /*p:(JavaClass)*/j./*p:JavaClass p:JavaClass(getBAZBaz) p:JavaClass(getBazBaz) p:foo.bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/bazBaz + /*p:(JavaClass)*/j./*p:JavaClass p:JavaClass(getBAZBaz) p:JavaClass(getBazBaz) p:foo.bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/bazBaz = "" + /*p:(JavaClass)*/j./*p:JavaClass*/setBoo(2) + /*p:(JavaClass)*/j./*p:JavaClass p:JavaClass(getBOO) p:JavaClass(getBoo) p:foo.bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/boo = 2 + /*p:foo(KotlinClass)*/k./*p:JavaClass p:foo.KotlinClass*/getFoo() // getFoo may be an inner class in JavaClass + /*p:foo(KotlinClass)*/k./*p:JavaClass p:foo.KotlinClass*/setFoo(2) + /*p:foo(KotlinClass)*/k./*p:foo.KotlinClass p:foo.KotlinClass(getFOO) p:foo.KotlinClass(getFoo) p:foo.KotlinClass(setFoo)*/foo = 2 + /*p:foo(KotlinClass)*/k./*p:foo.KotlinClass p:foo.KotlinClass(getFOO) p:foo.KotlinClass(getFoo) p:foo.KotlinClass(setFoo)*/foo + /*p:foo(KotlinClass)*/k./*p:foo.KotlinClass p:foo.KotlinClass(getBAR) p:foo.KotlinClass(getBar) p:foo.KotlinClass(setBar)*/bar + /*p:foo(KotlinClass)*/k./*p:foo.KotlinClass p:foo.KotlinClass(getBAR) p:foo.KotlinClass(getBar) p:foo.KotlinClass(setBar)*/bar = "" + /*p:foo(KotlinClass)*/k./*p:JavaClass p:foo.KotlinClass p:foo.KotlinClass(getBAZBaz) p:foo.KotlinClass(getBazBaz) p:foo.bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/bazBaz + /*p:foo(KotlinClass)*/k./*p:JavaClass p:foo.KotlinClass p:foo.KotlinClass(getBAZBaz) p:foo.KotlinClass(getBazBaz) p:foo.bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/bazBaz = "" + /*p:foo(KotlinClass)*/k./*p:JavaClass p:foo.KotlinClass*/setBoo(2) + /*p:foo(KotlinClass)*/k./*p:JavaClass p:foo.KotlinClass p:foo.KotlinClass(getBOO) p:foo.KotlinClass(getBoo) p:foo.bar p:java.lang p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.comparisons p:kotlin.io p:kotlin.jvm p:kotlin.ranges p:kotlin.sequences p:kotlin.text*/boo = 2 +} diff --git a/jps/jps-plugin/testData/incremental/lookupTracker/jvm/typeAliasAndUsage/usage.K1.kt b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/typeAliasAndUsage/usage.K1.kt new file mode 100644 index 00000000000..329997836ea --- /dev/null +++ b/jps/jps-plugin/testData/incremental/lookupTracker/jvm/typeAliasAndUsage/usage.K1.kt @@ -0,0 +1,5 @@ +package top + +/*p:top*/fun typeAliasUsage(a: /*p:top*/TypeAlias) { + /*p:top(Foo)*/a./*p:top.Foo*/prop +}