Fix incremental build after changing Java const used as class property

Report Java static final constant with InlineConstantTracker, used as class property in Kotlin for further registration in JPS

#KT-49177 Fixed

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt

@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.frontend.java.di.initJvmBuiltInsForTopDownAnalysis
 import org.jetbrains.kotlin.frontend.java.di.initialize
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.ir.backend.jvm.jvmLibrariesProvidedByDefault
 import org.jetbrains.kotlin.javac.components.JavacBasedClassFinder
 import org.jetbrains.kotlin.javac.components.JavacBasedSourceElementFactory
@@ -160,6 +161,7 @@ object TopDownAnalyzerFacadeForJVM {
         val incrementalComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)
         val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: LookupTracker.DO_NOTHING
         val expectActualTracker = configuration.get(CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER) ?: ExpectActualTracker.DoNothing
+        val inlineConstTracker = configuration.get(CommonConfigurationKeys.INLINE_CONST_TRACKER) ?: InlineConstTracker.DoNothing
         val targetIds = configuration.get(JVMConfigurationKeys.MODULES)?.map(::TargetId)
 
         val separateModules = !configuration.getBoolean(JVMConfigurationKeys.USE_SINGLE_MODULE)
@@ -194,7 +196,7 @@ object TopDownAnalyzerFacadeForJVM {
             val dependenciesContainer = createContainerForLazyResolveWithJava(
                 jvmPlatform,
                 dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, moduleClassResolver,
-                targetEnvironment, lookupTracker, expectActualTracker,
+                targetEnvironment, lookupTracker, expectActualTracker, inlineConstTracker,
                 packagePartProvider(dependencyScope), languageVersionSettings,
                 useBuiltInsProvider = true,
                 configureJavaClassFinder = configureJavaClassFinder,
@@ -229,7 +231,7 @@ object TopDownAnalyzerFacadeForJVM {
         val container = createContainerForLazyResolveWithJava(
             jvmPlatform,
             moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, moduleClassResolver,
-            targetEnvironment, lookupTracker, expectActualTracker,
+            targetEnvironment, lookupTracker, expectActualTracker, inlineConstTracker,
             partProvider, languageVersionSettings,
             useBuiltInsProvider = true,
             configureJavaClassFinder = configureJavaClassFinder,

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.frontend.di.configureIncrementalCompilation
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.frontend.di.configureStandardResolveComponents
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.java.AbstractJavaClassFinder
 import org.jetbrains.kotlin.load.java.InternalFlexibleTypeTransformer
@@ -61,6 +62,7 @@ fun createContainerForLazyResolveWithJava(
     targetEnvironment: TargetEnvironment,
     lookupTracker: LookupTracker,
     expectActualTracker: ExpectActualTracker,
+    inlineConstTracker: InlineConstTracker,
     packagePartProvider: PackagePartProvider,
     languageVersionSettings: LanguageVersionSettings,
     useBuiltInsProvider: Boolean,
@@ -74,7 +76,7 @@ fun createContainerForLazyResolveWithJava(
         sealedInheritorsProvider
     )
 
-    configureIncrementalCompilation(lookupTracker, expectActualTracker)
+    configureIncrementalCompilation(lookupTracker, expectActualTracker, inlineConstTracker)
     configureStandardResolveComponents()
 
     useInstance(moduleContentScope)

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmResolverForModuleFactory.kt

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
 import org.jetbrains.kotlin.load.java.structure.JavaClass
@@ -112,6 +113,7 @@ class JvmResolverForModuleFactory(
             targetEnvironment,
             lookupTracker,
             ExpectActualTracker.DoNothing,
+            InlineConstTracker.DoNothing,
             packagePartProvider,
             languageVersionSettings,
             sealedInheritorsProvider = sealedInheritorsProvider,

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt

@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.frontend.di.configureStandardResolveComponents
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.load.kotlin.MetadataFinderFactory
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
@@ -244,6 +245,7 @@ private fun createContainerToResolveCommonCode(
         if (shouldCheckExpectActual) {
             useImpl<ExpectedActualDeclarationChecker>()
         }
+        useInstance(InlineConstTracker.DoNothing)
     }
 
 fun StorageComponentContainer.configureCommonSpecificComponents() {

compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.contracts.ContractDeserializerImpl
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
 import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.TargetPlatformVersion
@@ -126,9 +127,10 @@ fun StorageComponentContainer.configureStandardResolveComponents() {
     useImpl<AnnotationResolverImpl>()
 }
 
-fun StorageComponentContainer.configureIncrementalCompilation(lookupTracker: LookupTracker, expectActualTracker: ExpectActualTracker) {
+fun StorageComponentContainer.configureIncrementalCompilation(lookupTracker: LookupTracker, expectActualTracker: ExpectActualTracker, inlineConstTracker: InlineConstTracker) {
     useInstance(lookupTracker)
     useInstance(expectActualTracker)
+    useInstance(inlineConstTracker)
 }
 
 fun createContainerForBodyResolve(
@@ -152,6 +154,7 @@ fun createContainerForBodyResolve(
     useImpl<BodyResolver>()
     useInstance(moduleStructureOracle)
     useInstance(controlFlowInformationProviderFactory)
+    useInstance(InlineConstTracker.DoNothing)
 }
 
 fun createContainerForLazyBodyResolve(
@@ -177,6 +180,7 @@ fun createContainerForLazyBodyResolve(
     useImpl<BasicAbsentDescriptorHandler>()
     useInstance(moduleStructureOracle)
     useInstance(controlFlowInformationProviderFactory)
+    useInstance(InlineConstTracker.DoNothing)
 
     // All containers except common inject ExpectedActualDeclarationChecker, so for common we do that
     // explicitly.
@@ -201,6 +205,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(
     useInstance(localClassDescriptorHolder)
     useInstance(lookupTracker)
     useInstance(ExpectActualTracker.DoNothing)
+    useInstance(InlineConstTracker.DoNothing)
 
     useImpl<LazyTopDownAnalyzer>()
 
@@ -233,6 +238,7 @@ fun createContainerForLazyResolve(
     configureStandardResolveComponents()
 
     useInstance(declarationProviderFactory)
+    useInstance(InlineConstTracker.DoNothing)
 
 
     targetEnvironment.configure(this)

compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt

@@ -21,7 +21,10 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.diagnostics.reportDiagnosticOnce
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.resolve.descriptorUtil.isCompanionObject
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.parsing.*
@@ -55,7 +58,8 @@ import java.util.*
 class ConstantExpressionEvaluator(
     internal val module: ModuleDescriptor,
     internal val languageVersionSettings: LanguageVersionSettings,
-    project: Project
+    project: Project,
+    internal val inlineConstTracker: InlineConstTracker = InlineConstTracker.DoNothing
 ) {
     private val moduleAnnotationsResolver = ModuleAnnotationsResolver.getInstance(project)
 
@@ -382,6 +386,11 @@ private class ConstantExpressionEvaluatorVisitor(
     private val builtIns = constantExpressionEvaluator.module.builtIns
     private val defaultValueForDontCreateIntegerLiteralType =
         languageVersionSettings.supportsFeature(ApproximateIntegerLiteralTypesInReceiverPosition)
+    private val inlineConstTracker =
+        if (constantExpressionEvaluator.inlineConstTracker is InlineConstTracker.DoNothing)
+            null
+        else
+            constantExpressionEvaluator.inlineConstTracker
 
     fun evaluate(expression: KtExpression, expectedType: KotlinType?): CompileTimeConstant<*>? {
         val recordedCompileTimeConstant = ConstantExpressionEvaluator.getPossiblyErrorConstant(expression, trace.bindingContext)
@@ -798,6 +807,14 @@ private class ConstantExpressionEvaluatorVisitor(
             return EnumValue(enumClassId, enumDescriptor.name).wrap()
         }
 
+        val variableDescriptor = enumDescriptor as? VariableDescriptor
+        if (variableDescriptor != null
+            && isPropertyCompileTimeConstant(variableDescriptor)
+            && !variableDescriptor.containingDeclaration.isCompanionObject()
+        ) {
+            reportInlineConst(expression, variableDescriptor)
+        }
+
         val resolvedCall = expression.getResolvedCall(trace.bindingContext)
         if (resolvedCall != null) {
             val callableDescriptor = resolvedCall.resultingDescriptor
@@ -827,6 +844,23 @@ private class ConstantExpressionEvaluatorVisitor(
         return null
     }
 
+    private fun reportInlineConst(expression: KtSimpleNameExpression, variableDescriptor: VariableDescriptor) {
+        if (inlineConstTracker == null) return
+        val filePath = expression.containingFile.virtualFile?.path ?: return
+        val name = expression.getReferencedName()
+        val constType = variableDescriptor.type.toString()
+
+        // Transformation of fqName to the form "package.Outer$Inner"
+        val containingPackage = variableDescriptor.containingPackage()?.toString() ?: return
+        val fqName = variableDescriptor.containingDeclaration.fqNameSafe.asString()
+        val owner = if (fqName.startsWith("$containingPackage.")) {
+            containingPackage + "." + fqName.substring(containingPackage.length + 1).replace(".", "$")
+        } else {
+            fqName.replace(".", "$")
+        }
+        inlineConstTracker.report(filePath, owner, name, constType)
+    }
+
     // TODO: Should be replaced with descriptor.isConst
     private fun isPropertyCompileTimeConstant(descriptor: VariableDescriptor): Boolean {
         if (descriptor.isVar) {

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

@@ -1295,6 +1295,11 @@ public class IncrementalFirJvmCompilerRunnerTestGenerated extends AbstractIncrem
                 runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/");
             }
 
+            @TestMetadata("constantPropertyChanged")
+            public void testConstantPropertyChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/");
+            }
+
             @TestMetadata("constantUnchanged")
             public void testConstantUnchanged() throws Exception {
                 runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged/");
@@ -1459,6 +1464,19 @@ public class IncrementalFirJvmCompilerRunnerTestGenerated extends AbstractIncrem
                 }
             }
 
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ConstantPropertyChanged extends AbstractIncrementalFirJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInConstantPropertyChanged() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true);
+                }
+            }
+
             @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)

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

@@ -1295,6 +1295,11 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
                 runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/");
             }
 
+            @TestMetadata("constantPropertyChanged")
+            public void testConstantPropertyChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/");
+            }
+
             @TestMetadata("constantUnchanged")
             public void testConstantUnchanged() throws Exception {
                 runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged/");
@@ -1459,6 +1464,19 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement
                 }
             }
 
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ConstantPropertyChanged extends AbstractIncrementalJvmCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInConstantPropertyChanged() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true);
+                }
+            }
+
             @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)

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

@@ -1295,6 +1295,11 @@ public class IncrementalJvmOldBackendCompilerRunnerTestGenerated extends Abstrac
                 runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/");
             }
 
+            @TestMetadata("constantPropertyChanged")
+            public void testConstantPropertyChanged() throws Exception {
+                runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/");
+            }
+
             @TestMetadata("constantUnchanged")
             public void testConstantUnchanged() throws Exception {
                 runTest("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged/");
@@ -1459,6 +1464,19 @@ public class IncrementalJvmOldBackendCompilerRunnerTestGenerated extends Abstrac
                 }
             }
 
+            @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class ConstantPropertyChanged extends AbstractIncrementalJvmOldBackendCompilerRunnerTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInConstantPropertyChanged() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true);
+                }
+            }
+
             @TestMetadata("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava
 import org.jetbrains.kotlin.frontend.java.di.initJvmBuiltInsForTopDownAnalysis
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.config.JsConfig
@@ -212,6 +213,7 @@ class ClassicFrontendFacade(
             moduleClassResolver,
             CompilerEnvironment, LookupTracker.DO_NOTHING,
             ExpectActualTracker.DoNothing,
+            InlineConstTracker.DoNothing,
             packagePartProviderFactory(moduleContentScope),
             module.languageVersionSettings,
             useBuiltInsProvider = true

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt

@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.diagnostics.Errors.*
 import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava
 import org.jetbrains.kotlin.frontend.java.di.initJvmBuiltInsForTopDownAnalysis
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
 import org.jetbrains.kotlin.name.FqName
@@ -422,8 +423,8 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
             FileBasedDeclarationProviderFactory(moduleContext.storageManager, files),
             moduleContentScope,
             moduleClassResolver,
-            CompilerEnvironment, LookupTracker.DO_NOTHING,
+            CompilerEnvironment,
-            ExpectActualTracker.DoNothing,
+            LookupTracker.DO_NOTHING, ExpectActualTracker.DoNothing, InlineConstTracker.DoNothing,
             environment.createPackagePartProvider(moduleContentScope),
             languageVersionSettings,
             useBuiltInsProvider = true

compiler/tests-common/tests/org/jetbrains/kotlin/tests/di/injection.kt

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
 import org.jetbrains.kotlin.types.expressions.FakeCallResolver
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 
 fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
     return ContainerForTests(createContainer("Tests", JvmPlatformAnalyzerServices) {
@@ -45,6 +46,7 @@ fun createContainerForTests(project: Project, module: ModuleDescriptor): Contain
         useImpl<AnnotationResolverImpl>()
         useInstance(ModuleStructureOracle.SingleModule)
         useInstance(ControlFlowInformationProviderImpl.Factory)
+        useInstance(InlineConstTracker.DoNothing)
     })
 }
 

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/native/FakeTopDownAnalyzerFacadeForNative.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.frontend.di.configureStandardResolveComponents
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.platform.konan.NativePlatforms
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.*
@@ -57,6 +58,7 @@ private fun createFakeTopDownAnalyzerForNative(
     configureStandardResolveComponents()
 
     useInstance(declarationProviderFactory)
+    useInstance(InlineConstTracker.DoNothing)
     CompilerEnvironment.configure(this)
 }.apply {
     val moduleDescriptor = get<ModuleDescriptorImpl>()

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/JavaClass.java

@@ -1,3 +1,7 @@
 public class JavaClass {
-    public static final String CONST = "A";
+    public class Inner {
-}
+        public class InnerInner {
+            public static final String CONST = "A";
+        }
+    }
+}

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/JavaClass.java.new

@@ -1,3 +1,7 @@
 public class JavaClass {
-    public static final String CONST = "B";
+    public class Inner {
-}
+        public class InnerInner {
+            public static final String CONST = "B";
+        }
+    }
+}

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/build.log

@@ -1,6 +1,8 @@
 ================ Step #1 =================
 
 Cleaning output files:
+  out/production/module/JavaClass$Inner$InnerInner.class
+  out/production/module/JavaClass$Inner.class
   out/production/module/JavaClass.class
 End of files
 Exit code: NOTHING_DONE
@@ -10,7 +12,7 @@ Compiling files:
 End of files
 Cleaning output files:
   out/production/module/META-INF/module.kotlin_module
-  out/production/module/Usage.class
+  out/production/module/UsageKt.class
 End of files
 Compiling files:
   src/usage.kt

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/dummy.kt

@@ -0,0 +1 @@
+fun dummy() {}

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged/usage.kt

@@ -1,2 +1,5 @@
-@Deprecated(JavaClass.CONST + JavaClass.CONST)
+import JavaClass.Inner.InnerInner.CONST
-class Usage
+
+fun main() {
+    val myKotlinConst = CONST
+}

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/JavaClass.java

@@ -0,0 +1,7 @@
+public class JavaClass {
+    public class Inner {
+        public class InnerInner {
+            public static final String CONST = "A";
+        }
+    }
+}

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/JavaClass.java.new

@@ -0,0 +1,7 @@
+public class JavaClass {
+    public class Inner {
+        public class InnerInner {
+            public static final String CONST = "B";
+        }
+    }
+}

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/KotlinUsageClass.kt

@@ -0,0 +1,5 @@
+import JavaClass.Inner.InnerInner.CONST
+
+class KotlinUsageClass {
+    val myKotlinConst = CONST
+}

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/build.log

@@ -0,0 +1,21 @@
+================ Step #1 =================
+
+Cleaning output files:
+  out/production/module/JavaClass$Inner$InnerInner.class
+  out/production/module/JavaClass$Inner.class
+  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/KotlinUsageClass.class
+  out/production/module/META-INF/module.kotlin_module
+End of files
+Compiling files:
+  src/KotlinUsageClass.kt
+End of files
+Exit code: OK
+------------------------------------------

jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantPropertyChanged/dummy.kt

@@ -0,0 +1 @@
+fun dummy() {}

js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.frontend.di.configureIncrementalCompilation
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.frontend.di.configureStandardResolveComponents
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.platform.js.JsPlatforms
@@ -45,6 +46,7 @@ fun createContainerForJS(
     languageVersionSettings: LanguageVersionSettings,
     lookupTracker: LookupTracker,
     expectActualTracker: ExpectActualTracker,
+    inlineConstTracker: InlineConstTracker,
     additionalPackages: List<PackageFragmentProvider>,
     targetEnvironment: TargetEnvironment,
 ): StorageComponentContainer {
@@ -57,7 +59,7 @@ fun createContainerForJS(
             languageVersionSettings
         )
 
-        configureIncrementalCompilation(lookupTracker, expectActualTracker)
+        configureIncrementalCompilation(lookupTracker, expectActualTracker, inlineConstTracker)
         configureStandardResolveComponents()
 
         useInstance(declarationProviderFactory)
@@ -80,11 +82,12 @@ fun createTopDownAnalyzerForJs(
     languageVersionSettings: LanguageVersionSettings,
     lookupTracker: LookupTracker,
     expectActualTracker: ExpectActualTracker,
+    inlineConstTracker: InlineConstTracker,
     additionalPackages: List<PackageFragmentProvider>,
     targetEnvironment: TargetEnvironment,
 ): LazyTopDownAnalyzer {
     return createContainerForJS(
         moduleContext, bindingTrace, declarationProviderFactory, languageVersionSettings,
-        lookupTracker, expectActualTracker, additionalPackages, targetEnvironment
+        lookupTracker, expectActualTracker, inlineConstTracker, additionalPackages, targetEnvironment
     ).get<LazyTopDownAnalyzer>()
 }

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.js.di.createContainerForJS
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult
@@ -105,6 +106,7 @@ abstract class AbstractTopDownAnalyzerFacadeForJS {
     ): JsAnalysisResult {
         val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: LookupTracker.DO_NOTHING
         val expectActualTracker = configuration.get(CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER) ?: ExpectActualTracker.DoNothing
+        val inlineConstTracker = configuration.get(CommonConfigurationKeys.INLINE_CONST_TRACKER) ?: InlineConstTracker.DoNothing
         val languageVersionSettings = configuration.languageVersionSettings
         val packageFragment = configuration[JSConfigurationKeys.INCREMENTAL_DATA_PROVIDER]?.let {
             loadIncrementalCacheMetadata(it, moduleContext, lookupTracker, languageVersionSettings)
@@ -116,6 +118,7 @@ abstract class AbstractTopDownAnalyzerFacadeForJS {
             languageVersionSettings,
             lookupTracker,
             expectActualTracker,
+            inlineConstTracker,
             additionalPackages + listOfNotNull(packageFragment),
             targetEnvironment,
         )

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/injection.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.platform.konan.NativePlatforms
 import org.jetbrains.kotlin.resolve.*
@@ -37,6 +38,7 @@ fun createTopDownAnalyzerProviderForKonan(
 
         useImpl<ResolveSession>()
         useImpl<LazyTopDownAnalyzer>()
+        useInstance(InlineConstTracker.DoNothing)
 
         initContainer()
     }.apply {

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/AbstractJsScriptlikeCodeAnalyser.kt

@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.frontend.js.di.createTopDownAnalyzerForJs
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
@@ -54,6 +55,7 @@ abstract class AbstractJsScriptlikeCodeAnalyser(
         val languageVersionSettings = environment.configuration.languageVersionSettings
         val lookupTracker = LookupTracker.DO_NOTHING
         val expectActualTracker = ExpectActualTracker.DoNothing
+        val inlineConstTracker = InlineConstTracker.DoNothing
         val additionalPackages = emptyList<PackageFragmentProvider>()
         val moduleDescriptor = moduleContext.module
 
@@ -65,6 +67,7 @@ abstract class AbstractJsScriptlikeCodeAnalyser(
             languageVersionSettings,
             lookupTracker,
             expectActualTracker,
+            inlineConstTracker,
             additionalPackages,
             CompilerEnvironment,
         )