[JPS] Fix incremental build after changing Java constant

InlineConstantTracker implemented for tracking changed java static final constants, that used in kotlin. #KT-46506 Fixed
2021-09-02 12:32:30 +03:00
parent 23420ecf7a
commit cc5382b37e
9 changed files with 126 additions and 1 deletions
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.incremental
+
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
+import org.jetbrains.kotlin.incremental.components.ConstantRef
+
+class InlineConstTrackerImpl : InlineConstTracker {
+    private val inlineConst = hashMapOf<String, MutableSet<ConstantRef>>()
+
+    val inlineConstMap: Map<String, Collection<ConstantRef>>
+        get() = inlineConst
+
+    override fun report(filePath: String, cRefs: Collection<ConstantRef>) {
+        inlineConst.getOrPut(filePath) { hashSetOf() }.addAll(cRefs)
+    }
+}
@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.codegen.CompilationException
 import org.jetbrains.kotlin.config.*
 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.load.java.JavaClassesTracker
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
@@ -244,6 +245,8 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {

                putIfNotNull(CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER, services[ExpectActualTracker::class.java])

+                putIfNotNull(CommonConfigurationKeys.INLINE_CONST_TRACKER, services[InlineConstTracker::class.java])
+
                putIfNotNull(
                    JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS,
                    services[IncrementalCompilationComponents::class.java]
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.config

 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.metadata.deserialization.BinaryVersion

 object CommonConfigurationKeys {
@@ -39,6 +40,9 @@ object CommonConfigurationKeys {
    @JvmField
    val EXPECT_ACTUAL_TRACKER = CompilerConfigurationKey.create<ExpectActualTracker>("expect actual tracker")

+    @JvmField
+    val INLINE_CONST_TRACKER = CompilerConfigurationKey.create<InlineConstTracker>("inline constant tracker")
+
    @JvmField
    val METADATA_VERSION = CompilerConfigurationKey.create<BinaryVersion>("metadata version")

@@ -18,6 +18,8 @@ package org.jetbrains.kotlin.daemon.client

 import org.jetbrains.kotlin.daemon.common.*
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
+import org.jetbrains.kotlin.incremental.components.ConstantRef
 import org.jetbrains.kotlin.incremental.components.LookupInfo
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
@@ -36,6 +38,7 @@ open class CompilerCallbackServicesFacadeServer(
    val lookupTracker: LookupTracker? = null,
    val compilationCanceledStatus: CompilationCanceledStatus? = null,
    val expectActualTracker: ExpectActualTracker? = null,
+    val inlineConstTracker: InlineConstTracker? = null,
    val incrementalResultsConsumer: IncrementalResultsConsumer? = null,
    val incrementalDataProvider: IncrementalDataProvider? = null,
    port: Int = SOCKET_ANY_FREE_PORT
@@ -53,6 +56,8 @@ open class CompilerCallbackServicesFacadeServer(

    override fun hasExpectActualTracker(): Boolean = expectActualTracker != null

+    override fun hasInlineConstTracker(): Boolean = inlineConstTracker != null
+
    override fun hasIncrementalResultsConsumer(): Boolean = incrementalResultsConsumer != null

    override fun hasIncrementalDataProvider(): Boolean = incrementalDataProvider != null
@@ -116,6 +121,10 @@ open class CompilerCallbackServicesFacadeServer(
        expectActualTracker!!.report(File(expectedFilePath), File(actualFilePath))
    }

+    override fun inlineConstTracker_report(className: String, cRefs: Collection<ConstantRef>) {
+        inlineConstTracker?.report(className, cRefs) ?: throw NullPointerException("inlineConstTracker was not initialized")
+    }
+
    override fun incrementalResultsConsumer_processHeader(headerMetadata: ByteArray) {
        incrementalResultsConsumer!!.processHeader(headerMetadata)
    }
@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.daemon.common

 import org.jetbrains.kotlin.incremental.components.LookupInfo
+import org.jetbrains.kotlin.incremental.components.ConstantRef
 import org.jetbrains.kotlin.incremental.js.JsInlineFunctionHash
 import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto
 import org.jetbrains.kotlin.modules.TargetId
@@ -48,6 +49,9 @@ interface CompilerCallbackServicesFacade : Remote {
    @Throws(RemoteException::class)
    fun hasExpectActualTracker(): Boolean

+    @Throws(RemoteException::class)
+    fun hasInlineConstTracker(): Boolean
+
    @Throws(RemoteException::class)
    fun hasIncrementalResultsConsumer(): Boolean

@@ -101,6 +105,11 @@ interface CompilerCallbackServicesFacade : Remote {
    @Throws(RemoteException::class)
    fun expectActualTracker_report(expectedFilePath: String, actualFilePath: String)

+    // ---------------------------------------------------
+    // InlineConstTracker
+    @Throws(RemoteException::class)
+    fun inlineConstTracker_report(className: String, cRefs: Collection<ConstantRef>)
+
    // ---------------------------------------------------
    // IncrementalResultsConsumer (js)
    @Throws(RemoteException::class)
@@ -47,6 +47,7 @@ import org.jetbrains.kotlin.daemon.report.getBuildReporter
 import org.jetbrains.kotlin.incremental.*
 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.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
 import org.jetbrains.kotlin.incremental.multiproject.ModulesApiHistoryAndroid
@@ -873,6 +874,9 @@ class CompileServiceImpl(
        if (facade.hasExpectActualTracker()) {
            builder.register(ExpectActualTracker::class.java, RemoteExpectActualTracker(facade, rpcProfiler))
        }
+        if (facade.hasInlineConstTracker()) {
+            builder.register(InlineConstTracker::class.java, RemoteInlineConstTracker(facade, rpcProfiler))
+        }
        if (facade.hasIncrementalResultsConsumer()) {
            builder.register(IncrementalResultsConsumer::class.java, RemoteIncrementalResultsConsumer(facade, eventManager, rpcProfiler))
        }
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2018 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.daemon
+
+import org.jetbrains.kotlin.daemon.common.DummyProfiler
+import org.jetbrains.kotlin.daemon.common.Profiler
+import org.jetbrains.kotlin.daemon.common.withMeasure
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
+import org.jetbrains.kotlin.incremental.components.ConstantRef
+
+class RemoteInlineConstTracker(
+    @Suppress("DEPRECATION") val facade: org.jetbrains.kotlin.daemon.common.CompilerCallbackServicesFacade,
+    val profiler: Profiler = DummyProfiler()
+): InlineConstTracker {
+    override fun report(filePath: String, cRefs: Collection<ConstantRef>) {
+        profiler.withMeasure(this) {
+            facade.inlineConstTracker_report(filePath, cRefs)
+        }
+    }
+}
@@ -19,6 +19,14 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
 import org.jetbrains.kotlin.ir.types.isPrimitiveType
 import org.jetbrains.kotlin.ir.types.isStringClassType
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
+import org.jetbrains.kotlin.incremental.components.InlineConstTracker
+import org.jetbrains.kotlin.incremental.components.ConstantRef
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.descriptors.SourceFile
+import org.jetbrains.kotlin.ir.descriptors.toIrBasedDescriptor
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.ir.util.IdSignature
+import org.jetbrains.kotlin.load.kotlin.toSourceElement

 internal val constPhase1 = makeIrFilePhase(
    ::ConstLowering,
@@ -48,11 +56,16 @@ fun IrField.constantValue(context: JvmBackendContext? = null): IrConst<*>? {
 }

 class ConstLowering(val context: JvmBackendContext) : IrElementTransformerVoid(), FileLoweringPass {
+    val inlineConstTracker =
+        context.state.configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER] ?: InlineConstTracker.DoNothing
+
    override fun lower(irFile: IrFile) = irFile.transformChildrenVoid()

    private fun IrExpression.lowerConstRead(receiver: IrExpression?, field: IrField?): IrExpression? {
        val value = field?.constantValue() ?: return null
        transformChildrenVoid()
+        reportInlineConst(this@lowerConstRead, field)
+
        val resultExpression = if (context.state.shouldInlineConstVals)
            value.copyWithOffsets(startOffset, endOffset)
        else
@@ -66,7 +79,31 @@ class ConstLowering(val context: JvmBackendContext) : IrElementTransformerVoid()
                listOf(receiver, resultExpression)
            )
    }
-    
+
+    private fun reportInlineConst(irExpression: IrExpression, field: IrField?) {
+        if (inlineConstTracker == InlineConstTracker.DoNothing) return
+        val value = field?.constantValue() ?: return
+
+        if (!field.isFinal || !field.isStatic) return
+
+        val sourceFile = field.toIrBasedDescriptor().containingDeclaration.toSourceElement.containingFile
+        if (sourceFile == SourceFile.NO_SOURCE_FILE || sourceFile.toString().lowercase().endsWith(".kt")) return
+
+        for (file: KtFile in context.state.files) {
+            val fileName = file.virtualFilePath
+            val owner =
+                ((irExpression as? IrGetFieldImpl)?.symbol?.signature as? IdSignature.CompositeSignature)?.container?.asPublic()?.firstNameSegment
+                    ?: continue
+            val name = field.name.asString()
+            val constType = value.kind.toString()
+
+            inlineConstTracker.report(
+                fileName,
+                listOf(ConstantRef(owner, name, constType))
+            )
+        }
+    }
+
    private fun IrExpression.shouldDropConstReceiver() =
        this is IrConst<*> || this is IrGetValue ||
                this is IrGetObjectValue
@@ -0,0 +1,16 @@
+package org.jetbrains.kotlin.incremental.components
+
+import org.jetbrains.kotlin.container.DefaultImplementation
+import java.io.Serializable
+
+@DefaultImplementation(InlineConstTracker.DoNothing::class)
+interface InlineConstTracker {
+    fun report(filePath: String, cRefs: Collection<ConstantRef>)
+
+    object DoNothing : InlineConstTracker {
+        override fun report(filePath: String, cRefs: Collection<ConstantRef>) {
+        }
+    }
+}
+
+data class ConstantRef(var owner: String, var name: String, var constType: String) : Serializable